Centralize thread context ID allocation (#62633)

## Why

Response item IDs and context window IDs use separate generator callbacks.
A shared allocator gives history and inference a single API for both.

## What changed

Use `ThreadContextIds` to allocate response item IDs, retained-context
revisions, and compaction window IDs. Move initial window selection into
`InitialHistory` so resumed threads reuse a valid window ID from their
rollout. Give rollout reconstruction its own allocator.

Assign hook prompt IDs through the session's normal response item
recording path.

## Testing

Move the prefixed UUIDv7 item ID test to the allocator crate and add
coverage for JSON escaping in Guardian's item ID token budget.

GitOrigin-RevId: 31232f50648382033506d1f86815ce7c1de78378
This commit is contained in:
Ruslan Nigmatullin
2026-11-20 00:44:31 +00:00
committed by copyberry
parent ead489ac4d
commit 583ec348cf
87 changed files with 553 additions and 491 deletions
+28 -4
View File
@@ -2296,7 +2296,6 @@ dependencies = [
"codex-extension-items",
"codex-history",
"codex-protocol",
"codex-protocol-test-support",
"codex-rollout",
"codex-secrets",
"codex-shell-command",
@@ -3115,6 +3114,8 @@ dependencies = [
"codex-state",
"codex-terminal-detection",
"codex-test-binary-support",
"codex-thread-context-ids",
"codex-thread-context-ids-test-support",
"codex-thread-store",
"codex-tools",
"codex-user-input",
@@ -3781,6 +3782,8 @@ dependencies = [
"codex-history",
"codex-protocol",
"codex-protocol-test-support",
"codex-thread-context-ids",
"codex-thread-context-ids-test-support",
"codex-utils-output-truncation",
"pretty_assertions",
"serde",
@@ -3808,6 +3811,7 @@ dependencies = [
"codex-protocol-test-support",
"codex-rmcp-client",
"codex-shell-command",
"codex-thread-context-ids",
"codex-utils-output-truncation",
"codex-utils-path-uri",
"codex-utils-string",
@@ -3849,6 +3853,8 @@ dependencies = [
"codex-protocol",
"codex-protocol-test-support",
"codex-runtime-agent-instance",
"codex-thread-context-ids",
"codex-thread-context-ids-test-support",
"codex-utils-cargo-bin",
"codex-websocket-client",
"core_test_support",
@@ -3914,7 +3920,8 @@ version = "0.0.0"
dependencies = [
"anyhow",
"codex-protocol",
"codex-protocol-test-support",
"codex-thread-context-ids",
"codex-thread-context-ids-test-support",
"codex-utils-absolute-path",
"codex-utils-model-facing-id",
"pretty_assertions",
@@ -4341,6 +4348,7 @@ dependencies = [
"codex-secrets",
"codex-state",
"codex-terminal-detection",
"codex-thread-context-ids",
"codex-utils-absolute-path",
"codex-utils-output-truncation",
"codex-utils-template",
@@ -4789,7 +4797,6 @@ name = "codex-protocol-test-support"
version = "0.0.0"
dependencies = [
"codex-protocol",
"uuid",
]
[[package]]
@@ -5201,6 +5208,23 @@ dependencies = [
"tempfile",
]
[[package]]
name = "codex-thread-context-ids"
version = "0.0.0"
dependencies = [
"codex-protocol",
"codex-thread-context-ids-test-support",
"pretty_assertions",
"uuid",
]
[[package]]
name = "codex-thread-context-ids-test-support"
version = "0.0.0"
dependencies = [
"codex-thread-context-ids",
]
[[package]]
name = "codex-thread-manager-sample"
version = "0.0.0"
@@ -5224,9 +5248,9 @@ dependencies = [
"codex-install-context",
"codex-otel",
"codex-protocol",
"codex-protocol-test-support",
"codex-rollout",
"codex-state",
"codex-thread-context-ids-test-support",
"codex-utils-absolute-path",
"codex-utils-path",
"codex-utils-path-uri",
+4
View File
@@ -166,6 +166,8 @@ members = [
"terminal-detection",
"test-binary-support",
"thread-manager-sample",
"thread-context-ids",
"thread-context-ids/tests/support",
"thread-store",
"uds",
"codex-experimental-api-macros",
@@ -307,6 +309,8 @@ codex-skills = { path = "skills" }
codex-state = { path = "state" }
codex-terminal-detection = { path = "terminal-detection" }
codex-test-binary-support = { path = "test-binary-support" }
codex-thread-context-ids = { path = "thread-context-ids" }
codex-thread-context-ids-test-support = { path = "thread-context-ids/tests/support" }
codex-thread-store = { path = "thread-store" }
codex-tools = { path = "tools" }
codex-tcp-tunnel = { path = "tcp-tunnel" }
-1
View File
@@ -42,7 +42,6 @@ uuid = { workspace = true, features = ["serde", "v7"] }
zstd = { workspace = true }
[dev-dependencies]
codex-protocol-test-support = { workspace = true }
anyhow = { workspace = true }
codex-utils-cargo-bin = { workspace = true }
pretty_assertions = { workspace = true }
@@ -5504,14 +5504,14 @@ mod tests {
#[test]
fn rebuilds_hook_prompt_items_from_rollout_response_items() {
let hook_prompt = build_hook_prompt_message(
&[
CoreHookPromptFragment::from_single_hook("Retry with tests.", "hook-run-1"),
CoreHookPromptFragment::from_single_hook("Then summarize cleanly.", "hook-run-2"),
],
&codex_protocol_test_support::uuid_v7_item_id_generator_for_test(),
)
let mut hook_prompt = build_hook_prompt_message(&[
CoreHookPromptFragment::from_single_hook("Retry with tests.", "hook-run-1"),
CoreHookPromptFragment::from_single_hook("Then summarize cleanly.", "hook-run-2"),
])
.expect("hook prompt message");
hook_prompt.set_id(Some(codex_protocol::ResponseItemId::from_server(
"msg_hook".to_owned(),
)));
let items = vec![
RolloutItem::EventMsg(EventMsg::TurnStarted(TurnStartedEvent {
turn_attribution: None,
+2
View File
@@ -12,6 +12,7 @@ path = "src/lib.rs"
workspace = true
[dependencies]
codex-thread-context-ids = { workspace = true }
codex-utils-process = { workspace = true }
anyhow = { workspace = true }
arc-swap = { workspace = true }
@@ -142,6 +143,7 @@ openssl-sys = { workspace = true, features = ["vendored"] }
openssl-sys = { workspace = true, features = ["vendored"] }
[dev-dependencies]
codex-thread-context-ids-test-support = { workspace = true }
codex-backend-client = { workspace = true }
codex-message-board = { workspace = true }
codex-agent-message-board-host = { workspace = true }
@@ -5,7 +5,6 @@
use crate::context::GuardianSenderMessages;
use crate::context_manager::ContextManager;
use crate::session::session::Session;
use codex_history::RolloutItem;
use codex_protocol::SessionId;
use codex_protocol::ThreadId;
@@ -130,7 +129,7 @@ impl LocalAgentRuntime {
let context = ContextManager::reconstruct_rollout(
&history,
history_mode,
ContextManager::new(Session::new_item_id_generator()),
ContextManager::new,
// Tool bodies are not sender authorization evidence.
TruncationPolicy::Bytes(0),
)
+2 -4
View File
@@ -104,6 +104,7 @@ use codex_protocol::protocol::TurnEnvironmentSelections;
use codex_protocol::protocol::TurnStartedEvent;
use codex_protocol::protocol::WorldStateItem;
use codex_protocol_test_support::ContentItemTestExt;
use codex_thread_context_ids_test_support::thread_context_ids;
use codex_thread_store::ArchiveThreadParams;
use codex_thread_store::InMemoryThreadStore;
use codex_thread_store::LocalThreadStore;
@@ -3410,10 +3411,7 @@ async fn spawn_agent_fork_strips_parent_usage_hints_from_compacted_history(marke
}),
};
let mut retained_context = codex_history::RetainedContext::default();
retained_context.record(
&answer_event,
&codex_protocol_test_support::uuid_v7_item_id_generator_for_test(),
);
retained_context.record(&answer_event, &thread_context_ids());
retained_context.record_sender_user_messages(delivery.metadata.as_ref().unwrap());
parent_thread
.session
+9 -9
View File
@@ -84,7 +84,6 @@ use codex_otel::SessionTelemetry;
use codex_otel::WEBSOCKET_CONTINUATION_COUNT_METRIC;
use codex_otel::current_span_w3c_trace_context;
use codex_otel::inject_span_w3c_trace_headers;
use codex_protocol::ItemIdGenerator;
use codex_protocol::ResponseItemId;
use codex_protocol::auth::AuthMode;
@@ -165,6 +164,7 @@ use codex_response_debug_context::extract_response_debug_context;
use codex_response_debug_context::extract_response_debug_context_from_api_error;
use codex_response_debug_context::telemetry_api_error_message;
use codex_response_debug_context::telemetry_transport_error_message;
use codex_thread_context_ids::ThreadContextIds;
pub const OPENAI_BETA_HEADER: &str = "OpenAI-Beta";
pub const X_CODEX_INSTALLATION_ID_HEADER: &str = "x-codex-installation-id";
@@ -209,7 +209,7 @@ fn session_telemetry_for_request(
/// configuration is per turn and is passed explicitly to streaming/unary methods.
struct ModelClientState {
thread_id: ThreadId,
item_id_generator: ItemIdGenerator,
context_ids: ThreadContextIds,
provider: SharedModelProvider,
workspace_routing: WorkspaceRoutingContext,
auth_env_telemetry: AuthEnvTelemetry,
@@ -648,7 +648,7 @@ impl ModelClient {
model_provider: SharedModelProvider,
agent_identity_policy: AgentIdentityAuthPolicy,
thread_id: ThreadId,
item_id_generator: ItemIdGenerator,
context_ids: ThreadContextIds,
session_source: SessionSource,
originator: String,
model_verbosity: Option<VerbosityConfig>,
@@ -684,7 +684,7 @@ impl ModelClient {
Self {
state: Arc::new(ModelClientState {
thread_id,
item_id_generator,
context_ids,
provider: model_provider,
workspace_routing,
auth_env_telemetry,
@@ -3070,7 +3070,7 @@ where
let consumer_dropped_for_stream = consumer_dropped.clone();
let settlement_started = Arc::clone(&delivery.settlement_started);
let provider = Arc::clone(&client.provider);
let item_id_generator = Arc::clone(&client.item_id_generator);
let context_ids = client.context_ids.clone();
tokio::spawn(async move {
let mut logged_error = false;
@@ -3115,9 +3115,9 @@ where
// Reuse the added event's ID so tracing and the harness agree.
if item.id().is_none_or(|id| id.is_empty()) {
item.set_id(
active_item_id
.take()
.or_else(|| item.id_prefix().map(item_id_generator.as_ref())),
active_item_id.take().or_else(|| {
item.id_prefix().map(|kind| context_ids.next_item(kind))
}),
);
}
active_item_id = None;
@@ -3161,7 +3161,7 @@ where
Ok(mut event) => {
if let ResponseEvent::OutputItemAdded(item) = &mut event {
if item.id().is_none_or(|id| id.is_empty()) {
item.set_id(item.id_prefix().map(item_id_generator.as_ref()));
item.set_id(item.id_prefix().map(|kind| context_ids.next_item(kind)));
}
active_item_id = item.id().cloned();
}
+4 -4
View File
@@ -65,7 +65,6 @@ use codex_protocol::openai_models::ReasoningEffortPreset;
use codex_protocol::protocol::InternalSessionSource;
use codex_protocol::protocol::SessionSource;
use codex_protocol::protocol::SubAgentSource;
use codex_protocol_test_support::uuid_v7_item_id_generator_for_test;
use codex_rollout_trace::ExecutionStatus;
use codex_rollout_trace::InferenceTraceAttempt;
use codex_rollout_trace::InferenceTraceContext;
@@ -78,6 +77,7 @@ use codex_runtime_agent_instance::AgentHostAuthorization;
use codex_runtime_agent_instance::RuntimeAuthManager;
use codex_runtime_agent_instance::RuntimeRegistrationMetadata;
use codex_runtime_agent_instance::RuntimeRole;
use codex_thread_context_ids_test_support::thread_context_ids;
use codex_tools::JsonSchema;
use codex_tools::ResponsesApiTool;
use codex_tools::ToolSpec;
@@ -126,7 +126,7 @@ fn test_model_client_with_thread_id(
codex_model_provider::create_model_provider(provider, /*auth_manager*/ None),
AgentIdentityAuthPolicy::JwtOnly,
thread_id,
uuid_v7_item_id_generator_for_test(),
thread_context_ids(),
session_source,
"test_originator".to_string(),
/*model_verbosity*/ None,
@@ -595,7 +595,7 @@ async fn responses_request_includes_internal_metadata_for_provider_grant_or_firs
recorder.attach_direct_call_to_output(
&mut item,
Some((recorded, permit)),
&session.item_id_generator,
&session.context_ids,
);
outputs.push(item);
}
@@ -2188,7 +2188,7 @@ fn model_client_with_counting_attestation(
codex_model_provider::create_model_provider(provider, auth_manager),
AgentIdentityAuthPolicy::JwtOnly,
ThreadId::new(),
uuid_v7_item_id_generator_for_test(),
thread_context_ids(),
SessionSource::Exec,
"test_originator".to_string(),
/*model_verbosity*/ None,
+3 -3
View File
@@ -428,9 +428,9 @@ impl CodexThread {
&self.session.services.thread_extension_data
}
/// Generator used for response items produced on behalf of this thread.
pub fn item_id_generator(&self) -> &codex_protocol::ItemIdGenerator {
&self.session.item_id_generator
/// Allocates context IDs on behalf of this thread.
pub fn context_ids(&self) -> &codex_thread_context_ids::ThreadContextIds {
&self.session.context_ids
}
/// Returns tools from this thread’s ready, unshared Apps MCP client.
+3 -6
View File
@@ -1038,12 +1038,9 @@ mod tests {
#[test]
fn build_v2_compacted_history_filters_to_installed_retention_shape() {
let hook = codex_protocol::items::build_hook_prompt_message(
&[codex_protocol::items::HookPromptFragment::from_single_hook(
"hook", "hook-run",
)],
&codex_protocol_test_support::uuid_v7_item_id_generator_for_test(),
)
let hook = codex_protocol::items::build_hook_prompt_message(&[
codex_protocol::items::HookPromptFragment::from_single_hook("hook", "hook-run"),
])
.expect("hook prompt");
let input = vec![
message("developer", "dev", /*phase*/ None),
@@ -148,13 +148,10 @@ fn ignores_regular_user_text() {
#[test]
fn detects_hook_prompt_fragment_and_roundtrips_escaping() {
let message = build_hook_prompt_message(
&[HookPromptFragment::from_single_hook(
r#"Retry with "waves" & <tides>"#,
"hook-run-1",
)],
&codex_protocol_test_support::uuid_v7_item_id_generator_for_test(),
)
let message = build_hook_prompt_message(&[HookPromptFragment::from_single_hook(
r#"Retry with "waves" & <tides>"#,
"hook-run-1",
)])
.expect("hook prompt message");
let ResponseItem::Message { content, .. } = message else {
+12 -10
View File
@@ -51,7 +51,6 @@ use codex_history::RetainedContextEvent;
use codex_history::RetainedInputSource;
use codex_prompts::render_model_instructions;
use codex_protocol::DEFAULT_FUNCTION_NAMESPACE;
use codex_protocol::ItemIdGenerator;
use codex_protocol::items::TurnItem;
use codex_protocol::models::AgentMessageInputContent;
use codex_protocol::models::AudioReference;
@@ -69,6 +68,7 @@ use codex_protocol::protocol::TokenUsageInfo;
use codex_protocol::protocol::TurnCompleteEvent;
use codex_protocol::protocol::TurnContextItem;
use codex_protocol::protocol::WorldStateItem;
use codex_thread_context_ids::ThreadContextIds;
use codex_utils_audio::estimate_tool_audio_tokens;
use codex_utils_cache::BlockingLruCache;
use codex_utils_cache::sha1_digest;
@@ -103,7 +103,7 @@ fn next_guardian_review_context_revision() -> u64 {
/// Transcript of thread history
#[derive(Clone)]
pub(crate) struct ContextManager {
item_id_generator: ItemIdGenerator,
context_ids: ThreadContextIds,
sampling: super::sampling::SamplingProgress,
/// Inclusive sequence cutoff for calls that may still be running in the fork source.
pub(crate) restored_through_sequence: u64,
@@ -312,14 +312,18 @@ impl SharedConversationHistory {
#[cfg(test)]
impl Default for ContextManager {
fn default() -> Self {
Self::new(codex_protocol_test_support::uuid_v7_item_id_generator_for_test())
Self::new(codex_thread_context_ids_test_support::thread_context_ids())
}
}
impl ContextManager {
pub(crate) fn new(item_id_generator: ItemIdGenerator) -> Self {
pub(crate) fn context_ids(&self) -> &ThreadContextIds {
&self.context_ids
}
pub(crate) fn new(context_ids: ThreadContextIds) -> Self {
Self {
item_id_generator,
context_ids,
sampling: Default::default(),
restored_through_sequence: 0,
items: Arc::new(Vec::new()),
@@ -366,7 +370,7 @@ impl ContextManager {
features: &ManagedFeatures,
reuse_parent_compaction: bool,
budgeting: ContextBudgeting,
item_id_generator: ItemIdGenerator,
context_ids: ThreadContextIds,
) -> Self {
let independent = !reuse_parent_compaction;
Self {
@@ -381,7 +385,7 @@ impl ContextManager {
review_budgeting: budgeting,
review_history: independent
.then(|| TranscriptHistory::new(/*generation*/ 0, budgeting)),
..Self::new(item_id_generator)
..Self::new(context_ids)
}
}
@@ -397,9 +401,7 @@ impl ContextManager {
&mut self,
event: &mut RetainedContextEvent,
) -> bool {
if !Arc::make_mut(&mut self.retained_context)
.record_and_capture(event, &self.item_id_generator)
{
if !Arc::make_mut(&mut self.retained_context).record_and_capture(event, &self.context_ids) {
return false;
}
match event {
@@ -3,6 +3,7 @@
use super::*;
use codex_protocol::models::ContentItemKind;
use codex_protocol::models::InternalChatMessageMetadataPassthrough;
use codex_thread_context_ids_test_support::thread_context_ids;
use pretty_assertions::assert_eq;
fn file_audio(file_id: &str) -> ContentItem {
@@ -61,7 +62,7 @@ fn previously_accepted_file_only_disambiguates_clip_specific_errors() {
&codex_history::RetainedContextEvent::AcceptedFileAudio {
evidence: evidence.into(),
},
&codex_protocol_test_support::uuid_v7_item_id_generator_for_test(),
&thread_context_ids(),
);
assert!(
context
@@ -43,6 +43,7 @@ use codex_protocol::protocol::InterAgentCommunication;
use codex_protocol::protocol::PLUGINS_INSTRUCTIONS_OPEN_TAG;
use codex_protocol::protocol::TurnContextItem;
use codex_protocol_test_support::ContentItemTestExt;
use codex_thread_context_ids_test_support::thread_context_ids;
use codex_utils_absolute_path::AbsolutePathBuf;
use codex_utils_output_truncation::TruncationPolicy;
use codex_utils_output_truncation::truncate_text;
@@ -160,7 +161,7 @@ fn root_history() -> ContextManager {
&ManagedFeatures::from(codex_features::Features::with_defaults()),
/*reuse_parent_compaction*/ true,
codex_guardian_context::ContextBudgeting::Fixed,
codex_protocol_test_support::uuid_v7_item_id_generator_for_test(),
thread_context_ids(),
)
}
@@ -594,7 +595,7 @@ fn guardian_checkpoint_applies_additional_context_policy_after_resume(include: b
&features,
features.enabled(Feature::GuardianReuseParentCompaction),
codex_guardian_context::ContextBudgeting::Fixed,
codex_protocol_test_support::uuid_v7_item_id_generator_for_test(),
thread_context_ids(),
);
let additional_context: ResponseItem = crate::context::AdditionalContextToolOutput::new(
"browser_info",
@@ -638,7 +639,7 @@ fn guardian_checkpoint_applies_additional_context_policy_after_resume(include: b
&features,
features.enabled(Feature::GuardianReuseParentCompaction),
codex_guardian_context::ContextBudgeting::Fixed,
codex_protocol_test_support::uuid_v7_item_id_generator_for_test(),
thread_context_ids(),
);
resumed.replace_annotated(compacted);
resumed.restore_review_context(
@@ -145,7 +145,7 @@ impl ContextManager {
complete: true,
},
source,
&self.item_id_generator,
&self.context_ids,
);
return None;
}
@@ -209,9 +209,9 @@ impl ContextManager {
};
let retained = Arc::make_mut(&mut self.retained_context);
captured = if is_assistant {
retained.record_assistant_message(message, metadata.into(), &self.item_id_generator)
retained.record_assistant_message(message, metadata.into(), &self.context_ids)
} else {
retained.record_user_message(message, metadata.into(), &self.item_id_generator)
retained.record_user_message(message, metadata.into(), &self.context_ids)
};
}
if !is_assistant {
+4 -7
View File
@@ -452,13 +452,10 @@ fn skips_user_instructions_and_env() {
#[test]
fn parses_hook_prompt_message_as_distinct_turn_item() {
let item = build_hook_prompt_message(
&[HookPromptFragment::from_single_hook(
"Retry with exactly the phrase meow meow meow.",
"hook-run-1",
)],
&codex_protocol_test_support::uuid_v7_item_id_generator_for_test(),
)
let item = build_hook_prompt_message(&[HookPromptFragment::from_single_hook(
"Retry with exactly the phrase meow meow meow.",
"hook-run-1",
)])
.expect("hook prompt message");
let turn_item = parse_turn_item(&item).expect("expected hook prompt turn item");
+1 -1
View File
@@ -409,7 +409,7 @@ impl ReviewHost for super::super::runtime::ReviewRuntime {
evidence.authorization_version,
evidence.review_context_revision,
evidence.root_versions,
&self.session.item_id_generator,
&self.session.context_ids,
);
}
}
@@ -6,13 +6,13 @@ use crate::context_manager::ContextManager;
use codex_protocol::models::BaseInstructions;
use codex_protocol::models::ContentItem;
use codex_protocol::models::ResponseInputItem;
use codex_protocol_test_support::uuid_v7_item_id_generator_for_test;
use codex_thread_context_ids_test_support::thread_context_ids;
use codex_utils_output_truncation::TruncationPolicy;
use pretty_assertions::assert_eq;
#[test]
fn history_sums_measured_and_unknown_file_audio() {
let mut history = ContextManager::new(uuid_v7_item_id_generator_for_test());
let mut history = ContextManager::new(thread_context_ids());
let item = ResponseInputItem::Message {
role: "user".to_string(),
content: ["short", "unknown"]
@@ -119,7 +119,7 @@ async fn producer_bounded_audio_keeps_the_same_parts_as_inline_history() {
)
.unwrap();
codex_utils_audio::prepare_response_items(std::slice::from_mut(&mut inline));
let mut history = ContextManager::new(uuid_v7_item_id_generator_for_test());
let mut history = ContextManager::new(thread_context_ids());
history.record_items([&inline], policy);
let expected =
serde_json::to_value(history.raw_items().last().unwrap()).unwrap()["output"].take();
@@ -6,7 +6,7 @@ use codex_history::InitialHistory;
use codex_protocol::models::ResponseItem;
use codex_protocol::protocol::ThreadHistoryMode;
use codex_protocol::protocol::TokenUsage;
use codex_protocol_test_support::uuid_v7_item_id_generator_for_test;
use codex_thread_context_ids_test_support::thread_context_ids;
use pretty_assertions::assert_eq;
use serde_json::json;
use test_case::test_case;
@@ -40,7 +40,7 @@ async fn guardian_checkpoint_preserves_live_context_without_storage(
&crate::config::ManagedFeatures::from(codex_features::Features::with_defaults()),
/*reuse_parent_compaction*/ true,
codex_guardian_context::ContextBudgeting::Fixed,
uuid_v7_item_id_generator_for_test(),
thread_context_ids(),
);
state
.history
@@ -114,7 +114,7 @@ async fn guardian_checkpoint_preserves_live_context_without_storage(
&crate::config::ManagedFeatures::from(codex_features::Features::with_defaults()),
/*reuse_parent_compaction*/ true,
codex_guardian_context::ContextBudgeting::Fixed,
uuid_v7_item_id_generator_for_test(),
thread_context_ids(),
);
fork.record_initial_history(InitialHistory::Forked(items))
.await;
+5 -5
View File
@@ -276,7 +276,6 @@ mod mcp_prewarm;
mod mcp_refresh;
mod mcp_runtime;
mod model_catalog_settings;
mod model_ids;
pub(crate) mod multi_agents;
mod plugin_selection;
mod realtime_handoff;
@@ -605,12 +604,12 @@ const CYBER_SAFETY_URL: &str = "https://developers.openai.com/codex/concepts/cyb
pub(crate) fn assign_missing_item_id(
item: &mut ResponseItem,
item_id_generator: &codex_protocol::ItemIdGenerator,
context_ids: &codex_thread_context_ids::ThreadContextIds,
) {
if item.id().is_none_or(|id| id.is_empty())
&& let Some(prefix) = item.id_prefix()
{
item.set_id(Some(item_id_generator(prefix)));
item.set_id(Some(context_ids.next_item(prefix)));
}
}
@@ -4036,7 +4035,7 @@ impl Session {
}
pub(crate) fn assign_missing_response_item_id(&self, item: &mut ResponseItem) {
assign_missing_item_id(item, &self.item_id_generator);
assign_missing_item_id(item, &self.context_ids);
}
pub(crate) fn response_item_from_user_input(
@@ -6060,8 +6059,9 @@ impl Session {
&self,
turn_context: &TurnContext,
model_info: &ModelInfo,
response_item: ResponseItem,
mut response_item: ResponseItem,
) {
self.assign_missing_response_item_id(&mut response_item);
// Add to conversation history and persist response item to rollout.
self.record_conversation_items(
turn_context,
-52
View File
@@ -1,52 +0,0 @@
//! Creates this thread's item and window sequences from the history it will actually replay.
use std::sync::Arc;
use codex_history::InitialHistory;
use codex_history::RolloutItem;
use codex_protocol::ContextWindowId;
use codex_protocol::ItemIdGenerator;
use super::session::Session;
use crate::state::AutoCompactWindowIds;
use crate::state::ContextWindowIdGenerator;
pub(super) struct InitialModelIds {
pub item_id_generator: ItemIdGenerator,
pub context_window_id_generator: ContextWindowIdGenerator,
pub initial_auto_compact_window_ids: AutoCompactWindowIds,
}
pub(super) fn from_history(history: &InitialHistory) -> InitialModelIds {
// A resume already owns its window. Allocating a provisional one would skip an ordinal.
let resumed_window = match history {
InitialHistory::Resumed(resumed) => {
resumed
.history
.iter()
.rev()
.find_map(|record| match record {
RolloutItem::Compacted(checkpoint) => {
checkpoint.window_id.as_ref()?.validated()
}
RolloutItem::SessionMeta(meta) if meta.meta.id == resumed.conversation_id => {
meta.meta.context_window.as_ref()?.window_id.validated()
}
_ => None,
})
}
InitialHistory::New | InitialHistory::Cleared | InitialHistory::Forked(_) => None,
};
let initialize = |item_id_generator, context_window_id_generator: ContextWindowIdGenerator| {
let initial = resumed_window.unwrap_or_else(|| context_window_id_generator());
InitialModelIds {
item_id_generator,
context_window_id_generator,
initial_auto_compact_window_ids: AutoCompactWindowIds::new_initial(initial),
}
};
initialize(
Session::new_item_id_generator(),
Arc::new(ContextWindowId::new_uuid_v7),
)
}
@@ -196,15 +196,15 @@ impl Session {
ContextManager::reconstruct_rollout(
rollout_items,
turn_context.history_mode,
ContextManager::for_session(
turn_context.root_capabilities_restricted,
&turn_context.config.features,
turn_context.config.guardian_reuses_parent_compaction(),
turn_context.config.guardian_context_budgeting(),
// Reconstructing retained evidence may mint temporary revisions before restoring
// the durable originals. Replay must not consume the live thread's item sequence.
Self::new_item_id_generator(),
),
|ids| {
ContextManager::for_session(
turn_context.root_capabilities_restricted,
&turn_context.config.features,
turn_context.config.guardian_reuses_parent_compaction(),
turn_context.config.guardian_context_budgeting(),
ids,
)
},
turn_context.model_info().truncation_policy.into(),
)
}
@@ -215,9 +215,13 @@ impl ContextManager {
pub(crate) fn reconstruct_rollout(
rollout_items: &[RolloutItem],
history_mode: ThreadHistoryMode,
mut history: Self,
create_history: impl FnOnce(codex_thread_context_ids::ThreadContextIds) -> Self,
truncation_policy: TruncationPolicy,
) -> RolloutReconstruction {
// Reconstruction may mint temporary revisions before restoring durable ones.
// Use an independent allocator for replay.
let ids = codex_history::context_ids_from_rollout(rollout_items);
let mut history = create_history(ids);
// Rejection facts are durable across compaction boundaries. File IDs are immutable,
// so retaining a fact after rollback is conservative and cannot suppress a different
// future upload.
@@ -22,9 +22,9 @@ use codex_protocol::protocol::ThreadRolledBackEvent;
use codex_protocol::protocol::WorldStateItem;
use codex_protocol::security_risk::SecurityRiskScore;
use codex_protocol::turn_input::CyberAccessProgram;
use codex_protocol_test_support::uuid_v7_item_id_generator_for_test;
use codex_rollout::ModelContextScan;
use codex_rollout::ModelContextScanProgress;
use codex_thread_context_ids_test_support::thread_context_ids;
use core_test_support::responses::strip_metadata_from_items;
use pretty_assertions::assert_eq;
use serde_json::json;
@@ -131,7 +131,7 @@ async fn sender_context_follows_its_delivery_through_checkpoint_and_rollback() {
&crate::config::ManagedFeatures::from(codex_features::Features::with_defaults()),
/*reuse_parent_compaction*/ true,
codex_guardian_context::ContextBudgeting::Fixed,
uuid_v7_item_id_generator_for_test(),
thread_context_ids(),
);
let mut items = Vec::new();
let mut snapshots = Vec::new();
@@ -2054,9 +2054,9 @@ async fn reconstruct_history_legacy_compaction_without_replacement_history_does_
complete: false,
},
codex_history::RetainedInputSource::Local(None),
&uuid_v7_item_id_generator_for_test(),
&thread_context_ids(),
);
retained.record(&answer, &uuid_v7_item_id_generator_for_test());
retained.record(&answer, &thread_context_ids());
let rollout_items = vec![
RolloutItem::ResponseItem(user_message("before compact").into()),
RolloutItem::ResponseItem(assistant_message("assistant reply").into()),
+14 -24
View File
@@ -35,7 +35,6 @@ use codex_login::auth::AgentIdentityAuthPolicy;
use codex_model_provider::SharedModelProvider;
use codex_prompts::render_model_instructions;
use codex_protocol::ContextWindowId;
use codex_protocol::ItemIdGenerator;
use codex_protocol::SessionId;
use codex_protocol::capabilities::SelectedCapabilityRoot;
use codex_protocol::config_types::ShellEnvironmentPolicy;
@@ -51,6 +50,7 @@ use codex_protocol::protocol::TurnEnvironmentRequests;
use codex_protocol::protocol::TurnEnvironmentSelections;
use codex_sandboxing::SandboxType;
use codex_skills::SkillError;
use codex_thread_context_ids::ThreadContextIds;
use codex_utils_git_discovery::GitRootDiscovery;
use codex_utils_path::replace_path_and_deduplicate;
use std::sync::OnceLock;
@@ -72,7 +72,7 @@ pub(crate) struct AgentOutcomeReporting {
/// A session has at most 1 running task at a time, and can be interrupted by user input.
pub(crate) struct Session {
pub(crate) thread_id: ThreadId,
pub(crate) item_id_generator: ItemIdGenerator,
pub(crate) context_ids: ThreadContextIds,
pub(crate) agent_runtime: AgentRuntimeServices,
pub(crate) outcome_reporting: Option<AgentOutcomeReporting>,
pub(crate) installation_id: String,
@@ -642,10 +642,6 @@ impl Session {
.is_some_and(|reporting| reporting.handoffs.is_closed())
}
pub(crate) fn new_item_id_generator() -> ItemIdGenerator {
Arc::new(|prefix| ResponseItemId::with_suffix(prefix, uuid::Uuid::now_v7()))
}
pub(super) async fn effective_thread_config_snapshot(
&self,
configuration: &SessionConfiguration,
@@ -906,7 +902,7 @@ impl Session {
session_configuration.thread_source.as_ref(),
Some(ThreadSource::Subagent | ThreadSource::GuardianReview)
);
let prepare_ids = super::model_ids::from_history;
let prepare_ids = InitialHistory::initialize_context_ids;
// New threads need their window ID to create the rollout. Resumes initialize once the
// writer has validated or refreshed the history snapshot.
let new_thread_ids = (!matches!(initial_history, InitialHistory::Resumed(_)))
@@ -921,15 +917,13 @@ impl Session {
for record in records {
match record {
RolloutItem::ResponseItem(item) => {
assign_missing_item_id(&mut item.item, &ids.item_id_generator)
assign_missing_item_id(&mut item.item, &ids.context_ids)
}
RolloutItem::Compacted(checkpoint) if restore_child_window => {
checkpoint.window_number = Some(0);
checkpoint.first_window_id =
Some(ids.initial_auto_compact_window_ids.window_id.clone());
checkpoint.first_window_id = Some(ids.initial_window_id.clone());
checkpoint.previous_window_id = None;
checkpoint.window_id =
Some(ids.initial_auto_compact_window_ids.window_id.clone());
checkpoint.window_id = Some(ids.initial_window_id.clone());
}
_ => {}
}
@@ -1155,10 +1149,7 @@ impl Session {
ForkPersistence::Referenced { history_base, .. } => *history_base,
},
subagent_history_start_ordinal: None,
initial_window_id: ids
.initial_auto_compact_window_ids
.window_id
.clone(),
initial_window_id: ids.initial_window_id.clone(),
runtime_workspace_roots: Some(config.workspace_roots.clone()),
metadata: config.thread_persistence_metadata(),
};
@@ -1310,11 +1301,11 @@ impl Session {
version,
)?;
}
let super::model_ids::InitialModelIds {
item_id_generator,
context_window_id_generator,
initial_auto_compact_window_ids,
let codex_history::InitialContextIds {
context_ids,
initial_window_id,
} = new_thread_ids.unwrap_or_else(|| prepare_ids(&initial_history));
let initial_auto_compact_window_ids = crate::state::AutoCompactWindowIds::new_initial(initial_window_id);
let rollout_path = if let Some(live_thread) = live_thread.as_ref() {
live_thread.local_rollout_path().await?
} else {
@@ -1606,13 +1597,12 @@ impl Session {
let mut state = SessionState::new_with_auto_compact_window_ids(
session_configuration.clone(),
initial_auto_compact_window_ids.clone(),
context_window_id_generator,
ContextManager::for_session(
session_configuration.root_capabilities_restricted,
&config.features,
config.guardian_reuses_parent_compaction(),
config.guardian_context_budgeting(),
Arc::clone(&item_id_generator),
context_ids.clone(),
),
);
if matches!(initial_history, InitialHistory::Resumed(_)) {
@@ -1871,7 +1861,7 @@ impl Session {
AgentIdentityAuthPolicy::JwtOnly
},
thread_id,
Arc::clone(&item_id_generator),
context_ids.clone(),
session_configuration.session_source.clone(),
session_configuration.originator.clone(),
config.model_verbosity,
@@ -2014,7 +2004,7 @@ impl Session {
let (mcp_prewarm_tx, mcp_prewarm_rx) = async_channel::bounded(1);
let sess = Arc::new(Session {
thread_id,
item_id_generator,
context_ids,
agent_runtime,
outcome_reporting,
installation_id,
+14 -16
View File
@@ -3,6 +3,7 @@ use crate::agent::LocalAgentControl;
use codex_mcp::McpServerKey;
use codex_protocol::ContextWindowId;
use codex_protocol::RequestCountry;
use codex_thread_context_ids_test_support::thread_context_ids;
use codex_thread_store::ThreadPersistenceMetadata;
#[path = "compaction_replay_tests.rs"]
mod compaction_replay_tests;
@@ -865,7 +866,7 @@ fn test_model_client_session() -> crate::client::ModelClientSession {
),
AgentIdentityAuthPolicy::JwtOnly,
thread_id,
codex_protocol_test_support::uuid_v7_item_id_generator_for_test(),
thread_context_ids(),
codex_protocol::protocol::SessionSource::Exec,
"test_originator".to_string(),
/*model_verbosity*/ None,
@@ -2414,13 +2415,10 @@ async fn record_conversation_items_stamps_missing_turn_id_and_preserves_existing
#[tokio::test]
async fn record_response_item_and_emit_turn_item_emits_hook_prompt_lifecycle() {
let (session, turn_context, rx) = make_session_and_context_with_rx().await;
let response_item = build_hook_prompt_message(
&[HookPromptFragment::from_single_hook(
"Retry with tests.",
"hook-run-1",
)],
&session.item_id_generator,
)
let response_item = build_hook_prompt_message(&[HookPromptFragment::from_single_hook(
"Retry with tests.",
"hook-run-1",
)])
.expect("hook prompt message");
session
@@ -6679,7 +6677,7 @@ pub(crate) async fn make_session_and_context() -> (Session, TurnContext) {
config.model_provider.clone(),
);
let agent_control = LocalAgentControl::default();
let item_id_generator = Session::new_item_id_generator();
let context_ids = thread_context_ids();
let exec_policy = Arc::new(ExecPolicyManager::default());
let (agent_status_tx, _agent_status_rx) = watch::channel(AgentStatus::PendingInit);
let model = get_model_offline_for_tests(config.model.as_deref());
@@ -6756,7 +6754,7 @@ pub(crate) async fn make_session_and_context() -> (Session, TurnContext) {
&config.features,
config.guardian_reuses_parent_compaction(),
config.guardian_context_budgeting(),
Arc::clone(&item_id_generator),
context_ids.clone(),
);
let (environment_manager, resolved_environments) =
resolved_environments_for_configuration(&session_configuration, &default_environments)
@@ -6876,7 +6874,7 @@ pub(crate) async fn make_session_and_context() -> (Session, TurnContext) {
),
AgentIdentityAuthPolicy::JwtOnly,
thread_id,
Arc::clone(&item_id_generator),
context_ids.clone(),
session_configuration.session_source.clone(),
session_configuration.originator.clone(),
config.model_verbosity,
@@ -6908,7 +6906,7 @@ pub(crate) async fn make_session_and_context() -> (Session, TurnContext) {
let session = Session {
thread_id,
item_id_generator,
context_ids,
agent_runtime: crate::agent::host::AgentRuntimeServices::Controller,
outcome_reporting: None,
installation_id: "11111111-1111-4111-8111-111111111111".to_string(),
@@ -9038,7 +9036,7 @@ where
config.model_provider.clone(),
);
let agent_control = LocalAgentControl::default();
let item_id_generator = Session::new_item_id_generator();
let context_ids = thread_context_ids();
let exec_policy = Arc::new(ExecPolicyManager::default());
let (agent_status_tx, _agent_status_rx) = watch::channel(AgentStatus::PendingInit);
let model = get_model_offline_for_tests(config.model.as_deref());
@@ -9115,7 +9113,7 @@ where
&config.features,
config.guardian_reuses_parent_compaction(),
config.guardian_context_budgeting(),
Arc::clone(&item_id_generator),
context_ids.clone(),
);
let (environment_manager, resolved_turn_environments) =
resolved_environments_for_configuration(&session_configuration, &default_environments)
@@ -9234,7 +9232,7 @@ where
),
AgentIdentityAuthPolicy::JwtOnly,
thread_id,
Arc::clone(&item_id_generator),
context_ids.clone(),
session_configuration.session_source.clone(),
session_configuration.originator.clone(),
config.model_verbosity,
@@ -9266,7 +9264,7 @@ where
let session = Arc::new(Session {
thread_id,
item_id_generator,
context_ids,
agent_runtime: crate::agent::host::AgentRuntimeServices::Controller,
outcome_reporting: None,
installation_id: "11111111-1111-4111-8111-111111111111".to_string(),
+4 -5
View File
@@ -894,10 +894,9 @@ pub(crate) async fn run_turn(
));
}
if stop_outcome.should_block {
if let Some(hook_prompt_message) = build_hook_prompt_message(
&stop_outcome.continuation_fragments,
&sess.item_id_generator,
) {
if let Some(hook_prompt_message) =
build_hook_prompt_message(&stop_outcome.continuation_fragments)
{
sess.record_response_item_and_emit_turn_item(
&turn_context,
&step_context.settings.model_info,
@@ -1279,7 +1278,7 @@ pub(crate) async fn merge_submitted_context(
context.0.clone(),
sess.additional_context_format(),
&turn_context.session_telemetry,
&sess.item_id_generator,
&sess.context_ids,
);
items
.into_iter()
+1 -1
View File
@@ -871,7 +871,7 @@ impl Session {
)]),
self.additional_context_format(),
&task.turn_context.session_telemetry,
&self.item_id_generator,
&self.context_ids,
);
if !input.is_empty() {
self.input_queue
@@ -14,10 +14,10 @@ use codex_otel::ADDITIONAL_CONTEXT_COUNT_METRIC;
use codex_otel::ADDITIONAL_CONTEXT_VALUE_BYTES_BUCKETS;
use codex_otel::ADDITIONAL_CONTEXT_VALUE_BYTES_METRIC;
use codex_otel::SessionTelemetry;
use codex_protocol::ItemIdGenerator;
use codex_protocol::ResponseItemId;
use codex_protocol::protocol::AdditionalContextEntry;
use codex_protocol::protocol::AdditionalContextKind;
use codex_thread_context_ids::ThreadContextIds;
use codex_utils_string::truncate_middle_with_token_budget;
pub(crate) enum AdditionalContextFormat {
@@ -92,10 +92,10 @@ impl AdditionalContextStore {
values: BTreeMap<String, AdditionalContextEntry>,
format: AdditionalContextFormat,
telemetry: &SessionTelemetry,
item_id_generator: &ItemIdGenerator,
context_ids: &ThreadContextIds,
) -> Vec<ResponseItemEnvelope> {
self.values.retain(|key, _| values.contains_key(key));
self.extend(values, format, telemetry, item_id_generator)
self.extend(values, format, telemetry, context_ids)
}
/// Adds a producer's updates without dropping unrelated client context.
@@ -104,7 +104,7 @@ impl AdditionalContextStore {
values: BTreeMap<String, AdditionalContextEntry>,
format: AdditionalContextFormat,
telemetry: &SessionTelemetry,
item_id_generator: &ItemIdGenerator,
context_ids: &ThreadContextIds,
) -> Vec<ResponseItemEnvelope> {
let mut fragments = Vec::new();
for (key, entry) in values {
@@ -121,7 +121,7 @@ impl AdditionalContextStore {
let Some(prefix) = envelope.id_prefix() else {
unreachable!("additional context has an item ID")
};
let id = item_id_generator(prefix);
let id = context_ids.next_item(prefix);
envelope.set_id(Some(id.clone()));
self.values.insert(key, (value, id));
fragments.push(envelope);
@@ -1,9 +1,5 @@
use codex_protocol::ContextWindowId;
use codex_protocol::protocol::TokenUsage;
use std::sync::Arc;
/// Allocates context window IDs. Clones share the same allocator.
pub(crate) type ContextWindowIdGenerator = Arc<dyn Fn() -> ContextWindowId + Send + Sync>;
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct AutoCompactWindowIds {
-1
View File
@@ -10,7 +10,6 @@ pub(crate) use additional_context::AdditionalContextFormat;
pub(crate) use additional_context::AdditionalContextStore;
pub(crate) use auto_compact_window::AutoCompactWindowIds;
pub(crate) use auto_compact_window::AutoCompactWindowSnapshot;
pub(crate) use auto_compact_window::ContextWindowIdGenerator;
pub(crate) use service::SessionServices;
pub(crate) use session::ReasoningEffortPin;
pub(crate) use session::SessionState;
+4 -10
View File
@@ -15,7 +15,6 @@ use super::AdditionalContextStore;
use super::auto_compact_window::AutoCompactWindow;
use super::auto_compact_window::AutoCompactWindowIds;
use super::auto_compact_window::AutoCompactWindowSnapshot;
use super::auto_compact_window::ContextWindowIdGenerator;
use crate::TurnStartOptions;
use crate::agent::host::ServiceTierAcceptance;
use crate::config::Config;
@@ -110,7 +109,6 @@ pub(crate) struct SessionState {
pub(crate) restored_turn_routing: Option<(String, Vec<String>)>,
/// Runtime accounting state for the active auto-compaction window.
auto_compact_window: AutoCompactWindow,
context_window_id_generator: ContextWindowIdGenerator,
pub(crate) async_compaction: crate::session::async_compaction::AsyncCompactionState,
/// Original request effort for the current model while configuration updates remain active.
pub(crate) reasoning_effort_pin: ReasoningEffortPin,
@@ -131,20 +129,17 @@ impl SessionState {
/// Create a new session state mirroring previous `State::default()` semantics.
#[cfg(test)]
pub(crate) fn new(session_configuration: SessionConfiguration) -> Self {
let context_window_id_generator: ContextWindowIdGenerator =
Arc::new(codex_protocol::ContextWindowId::new_uuid_v7);
let history = ContextManager::default();
Self::new_with_auto_compact_window_ids(
session_configuration,
AutoCompactWindowIds::new_initial(context_window_id_generator()),
context_window_id_generator,
ContextManager::default(),
AutoCompactWindowIds::new_initial(history.context_ids().next_window()),
history,
)
}
pub(crate) fn new_with_auto_compact_window_ids(
session_configuration: SessionConfiguration,
auto_compact_window_ids: AutoCompactWindowIds,
context_window_id_generator: ContextWindowIdGenerator,
history: ContextManager,
) -> Self {
Self {
@@ -167,7 +162,6 @@ impl SessionState {
turn_attribution: None,
restored_turn_routing: None,
auto_compact_window: AutoCompactWindow::new_with_ids(auto_compact_window_ids),
context_window_id_generator,
async_compaction: crate::session::async_compaction::AsyncCompactionState::default(),
reasoning_effort_pin: ReasoningEffortPin::Unset,
shutting_down: false,
@@ -386,7 +380,7 @@ impl SessionState {
pub(crate) fn advance_auto_compact_window(&mut self) -> (u64, AutoCompactWindowIds) {
self.auto_compact_window
.advance((self.context_window_id_generator)())
.advance(self.history.context_ids().next_window())
}
pub(crate) fn request_new_context_window(&mut self) {
+2 -2
View File
@@ -241,7 +241,7 @@ pub(crate) async fn exit_review_mode(
&[ResponseItem::Message {
status: None,
encrypted_content: None,
id: Some((session.item_id_generator)("msg")),
id: Some(session.context_ids.next_item("msg")),
role: "user".to_string(),
content: vec![ContentItem::InputText { text: user_message }],
phase: None,
@@ -263,7 +263,7 @@ pub(crate) async fn exit_review_mode(
ResponseItem::Message {
status: None,
encrypted_content: None,
id: Some((session.item_id_generator)("msg")),
id: Some(session.context_ids.next_item("msg")),
role: "assistant".to_string(),
content: vec![ContentItem::OutputText {
annotations: None,
@@ -692,7 +692,7 @@ impl ExecutedToolCalls {
&self,
item: &mut ResponseItem,
prepared: Option<(ExecutedToolCall, DirectCallPermit)>,
item_id_generator: &codex_protocol::ItemIdGenerator,
context_ids: &codex_thread_context_ids::ThreadContextIds,
) {
let Some((mut call, permit)) = prepared else {
if self.captures_result_bodies
@@ -703,7 +703,7 @@ impl ExecutedToolCalls {
&& cell.truncated_metadata_binding_valid
{
// Bind nested results to the actual exec/wait output before history projection.
crate::session::assign_missing_item_id(item, item_id_generator);
crate::session::assign_missing_item_id(item, context_ids);
cell.output_item_id = item.id().cloned();
}
return;
@@ -717,7 +717,7 @@ impl ExecutedToolCalls {
{
return;
}
crate::session::assign_missing_item_id(item, item_id_generator);
crate::session::assign_missing_item_id(item, context_ids);
let keep_live_call = !self.captures_result_bodies
|| state.direct_calls.len() < MAX_PENDING_EXECUTED_TOOL_CALLS
|| item
@@ -5,6 +5,7 @@ use codex_protocol::models::ToolResultMetadata;
use codex_protocol::protocol::SessionMeta;
use codex_protocol::protocol::SessionMetaLine;
use codex_protocol::protocol::ThreadHistoryMode;
use codex_thread_context_ids_test_support::thread_context_ids;
use pretty_assertions::assert_eq;
use serde_json::json;
@@ -228,7 +229,7 @@ async fn capture_only_request_metadata_preserves_late_bindings_and_restores_full
recorder.attach_direct_call_to_output(
&mut output,
/*prepared*/ None,
&codex_protocol_test_support::uuid_v7_item_id_generator_for_test(),
&thread_context_ids(),
);
let mut items = [exec_input("exec"), output];
let history = items.clone();
@@ -324,7 +325,7 @@ fn large_direct_and_code_mode_metadata_survive_sampling_and_compaction() {
recorder.attach_direct_call_to_output(
&mut direct,
Some((direct_call, recorder.reserve_direct_call().unwrap())),
&codex_protocol_test_support::uuid_v7_item_id_generator_for_test(),
&thread_context_ids(),
);
assert!(direct.executed_tool_call_metadata().is_none());
@@ -396,7 +397,7 @@ fn failed_compaction_preserves_observations_absent_from_trimmed_retries() {
recorder.attach_direct_call_to_output(
&mut direct,
Some((direct_call, recorder.reserve_direct_call().unwrap())),
&codex_protocol_test_support::uuid_v7_item_id_generator_for_test(),
&thread_context_ids(),
);
assert!(direct.executed_tool_call_metadata().is_none());
let mut history = vec![direct.clone()];
@@ -452,7 +453,7 @@ fn compaction_keeps_direct_outputs_in_code_mode_binding_validation() {
recorder.attach_direct_call_to_output(
&mut direct,
Some((call.clone(), recorder.reserve_direct_call().unwrap())),
&codex_protocol_test_support::uuid_v7_item_id_generator_for_test(),
&thread_context_ids(),
);
let mut compact = vec![exec_input("exec"), exec_output("exec"), direct.clone()];
recorder.attach_to_compaction_prompt(&mut compact);
@@ -475,7 +476,7 @@ fn direct_retained_metadata_budget_sheds_results_then_calls_across_refresh() {
recorder.attach_direct_call_to_output(
&mut first,
Some((call.clone(), recorder.reserve_direct_call().unwrap())),
&codex_protocol_test_support::uuid_v7_item_id_generator_for_test(),
&thread_context_ids(),
);
let mut expected_first = output("first");
expected_first.set_id(first.id().cloned());
@@ -511,7 +512,7 @@ fn direct_retained_metadata_budget_sheds_results_then_calls_across_refresh() {
recorder.clone().attach_direct_call_to_output(
&mut resource_only_output,
Some((call.clone(), recorder.reserve_direct_call().unwrap())),
&codex_protocol_test_support::uuid_v7_item_id_generator_for_test(),
&thread_context_ids(),
);
expected_resource_only.set_id(resource_only_output.id().cloned());
assert_eq!(resource_only_output, expected_resource_only);
@@ -536,7 +537,7 @@ fn direct_retained_metadata_budget_sheds_results_then_calls_across_refresh() {
recorder.clone().attach_direct_call_to_output(
&mut second,
Some((call.clone(), recorder.reserve_direct_call().unwrap())),
&codex_protocol_test_support::uuid_v7_item_id_generator_for_test(),
&thread_context_ids(),
);
let mut expected_second = output("second");
expected_second.set_id(second.id().cloned());
@@ -576,7 +577,7 @@ fn direct_retained_metadata_budget_sheds_results_then_calls_across_refresh() {
recorder.attach_direct_call_to_output(
&mut third,
Some((call, recorder.reserve_direct_call().unwrap())),
&codex_protocol_test_support::uuid_v7_item_id_generator_for_test(),
&thread_context_ids(),
);
assert!(third.executed_tool_call_metadata().is_none());
assert_eq!(
@@ -689,18 +690,14 @@ async fn recorder_refreshes_without_changing_execution_features_or_claiming_miss
calls.attach_direct_call_to_output(
&mut stale_output,
Some(stale),
&session.item_id_generator,
&session.context_ids,
);
assert!(stale_output.executed_tool_call_metadata().is_none());
}
prior_generation = calls.prepare_direct_call(&call, &ToolCallSource::Direct, &step);
}
let mut direct_output = output(&call.call_id);
calls.attach_direct_call_to_output(
&mut direct_output,
prepared,
&session.item_id_generator,
);
calls.attach_direct_call_to_output(&mut direct_output, prepared, &session.context_ids);
assert_eq!(
direct_output
.executed_tool_call_metadata()
@@ -722,7 +719,7 @@ async fn recorder_refreshes_without_changing_execution_features_or_claiming_miss
let mut replay = output(&call.call_id);
// Replay the same history item across the configuration refresh.
replay.set_id(direct_output.id().cloned());
calls.attach_direct_call_to_output(&mut replay, prepared, &session.item_id_generator);
calls.attach_direct_call_to_output(&mut replay, prepared, &session.context_ids);
assert_eq!(
replay.executed_tool_call_metadata(),
direct_output.executed_tool_call_metadata()
@@ -1428,7 +1425,7 @@ async fn nested_result_budget_reopens_after_binding_loss(invalidate_origin: bool
recorder.attach_direct_call_to_output(
&mut output,
/*prepared*/ None,
&codex_protocol_test_support::uuid_v7_item_id_generator_for_test(),
&thread_context_ids(),
);
[exec_input(id), output]
};
@@ -1497,7 +1494,7 @@ async fn result_metadata_updates_the_exact_retained_call_and_preserves_large_ret
recorder.attach_direct_call_to_output(
&mut history[1],
/*prepared*/ None,
&codex_protocol_test_support::uuid_v7_item_id_generator_for_test(),
&thread_context_ids(),
);
assert!(recorder.attach_pending_to_prompt(&mut history.clone(), &mut retry_cache));
@@ -9,6 +9,7 @@ use codex_login::ExternalAuthRefreshContext;
use codex_protocol::ResponseItemId;
use codex_protocol::models::FunctionCallOutputPayload;
use codex_protocol::models::ResponseInputItem;
use codex_thread_context_ids_test_support::thread_context_ids;
use pretty_assertions::assert_eq;
use serde_json::json;
@@ -38,7 +39,7 @@ fn capture_only_does_not_publish_general_direct_metadata_after_refresh() {
recorder.attach_direct_call_to_output(
&mut item,
Some((call.clone(), permit)),
&codex_protocol_test_support::uuid_v7_item_id_generator_for_test(),
&thread_context_ids(),
);
if enabled {
assert_eq!(
@@ -69,7 +70,7 @@ fn direct_request_uses_live_window_after_persisted_budget_is_exhausted() {
recorder.attach_direct_call_to_output(
&mut item,
Some((call, recorder.reserve_direct_call().unwrap())),
&codex_protocol_test_support::uuid_v7_item_id_generator_for_test(),
&thread_context_ids(),
);
item
};
@@ -156,7 +157,7 @@ async fn direct_result_body_budget_reopens_when_the_output_is_lost(available: us
recorder.attach_direct_call_to_output(
&mut item,
Some((call, recorder.reserve_direct_call().unwrap())),
&codex_protocol_test_support::uuid_v7_item_id_generator_for_test(),
&thread_context_ids(),
);
item
};
@@ -253,7 +254,7 @@ async fn direct_result_bodies_require_the_originating_output_turn_and_owner(
recorder.attach_direct_call_to_output(
&mut item,
Some((call, recorder.reserve_direct_call().unwrap())),
&codex_protocol_test_support::uuid_v7_item_id_generator_for_test(),
&thread_context_ids(),
);
item
};
@@ -358,7 +359,7 @@ fn direct_metadata_follows_output_ids_with_reused_call_ids_and_reverse_completio
recorder.attach_direct_call_to_output(
&mut outputs[index],
prepared[index].take(),
&codex_protocol_test_support::uuid_v7_item_id_generator_for_test(),
&thread_context_ids(),
);
assert!(outputs[index].executed_tool_call_metadata().is_none());
if supplied_ids {
@@ -421,7 +422,7 @@ fn direct_budget_keeps_an_omission_marker_when_it_fits() {
recorder.attach_direct_call_to_output(
&mut item,
Some((call, recorder.reserve_direct_call().unwrap())),
&codex_protocol_test_support::uuid_v7_item_id_generator_for_test(),
&thread_context_ids(),
);
expected.set_id(item.id().cloned());
@@ -460,11 +461,7 @@ async fn direct_pending_limit_releases_on_completion_or_dropped_future() {
let cloned = recorder.clone();
let mut overflow = output("overflow");
let before = serde_json::to_value(&overflow).expect("serializable output");
cloned.attach_direct_call_to_output(
&mut overflow,
prepare(&cloned),
&codex_protocol_test_support::uuid_v7_item_id_generator_for_test(),
);
cloned.attach_direct_call_to_output(&mut overflow, prepare(&cloned), &thread_context_ids());
assert_eq!(
serde_json::to_value(&overflow).expect("serializable output"),
before,
@@ -481,11 +478,7 @@ async fn direct_pending_limit_releases_on_completion_or_dropped_future() {
assert!(prepare(&recorder).is_none());
let mut completed = output("completed");
recorder.attach_direct_call_to_output(
&mut completed,
pending.pop(),
&codex_protocol_test_support::uuid_v7_item_id_generator_for_test(),
);
recorder.attach_direct_call_to_output(&mut completed, pending.pop(), &thread_context_ids());
assert_eq!(
completed
.executed_tool_call_metadata()
@@ -498,11 +491,7 @@ async fn direct_pending_limit_releases_on_completion_or_dropped_future() {
recorder.refresh(&features);
assert!(prepare(&recorder).is_none());
let mut stale = output("stale");
recorder.attach_direct_call_to_output(
&mut stale,
Some(replacement),
&codex_protocol_test_support::uuid_v7_item_id_generator_for_test(),
);
recorder.attach_direct_call_to_output(&mut stale, Some(replacement), &thread_context_ids());
assert!(stale.id().is_none());
assert!(stale.executed_tool_call_metadata().is_none());
let current = prepare(&recorder).expect("stale call released its slot");
@@ -510,7 +499,7 @@ async fn direct_pending_limit_releases_on_completion_or_dropped_future() {
recorder.attach_direct_call_to_output(
&mut current_output,
Some(current),
&codex_protocol_test_support::uuid_v7_item_id_generator_for_test(),
&thread_context_ids(),
);
assert_eq!(
current_output
@@ -547,7 +536,7 @@ async fn direct_recording_preserves_encoded_arguments_in_history() {
recorder.attach_direct_call_to_output(
&mut item,
recorder.prepare_direct_call(&call, &ToolCallSource::Direct, &step),
&codex_protocol_test_support::uuid_v7_item_id_generator_for_test(),
&thread_context_ids(),
);
let wire = serde_json::to_value(&item).unwrap();
assert_eq!(wire["output"], ordinary_output);
+2 -6
View File
@@ -158,7 +158,7 @@ impl ToolCallRuntime {
.features
.enabled(codex_features::Feature::FileBackedToolAudio);
let recorder = self.session.services.executed_tool_calls.clone();
let item_id_generator = Arc::clone(&self.session.item_id_generator);
let context_ids = self.session.context_ids.clone();
let recorded_call = recorder.prepare_direct_call(&call, &source, &self.step_context);
let step_context = Arc::clone(&self.step_context);
let call_state = Arc::new(ToolCallState::default());
@@ -191,11 +191,7 @@ impl ToolCallRuntime {
.get_or_insert_default()
.delivered_assistant_message = Some(text.clone());
}
recorder.attach_direct_call_to_output(
&mut response.item,
recorded_call,
&item_id_generator,
);
recorder.attach_direct_call_to_output(&mut response.item, recorded_call, &context_ids);
Ok(response)
}
}
+4 -4
View File
@@ -17,7 +17,7 @@ use codex_protocol::models::ContentItem;
use codex_protocol::models::ResponseItem;
use codex_protocol::protocol::SessionSource;
use codex_protocol::protocol::SubAgentSource;
use codex_protocol_test_support::uuid_v7_item_id_generator_for_test;
use codex_thread_context_ids_test_support::thread_context_ids;
use core_test_support::TestCodexResponsesRequestKind;
use core_test_support::load_default_config_for_test;
use core_test_support::responses;
@@ -133,7 +133,7 @@ async fn responses_stream_includes_subagent_header_on_review() {
codex_model_provider::create_model_provider(provider.clone(), /*auth_manager*/ None),
AgentIdentityAuthPolicy::JwtOnly,
thread_id,
uuid_v7_item_id_generator_for_test(),
thread_context_ids(),
session_source.clone(),
"test_originator".to_string(),
config.model_verbosity,
@@ -283,7 +283,7 @@ async fn responses_stream_includes_subagent_header_on_other() {
codex_model_provider::create_model_provider(provider.clone(), /*auth_manager*/ None),
AgentIdentityAuthPolicy::JwtOnly,
thread_id,
uuid_v7_item_id_generator_for_test(),
thread_context_ids(),
session_source.clone(),
"test_originator".to_string(),
config.model_verbosity,
@@ -418,7 +418,7 @@ async fn responses_respects_model_info_overrides_from_config() {
codex_model_provider::create_model_provider(provider.clone(), /*auth_manager*/ None),
AgentIdentityAuthPolicy::JwtOnly,
thread_id,
uuid_v7_item_id_generator_for_test(),
thread_context_ids(),
session_source.clone(),
"test_originator".to_string(),
config.model_verbosity,
+3 -3
View File
@@ -64,7 +64,7 @@ use codex_protocol::protocol::SessionMetaLine;
use codex_protocol::protocol::SessionSource;
use codex_protocol::protocol::ThreadSettingsOverrides;
use codex_protocol::user_input::UserInput;
use codex_protocol_test_support::uuid_v7_item_id_generator_for_test;
use codex_thread_context_ids_test_support::thread_context_ids;
use core_test_support::TestCodexResponsesRequestKind;
use core_test_support::apps_test_server::AppsTestServer;
use core_test_support::load_default_config_for_test;
@@ -1977,7 +1977,7 @@ async fn send_request_with_provider(provider: ModelProviderInfo) {
),
AgentIdentityAuthPolicy::JwtOnly,
thread_id,
uuid_v7_item_id_generator_for_test(),
thread_context_ids(),
SessionSource::Exec,
"test_originator".to_string(),
config.model_verbosity,
@@ -3679,7 +3679,7 @@ async fn azure_responses_request_does_not_store_and_preserves_prefixed_item_ids(
codex_model_provider::create_model_provider(provider.clone(), /*auth_manager*/ None),
AgentIdentityAuthPolicy::JwtOnly,
thread_id,
uuid_v7_item_id_generator_for_test(),
thread_context_ids(),
SessionSource::Exec,
"test_originator".to_string(),
config.model_verbosity,
@@ -3135,7 +3135,7 @@ async fn websocket_harness_with_provider_factory(
provider_factory(provider.clone(), client_auth_manager),
AgentIdentityAuthPolicy::JwtOnly,
thread_id,
codex_protocol_test_support::uuid_v7_item_id_generator_for_test(),
codex_thread_context_ids_test_support::thread_context_ids(),
SessionSource::Exec,
"test_originator".to_string(),
config.model_verbosity,
@@ -13,6 +13,7 @@ path = "src/lib.rs"
workspace = true
[dependencies]
codex-thread-context-ids = { workspace = true }
anyhow = { workspace = true }
codex-analytics = { workspace = true }
codex-context-fragments = { workspace = true }
@@ -1,7 +1,7 @@
//! Selects Guardian answer evidence from the review's history snapshot and retains reviews.
//! Retained answers survive restart even while incompatible checkpoints use legacy review.
use codex_protocol::ItemIdGenerator;
use codex_thread_context_ids::ThreadContextIds;
use std::collections::BTreeSet;
use std::collections::VecDeque;
use std::sync::Arc;
@@ -184,14 +184,14 @@ impl GuardianReviewEvidence {
authorization_version: GuardianAuthorizationVersion,
review_context_revision: u64,
root_versions: Option<(GuardianAuthorizationVersion, u64)>,
item_id_generator: &ItemIdGenerator,
context_ids: &ThreadContextIds,
) {
let Some(completed_at_ms) = assessment.completed_at_ms else {
return;
};
let (root_authorization_version, root_review_context_revision) = root_versions.unzip();
let review = Arc::new(GuardianReviewEvidenceRecord {
delivery_id: item_id_generator("guardian_review"),
delivery_id: context_ids.next_item("guardian_review"),
completed_at_ms,
authorization_version,
review_context_revision,
+2
View File
@@ -13,6 +13,7 @@ doctest = false
workspace = true
[dependencies]
codex-thread-context-ids = { workspace = true }
codex-agent-identity = { workspace = true }
codex-runtime-agent-instance = { workspace = true }
anyhow = { workspace = true }
@@ -41,6 +42,7 @@ tracing = { workspace = true }
uuid = { workspace = true }
[dev-dependencies]
codex-thread-context-ids-test-support = { workspace = true }
base64 = { workspace = true }
codex-model-provider-info = { workspace = true }
codex-protocol-test-support = { workspace = true }
@@ -322,7 +322,7 @@ impl Classification {
// Retries keep the classification's inference turn identity.
let request_turn_id = Uuid::now_v7();
let sampling = LunaSamplingRequest {
item_id_generator: Arc::clone(thread.item_id_generator()),
context_ids: thread.context_ids().clone(),
cyber_access_program,
parent_response_id,
instructions,
@@ -63,7 +63,7 @@ use codex_protocol::protocol::ReviewDecision;
use codex_protocol::protocol::SessionSource;
use codex_protocol::protocol::TruncationPolicy;
use codex_protocol::security_risk::SecurityRiskScore;
use codex_protocol_test_support::uuid_v7_item_id_generator_for_test;
use codex_thread_context_ids_test_support::thread_context_ids;
use core_test_support::ThreadIdle;
use core_test_support::apps_test_server::HostedMessagingServer;
use core_test_support::responses;
@@ -507,7 +507,7 @@ fn user_instruction(text: &str) -> ResponseItem {
ResponseItem::Message {
status: None,
encrypted_content: None,
id: Some(uuid_v7_item_id_generator_for_test()("msg")),
id: Some(thread_context_ids().next_item("msg")),
role: "user".to_owned(),
content: vec![ContentItem::InputText {
text: text.to_owned(),
@@ -2490,7 +2490,7 @@ async fn contributor_samples_tool_calls_with_the_existing_luna_pool() -> Result<
ResponseItem::Message {
status: None,
encrypted_content: None,
id: Some(uuid_v7_item_id_generator_for_test()("assistant")),
id: Some(thread_context_ids().next_item("assistant")),
role: "assistant".to_owned(),
content: vec![ContentItem::OutputText {
annotations: None,
@@ -71,7 +71,7 @@ impl LunaSamplingRequest {
.ok()?
.prepare_delivery(history)
.ok()?;
let ids = ReservedElasticItemIds::reserve(&prepared, &self.item_id_generator);
let ids = ReservedElasticItemIds::reserve(&prepared, &self.context_ids);
context = prepared
.enforce_budget(
RequestBudget {
@@ -74,22 +74,27 @@ fn collect(
.unwrap()
}
fn native_message(ciphertext: &str) -> ResponseItem {
ResponseItem::AgentMessage {
id: None,
author: "/root".to_owned(),
recipient: "/root/worker".to_owned(),
content: vec![
codex_protocol::models::AgentMessageInputContent::EncryptedContent {
encrypted_content: ciphertext.to_owned(),
},
],
internal_chat_message_metadata_passthrough: None,
}
}
#[test_case::test_case(ContextBudgeting::Fixed; "fixed")]
#[test_case::test_case(ContextBudgeting::Elastic; "elastic")]
fn preparation_preserves_committed_prefix_and_selects_only_new_entries_and_images(
mode: ContextBudgeting,
) {
let native = ResponseItem::AgentMessage {
id: Some(ResponseItemId::from_server("amsg_parent".to_owned())),
author: "/root".to_owned(),
recipient: "/root/worker".to_owned(),
content: vec![
codex_protocol::models::AgentMessageInputContent::EncryptedContent {
encrypted_content: "opaque-parent-restriction".to_owned(),
},
],
internal_chat_message_metadata_passthrough: None,
};
let mut native = native_message("opaque-parent-restriction");
native.set_id(Some(ResponseItemId::from_server("amsg_parent".to_owned())));
let images = [
ImageReference::Inline {
image_url: "data:image/png;base64,Zmlyc3Q=".to_owned(),
@@ -283,14 +288,8 @@ fn rejected_preparation_preserves_committed_history_and_cursor(mode: ContextBudg
#[test]
fn elastic_fits_ids_without_resetting_committed_history() {
const ID_PADDING_BYTES: usize = 1_024;
let mode = ContextBudgeting::Elastic;
let mut config = sample_request("parent");
let original_generator = std::sync::Arc::clone(&config.item_id_generator);
let padding = "x".repeat(ID_PADDING_BYTES);
config.item_id_generator = std::sync::Arc::new(move |prefix| {
ResponseItemId::from_server(format!("{}{padding}", original_generator(prefix)))
});
let config = sample_request("parent");
let mut history = History {
items: vec![responses::user_message_item("Inspect README.md.")],
version: 1,
@@ -304,6 +303,10 @@ fn elastic_fits_ids_without_resetting_committed_history() {
history
.items
.push(responses::user_message_item("Inspect LICENSE next."));
// Reserve enough real IDs for their combined cost to affect image admission.
history
.items
.extend((0..16).map(|index| native_message(&format!("instruction-{index}"))));
let image = ContentItem::InputImage {
image: ImageReference::Inline {
image_url: "data:image/png;base64,b3B0aW9uYWw=".to_owned(),
@@ -82,7 +82,7 @@ pub struct LunaSamplerConfig {
/// One tool-less Luna classification request.
pub struct LunaSamplingRequest {
/// Generator selected by the owning session for response items.
pub item_id_generator: codex_protocol::ItemIdGenerator,
pub context_ids: codex_thread_context_ids::ThreadContextIds,
/// Cyber selection captured from the owning turn; Daybreak reviews use Blue.
pub cyber_access_program: Option<CyberAccessProgram>,
/// ID of the response handling the classified tool.
@@ -251,7 +251,7 @@ impl LunaSampler {
if item.id().is_none()
&& let Some(prefix) = item.id_prefix()
{
item.set_id(Some((request.item_id_generator)(prefix)));
item.set_id(Some(request.context_ids.next_item(prefix)));
}
}
}
@@ -25,7 +25,7 @@ use codex_protocol::models::ResponseItem;
use codex_protocol::openai_models::ReasoningEffort;
use codex_protocol::protocol::SessionSource;
use codex_protocol::turn_input::CyberAccessProgram;
use codex_protocol_test_support::uuid_v7_item_id_generator_for_test;
use codex_thread_context_ids_test_support::thread_context_ids;
use core_test_support::responses;
use core_test_support::responses::WebSocketConnectionConfig;
use core_test_support::responses::ev_assistant_message;
@@ -310,7 +310,7 @@ fn assert_classifier_instructions(request: &serde_json::Value) {
pub(in crate::async_scorer) fn sample_request(parent_turn_id: &str) -> LunaSamplingRequest {
LunaSamplingRequest {
item_id_generator: uuid_v7_item_id_generator_for_test(),
context_ids: thread_context_ids(),
cyber_access_program: None,
parent_response_id: None,
instructions: classifier_instructions(),
@@ -711,7 +711,7 @@ async fn preconnected_sampler_reuses_authenticated_websocket_for_classifications
let first = sampler
.sample(LunaSamplingRequest {
item_id_generator: uuid_v7_item_id_generator_for_test(),
context_ids: thread_context_ids(),
cyber_access_program: None,
parent_response_id: None,
instructions: classifier_instructions(),
@@ -759,7 +759,7 @@ async fn preconnected_sampler_reuses_authenticated_websocket_for_classifications
sampler.prewarm().await;
let second = sampler
.sample(LunaSamplingRequest {
item_id_generator: uuid_v7_item_id_generator_for_test(),
context_ids: thread_context_ids(),
cyber_access_program: None,
parent_response_id: None,
instructions: classifier_instructions(),
@@ -100,7 +100,7 @@ impl HousekeeperSampler {
)],
);
if let Some(prefix) = instructions.id_prefix() {
instructions.set_id(Some((parent.item_id_generator())(prefix)));
instructions.set_id(Some(parent.context_ids().next_item(prefix)));
}
Ok(Self {
parent: Arc::downgrade(parent),
@@ -152,7 +152,7 @@ impl HousekeeperSampler {
let (input, schema, input_tokens, history_budget) = loop {
let (mut input, schema) = build_request(count)?;
if let Some(prefix) = input.id_prefix() {
let id = item_id.get_or_insert_with(|| (parent.item_id_generator())(prefix));
let id = item_id.get_or_insert_with(|| parent.context_ids().next_item(prefix));
input.set_id(Some(id.clone()));
}
let fixed_tokens =
+2
View File
@@ -16,10 +16,12 @@ workspace = true
codex-context-fragments = { workspace = true }
codex-history = { workspace = true }
codex-protocol = { workspace = true }
codex-thread-context-ids = { workspace = true }
codex-utils-output-truncation = { workspace = true }
serde = { workspace = true, features = ["derive"] }
serde_json = { workspace = true }
[dev-dependencies]
codex-thread-context-ids-test-support = { workspace = true }
codex-protocol-test-support = { workspace = true }
pretty_assertions = { workspace = true }
+11 -10
View File
@@ -22,10 +22,10 @@ use crate::budget::section_tokens;
use crate::composition::SectionDelivery;
use crate::composition::SectionOutput;
use codex_history::ResponseItemEnvelope;
use codex_protocol::ItemIdGenerator;
use codex_protocol::ResponseItemId;
use codex_protocol::models::ContentItem;
use codex_protocol::protocol::TruncationPolicy;
use codex_thread_context_ids::ThreadContextIds;
const REQUEST_BUDGET_EXCEEDED: SectionError = SectionError::EvidenceLimitExceeded {
section: "request_budget",
@@ -292,6 +292,13 @@ impl PreparedElasticContext<'_> {
const MESSAGE_ID_PREFIX: &str = "msg";
const ID_FIELD_FRAMING: &str = r#","id":"#;
fn id_token_budget(id: &ResponseItemId) -> usize {
// Measure the wire string, including escaping and the optional field framing.
let wire_bytes = ByteCount::measure(|counter| serde_json::to_writer(counter, id.as_str()))
.saturating_add(ID_FIELD_FRAMING.len());
TruncationPolicy::Bytes(wire_bytes).token_budget()
}
/// Actual IDs reserved for possible new messages and their conservative wire token cost.
pub struct ReservedElasticItemIds {
by_prefix: BTreeMap<&'static str, Vec<ResponseItemId>>,
@@ -301,21 +308,15 @@ pub struct ReservedElasticItemIds {
impl ReservedElasticItemIds {
/// Reserves IDs for the largest possible emitted suffix before dropping evidence.
/// Removing a native item can merge adjacent user messages, never split them.
pub fn reserve(prepared: &PreparedElasticContext<'_>, generate: &ItemIdGenerator) -> Self {
pub fn reserve(prepared: &PreparedElasticContext<'_>, context_ids: &ThreadContextIds) -> Self {
let mut reserved = Self {
by_prefix: BTreeMap::new(),
tokens: 0,
};
let mut has_user_content = false;
let mut reserve = |prefix| {
let id = generate(prefix);
// Measure the wire string, including escaping and the optional field framing.
let wire_bytes =
ByteCount::measure(|counter| serde_json::to_writer(counter, id.as_str()))
.saturating_add(ID_FIELD_FRAMING.len());
reserved.tokens = reserved
.tokens
.saturating_add(TruncationPolicy::Bytes(wire_bytes).token_budget());
let id = context_ids.next_item(prefix);
reserved.tokens = reserved.tokens.saturating_add(id_token_budget(&id));
reserved.by_prefix.entry(prefix).or_default().push(id);
};
for section in &prepared.context.sections {
@@ -6,12 +6,21 @@ use crate::estimate_input_tokens;
use codex_protocol::models::ImageReference;
use codex_protocol::models::ResponseItem;
use codex_protocol::models::input_text;
use codex_protocol_test_support::uuid_v7_item_id_generator_for_test;
use codex_thread_context_ids_test_support::thread_context_ids;
use pretty_assertions::assert_eq;
use std::sync::Arc;
#[test]
fn reserves_escaped_ids_for_user_messages_and_native_call_outputs() {
fn id_budget_accounts_for_json_escaping() {
let id = ResponseItemId::from_server("\"".repeat(32));
let wire = format!(r#","id":{}"#, serde_json::to_string(id.as_str()).unwrap());
assert_eq!(
id_token_budget(&id),
TruncationPolicy::Bytes(wire.len()).token_budget()
);
}
#[test]
fn reserves_ids_for_user_messages_and_native_call_outputs() {
let call: ResponseItem = serde_json::from_value(serde_json::json!({
"type": "function_call",
"id": "fc_committed",
@@ -44,10 +53,7 @@ fn reserves_escaped_ids_for_user_messages_and_native_call_outputs() {
config: &ElasticBudgetConfig::default(),
delivered_omissions: None,
};
let uuid = uuid_v7_item_id_generator_for_test();
let generator: ItemIdGenerator =
Arc::new(move |prefix| ResponseItemId::from_server(format!("{}\"\\", uuid(prefix))));
let reserved = ReservedElasticItemIds::reserve(&prepared, &generator);
let reserved = ReservedElasticItemIds::reserve(&prepared, &thread_context_ids());
let mut suffix = prepared.context.into_annotated_messages();
let measure = |items: &[ResponseItemEnvelope]| {
items
@@ -99,7 +99,7 @@ fn elastic_pending_action_defers_the_exact_call_to_final_admission() {
#[test]
fn delivery_preserves_arbitrary_message_boundaries_and_rejects_them_for_sync() {
let message = crate::PreviousReviews::try_from_fragments(vec![crate::PreviousReview {
id: codex_protocol_test_support::uuid_v7_item_id_generator_for_test()("review"),
id: codex_thread_context_ids_test_support::thread_context_ids().next_item("review"),
fragment: "host-attested review".into(),
}])
.unwrap()
@@ -403,7 +403,7 @@ fn planned_action_budget_omits_descriptions_without_changing_arguments() {
#[test]
fn budget_reserves_existing_context_and_preserves_required_messages() {
let trusted = crate::PreviousReviews::try_from_fragments(vec![crate::PreviousReview {
id: codex_protocol_test_support::uuid_v7_item_id_generator_for_test()("review"),
id: codex_thread_context_ids_test_support::thread_context_ids().next_item("review"),
fragment: "verified review".to_owned(),
}])
.unwrap()
@@ -207,7 +207,7 @@ fn reused_registry_preserves_section_identity_and_source_roles() {
];
let answers = ["assistant: Publish?\nuser: No.\n".to_string()];
let reviews = super::PreviousReviews::try_from_fragments(vec![super::PreviousReview {
id: codex_protocol_test_support::uuid_v7_item_id_generator_for_test()("review"),
id: codex_thread_context_ids_test_support::thread_context_ids().next_item("review"),
fragment: "<guardian_sync_review>debug-secret review</guardian_sync_review>".to_string(),
}])
.unwrap();
@@ -4,7 +4,7 @@ use codex_history::RetainedInputSource;
use codex_history::RetainedUserMessage;
use codex_history::VerifiedAnswer;
use codex_history::VerifiedQuestionAnswer;
use codex_protocol_test_support::uuid_v7_item_id_generator_for_test;
use codex_thread_context_ids_test_support::thread_context_ids;
use pretty_assertions::assert_eq;
#[test]
@@ -24,7 +24,7 @@ fn instructions_preserve_source_order_and_whole_records() {
},
acceptance_order: None,
},
&uuid_v7_item_id_generator_for_test(),
&thread_context_ids(),
);
context.record_user_message(
RetainedUserMessage {
@@ -36,7 +36,7 @@ fn instructions_preserve_source_order_and_whole_records() {
complete: true,
},
RetainedInputSource::Local(None),
&uuid_v7_item_id_generator_for_test(),
&thread_context_ids(),
);
let rendered = render_retained_instructions(&context, retained_assistant_message);
assert_eq!(
@@ -66,7 +66,7 @@ fn instructions_preserve_source_order_and_whole_records() {
complete: true,
},
RetainedInputSource::Local(None),
&uuid_v7_item_id_generator_for_test(),
&thread_context_ids(),
);
let rendered = render_retained_instructions(&context, retained_assistant_message);
let history = RetainedTranscript {
@@ -123,7 +123,7 @@ fn ordinary_exchanges_keep_roles_and_drop_assistant_context_before_restrictions(
complete: true,
},
RetainedInputSource::Local(Some(0)),
&uuid_v7_item_id_generator_for_test(),
&thread_context_ids(),
);
context.record_user_message(
RetainedUserMessage {
@@ -135,7 +135,7 @@ fn ordinary_exchanges_keep_roles_and_drop_assistant_context_before_restrictions(
complete: true,
},
RetainedInputSource::Local(Some(1)),
&uuid_v7_item_id_generator_for_test(),
&thread_context_ids(),
);
for presentation in [
crate::ContextPresentation::SyncFull { session_id: "test" },
@@ -211,7 +211,7 @@ fn ordinary_exchanges_keep_roles_and_drop_assistant_context_before_restrictions(
complete: true,
},
RetainedInputSource::Local(Some(2)),
&uuid_v7_item_id_generator_for_test(),
&thread_context_ids(),
);
let rendered = render_retained_instructions(&context, retained_assistant_message);
let history = RetainedTranscript {
@@ -284,7 +284,7 @@ fn legacy_verified_answers_keep_distinct_source_order() {
},
acceptance_order: None,
},
&uuid_v7_item_id_generator_for_test(),
&thread_context_ids(),
);
let raw = crate::collect_verified_answer_candidates(&context);
let old = crate::render_verified_answers(&context);
@@ -356,7 +356,7 @@ fn delivery_uses_source_revision_and_complete_host_metadata() {
retained.record_user_message(
message.clone(),
RetainedInputSource::Local(Some(4)),
&uuid_v7_item_id_generator_for_test(),
&thread_context_ids(),
);
let original = compose(&retained);
let delivered = original.clone().into_annotated_messages();
@@ -412,7 +412,7 @@ fn delivery_uses_source_revision_and_complete_host_metadata() {
retained.record_user_message(
message,
RetainedInputSource::Local(Some(4)),
&uuid_v7_item_id_generator_for_test(),
&thread_context_ids(),
);
let retained: RetainedContext =
serde_json::from_value(serde_json::to_value(retained).unwrap()).unwrap();
@@ -563,7 +563,7 @@ fn transcript_original_requires_complete_source_proof_and_survives_budgeting() {
phase: None,
},
RetainedInputSource::Local(Some(6)),
&uuid_v7_item_id_generator_for_test(),
&thread_context_ids(),
);
let source = retained
.source(retained.ordered_entries().next().unwrap().1)
@@ -585,7 +585,7 @@ fn transcript_original_requires_complete_source_proof_and_survives_budgeting() {
},
acceptance_order: Some(7),
},
&uuid_v7_item_id_generator_for_test(),
&thread_context_ids(),
);
let mut history = RetainedTranscript {
retained,
@@ -634,7 +634,7 @@ fn transcript_original_requires_complete_source_proof_and_survives_budgeting() {
.is_err()
);
// An ID alone, or a partial copy of that ID/revision, cannot suppress its original.
// An ID alone, or a partial copy of that ID/&thread_context_ids(), cannot suppress its original.
let original_metadata = history.messages[0].metadata.clone();
history.messages[0]
.metadata
@@ -710,7 +710,7 @@ fn transcript_original_requires_complete_source_proof_and_survives_budgeting() {
.record_user_message(
grant.clone(),
RetainedInputSource::Local(Some(EARLIER_SOURCE_ORDER)),
&uuid_v7_item_id_generator_for_test(),
&thread_context_ids(),
)
.unwrap();
let mut item =
@@ -744,7 +744,7 @@ fn transcript_original_requires_complete_source_proof_and_survives_budgeting() {
.record_user_message(
newer.clone(),
RetainedInputSource::Local(Some(NEWEST_SOURCE_ORDER)),
&uuid_v7_item_id_generator_for_test(),
&thread_context_ids(),
)
.unwrap();
let newest_id = source.id.clone();
@@ -853,7 +853,7 @@ fn coalesced_repl_text_cannot_attest_to_host_omission_delivery() {
complete: true,
},
RetainedInputSource::Local(Some(0)),
&uuid_v7_item_id_generator_for_test(),
&thread_context_ids(),
);
let profile = crate::ContextProfile::synchronous();
let mut previous = transcript_context(&history, &profile);
@@ -1,7 +1,7 @@
//! Constructor boundaries preserve valid evidence and reject oversize sections.
use super::*;
use codex_protocol_test_support::uuid_v7_item_id_generator_for_test;
use codex_thread_context_ids_test_support::thread_context_ids;
use pretty_assertions::assert_eq;
#[test]
@@ -10,7 +10,7 @@ fn previous_reviews_checks_count_and_size_without_rewriting_fragments() {
let fragment = "é".repeat(max_bytes / 2);
let fragments = vec![
PreviousReview {
id: uuid_v7_item_id_generator_for_test()("review"),
id: thread_context_ids().next_item("review"),
fragment: fragment.clone(),
};
MAX_PREVIOUS_REVIEWS
@@ -38,7 +38,7 @@ fn previous_reviews_checks_count_and_size_without_rewriting_fragments() {
invalid
.into_iter()
.map(|fragment| PreviousReview {
id: uuid_v7_item_id_generator_for_test()("review"),
id: thread_context_ids().next_item("review"),
fragment,
})
.collect()
@@ -53,12 +53,12 @@ fn previous_reviews_checks_count_and_size_without_rewriting_fragments() {
#[test]
fn review_delivery_requires_complete_host_metadata_and_preserves_distinct_completions() {
let first = PreviousReview {
id: uuid_v7_item_id_generator_for_test()("review"),
id: thread_context_ids().next_item("review"),
fragment: "Approved reading README.md.".to_owned(),
};
// A different completion remains new evidence even when its text is identical.
let second = PreviousReview {
id: uuid_v7_item_id_generator_for_test()("review"),
id: thread_context_ids().next_item("review"),
fragment: first.fragment.clone(),
};
let first_message = PreviousReviews::try_from_fragments(vec![first.clone()])
@@ -33,7 +33,8 @@ use codex_history::VerifiedQuestionAnswer;
use codex_protocol::models::ContentItem;
use codex_protocol::models::ResponseItem;
use codex_protocol::user_input::UserInput;
use codex_protocol_test_support::uuid_v7_item_id_generator_for_test;
use codex_thread_context_ids_test_support::thread_context_ids;
use pretty_assertions::assert_eq;
struct History {
@@ -80,7 +81,7 @@ fn changing_retained_context_and_attestations_preserves_history_before_the_curre
complete: true,
},
RetainedInputSource::Local(None),
&uuid_v7_item_id_generator_for_test(),
&thread_context_ids(),
);
// Legacy review history and Felix's retained, thread-owned history use the
// same composer. Retained assistant growth and eviction must also preserve its prefix.
@@ -112,12 +113,12 @@ fn changing_retained_context_and_attestations_preserves_history_before_the_curre
complete: true,
},
RetainedInputSource::Local(Some(generation + 1)),
&uuid_v7_item_id_generator_for_test(),
&thread_context_ids(),
);
}
let reviews =
PreviousReviews::try_from_fragments(vec![codex_guardian_context::PreviousReview {
id: uuid_v7_item_id_generator_for_test()("review"),
id: thread_context_ids().next_item("review"),
fragment: format!("Host-attested decision {generation}: denied."),
}])
.unwrap();
@@ -244,7 +245,7 @@ fn elastic_verified_answers_preserve_question_answer_identity() {
answer,
acceptance_order: Some(7),
},
&uuid_v7_item_id_generator_for_test(),
&thread_context_ids(),
);
let trusted_answers = collect_verified_answer_candidates(&retained);
let root = [GuardianRootMessage::UserInput(original.clone())];
+2 -1
View File
@@ -14,6 +14,7 @@ workspace = true
[dependencies]
codex-protocol = { workspace = true }
codex-thread-context-ids = { workspace = true }
codex-utils-absolute-path = { workspace = true }
codex-utils-model-facing-id = { workspace = true }
schemars = { workspace = true }
@@ -21,6 +22,6 @@ serde = { workspace = true, features = ["derive"] }
serde_json = { workspace = true }
[dev-dependencies]
codex-protocol-test-support = { workspace = true }
codex-thread-context-ids-test-support = { workspace = true }
anyhow = { workspace = true }
pretty_assertions = { workspace = true }
@@ -2,14 +2,15 @@
use super::*;
use crate::CodexHarnessMetadata;
use codex_protocol_test_support::uuid_v7_item_id_generator_for_test;
use pretty_assertions::assert_eq;
#[test]
fn latest_checkpoint_keeps_its_own_producer_even_when_unusable() {
let older = ResponseItemEnvelope {
item: ResponseItem::Compaction {
id: Some(uuid_v7_item_id_generator_for_test()("old")),
id: Some(codex_protocol::ResponseItemId::from_server(
"old".to_owned(),
)),
encrypted_content: "older checkpoint".to_owned(),
internal_chat_message_metadata_passthrough: None,
},
@@ -21,7 +22,9 @@ fn latest_checkpoint_keeps_its_own_producer_even_when_unusable() {
for content in [None, Some(String::new()), Some("new checkpoint".to_owned())] {
let usable = content.as_ref().is_some_and(|text| !text.is_empty());
let latest = ResponseItem::ContextCompaction {
id: Some(uuid_v7_item_id_generator_for_test()("new")),
id: Some(codex_protocol::ResponseItemId::from_server(
"new".to_owned(),
)),
encrypted_content: content,
internal_chat_message_metadata_passthrough: None,
};
@@ -0,0 +1,53 @@
//! Initializes the thread allocator and active window from rollout history.
use codex_protocol::ContextWindowId;
use codex_thread_context_ids::ThreadContextIds;
use crate::InitialHistory;
use crate::RolloutItem;
/// Ready-to-use allocator and the window it starts or resumes.
pub struct InitialContextIds {
pub context_ids: ThreadContextIds,
pub initial_window_id: ContextWindowId,
}
impl InitialHistory {
/// Initializes the allocator and active window from the history the thread will replay.
/// On resume, use the snapshot validated by the rollout writer. For fixtures use
/// `codex_thread_context_ids_test_support::thread_context_ids()`.
pub fn initialize_context_ids(&self) -> InitialContextIds {
// A resume already owns its window.
let resumed_window = match self {
InitialHistory::Resumed(resumed) => {
resumed
.history
.iter()
.rev()
.find_map(|record| match record {
RolloutItem::Compacted(checkpoint) => {
checkpoint.window_id.as_ref()?.validated()
}
RolloutItem::SessionMeta(meta)
if meta.meta.id == resumed.conversation_id =>
{
meta.meta.context_window.as_ref()?.window_id.validated()
}
_ => None,
})
}
InitialHistory::New | InitialHistory::Cleared | InitialHistory::Forked(_) => None,
};
let context_ids = context_ids_from_rollout(self.get_rollout_items());
let initial_window_id = resumed_window.unwrap_or_else(|| context_ids.next_window());
InitialContextIds {
context_ids,
initial_window_id,
}
}
}
/// Creates an allocator without allocating a window, for isolated rollout reconstruction.
pub fn context_ids_from_rollout(_records: &[RolloutItem]) -> ThreadContextIds {
ThreadContextIds::for_thread()
}
+3
View File
@@ -505,6 +505,9 @@ impl JsonSchema for RolloutItem {
}
mod guardian_history;
mod initial_context_ids;
pub use initial_context_ids::InitialContextIds;
pub use initial_context_ids::context_ids_from_rollout;
mod model_id_ordinals;
pub use model_id_ordinals::next_model_id_ordinals;
pub use model_id_ordinals::stamp_item_ordinals;
@@ -3,7 +3,7 @@ use crate::RetainedContextEvent;
use crate::RetainedInputSource;
use crate::VerifiedAnswer;
use crate::VerifiedQuestionAnswer;
use codex_protocol_test_support::uuid_v7_item_id_generator_for_test;
use codex_thread_context_ids_test_support::thread_context_ids;
use pretty_assertions::assert_eq;
fn instruction(text: &str) -> RetainedUserMessage {
@@ -32,12 +32,12 @@ fn recovery_preserves_source_identity_acceptance_order_and_checkpoint_gaps() {
retained.record_user_message(
initial.clone(),
RetainedInputSource::Local(Some(0)),
&uuid_v7_item_id_generator_for_test(),
&thread_context_ids(),
);
retained.record_user_message(
retained_excerpt,
RetainedInputSource::Local(Some(1)),
&uuid_v7_item_id_generator_for_test(),
&thread_context_ids(),
);
retained.record(
&RetainedContextEvent::VerifiedAnswer {
@@ -51,7 +51,7 @@ fn recovery_preserves_source_identity_acceptance_order_and_checkpoint_gaps() {
},
acceptance_order: Some(3),
},
&uuid_v7_item_id_generator_for_test(),
&thread_context_ids(),
);
retained.mark_user_messages_incomplete();
let checkpoint = retained.clone();
@@ -124,7 +124,7 @@ fn recovery_marks_missing_and_conflicting_orders_incomplete() {
retained.record_user_message(
instruction("Inspect the deployment."),
RetainedInputSource::Local(Some(1)),
&uuid_v7_item_id_generator_for_test(),
&thread_context_ids(),
);
assert!(!retained.has_missing_user_messages());
let checkpoint = retained.clone();
@@ -193,7 +193,7 @@ fn heartbeat_versions_survive_retention_restore_and_reconciliation() {
retained.record_user_message(
message.clone(),
RetainedInputSource::Local(Some(index as u64)),
&uuid_v7_item_id_generator_for_test(),
&thread_context_ids(),
);
}
let expected = [0, 1, 31, 32, 33]
@@ -9,7 +9,7 @@ use super::RetainedSource;
use super::RetainedSourceRole;
use super::RetainedUserMessage;
use super::bound_family;
use codex_protocol::ItemIdGenerator;
use codex_thread_context_ids::ThreadContextIds;
impl RetainedContext {
/// Reports observed storage loss or a retained message that cannot be delivered whole.
@@ -39,18 +39,22 @@ impl RetainedContext {
&mut self,
message: RetainedUserMessage,
source: RetainedInputSource,
item_id_generator: &ItemIdGenerator,
context_ids: &ThreadContextIds,
) -> Option<RetainedSource> {
self.record_assistant_message_with_revision(message, source, || {
item_id_generator("retained")
})
self.record_assistant_message_with_revision(
message,
source,
context_ids,
/*revision*/ None,
)
}
pub(super) fn record_assistant_message_with_revision(
&mut self,
mut message: RetainedUserMessage,
source: RetainedInputSource,
revision: impl FnOnce() -> codex_protocol::ResponseItemId,
context_ids: &ThreadContextIds,
revision: Option<&codex_protocol::ResponseItemId>,
) -> Option<RetainedSource> {
if source == RetainedInputSource::Local(None) {
// Leave unsequenced sources to legacy transcript selection. Missing
@@ -83,7 +87,11 @@ impl RetainedContext {
if empty {
return None;
}
let revision = message.message_id.as_ref().map(|_| revision());
let revision = message.message_id.as_ref().map(|_| {
revision
.cloned()
.unwrap_or_else(|| context_ids.next_item("retained"))
});
let entry = Ordered {
revision,
inherited,
+8 -16
View File
@@ -11,7 +11,7 @@ pub use source::RetainedSource;
pub use source::RetainedSourceId;
pub use source::RetainedSourceRole;
use codex_protocol::ItemIdGenerator;
use codex_thread_context_ids::ThreadContextIds;
use std::collections::BTreeSet;
use std::collections::VecDeque;
use std::sync::Arc;
@@ -390,7 +390,7 @@ impl RetainedContext {
&mut self,
mut message: RetainedUserMessage,
source: RetainedInputSource,
item_id_generator: &ItemIdGenerator,
context_ids: &ThreadContextIds,
) -> Option<RetainedSource> {
message.bound();
let inherited = source == RetainedInputSource::Inherited;
@@ -442,7 +442,7 @@ impl RetainedContext {
let revision = message
.message_id
.as_ref()
.map(|_| item_id_generator("retained"));
.map(|_| context_ids.next_item("retained"));
let entry = Ordered {
revision,
inherited,
@@ -475,19 +475,15 @@ impl RetainedContext {
}
/// Same-event delivery is idempotent; changed contents replace that source's record.
pub fn record(
&mut self,
event: &RetainedContextEvent,
item_id_generator: &ItemIdGenerator,
) -> bool {
self.record_and_capture(&mut event.clone(), item_id_generator)
pub fn record(&mut self, event: &RetainedContextEvent, context_ids: &ThreadContextIds) -> bool {
self.record_and_capture(&mut event.clone(), context_ids)
}
/// Records a host event and fills in its retained source for rollout persistence.
pub fn record_and_capture(
&mut self,
event: &mut RetainedContextEvent,
item_id_generator: &ItemIdGenerator,
context_ids: &ThreadContextIds,
) -> bool {
event.bound();
match event {
@@ -543,12 +539,8 @@ impl RetainedContext {
*retained_source = self.record_assistant_message_with_revision(
message.clone(),
RetainedInputSource::Local(Some(*acceptance_order)),
|| {
retained_source.as_ref().map_or_else(
|| item_id_generator("retained"),
|source| source.revision.clone(),
)
},
context_ids,
retained_source.as_ref().map(|source| &source.revision),
);
true
}
+29 -30
View File
@@ -2,7 +2,7 @@ use super::*;
use crate::CodexHarnessMetadata;
use codex_protocol::models::ContentItem;
use codex_protocol::models::ResponseItem;
use codex_protocol_test_support::uuid_v7_item_id_generator_for_test;
use codex_thread_context_ids_test_support::thread_context_ids;
use pretty_assertions::assert_eq;
#[test]
@@ -16,9 +16,8 @@ fn accepted_audio_checkpoint_discards_oversized_and_rolled_back_evidence() {
file_ids: BTreeSet::from([id]),
}),
};
let item_id_generator = uuid_v7_item_id_generator_for_test();
assert!(retained.record(&proof("file_a".into()), &item_id_generator));
assert!(!retained.record(&proof("x".repeat(MAX_RECORD_BYTES)), &item_id_generator));
assert!(retained.record(&proof("file_a".into()), &thread_context_ids()));
assert!(!retained.record(&proof("x".repeat(MAX_RECORD_BYTES)), &thread_context_ids()));
let bytes = serde_json::to_vec(&retained).expect("encode checkpoint");
let mut restored: RetainedContext = serde_json::from_slice(&bytes).expect("decode checkpoint");
let get_ids = |state: &RetainedContext| {
@@ -68,7 +67,7 @@ fn delivered_message(id: &str, text: &str, acceptance_order: u64) -> RetainedCon
fn retained_evidence_preserves_order_through_recovery_checkpoint_and_rollback() {
let mut context = RetainedContext::default();
let first = publish_answer();
assert!(context.record(&first, &uuid_v7_item_id_generator_for_test()));
assert!(context.record(&first, &thread_context_ids()));
let before_restriction = context.clone();
context.record_user_message(
RetainedUserMessage {
@@ -80,7 +79,7 @@ fn retained_evidence_preserves_order_through_recovery_checkpoint_and_rollback()
complete: false,
},
RetainedInputSource::Local(None),
&uuid_v7_item_id_generator_for_test(),
&thread_context_ids(),
);
let mut expected = context.clone();
expected.user_messages[0].value.text = "Do not publish after all.".to_owned();
@@ -91,7 +90,7 @@ fn retained_evidence_preserves_order_through_recovery_checkpoint_and_rollback()
assert_eq!(context, expected);
context.recover_user_message_excerpts(|_| panic!("existing text must not be replaced"));
let snapshot = context.clone();
assert!(!context.record(&first, &uuid_v7_item_id_generator_for_test()));
assert!(!context.record(&first, &thread_context_ids()));
assert_eq!(context, snapshot);
let checkpoint =
serde_json::from_str(&serde_json::to_string(&context).expect("retained answer fixture"))
@@ -128,7 +127,7 @@ fn retained_evidence_preserves_order_through_recovery_checkpoint_and_rollback()
fn retained_families_enforce_storage_limits_without_changing_snapshots() {
let mut context = RetainedContext::default();
let first = publish_answer();
context.record(&first, &uuid_v7_item_id_generator_for_test());
context.record(&first, &thread_context_ids());
let snapshot = context.clone();
for index in 2..=10 {
@@ -144,7 +143,7 @@ fn retained_families_enforce_storage_limits_without_changing_snapshots() {
},
acceptance_order: None,
},
&uuid_v7_item_id_generator_for_test(),
&thread_context_ids(),
);
}
assert!(!context.verified_answers_complete());
@@ -163,7 +162,7 @@ fn retained_families_enforce_storage_limits_without_changing_snapshots() {
panic!("verified answer fixture");
};
answer.questions[0].answer = "a".repeat(MAX_RECORD_BYTES);
restored.record(&oversized, &uuid_v7_item_id_generator_for_test());
restored.record(&oversized, &thread_context_ids());
assert!(!restored.verified_answers_complete());
assert!(
restored
@@ -193,7 +192,7 @@ fn retained_families_enforce_storage_limits_without_changing_snapshots() {
complete: true,
},
RetainedInputSource::Local(None),
&uuid_v7_item_id_generator_for_test(),
&thread_context_ids(),
);
}
assert!(!restored.user_messages_complete());
@@ -215,7 +214,7 @@ fn retained_families_enforce_storage_limits_without_changing_snapshots() {
complete: true,
},
RetainedInputSource::Local(Some(0)),
&uuid_v7_item_id_generator_for_test(),
&thread_context_ids(),
);
assert_eq!(
restored, recent,
@@ -231,7 +230,7 @@ fn retained_families_enforce_storage_limits_without_changing_snapshots() {
complete: true,
},
RetainedInputSource::Local(None),
&uuid_v7_item_id_generator_for_test(),
&thread_context_ids(),
);
let Some((_, RetainedContextEntry::UserMessage(message))) =
restored.ordered_entries().next_back()
@@ -251,19 +250,19 @@ fn retained_families_enforce_storage_limits_without_changing_snapshots() {
..restrictions.back().unwrap().value.clone()
},
RetainedInputSource::Local(Some(order)),
&uuid_v7_item_id_generator_for_test(),
&thread_context_ids(),
);
}
assert!(!restored.has_omitted_assistant_messages());
let evicted = delivered_message("evicted", "Already replaced?", /*acceptance_order*/ 0);
assert!(restored.record(&evicted, &uuid_v7_item_id_generator_for_test()));
assert!(restored.record(&evicted, &thread_context_ids()));
// The old-order delivery is immediately evicted, so the bounded buffer
// cannot prove a subsequent recording with this ID is a duplicate.
assert!(restored.record(&evicted, &uuid_v7_item_id_generator_for_test()));
assert!(restored.record(&evicted, &thread_context_ids()));
let order = restored.reserve_order();
let oversized = delivered_message("oversized", &"x".repeat(MAX_RECORD_BYTES), order);
assert!(restored.record(&oversized, &uuid_v7_item_id_generator_for_test()));
assert!(!restored.record(&oversized, &uuid_v7_item_id_generator_for_test()));
assert!(restored.record(&oversized, &thread_context_ids()));
assert!(!restored.record(&oversized, &thread_context_ids()));
assert_eq!(restored.user_messages, restrictions);
assert_eq!(restored.verified_answers, authorization);
assert_eq!(restored.assistant_messages.len(), MAX_FAMILY_RECORDS);
@@ -282,8 +281,8 @@ fn retained_families_enforce_storage_limits_without_changing_snapshots() {
// Once the omission marker is set, another confirmed delivery still needs
// its own rollout record even when the bounded window stays incomplete.
let later = delivered_message("later", "A later question?", order + 1);
assert!(restored.record(&later, &uuid_v7_item_id_generator_for_test()));
assert!(!restored.record(&later, &uuid_v7_item_id_generator_for_test()));
assert!(restored.record(&later, &thread_context_ids()));
assert!(!restored.record(&later, &thread_context_ids()));
}
#[test]
@@ -300,7 +299,7 @@ fn recovered_excerpts_obey_record_and_family_limits() {
complete: false,
},
RetainedInputSource::Local(None),
&uuid_v7_item_id_generator_for_test(),
&thread_context_ids(),
);
}
let unchanged = context.clone();
@@ -393,7 +392,7 @@ fn accepted_order_survives_delayed_recording_and_checkpoint_replay() {
answer,
acceptance_order: Some(answer_order),
};
context.record(&event, &uuid_v7_item_id_generator_for_test());
context.record(&event, &thread_context_ids());
let instruction = RetainedUserMessage {
phase: None,
origin: crate::UserInputOrigin::User,
@@ -405,20 +404,20 @@ fn accepted_order_survives_delayed_recording_and_checkpoint_replay() {
// Assistant delivery after accepted steering must not move the steering past it.
let assistant_order = context.reserve_order();
let delivered = delivered_message("assistant", "Publish publicly?", assistant_order);
assert!(context.record(&delivered, &uuid_v7_item_id_generator_for_test()));
assert!(context.record(&delivered, &thread_context_ids()));
let checkpoint = serde_json::from_value(serde_json::to_value(&context).unwrap()).unwrap();
context.record_user_message(
instruction.clone(),
RetainedInputSource::Local(Some(steer_order)),
&uuid_v7_item_id_generator_for_test(),
&thread_context_ids(),
);
let mut resumed = RetainedContext::default();
resumed.restore(Some(&checkpoint), &[]);
assert!(!resumed.record(&delivered, &uuid_v7_item_id_generator_for_test()));
assert!(!resumed.record(&delivered, &thread_context_ids()));
resumed.record_user_message(
instruction,
RetainedInputSource::Local(Some(steer_order)),
&uuid_v7_item_id_generator_for_test(),
&thread_context_ids(),
);
// This suffix has no captured version metadata, so replay creates a fresh revision.
// Its original contents and acceptance order still reconstruct identically.
@@ -488,7 +487,7 @@ fn accepted_order_survives_delayed_recording_and_checkpoint_replay() {
#[test]
fn adopted_instructions_preserve_local_order_and_rollback_scope() {
let mut context = RetainedContext::default();
context.record(&publish_answer(), &uuid_v7_item_id_generator_for_test());
context.record(&publish_answer(), &thread_context_ids());
for index in 0..2 {
let message = RetainedUserMessage {
phase: None,
@@ -501,17 +500,17 @@ fn adopted_instructions_preserve_local_order_and_rollback_scope() {
context.record_user_message(
message.clone(),
RetainedInputSource::Inherited,
&uuid_v7_item_id_generator_for_test(),
&thread_context_ids(),
);
context.record_user_message(
message.clone(),
RetainedInputSource::Inherited,
&uuid_v7_item_id_generator_for_test(),
&thread_context_ids(),
);
context.record_assistant_message(
message,
RetainedInputSource::Inherited,
&uuid_v7_item_id_generator_for_test(),
&thread_context_ids(),
);
}
assert_eq!(context.reserve_order(), 1);
+5 -14
View File
@@ -1,6 +1,5 @@
use anyhow::Result;
use codex_protocol::ContextWindowId;
use codex_protocol::ResponseItemId;
use codex_protocol::models::AudioReference;
use codex_protocol::models::ConfigurationReasoning;
use codex_protocol::models::PermissionProfile;
@@ -11,6 +10,7 @@ use codex_protocol::permissions::FileSystemSandboxEntry;
use codex_protocol::permissions::FileSystemSandboxPolicy;
use codex_protocol::permissions::NetworkSandboxPolicy;
use codex_protocol::protocol::ThreadSettingsSnapshot;
use codex_thread_context_ids_test_support::thread_context_ids;
use pretty_assertions::assert_eq;
use serde_json::json;
@@ -432,14 +432,9 @@ fn delivered_assistant_rollout_survives_an_earlier_read_and_rewrite() -> Result<
},
acceptance_order: 7,
};
let sequence = std::sync::Mutex::new(
codex_utils_model_facing_id::ModelFacingIdGenerator::new(/*seed*/ 42, "item"),
);
let generator: codex_protocol::ItemIdGenerator = Arc::new(move |kind| {
ResponseItemId::generated(kind, sequence.lock().unwrap().fetch_next())
});
let ids = thread_context_ids();
let mut live = RetainedContext::default();
assert!(live.record_and_capture(&mut original, &generator));
assert!(live.record_and_capture(&mut original, &ids));
let wire = serde_json::to_value(RolloutItem::RetainedContext(original.clone()))?;
let earlier = serde_json::from_value::<EarlierRolloutItem>(wire)?;
let EarlierRolloutItem::ResponseItem { payload, metadata } = &earlier;
@@ -476,7 +471,7 @@ fn delivered_assistant_rollout_survives_an_earlier_read_and_rewrite() -> Result<
phase: None,
},
RetainedInputSource::Local(metadata.user_input_order),
&codex_protocol_test_support::uuid_v7_item_id_generator_for_test(),
&thread_context_ids(),
);
let rewritten_checkpoint =
serde_json::from_value(serde_json::to_value(earlier_checkpoint)?)?;
@@ -496,12 +491,8 @@ fn delivered_assistant_rollout_survives_an_earlier_read_and_rewrite() -> Result<
};
assert_eq!(restored, original);
let mut replayed = RetainedContext::default();
assert!(replayed.record(&restored, &generator));
assert!(replayed.record(&restored, &thread_context_ids()));
assert_eq!(replayed, live);
assert_eq!(
crate::next_model_id_ordinals(&[RolloutItem::RetainedContext(restored)]),
(1, 0)
);
}
Ok(())
}
+1
View File
@@ -13,6 +13,7 @@ doctest = false
workspace = true
[dependencies]
codex-thread-context-ids = { workspace = true }
anyhow = { workspace = true }
chrono = { workspace = true }
codex-backend-client = { workspace = true }
+1 -1
View File
@@ -300,7 +300,7 @@ mod job {
MemoryVersion::V1 => vec![ResponseItem::Message {
status: None,
encrypted_content: None,
id: Some(context.item_id_generator()("msg")),
id: Some(context.context_ids().next_item("msg")),
role: "user".to_string(),
content: vec![ContentItem::InputText { text: input_text }],
phase: None,
+3 -3
View File
@@ -139,8 +139,8 @@ fn build_session_telemetry(
}
impl MemoryStartupContext {
pub(crate) fn item_id_generator(&self) -> &codex_protocol::ItemIdGenerator {
self.thread.item_id_generator()
pub(crate) fn context_ids(&self) -> &codex_thread_context_ids::ThreadContextIds {
self.thread.context_ids()
}
pub(crate) fn new(
@@ -333,7 +333,7 @@ impl MemoryStartupContext {
Arc::clone(&self.provider),
AgentIdentityAuthPolicy::JwtOnly,
self.thread_id,
Arc::clone(self.item_id_generator()),
self.context_ids().clone(),
session_source.clone(),
config_snapshot.originator,
config.model_verbosity,
@@ -1,12 +0,0 @@
//! Response item ID allocation for a thread and its consumers.
use crate::ResponseItemId;
use std::sync::Arc;
/// Generates IDs for an item kind. Clones share the owning thread's sequence.
pub type ItemIdGenerator = Arc<dyn Fn(&str) -> ResponseItemId + Send + Sync>;
#[cfg(test)]
pub(super) fn uuid_v7_item_id_generator_for_test() -> ItemIdGenerator {
Arc::new(|prefix| ResponseItemId::with_suffix(prefix, uuid::Uuid::now_v7()))
}
+4 -11
View File
@@ -9,7 +9,6 @@ pub use display::HelplineSubject;
pub use display::TrustedContacts;
use crate::AgentPath;
use crate::ItemIdGenerator;
use crate::ThreadId;
use crate::dynamic_tools::DynamicToolCallOutputContentItem;
use crate::mcp::CallToolResult;
@@ -753,10 +752,7 @@ impl HookPromptFragment {
}
}
pub fn build_hook_prompt_message(
fragments: &[HookPromptFragment],
item_id_generator: &ItemIdGenerator,
) -> Option<ResponseItem> {
pub fn build_hook_prompt_message(fragments: &[HookPromptFragment]) -> Option<ResponseItem> {
let mut content = Vec::new();
let mut metadata = Vec::new();
for fragment in fragments {
@@ -773,7 +769,7 @@ pub fn build_hook_prompt_message(
Some(ResponseItem::Message {
status: None,
encrypted_content: None,
id: Some(item_id_generator("msg")),
id: None,
role: "user".to_string(),
content,
phase: None,
@@ -949,14 +945,11 @@ mod tests {
HookPromptFragment::from_single_hook("Retry with care & joy.", "hook-run-1"),
HookPromptFragment::from_single_hook("Then summarize cleanly.", "hook-run-2"),
];
let message =
build_hook_prompt_message(&original, &crate::uuid_v7_item_id_generator_for_test())
.expect("hook prompt");
let message = build_hook_prompt_message(&original).expect("hook prompt");
let ResponseItem::Message { id, content, .. } = message else {
let ResponseItem::Message { content, .. } = message else {
panic!("expected hook prompt message");
};
assert!(id.is_some_and(|id| id.starts_with("msg_")));
let parsed = parse_hook_prompt_message(/*id*/ None, &content).expect("parsed hook prompt");
assert_eq!(parsed.fragments, original);
-4
View File
@@ -3,7 +3,6 @@ mod agent_path;
pub mod auth;
mod budget_units;
mod context_window_id;
mod item_id_generator;
mod request_country;
pub use request_country::InvalidRequestCountry;
pub use request_country::RequestCountry;
@@ -16,9 +15,6 @@ mod tool_name;
pub use agent_path::AgentPath;
pub use budget_units::BudgetUnitsSum;
pub use context_window_id::ContextWindowId;
pub use item_id_generator::ItemIdGenerator;
#[cfg(test)]
use item_id_generator::uuid_v7_item_id_generator_for_test;
pub use permission_profile_intersection::PermissionIntersectionError;
pub use permission_profile_intersection::intersect_effective_permission_profiles;
pub use response_item_id::ResponseItemId;
@@ -20,8 +20,8 @@ fn configuration_update_round_trips_without_message_fields() {
}
);
item.set_id(Some(crate::uuid_v7_item_id_generator_for_test()(
"configuration-id",
item.set_id(Some(crate::ResponseItemId::from_server(
"configuration-id".to_owned(),
)));
item.set_turn_id_if_missing("turn-id");
item.set_create_time_if_missing(serde_json::Number::from(123));
@@ -1,20 +1,9 @@
use pretty_assertions::assert_eq;
use serde_json::json;
use uuid::Uuid;
use super::ResponseItemId;
use crate::models::ResponseItem;
#[test]
fn creates_prefixed_uuid_v7_ids() {
let id = crate::uuid_v7_item_id_generator_for_test()("msg");
let uuid = id.strip_prefix("msg_").expect("message prefix");
assert_eq!(
Uuid::parse_str(uuid).expect("UUID suffix").get_version(),
Some(uuid::Version::SortRand)
);
}
#[test]
fn creates_prefixed_ids_with_explicit_suffix() {
let id = ResponseItemId::with_suffix("msg", "test");
@@ -14,4 +14,3 @@ workspace = true
[dependencies]
codex-protocol = { workspace = true }
uuid = { workspace = true, features = ["v7"] }
-7
View File
@@ -1,13 +1,6 @@
//! Protocol fixtures and text assertions shared by test targets.
use codex_protocol::ItemIdGenerator;
use codex_protocol::ResponseItemId;
use codex_protocol::models::ContentItem;
use std::sync::Arc;
pub fn uuid_v7_item_id_generator_for_test() -> ItemIdGenerator {
Arc::new(|prefix| ResponseItemId::with_suffix(prefix, uuid::Uuid::now_v7()))
}
/// Assertion helpers for tests that require text rather than media content.
/// Implementations should fail at the calling assertion for non-text content.
+6
View File
@@ -0,0 +1,6 @@
load("//:defs.bzl", "codex_rust_crate")
codex_rust_crate(
name = "thread-context-ids",
crate_name = "codex_thread_context_ids",
)
+20
View File
@@ -0,0 +1,20 @@
[package]
name = "codex-thread-context-ids"
version.workspace = true
edition.workspace = true
license.workspace = true
[lib]
test = false
doctest = false
[lints]
workspace = true
[dependencies]
codex-protocol = { workspace = true }
uuid = { workspace = true, features = ["v7"] }
[dev-dependencies]
pretty_assertions = { workspace = true }
codex-thread-context-ids-test-support = { workspace = true }
+34
View File
@@ -0,0 +1,34 @@
//! Allocates thread context IDs shared by history and inference.
use codex_protocol::ContextWindowId;
use codex_protocol::ResponseItemId;
use uuid::Uuid;
/// Allocates IDs for one thread's context.
#[derive(Debug, Clone)]
pub struct ThreadContextIds(Allocator);
#[derive(Debug, Clone)]
enum Allocator {
Uuid,
}
impl ThreadContextIds {
/// Creates a thread allocator. Live sessions should use `InitialHistory::initialize_context_ids`
/// to initialize the active window. For fixtures use `codex_thread_context_ids_test_support::thread_context_ids()`.
pub fn for_thread() -> Self {
Self(Allocator::Uuid)
}
pub fn next_item(&self, kind: &str) -> ResponseItemId {
match &self.0 {
Allocator::Uuid => ResponseItemId::with_suffix(kind, Uuid::now_v7()),
}
}
pub fn next_window(&self) -> ContextWindowId {
match &self.0 {
Allocator::Uuid => ContextWindowId::new_uuid_v7(),
}
}
}
@@ -0,0 +1,7 @@
load("//:defs.bzl", "codex_rust_crate")
codex_rust_crate(
name = "support",
crate_name = "codex_thread_context_ids_test_support",
crate_srcs = glob(["*.rs"]),
)
@@ -0,0 +1,16 @@
[package]
name = "codex-thread-context-ids-test-support"
version.workspace = true
edition.workspace = true
license.workspace = true
[lib]
path = "lib.rs"
test = false
doctest = false
[lints]
workspace = true
[dependencies]
codex-thread-context-ids = { workspace = true }
@@ -0,0 +1,8 @@
//! Fresh thread context allocators for tests that do not exercise history recovery.
use codex_thread_context_ids::ThreadContextIds;
/// Creates an independent UUID-backed allocator.
pub fn thread_context_ids() -> ThreadContextIds {
ThreadContextIds::for_thread()
}
@@ -0,0 +1,15 @@
#![cfg(test)]
use codex_thread_context_ids_test_support::thread_context_ids;
use pretty_assertions::assert_eq;
use uuid::Uuid;
#[test]
fn creates_prefixed_uuid_v7_ids() {
let id = thread_context_ids().next_item("msg");
let uuid = id.strip_prefix("msg_").expect("message prefix");
assert_eq!(
Uuid::parse_str(uuid).expect("UUID suffix").get_version(),
Some(uuid::Version::SortRand)
);
}
+1 -1
View File
@@ -38,7 +38,7 @@ tracing = { workspace = true }
zstd = { workspace = true }
[dev-dependencies]
codex-protocol-test-support = { workspace = true }
codex-thread-context-ids-test-support = { workspace = true }
codex-utils-absolute-path = { workspace = true }
pretty_assertions = { workspace = true }
tempfile = { workspace = true }
@@ -1,3 +1,4 @@
use codex_thread_context_ids_test_support::thread_context_ids;
use std::fs;
use std::io::Write;
use std::path::Path;
@@ -47,7 +48,6 @@ use codex_protocol::protocol::UserMessageAudioKind;
use codex_protocol::protocol::UserMessageEvent;
use codex_protocol::protocol::UserMessageImageKind;
use codex_protocol::user_input::UserInput;
use codex_protocol_test_support::uuid_v7_item_id_generator_for_test;
use codex_rollout::CompactedItem;
use codex_rollout::RetainedContextEvent;
use codex_rollout::RolloutConfig;
@@ -1338,8 +1338,8 @@ async fn migration_rolls_back_pre_compaction_turns_from_sqlite_history() {
.retained_context
.as_mut()
.expect("retained context");
context.record(&answer_event, &uuid_v7_item_id_generator_for_test());
context.record(&wake_answer_event, &uuid_v7_item_id_generator_for_test());
context.record(&answer_event, &thread_context_ids());
context.record(&wake_answer_event, &thread_context_ids());
let path = write_rollout(
home.path(),
thread_id,
@@ -1437,7 +1437,7 @@ async fn migration_preserves_answers_before_a_rolled_back_steer() {
.retained_context
.as_mut()
.expect("retained context")
.record(&answer, &uuid_v7_item_id_generator_for_test());
.record(&answer, &thread_context_ids());
answers.push(answer);
}
// Delayed delivery must use the original call boundary, not the turn's latest steer.
@@ -1559,13 +1559,13 @@ async fn migration_rolls_back_nested_deliveries_by_acceptance_order() {
}))
.expect("retained instruction"),
codex_rollout::RetainedInputSource::Local(Some(order)),
&uuid_v7_item_id_generator_for_test(),
&thread_context_ids(),
);
}
context.record(&deliveries[0], &uuid_v7_item_id_generator_for_test());
context.record(&deliveries[0], &thread_context_ids());
let first_retained_message =
serde_json::to_value(&*context).expect("retained context")["assistant_messages"][0].clone();
context.record(&deliveries[1], &uuid_v7_item_id_generator_for_test());
context.record(&deliveries[1], &thread_context_ids());
let outer_call = serde_json::from_value(json!({
"type": "function_call", "call_id": "exec", "name": "exec", "arguments": "{}"
}))