Lightweight coding agent that runs in your terminal
Rust
Preserve turn lineage across goal continuations (#41562)
Eric Traut4210c08defe9
diff --git a/codex-rs/app-server/tests/suite/v2/thread_resume.rs b/codex-rs/app-server/tests/suite/v2/thread_resume.rsindex 807705667f..c7ba315ac8 100644--- a/codex-rs/app-server/tests/suite/v2/thread_resume.rs+++ b/codex-rs/app-server/tests/suite/v2/thread_resume.rs@@ -2985,6 +2985,214 @@ async fn thread_goal_set_edits_objective_without_resetting_usage() -> Result<()>Ok(())}+#[tokio::test]+async fn thread_goal_keeps_original_root_until_external_objective_edit() -> Result<()> {+ let (release_original_turn, original_turn_gate) = oneshot::channel();+ let (release_edited_turn, edited_turn_gate) = oneshot::channel();+ let (server, _response_completions) = start_streaming_sse_server(vec![+ ungated_goal_response(responses::sse(vec![+ responses::ev_response_created("create-original-goal"),+ responses::ev_function_call(+ "create-original-goal-call",+ "create_goal",+ r#"{"objective":"keep its original owner","token_budget":100}"#,+ ),+ responses::ev_completed_with_tokens("create-original-goal", /*total_tokens*/ 5),+ ])),+ vec![StreamingSseChunk {+ gate: Some(original_turn_gate),+ body: responses::sse_completed("finish-original-user-turn"),+ }],+ ungated_goal_response(responses::sse_completed("reopen-original-user-turn")),+ ungated_goal_response(responses::sse_completed("finish-intervening-user-turn")),+ ungated_goal_response(responses::sse(vec![+ responses::ev_response_created("goal-continuation-after-intervening-turn"),+ responses::ev_completed_with_tokens(+ "goal-continuation-after-intervening-turn",+ /*total_tokens*/ 40,+ ),+ ])),+ vec![StreamingSseChunk {+ gate: Some(edited_turn_gate),+ body: responses::sse_completed("second-goal-continuation"),+ }],+ ungated_goal_response(responses::sse_completed("reopened-goal-turn")),+ ungated_goal_response(responses::sse(vec![+ responses::ev_response_created("rootless-goal-continuation"),+ responses::ev_completed_with_tokens(+ "rootless-goal-continuation",+ /*total_tokens*/ 100,+ ),+ ])),+ ])+ .await;+ let codex_home = TempDir::new()?;+ mock_responses_config(server.uri())+ .enable_feature(Feature::Goals)+ .write(codex_home.path())?;+ let mut mcp = TestAppServer::builder()+ .with_codex_home(codex_home.path())+ .without_managed_config()+ .build_initialized()+ .await?;+ let thread = mcp.start_thread(ThreadStartParams::default()).await?.thread;++ let start_id = mcp+ .send_turn_start_request(TurnStartParams {+ thread_id: thread.id.clone(),+ input: vec![UserInput::Text {+ text: "create the original goal".to_string(),+ text_elements: Vec::new(),+ }],+ ..Default::default()+ })+ .await?;+ let original_turn: TurnStartResponse =+ timeout(DEFAULT_READ_TIMEOUT, mcp.read_response(start_id)).await??;+ timeout(+ DEFAULT_READ_TIMEOUT,+ server.wait_for_request_count(/*count*/ 2),+ )+ .await?;++ let injection_id = mcp+ .send_raw_request(+ "thread/inject_items",+ Some(json!({+ "threadId": thread.id,+ "items": [{+ "type": "message",+ "role": "developer",+ "content": [{+ "type": "input_text",+ "text": "externally injected context",+ }],+ }],+ })),+ )+ .await?;+ let _: serde_json::Value =+ timeout(DEFAULT_READ_TIMEOUT, mcp.read_response(injection_id)).await??;++ let queue_id = mcp+ .send_raw_request(+ "thread/queue/add",+ Some(json!({+ "threadId": thread.id,+ "input": [{+ "type": "text",+ "text": "an intervening user message",+ "textElements": [],+ }],+ "clientUserMessageId": "intervening-goal-message",+ })),+ )+ .await?;+ let _: serde_json::Value = timeout(DEFAULT_READ_TIMEOUT, mcp.read_response(queue_id)).await??;+ release_original_turn+ .send(())+ .expect("original turn should remain open until the user message is queued");++ for _ in 0..3 {+ timeout(+ DEFAULT_READ_TIMEOUT,+ mcp.read_stream_until_notification_message("turn/completed"),+ )+ .await??;+ }+ timeout(+ DEFAULT_READ_TIMEOUT,+ server.wait_for_request_count(/*count*/ 6),+ )+ .await?;++ let edit_id = mcp+ .send_raw_request(+ "thread/goal/set",+ Some(json!({+ "threadId": thread.id,+ "objective": "externally updated goal",+ "status": "active",+ })),+ )+ .await?;+ let edited_goal: ThreadGoalSetResponse =+ timeout(DEFAULT_READ_TIMEOUT, mcp.read_response(edit_id)).await??;+ assert_eq!(edited_goal.goal.objective, "externally updated goal");+ timeout(+ DEFAULT_READ_TIMEOUT,+ mcp.read_stream_until_notification_message("thread/goal/updated"),+ )+ .await??;++ let get_id = mcp+ .send_raw_request("thread/goal/get", Some(json!({ "threadId": thread.id })))+ .await?;+ let _: codex_app_server_protocol::ThreadGoalGetResponse =+ timeout(DEFAULT_READ_TIMEOUT, mcp.read_response(get_id)).await??;+ release_edited_turn+ .send(())+ .expect("goal turn should remain open until its external edit");++ for _ in 0..2 {+ timeout(+ DEFAULT_READ_TIMEOUT,+ mcp.read_stream_until_notification_message("turn/completed"),+ )+ .await??;+ }++ let requests = server.requests().await;+ assert_eq!(requests.len(), 8);+ let reopened_original_request = serde_json::from_slice::<serde_json::Value>(&requests[2])?;+ assert_eq!(+ reopened_original_request["client_metadata"]["turn_id"].as_str(),+ Some(original_turn.turn.id.as_str())+ );+ responses::assert_root_turn(&reopened_original_request, /*expected*/ None)?;+ let intervening_request = serde_json::from_slice::<serde_json::Value>(&requests[3])?;+ let intervening_turn_id = intervening_request["client_metadata"]["turn_id"]+ .as_str()+ .expect("intervening user turn ID");+ responses::assert_root_turn(&intervening_request, Some(intervening_turn_id))?;+ let first_continuation = serde_json::from_slice::<serde_json::Value>(&requests[4])?;+ let first_continuation_turn_id = first_continuation["client_metadata"]["turn_id"]+ .as_str()+ .expect("first continuation turn ID");+ let second_continuation = serde_json::from_slice::<serde_json::Value>(&requests[5])?;+ for (request, parent_turn_id) in [+ (&first_continuation, intervening_turn_id),+ (&second_continuation, first_continuation_turn_id),+ ] {+ responses::assert_root_turn(request, Some(original_turn.turn.id.as_str()))?;+ responses::assert_parent_turn(request, Some(parent_turn_id))?;+ }+ let edited_turn_id = second_continuation["client_metadata"]["turn_id"]+ .as_str()+ .expect("second continuation turn ID");++ let reopened_request = serde_json::from_slice::<serde_json::Value>(&requests[6])?;+ assert_eq!(+ reopened_request["client_metadata"]["turn_id"].as_str(),+ Some(edited_turn_id)+ );+ responses::assert_root_turn(&reopened_request, /*expected*/ None)?;+ 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)?;+ responses::assert_parent_turn(&continuation_request, /*expected*/ None)?;++ server.shutdown().await;+ Ok(())+}++fn ungated_goal_response(body: String) -> Vec<StreamingSseChunk> {+ vec![StreamingSseChunk { gate: None, body }]+}+#[tokio::test]async fn thread_goal_lifecycle_emits_analytics_and_clear_deletes_goal() -> Result<()> {let server = create_mock_responses_server_sequence_unchecked(vec![@@ -3131,6 +3339,20 @@ async fn thread_goal_lifecycle_emits_analytics_and_clear_deletes_goal() -> Resulserde_json::Value::Null);+ let requests = server.received_requests().await.expect("wiremock requests");+ let goal_request = requests+ .iter()+ .filter(|request| request.url.path().ends_with("/responses"))+ .nth(1)+ .expect("externally created goal continuation request");+ let goal_request_body = goal_request.body_json::<serde_json::Value>()?;+ assert_eq!(+ goal_request_body["client_metadata"]["turn_id"],+ causal_turn_id+ );+ responses::assert_root_turn(&goal_request_body, /*expected*/ None)?;+ responses::assert_parent_turn(&goal_request_body, /*expected*/ None)?;+let clear_id = mcp.send_raw_request("thread/goal/clear",diff --git a/codex-rs/core/src/codex_thread.rs b/codex-rs/core/src/codex_thread.rsindex 3527df18d5..533d1351c2 100644--- a/codex-rs/core/src/codex_thread.rs+++ b/codex-rs/core/src/codex_thread.rs@@ -510,6 +510,28 @@ impl CodexThread {self.session.inject_if_running(items).await}+ /// Returns the trusted root when the expected turn is currently active.+ pub async fn active_turn_root(&self, expected_turn_id: &str) -> Option<String> {+ let active = self.session.active_turn.lock().await;+ let task = active.as_ref()?.task.as_ref()?;+ if task.turn_context.sub_id != expected_turn_id {+ return None;+ }+ task.turn_context.turn_metadata_state.root_turn_id()+ }++ /// Invalidates the trusted root when the expected turn is currently active.+ pub async fn invalidate_turn_lineage(&self, expected_turn_id: &str) {+ let active = self.session.active_turn.lock().await;+ if let Some(task) = active.as_ref().and_then(|turn| turn.task.as_ref())+ && task.turn_context.sub_id == expected_turn_id+ {+ task.turn_context+ .turn_metadata_state+ .mark_root_turn_ambiguous();+ }+ }+pub async fn set_app_server_client_info(&self,app_server_client_name: Option<String>,diff --git a/codex-rs/core/src/hook_runtime.rs b/codex-rs/core/src/hook_runtime.rsindex e8202d38f5..f3a0ec11c9 100644--- a/codex-rs/core/src/hook_runtime.rs+++ b/codex-rs/core/src/hook_runtime.rs@@ -769,10 +769,21 @@ pub(crate) async fn drain_async_hook_results(.collect::<Vec<_>>();if before_user_prompt {+ // A fresh user turn owns its root; automatic turns only inherit one.+ let current_turn_id = Some(turn_context.sub_id.as_str());+ if !additional_contexts.is_empty()+ && result.turn_id.as_deref() != current_turn_id+ && turn_context.turn_metadata_state.root_turn_id().as_deref() != current_turn_id+ {+ turn_context.turn_metadata_state.mark_root_turn_ambiguous();+ }record_additional_contexts(sess, turn_context, additional_contexts).await;} else if !additional_contexts.is_empty() {let _ = sess- .inject_if_running(additional_context_messages(additional_contexts))+ .inject_hook_context_if_running(+ additional_context_messages(additional_contexts),+ result.turn_id.as_deref(),+ ).await;}diff --git a/codex-rs/core/src/session/inject.rs b/codex-rs/core/src/session/inject.rsindex 8c17a8ae5e..3c57e7033f 100644--- a/codex-rs/core/src/session/inject.rs+++ b/codex-rs/core/src/session/inject.rs@@ -35,6 +35,41 @@ impl Session {}}+ /// Injects hook context while classifying its actual receiving turn atomically.+ #[expect(+ clippy::await_holding_invalid_type,+ reason = "active turn provenance and turn state updates must remain atomic"+ )]+ pub(crate) async fn inject_hook_context_if_running(+ &self,+ input: Vec<ResponseItem>,+ source_turn_id: Option<&str>,+ ) -> Result<(), Vec<ResponseItem>> {+ let mut active = self.active_turn.lock().await;+ let Some(active_turn) = active.as_mut() else {+ return Err(input);+ };+ let Some(task) = active_turn.task.as_ref() else {+ return Err(input);+ };+ if source_turn_id != Some(task.turn_context.sub_id.as_str()) {+ task.turn_context+ .turn_metadata_state+ .mark_root_turn_ambiguous();+ }+ self.input_queue+ .extend_pending_input_and_accept_mailbox_delivery_for_turn_state(+ active_turn.turn_state.as_ref(),+ input+ .into_iter()+ .map(ResponseItemEnvelope::new)+ .map(PendingTurnInput::ResponseItem)+ .collect(),+ )+ .await;+ Ok(())+ }+/// Preserves trusted client provenance while items wait for an active turn.#[expect(clippy::await_holding_invalid_type,@@ -51,6 +86,11 @@ impl Session {.collect::<Vec<_>>();let mut active = self.active_turn.lock().await;if let Some(active_turn) = active.as_mut() {+ if let Some(task) = active_turn.task.as_ref() {+ task.turn_context+ .turn_metadata_state+ .mark_root_turn_ambiguous();+ }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/tests/suite/hooks.rs b/codex-rs/core/tests/suite/hooks.rsindex 1e88b17147..e4874b489c 100644--- a/codex-rs/core/tests/suite/hooks.rs+++ b/codex-rs/core/tests/suite/hooks.rs@@ -5,7 +5,9 @@ use anyhow::Context;use anyhow::Result;use codex_config::test_support::CloudConfigBundleFixture;use codex_core::StartThreadOptions;+use codex_core::TurnInput;use codex_core::TurnInputRequest;+use codex_core::TurnStartOptions;use codex_core::config::Config;use codex_core::config::Constrained;use codex_core::config::ThreadStoreConfig;@@ -39,6 +41,7 @@ use core_test_support::fs_wait;use core_test_support::hooks::trust_discovered_hooks;use core_test_support::hooks::trust_hooks;use core_test_support::managed_network_requirements_loader;+use core_test_support::responses;use core_test_support::responses::ev_apply_patch_custom_tool_call;use core_test_support::responses::ev_assistant_message;use core_test_support::responses::ev_completed;@@ -1704,6 +1707,11 @@ async fn async_hook_context_is_injected_into_the_active_turn() -> Result<()> {let requests = responses.requests();assert_eq!(requests.len(), 2);+ let first_request = requests[0].body_json();+ let turn_id = first_request["client_metadata"]["turn_id"]+ .as_str()+ .context("first model request should include its turn ID")?;+ responses::assert_root_turn(&requests[1].body_json(), Some(turn_id))?;assert!(requests[1].message_input_texts("developer")@@ -1714,8 +1722,12 @@ async fn async_hook_context_is_injected_into_the_active_turn() -> Result<()> {Ok(())}+#[test_case::test_case(/*automatic_continuation*/ false; "user_turn")]+#[test_case::test_case(/*automatic_continuation*/ true; "automatic_continuation")]#[tokio::test]-async fn async_hook_finishing_while_idle_waits_for_the_next_turn() -> Result<()> {+async fn async_hook_finishing_while_idle_waits_for_the_next_turn(+ automatic_continuation: bool,+) -> Result<()> {skip_if_no_network!(Ok(()));let server = start_mock_server().await;@@ -1785,12 +1797,22 @@ async fn async_hook_finishing_while_idle_waits_for_the_next_turn() -> Result<()>);let next_prompt = "observe the buffered async context";- test.codex- .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {+ let next_turn = if automatic_continuation {+ TurnInputRequest::new(TurnInput::ResponseItem(responses::user_message_item(+ next_prompt,+ )))+ .on_start(TurnStartOptions {+ root_turn_id: Some(first_turn_id.clone()),+ parent_turn_id: Some(first_turn_id.clone()),+ ..Default::default()+ })+ } else {+ TurnInputRequest::user_input(vec![UserInput::Text {text: next_prompt.to_string(),text_elements: Vec::new(),- }]))- .await?;+ }])+ };+ test.codex.start_turn_if_idle(next_turn).await?;let mut warning_event = None;timeout(Duration::from_secs(5), async {@@ -1819,6 +1841,10 @@ async fn async_hook_finishing_while_idle_waits_for_the_next_turn() -> Result<()>.context("second model request should include its turn ID")?.to_string();assert_ne!(first_turn_id, second_turn_id);+ responses::assert_root_turn(+ &requests[1].body_json(),+ (!automatic_continuation).then_some(second_turn_id.as_str()),+ )?;assert_eq!(warning_event.context("buffered async hook warning should be delivered during the next turn")?diff --git a/codex-rs/core/tests/suite/pending_input.rs b/codex-rs/core/tests/suite/pending_input.rsindex aa9b2f7918..440ba1d42d 100644--- a/codex-rs/core/tests/suite/pending_input.rs+++ b/codex-rs/core/tests/suite/pending_input.rs@@ -1043,6 +1043,7 @@ async fn queued_inter_agent_mail_does_not_restart_after_final_answer() {async fn injected_response_item_reopens_turn_after_final_answer() {const INITIAL_PROMPT: &str = "first prompt";const INJECTED_CONTEXT: &str = "late injected context";+ const EXTERNAL_CONTEXT: &str = "external injected context";let (gate_completed_tx, gate_completed_rx) = oneshot::channel();let first_chunks = vec![@@ -1083,18 +1084,35 @@ async fn injected_response_item_reopens_turn_after_final_answer() {.await.is_ok());+ codex+ .inject_response_items(vec![responses::user_message_item(EXTERNAL_CONTEXT)])+ .await+ .expect("external context should be injected");let _ = gate_completed_tx.send(());wait_for_turn_complete(&codex).await;let requests = server.requests().await;assert_eq!(requests.len(), 2);+ let first: Value = from_slice(&requests[0]).expect("parse first request");+ let first_turn_id = first["client_metadata"]["turn_id"]+ .as_str()+ .expect("first request should include its turn ID");+ responses::assert_root_turn(&first, Some(first_turn_id))+ .expect("initial root should be trusted");let second: Value = from_slice(&requests[1]).expect("parse second request");+ responses::assert_root_turn(&second, /*expected*/ None)+ .expect("external injection should invalidate the active turn root");let relevant_user_input = message_input_texts(&second, "user").into_iter()- .filter(|text| text == INITIAL_PROMPT || text == INJECTED_CONTEXT)+ .filter(|text| {+ text == INITIAL_PROMPT || text == INJECTED_CONTEXT || text == EXTERNAL_CONTEXT+ }).collect::<Vec<_>>();- assert_eq!(relevant_user_input, vec![INITIAL_PROMPT, INJECTED_CONTEXT]);+ assert_eq!(+ relevant_user_input,+ vec![INITIAL_PROMPT, INJECTED_CONTEXT, EXTERNAL_CONTEXT]+ );server.shutdown().await;}diff --git a/codex-rs/ext/goal/src/api.rs b/codex-rs/ext/goal/src/api.rsindex 94397d55b4..a643b90ff2 100644--- a/codex-rs/ext/goal/src/api.rs+++ b/codex-rs/ext/goal/src/api.rs@@ -275,6 +275,10 @@ impl GoalService {.map(|goal| (goal, Some(previous_goal)))?};+ if let Some(runtime) = runtime.as_ref() {+ runtime.invalidate_turn_lineage().await;+ }+if objective.is_some() {fill_empty_thread_preview_if_possible(state_db, thread_id, &goal).await;}@@ -316,6 +320,9 @@ impl GoalService {GoalServiceError::Internal(format!("failed to clear thread goal: {err}"))})?;let cleared = cleared_goal.is_some();+ if cleared && let Some(runtime) = runtime.as_ref() {+ runtime.invalidate_turn_lineage().await;+ }drop(goal_state_permit);drop(runtime);diff --git a/codex-rs/ext/goal/src/extension.rs b/codex-rs/ext/goal/src/extension.rsindex 0e8d9e7522..89848996fa 100644--- a/codex-rs/ext/goal/src/extension.rs+++ b/codex-rs/ext/goal/src/extension.rs@@ -3,6 +3,7 @@ use std::sync::Weak;use codex_analytics::AnalyticsEventsClient;use codex_core::ThreadManager;+use codex_core::TurnStartOptions;use codex_extension_api::ConfigContributor;use codex_extension_api::ExtensionData;use codex_extension_api::ExtensionEventSink;@@ -41,6 +42,7 @@ use crate::metrics::GoalMetrics;use crate::runtime::ActiveGoalStopReason;use crate::runtime::GoalRuntimeConfig;use crate::runtime::GoalRuntimeHandle;+use crate::spec::CREATE_GOAL_TOOL_NAME;use crate::spec::UPDATE_GOAL_TOOL_NAME;use crate::steering::budget_limit_steering_item;use crate::tool::GoalToolExecutor;@@ -288,6 +290,7 @@ where).await{+ input.thread_store.remove::<TurnStartOptions>();tracing::warn!("failed to stop active goal after repeated execution failures for {turn_id}: {err}");@@ -302,12 +305,27 @@ where).await{+ input.thread_store.remove::<TurnStartOptions>();tracing::warn!("failed to account active goal progress at turn stop for {turn_id}: {err}");return;}- runtime.accounting_state().finish_turn(turn_id);+ let accounting = runtime.accounting_state();+ if accounting+ .current_active_goal_id_for_turn(turn_id)+ .is_some()+ && let Some(options) = input.thread_store.get::<TurnStartOptions>()+ {+ input.thread_store.insert_if(+ TurnStartOptions {+ parent_turn_id: Some(turn_id.to_string()),+ ..options.as_ref().clone()+ },+ |current| current.is_some(),+ );+ }+ accounting.finish_turn(turn_id);})}@@ -321,6 +339,7 @@ where}let turn_id = input.turn_store.level_id();+ input.thread_store.remove::<TurnStartOptions>();if let Err(err) = runtime.account_active_goal_progress(turn_id,@@ -412,6 +431,23 @@ whereinput.tool_name,input.outcome,);+ if input.tool_name.is_default_namespace()+ && input.tool_name.name == CREATE_GOAL_TOOL_NAME+ && matches!(input.outcome, ToolCallOutcome::Completed { success: true })+ {+ input.thread_store.remove::<TurnStartOptions>();+ if let Ok(_goal_state_permit) = runtime.goal_state_permit().await+ && let Some(thread_manager) = self.thread_manager.upgrade()+ && let Ok(thread) = thread_manager.get_thread(runtime.thread_id()).await+ && let Some(root_turn_id) = thread.active_turn_root(input.turn_id).await+ {+ input.thread_store.insert(TurnStartOptions {+ root_turn_id: Some(root_turn_id),+ parent_turn_id: Some(input.turn_id.to_string()),+ ..Default::default()+ });+ }+ }let should_count_for_goal_progress =tool_attempt_counts_for_goal_progress(input.outcome)&& !(input.tool_name.is_default_namespace()diff --git a/codex-rs/ext/goal/src/runtime.rs b/codex-rs/ext/goal/src/runtime.rsindex 027378f837..dca0736c91 100644--- a/codex-rs/ext/goal/src/runtime.rs+++ b/codex-rs/ext/goal/src/runtime.rs@@ -135,6 +135,19 @@ impl GoalRuntimeHandle {self.inner.root_accounting_state.clone()}+ pub(crate) async fn invalidate_turn_lineage(&self) {+ let Some(thread_manager) = self.inner.thread_manager.upgrade() else {+ return;+ };+ let Ok(thread) = thread_manager.get_thread(self.inner.thread_id).await else {+ return;+ };+ thread.thread_extension_data().remove::<TurnStartOptions>();+ if let Some(turn_id) = self.inner.accounting_state.current_turn_id() {+ thread.invalidate_turn_lineage(turn_id.as_str()).await;+ }+ }+pub(crate) async fn goal_state_permit(&self) -> Result<SemaphorePermit<'_>, String> {self.inner.goal_state_lock@@ -430,13 +443,18 @@ impl GoalRuntimeHandle {self.inner.accounting_state.clear_active_goal();return Ok(());}+ let start_options = thread+ .thread_extension_data()+ .get::<TurnStartOptions>()+ .map(|options| options.as_ref().clone())+ .unwrap_or_default();let item = continuation_steering_item(&protocol_goal_from_state(goal));match thread.start_turn_if_idle(TurnInputRequest::new(TurnInput::ResponseItem(item)).on_start(TurnStartOptions {turn_trigger: Some("goal".to_string()),- ..Default::default()+ ..start_options}),).await