Lightweight coding agent that runs in your terminal
Rust
Establish root turn identity for independent tasks and memory requests (#42900)
pakrym-oaid05e6d5f4650
diff --git a/codex-rs/app-server/tests/suite/v2/thread_resume.rs b/codex-rs/app-server/tests/suite/v2/thread_resume.rsindex 10fadc9e7f..c70eda9e66 100644--- a/codex-rs/app-server/tests/suite/v2/thread_resume.rs+++ b/codex-rs/app-server/tests/suite/v2/thread_resume.rs@@ -3274,11 +3274,11 @@ async fn thread_goal_keeps_original_root_until_external_objective_edit() -> Resu);responses::assert_root_turn(&reopened_request, Some(original_turn.turn.id.as_str()))?;let continuation_request = serde_json::from_slice::<serde_json::Value>(&requests[7])?;- assert_ne!(- continuation_request["client_metadata"]["turn_id"].as_str(),- Some(edited_turn_id)- );- responses::assert_root_turn(&continuation_request, /*expected*/ None)?;+ let continuation_turn_id = continuation_request["client_metadata"]["turn_id"]+ .as_str()+ .expect("independent continuation turn ID");+ assert_ne!(continuation_turn_id, edited_turn_id);+ responses::assert_root_turn(&continuation_request, Some(continuation_turn_id))?;responses::assert_parent_turn(&continuation_request, /*expected*/ None)?;server.shutdown().await;@@ -3446,7 +3446,7 @@ async fn thread_goal_lifecycle_emits_analytics_and_clear_deletes_goal() -> Resulgoal_request_body["client_metadata"]["turn_id"],causal_turn_id);- responses::assert_root_turn(&goal_request_body, /*expected*/ None)?;+ responses::assert_root_turn(&goal_request_body, Some(causal_turn_id))?;responses::assert_parent_turn(&goal_request_body, /*expected*/ None)?;let clear_id = mcpdiff --git a/codex-rs/app-server/tests/suite/v2/turn_start.rs b/codex-rs/app-server/tests/suite/v2/turn_start.rsindex 397276ab3c..e567bceb4a 100644--- a/codex-rs/app-server/tests/suite/v2/turn_start.rs+++ b/codex-rs/app-server/tests/suite/v2/turn_start.rs@@ -386,9 +386,9 @@ async fn turn_start_with_empty_input_runs_model_request() -> Result<()> {assert_eq!((event["event_params"]["turn_id"].as_str(),- event["event_params"].get("root_turn_id"),+ event["event_params"]["root_turn_id"].as_str(),),- (Some(turn.id.as_str()), Some(&Value::Null))+ (Some(turn.id.as_str()), Some(turn.id.as_str())));let requests = serverdiff --git a/codex-rs/core/src/responses_metadata.rs b/codex-rs/core/src/responses_metadata.rsindex 6f64929ec8..8edfbdfc7a 100644--- a/codex-rs/core/src/responses_metadata.rs+++ b/codex-rs/core/src/responses_metadata.rs@@ -168,7 +168,7 @@ impl CodexResponsesRequestKind {}}- fn has_turn_identity(self) -> bool {+ fn has_thread_identity(self) -> bool {!matches!(self, CodexResponsesRequestKind::Memory)}}@@ -380,20 +380,18 @@ impl CodexResponsesMetadata {let (request_kind, compaction) = request_kind.metadata();(Some(request_kind), compaction)});- let has_turn_identity =- request_kind.is_none_or(CodexResponsesRequestKind::has_turn_identity);+ let has_thread_identity =+ request_kind.is_none_or(CodexResponsesRequestKind::has_thread_identity);let has_request_identity =- request_kind.is_some_and(CodexResponsesRequestKind::has_turn_identity);+ request_kind.is_some_and(CodexResponsesRequestKind::has_thread_identity);CodexTurnMetadataPayload {installation_id: has_request_identity.then_some(self.installation_id.as_str()),- session_id: has_turn_identity.then_some(self.session_id.as_str()),- thread_id: has_turn_identity.then_some(self.thread_id.as_str()),- agent_name: has_turn_identity+ session_id: has_thread_identity.then_some(self.session_id.as_str()),+ thread_id: has_thread_identity.then_some(self.thread_id.as_str()),+ agent_name: has_thread_identity.then_some(self.agent_name.as_deref()).flatten(),- turn_id: has_turn_identity- .then_some(self.turn_id.as_deref())- .flatten(),+ turn_id: self.turn_id.as_deref(),window_id: has_request_identity.then_some(self.window_id.as_str()),window_number: has_request_identity.then_some(self.window_number).flatten(),context_window_id: has_request_identitydiff --git a/codex-rs/core/src/session/input_queue.rs b/codex-rs/core/src/session/input_queue.rsindex 94d3dfeb4d..3efdb90b0c 100644--- a/codex-rs/core/src/session/input_queue.rs+++ b/codex-rs/core/src/session/input_queue.rs@@ -292,14 +292,10 @@ impl InputQueue {&self,active_turn: &Mutex<Option<ActiveTurn>>,) -> (Vec<TurnInput>, TurnStartOptions) {- let (pending_input, accepts_mailbox_delivery, active_turn_metadata) = {+ let (pending_input, accepts_mailbox_delivery) = {let mut active = active_turn.lock().await;match active.as_mut() {Some(active_turn) => {- let active_turn_metadata = active_turn- .task- .as_ref()- .map(|task| Arc::clone(&task.turn_context.turn_metadata_state));let mut turn_state = active_turn.turn_state.lock().await;let accepts_mailbox_delivery =turn_state.accepts_mailbox_delivery_for_current_turn();@@ -308,25 +304,15 @@ impl InputQueue {} else {Vec::new()};- (- pending_input,- accepts_mailbox_delivery,- active_turn_metadata,- )+ (pending_input, accepts_mailbox_delivery)}- None => (Vec::new(), true, None),+ None => (Vec::new(), true),}};if !accepts_mailbox_delivery {return (pending_input, TurnStartOptions::default());}let (mailbox_items, start_options) = self.drain_mailbox_input_items().await;- if let Some(active_turn_metadata) = active_turn_metadata- && active_turn_metadata.root_turn_id().is_none()- && let Some(root_turn_id) = start_options.root_turn_id.as_ref()- {- active_turn_metadata.set_root_turn_id(root_turn_id.clone());- }if pending_input.is_empty() {(mailbox_items, start_options)} else {diff --git a/codex-rs/core/src/session/review.rs b/codex-rs/core/src/session/review.rsindex 202aae4aca..695662914a 100644--- a/codex-rs/core/src/session/review.rs+++ b/codex-rs/core/src/session/review.rs@@ -130,9 +130,6 @@ pub(super) async fn spawn_review_thread(auto_review_enabled,&model_info,));- if turn_metadata_state.can_start_root_turn(&session_source) {- turn_metadata_state.set_root_turn_id(review_turn_id.clone());- }let extension_data = Arc::new(codex_extension_api::ExtensionData::new(review_turn_id.clone(),diff --git a/codex-rs/core/src/session/tests.rs b/codex-rs/core/src/session/tests.rsindex 0847c59ce2..79dc4f069f 100644--- a/codex-rs/core/src/session/tests.rs+++ b/codex-rs/core/src/session/tests.rs@@ -12053,20 +12053,14 @@ async fn trigger_turn_mailbox_mail_waits_for_next_turn_after_answer_boundary() {assert!(sess.input_queue.has_trigger_turn_mailbox_items().await);}+#[test_case(None; "independent root")]+#[test_case(Some("root-a"); "inherited root")]#[tokio::test]-async fn active_turn_keeps_first_root_when_mail_coalesces() {+async fn active_turn_keeps_first_root_when_mail_coalesces(inherited_root: Option<&str>) {let (sess, tc, _rx) = make_session_and_context_with_rx().await;- tc.turn_metadata_state- .set_root_turn_id("root-a".to_string());- sess.spawn_task(- Arc::clone(&tc),- Vec::new(),- NeverEndingTask {- kind: TaskKind::Regular,- listen_to_cancellation_token: true,- },- )- .await;+ if let Some(root) = inherited_root {+ tc.turn_metadata_state.set_root_turn_id(root.to_string());+ }let first = InterAgentCommunication::new(AgentPath::try_from("/root/worker_a").expect("worker path should parse"),AgentPath::root(),@@ -12081,10 +12075,13 @@ async fn active_turn_keeps_first_root_when_mail_coalesces() {"second".to_string(),/*trigger_turn*/ true,);- for (communication, parent_turn_id, root_turn_id) in [+ for (index, (communication, parent_turn_id, root_turn_id)) in [(first.clone(), "parent-a", "root-a"),(second.clone(), "parent-b", "root-b"),- ] {+ ]+ .into_iter()+ .enumerate()+ {sess.input_queue.enqueue_mailbox_communication(communication,@@ -12095,6 +12092,19 @@ async fn active_turn_keeps_first_root_when_mail_coalesces() {},).await;+ if index == 0 {+ // The first message is already queued when this independent task+ // starts; the second arrives after its root is established.+ sess.spawn_task(+ Arc::clone(&tc),+ Vec::new(),+ NeverEndingTask {+ kind: TaskKind::Regular,+ listen_to_cancellation_token: true,+ },+ )+ .await;+ }}assert_eq!(@@ -12106,7 +12116,7 @@ async fn active_turn_keeps_first_root_when_mail_coalesces() {);assert_eq!(tc.turn_metadata_state.root_turn_id().as_deref(),- Some("root-a")+ Some(inherited_root.unwrap_or(&tc.sub_id)));assert!(!sess.input_queue.has_pending_mailbox_items().await);diff --git a/codex-rs/core/src/session/turn_input.rs b/codex-rs/core/src/session/turn_input.rsindex fe7b5ce32b..4bb8a16cfc 100644--- a/codex-rs/core/src/session/turn_input.rs+++ b/codex-rs/core/src/session/turn_input.rs@@ -262,11 +262,6 @@ async fn start_or_steer());}};- let can_start_root_turn = start.parent_turn_id.is_none() && start.root_turn_id.is_none();- let incoming_root_turn_id = start- .parent_turn_id- .as_ref()- .map(|_| start.root_turn_id.clone());let settings = PreparedTurnInputSettings::prepare(session, thread_settings, start).await?;match session.steer_input(@@ -275,7 +270,6 @@ async fn start_or_steer(/*expected_turn_id*/ None,settings.required_active_final_output_json_schema(),responsesapi_client_metadata.clone(),- incoming_root_turn_id,).await{@@ -290,16 +284,6 @@ async fn start_or_steer(else {unreachable!("explicit user input can enter Plan mode");};- if can_start_root_turn- && has_explicit_input- && turn_context- .turn_metadata_state- .can_start_root_turn(&turn_context.session_source)- {- turn_context- .turn_metadata_state- .set_root_turn_id(submission_id.clone());- }if let Some(responsesapi_client_metadata) = responsesapi_client_metadata {turn_context.turn_metadata_state@@ -340,7 +324,6 @@ async fn start_if_idle(responsesapi_client_metadata,..} = request;- let can_start_root_turn = start.parent_turn_id.is_none() && start.root_turn_id.is_none();if session.input_queue.has_trigger_turn_mailbox_items().await {return Ok(TurnInputSubmission::NotSubmitted {reason: NotSubmittedReason::PendingTriggerTurn,@@ -403,16 +386,6 @@ async fn start_if_idle(.turn_metadata_state.set_responsesapi_client_metadata(responsesapi_client_metadata);}- if kind == TurnStartKind::User- && can_start_root_turn- && turn_context- .turn_metadata_state- .can_start_root_turn(&turn_context.session_source)- {- turn_context- .turn_metadata_state- .set_root_turn_id(submission_id.clone());- }session.maybe_emit_model_warnings_for_turn(turn_context.as_ref()).await;@@ -469,10 +442,6 @@ async fn steer("only user input can steer a turn".to_string(),));}- let incoming_root_turn_id = start- .parent_turn_id- .as_ref()- .map(|_| start.root_turn_id.clone());let settings = PreparedTurnInputSettings::prepare(session, thread_settings, start).await?;match session.steer_input(@@ -481,7 +450,6 @@ async fn steer(Some(expected_turn_id.as_str()),settings.required_active_final_output_json_schema(),responsesapi_client_metadata,- incoming_root_turn_id,).await{@@ -557,7 +525,6 @@ impl Session {expected_turn_id: Option<&str>,required_final_output_json_schema: Option<&Value>,responsesapi_client_metadata: Option<HashMap<String, String>>,- incoming_root_turn_id: Option<Option<String>>,) -> Result<String, NotSubmittedReason> {let mut active = self.active_turn.lock().await;let Some(active_turn) = active.as_mut() else {@@ -627,18 +594,6 @@ impl Session {input => pending_turn_input(self, input.clone()).await,};pending_input.push(input);- if active_task- .turn_context- .turn_metadata_state- .root_turn_id()- .is_none()- && let Some(Some(incoming_root_turn_id)) = incoming_root_turn_id- {- active_task- .turn_context- .turn_metadata_state- .set_root_turn_id(incoming_root_turn_id);- }self.input_queue.extend_pending_input_and_accept_mailbox_delivery_for_turn_state(active_turn.turn_state.as_ref(),diff --git a/codex-rs/core/src/tasks/mod.rs b/codex-rs/core/src/tasks/mod.rsindex 9cf988a295..9344f8262f 100644--- a/codex-rs/core/src/tasks/mod.rs+++ b/codex-rs/core/src/tasks/mod.rs@@ -285,6 +285,11 @@ impl Session {input: Vec<TurnInput>,task: T,) {+ // Inherited or recovered roots are applied before task start. Otherwise this+ // task owns its turn, including background work. Later mail cannot change it.+ turn_context+ .turn_metadata_state+ .set_root_turn_id(turn_context.sub_id.clone());let task: Arc<dyn AnySessionTask> = Arc::new(task);let task_kind = task.kind();let span_name = task.span_name();@@ -307,14 +312,7 @@ impl Session {.await.clear_turn(&turn_context.sub_id);- let (pending_items, start_options) = self.input_queue.drain_mailbox_input_items().await;- if turn_context.turn_metadata_state.root_turn_id().is_none()- && let Some(root_turn_id) = start_options.root_turn_id- {- turn_context- .turn_metadata_state- .set_root_turn_id(root_turn_id);- }+ let (pending_items, _) = self.input_queue.drain_mailbox_input_items().await;let turn_state = {let mut active = self.active_turn.lock().await;let turn = active.get_or_insert_with(ActiveTurn::default);diff --git a/codex-rs/core/src/turn_metadata.rs b/codex-rs/core/src/turn_metadata.rsindex 8d3114845c..681475b86e 100644--- a/codex-rs/core/src/turn_metadata.rs+++ b/codex-rs/core/src/turn_metadata.rs@@ -93,7 +93,10 @@ pub async fn detached_memory_responses_metadata(permission_profile: &PermissionProfile,sandbox: Option<&str>,) -> CodexResponsesMetadata {+ let turn_id = uuid::Uuid::now_v7().to_string();let mut metadata = CodexResponsesMetadata {+ turn_id: Some(turn_id.clone()),+ root_turn_id: Some(turn_id),request_kind: Some(CodexResponsesRequestKind::Memory),thread_source: Some(ThreadSource::MemoryConsolidation),subagent_header: subagent_header_value(session_source),@@ -340,24 +343,6 @@ impl TurnMetadataState {self.root_turn_id.get().cloned()}- pub(crate) fn can_start_root_turn(&self, session_source: &SessionSource) -> bool {- if session_source.is_non_root_agent() {- return false;- }- match &self.thread_source {- // Desktop create/fork/send lacks trusted app-server provenance; fail closed.- Some(- ThreadSource::Subagent- | ThreadSource::GuardianReview- | ThreadSource::MemoryConsolidation,- ) => false,- Some(ThreadSource::Feature(feature)) => {- !matches!(feature.as_str(), "system" | "title") && !feature.starts_with("ambient")- }- Some(ThreadSource::User) | None => true,- }- }-pub(crate) fn set_responsesapi_client_metadata(&self,responsesapi_client_metadata: HashMap<String, String>,diff --git a/codex-rs/core/src/turn_metadata_tests.rs b/codex-rs/core/src/turn_metadata_tests.rsindex 247b01c47f..fb6c118cc3 100644--- a/codex-rs/core/src/turn_metadata_tests.rs+++ b/codex-rs/core/src/turn_metadata_tests.rs@@ -139,7 +139,7 @@ async fn wait_for_git_enrichment(state: &TurnMetadataState) -> Value {}#[tokio::test]-async fn detached_memory_responses_metadata_omits_turn_identity() {+async fn detached_memory_responses_metadata_starts_an_independent_root_turn() {let (_temp_dir, repo_path) = create_clean_git_repo("repo-東京").await;let thread_manager = crate::ThreadManager::with_models_provider_for_tests(@@ -147,7 +147,7 @@ async fn detached_memory_responses_metadata_omits_turn_identity() {crate::config::test_config().await.model_provider,);- let header = detached_memory_responses_metadata(+ let metadata = detached_memory_responses_metadata(&thread_manager,String::new(),String::new(),@@ -158,9 +158,8 @@ async fn detached_memory_responses_metadata_omits_turn_identity() {&PermissionProfile::read_only(),Some("none"),)- .await- .turn_metadata_json()- .expect("header");+ .await;+ let header = metadata.turn_metadata_json().expect("header");assert!(header.is_ascii());assert!(!header.contains("東京"));let parsed: Value = serde_json::from_str(&header).expect("valid json");@@ -173,8 +172,18 @@ async fn detached_memory_responses_metadata_omits_turn_identity() {assert!(parsed.get("session_id").is_none());assert!(parsed.get("thread_id").is_none());assert!(parsed.get("forked_from_thread_id").is_none());- assert!(parsed.get("turn_id").is_none());- assert!(parsed.get(ROOT_TURN_ID_KEY).is_none());+ let turn_id = parsed["turn_id"].as_str().expect("memory turn ID");+ uuid::Uuid::parse_str(turn_id).expect("memory turn ID is a UUID");+ assert_eq!(parsed[ROOT_TURN_ID_KEY], parsed["turn_id"]);+ let client_metadata = metadata.client_metadata();+ assert_eq!(+ client_metadata.get("turn_id").map(String::as_str),+ Some(turn_id)+ );+ assert_eq!(+ client_metadata.get(ROOT_TURN_ID_KEY).map(String::as_str),+ Some(turn_id)+ );assert!(parsed.get(WINDOW_ID_KEY).is_none());let expected_repo_path = repo_path.to_string_lossy().into_owned();@@ -221,10 +230,14 @@ async fn detached_memory_responses_metadata_omits_empty_workspace_metadata() {.turn_metadata_json().expect("detached memory should emit its request kind");let parsed: Value = serde_json::from_str(&header).expect("valid json");+ let turn_id = parsed["turn_id"].as_str().expect("memory turn ID");+ uuid::Uuid::parse_str(turn_id).expect("memory turn ID is a UUID");assert_eq!(parsed,serde_json::json!({+ "turn_id": turn_id,+ "root_turn_id": turn_id,"request_kind": "memory","sandbox_mode": "read-only","thread_source": "memory_consolidation",diff --git a/codex-rs/core/tests/suite/compact_remote.rs b/codex-rs/core/tests/suite/compact_remote.rsindex cfaf139ddd..7de3e92541 100644--- a/codex-rs/core/tests/suite/compact_remote.rs+++ b/codex-rs/core/tests/suite/compact_remote.rs@@ -1259,7 +1259,7 @@ async fn assert_remote_manual_compact_request_parity(.await?;wait_for_turn_complete(&codex).await;- codex.submit(Op::Compact).await?;+ let compact_turn_id = codex.submit(Op::Compact).await?;wait_for_turn_complete(&codex).await;let response_requests = responses_mock.requests();@@ -1280,6 +1280,13 @@ async fn assert_remote_manual_compact_request_parity(let compact_request = compact_mock.single_request();let normal_body = normal_request.body_json();let compact_body = compact_request.body_json();+ let compact_metadata: Value = serde_json::from_str(+ &compact_request+ .header("x-codex-turn-metadata")+ .expect("compaction turn metadata"),+ )?;+ assert_eq!(compact_metadata["turn_id"], compact_turn_id);+ assert_eq!(compact_metadata["root_turn_id"], compact_turn_id);let expected_routing_hint = |body: &Value| {if !uses_codex_backend {return None;diff --git a/codex-rs/core/tests/suite/git_enrichment.rs b/codex-rs/core/tests/suite/git_enrichment.rsindex 989683fe82..5286068b10 100644--- a/codex-rs/core/tests/suite/git_enrichment.rs+++ b/codex-rs/core/tests/suite/git_enrichment.rs@@ -329,6 +329,9 @@ async fn guardian_prewarm_and_review_skip_redundant_git_enrichment() -> Result<(#[test_case("system"; "system background thread")]#[test_case("ambient_background"; "ambient background thread")]+#[test_case("ambient_suggestions"; "ambient suggestions")]+#[test_case("ambient_suggestion_safety"; "ambient suggestion safety")]+#[test_case("title"; "title background thread")]#[tokio::test(flavor = "multi_thread", worker_threads = 2)]async fn ephemeral_system_thread_prewarm_skips_and_turn_observes_fresh_state(thread_source: &str,@@ -388,7 +391,7 @@ async fn ephemeral_system_thread_prewarm_skips_and_turn_observes_fresh_state(assert!(turn_metadata(&prewarm)?.get("workspaces").is_none());std::fs::write(repo.path().join("untracked.txt"), "dirty\n")?;- system_thread+ let submission = system_thread.thread.start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {text: "generate a thread title".into(),@@ -405,7 +408,10 @@ async fn ephemeral_system_thread_prewarm_skips_and_turn_observes_fresh_state(.and_then(|connection| connection.get(2)).context("system turn follow-up request")?.body_json();- assert_root_turn(&turn, /*expected*/ None)?;+ let codex_core::TurnInputSubmission::Started { turn_id } = submission else {+ panic!("background input should start a turn");+ };+ assert_root_turn(&turn, Some(&turn_id))?;assert_eq!(turn_metadata(&turn)?["workspaces"],expected_workspace(repo.path(), &head, /*has_changes*/ true)diff --git a/codex-rs/core/tests/suite/pending_input.rs b/codex-rs/core/tests/suite/pending_input.rsindex c7ea6fe73b..f1086c7e41 100644--- a/codex-rs/core/tests/suite/pending_input.rs+++ b/codex-rs/core/tests/suite/pending_input.rs@@ -86,12 +86,14 @@ async fn idle_response_items_include_pending_mailbox_in_first_request() -> anyhoresponses::user_message_item("automatic response item"),))).await?;- assert!(matches!(submission, StartIfIdleSubmission::Started { .. }));+ let StartIfIdleSubmission::Started { turn_id } = submission else {+ panic!("automatic input should start a turn");+ };wait_for_turn_complete(test.codex.as_ref()).await;let request = response.single_request();let request_body = request.body_json();- responses::assert_root_turn(&request_body, /*expected*/ None)?;+ responses::assert_root_turn(&request_body, Some(&turn_id))?;responses::assert_parent_turn(&request_body, /*expected*/ None)?;let user_messages = request.message_input_texts("user");assert!(diff --git a/codex-rs/memories/write/src/startup_tests.rs b/codex-rs/memories/write/src/startup_tests.rsindex 53aa77793c..4771d42029 100644--- a/codex-rs/memories/write/src/startup_tests.rs+++ b/codex-rs/memories/write/src/startup_tests.rs@@ -670,7 +670,18 @@ async fn memories_startup_phase1_uses_live_thread_service_tier_and_detached_metaassert_eq!(metadata["sandbox_mode"].as_str(), Some("workspace-write"));assert!(metadata.get("session_id").is_none());assert!(metadata.get("thread_id").is_none());- assert!(metadata.get("turn_id").is_none());+ let turn_id = metadata["turn_id"].as_str().expect("memory turn ID");+ uuid::Uuid::parse_str(turn_id).expect("memory turn ID is a UUID");+ assert_eq!(metadata["root_turn_id"], metadata["turn_id"]);+ let request_body = request.body_json();+ assert_eq!(+ request_body["client_metadata"]["turn_id"],+ metadata["turn_id"]+ );+ assert_eq!(+ request_body["client_metadata"]["root_turn_id"],+ metadata["root_turn_id"]+ );assert!(metadata.get("window_id").is_none());assert!(metadata.get("workspaces").is_some());