Lightweight coding agent that runs in your terminal
Rust
Preserve turn attribution when queued mail wakes durable sleep (#51419)
Eddie Chenf1dd04959cd6
diff --git a/codex-rs/core/src/session/turn_input.rs b/codex-rs/core/src/session/turn_input.rsindex 84b418a94d..7672b541a1 100644--- a/codex-rs/core/src/session/turn_input.rs+++ b/codex-rs/core/src/session/turn_input.rs@@ -657,6 +657,36 @@ impl Session {}}+ #[expect(+ clippy::await_holding_invalid_type,+ reason = "The admission lock keeps the previous turn stable while capturing its attribution."+ )]+ pub(crate) async fn reserve_pending_work_turn(+ &self,+ ) -> Option<(Arc<tokio::sync::Mutex<TurnState>>, TurnStartOptions)> {+ let mut active_turn = self.active_turn.lock().await;+ if active_turn.is_some() {+ return None;+ }+ let needs_new_turn = self.input_queue.has_trigger_turn_mailbox_items().await;+ if !needs_new_turn && !self.has_outstanding_durable_sleep() {+ return None;+ }+ let active_turn = active_turn.get_or_insert_with(ActiveTurn::default);+ let previous_options = if needs_new_turn {+ Default::default()+ } else {+ self.state+ .lock()+ .await+ .turn_attribution+ .as_ref()+ .map(codex_history::TurnAttribution::start_options)+ .unwrap_or_default()+ };+ Some((Arc::clone(&active_turn.turn_state), previous_options))+ }+pub(crate) async fn route_realtime_text_input(self: &Arc<Self>,text: String,diff --git a/codex-rs/core/src/tasks/mod.rs b/codex-rs/core/src/tasks/mod.rsindex 44baa9d60d..0d183a1793 100644--- a/codex-rs/core/src/tasks/mod.rs+++ b/codex-rs/core/src/tasks/mod.rs@@ -457,20 +457,12 @@ impl Session {self: &Arc<Self>,sub_id: String,) {- if !self.input_queue.has_pending_mailbox_items().await- || (!self.input_queue.has_trigger_turn_mailbox_items().await- && !self.has_outstanding_durable_sleep())- {+ if !self.input_queue.has_pending_mailbox_items().await {return;}- let turn_state = {- let mut active_turn = self.active_turn.lock().await;- if active_turn.is_some() {- return;- }- let active_turn = active_turn.get_or_insert_with(ActiveTurn::default);- Arc::clone(&active_turn.turn_state)+ let Some((turn_state, previous_options)) = self.reserve_pending_work_turn().await else {+ return;};self.services@@ -493,6 +485,7 @@ impl Session {|item| matches!(item, TurnInput::InterAgentCommunication(mail) if mail.trigger_turn),) {// Queue-only mail wakes durable sleep without selecting a new task's settings.+ start_options = previous_options;start_options.cyber_access_program = self.reference_context_item().await@@ -511,14 +504,18 @@ impl Session {turn_context.turn_metadata_state.set_turn_trigger(trigger);}if let Some(id) = start_options.parent_turn_id {- if let Some(initiating_agent_path) = input.iter().find_map(|item| {- let TurnInput::InterAgentCommunication(communication) = item else {- return None;- };- communication- .trigger_turn- .then(|| communication.author.clone())- }) {+ if let Some(initiating_agent_path) = input+ .iter()+ .find_map(|item| {+ let TurnInput::InterAgentCommunication(communication) = item else {+ return None;+ };+ communication+ .trigger_turn+ .then(|| communication.author.clone())+ })+ .or(start_options.initiating_agent_path)+ {turn_context.turn_metadata_state.set_initiating_agent_path(initiating_agent_path);diff --git a/codex-rs/core/tests/suite/pending_input.rs b/codex-rs/core/tests/suite/pending_input.rsindex fee9018175..fed5252322 100644--- a/codex-rs/core/tests/suite/pending_input.rs+++ b/codex-rs/core/tests/suite/pending_input.rs@@ -27,6 +27,7 @@ use codex_protocol::models::AgentMessageInputContent;use codex_protocol::models::ContentItem;use codex_protocol::models::PermissionProfile;use codex_protocol::models::ResponseItem;+use codex_protocol::openai_models::ReasoningEffort;use codex_protocol::protocol::AskForApproval;use codex_protocol::protocol::CodexErrorInfo;use codex_protocol::protocol::EventMsg;@@ -518,14 +519,25 @@ impl codex_extension_api::ThreadLifecycleContributor<codex_core::config::Config>}}+#[test_case(false, Some("automation"), None, false; "live_root")]+#[test_case(true, Some("automation"), None, false; "reloaded_root")]+#[test_case(true, Some("automation"), Some("original-parent"), false; "reloaded_delegated")]+#[test_case(true, None, None, false; "reloaded_unknown")]+#[test_case(false, Some("automation"), Some("original-parent"), true; "settings_while_asleep")]#[tokio::test(flavor = "multi_thread", worker_threads = 2)]-async fn queue_only_agent_mail_wakes_sleeping_root_with_previous_turn_context() {+async fn queue_only_agent_mail_wakes_sleeping_root_with_previous_turn_context(+ reload: bool,+ trigger: Option<&str>,+ parent: Option<&str>,+ update_settings: bool,+) -> anyhow::Result<()> {const CHILD_MESSAGE: &str = "worker completed";let server = responses::start_mock_server().await;let requests = responses::mount_sse_sequence(&server,vec![+ responses::sse_completed("resp-earlier-human"),responses::sse_completed("resp-initial"),responses::sse_completed("resp-wake"),],@@ -534,41 +546,98 @@ async fn queue_only_agent_mail_wakes_sleeping_root_with_previous_turn_context()let mut extensions =codex_extension_api::ExtensionRegistryBuilder::<codex_core::config::Config>::new();extensions.thread_lifecycle_contributor(Arc::new(SleepingRootExtension));- let codex = test_codex()+ let mut builder = test_codex().with_model("gpt-5.4").with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing())- .with_extensions(Arc::new(extensions.build()))- .build_with_auto_env(&server)- .await- .expect("build Codex test session")- .codex;+ .with_extensions(Arc::new(extensions.build()));+ let mut test = builder.build_with_auto_env(&server).await?;- codex+ test.codex.start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {- text: "wait for the worker".to_string(),+ text: "establish an earlier human context".to_string(),text_elements: Vec::new(),}]).on_start(TurnStartOptions {+ turn_trigger: Some("composer".to_string()),+ ..Default::default()+ }),+ )+ .await?;+ wait_for_turn_complete(&test.codex).await;+ // Automatic turns need not replace the model-context baseline on replay.+ let TurnInputSubmission::Started { turn_id } = test+ .codex+ .start_or_steer_turn(+ TurnInputRequest::user_input(Vec::new()).on_start(TurnStartOptions {+ turn_trigger: trigger.map(str::to_owned),+ parent_turn_id: parent.map(str::to_owned),+ root_turn_id: parent.map(|_| "original-root".to_string()),cyber_access_program: Some(CyberAccessProgram::Standard),..Default::default()}),)- .await- .expect("start initial turn");- wait_for_turn_complete(&codex).await;- enqueue_queue_only_agent_mail(&codex, CHILD_MESSAGE).await;- wait_for_turn_complete(&codex).await;+ .await?+ else {+ panic!("expected an automatic turn");+ };+ wait_for_turn_complete(&test.codex).await;+ if reload {+ if let Some(url) = test.executor_environment().exec_server_url() {+ builder = builder.with_exec_server_url(url);+ }+ test = builder.restart(&server, &test).await?;+ }+ if update_settings {+ core_test_support::submit_thread_settings(+ &test.codex,+ ThreadSettingsOverrides {+ effort: Some(Some(ReasoningEffort::Low)),+ ..Default::default()+ },+ )+ .await?;+ }+ enqueue_queue_only_agent_mail(&test.codex, CHILD_MESSAGE).await;+ wait_for_turn_complete(&test.codex).await;+ let captured = requests.requests();+ let metadata = captured+ .iter()+ .skip(1)+ .map(|request| {+ serde_json::from_str::<Value>(+ &request.header("x-codex-turn-metadata").expect("metadata"),+ )+ })+ .collect::<Result<Vec<_>, _>>()?;+ let root = parent.map_or(turn_id.as_str(), |_| "original-root");assert_eq!(- requests- .requests()+ metadata.iter()- .map(|request| request.body_json()["access_programs"].clone())+ .map(|value| (+ value["turn_trigger"].as_str(),+ value["parent_turn_id"].as_str(),+ value["root_turn_id"].as_str(),+ )).collect::<Vec<_>>(),- vec![json!({"cyber": "standard"}); 2],+ vec![(trigger, parent, Some(root)); 2],);- let history = codex+ assert_ne!(metadata[0]["turn_id"], metadata[1]["turn_id"]);+ // Live wake keeps the existing execution-setting behavior. Attribution after+ // reload must use the automatic turn, not the earlier human context baseline.+ if !reload {+ assert_eq!(+ captured+ .iter()+ .skip(1)+ .map(|request| request.body_json()["access_programs"].clone())+ .collect::<Vec<_>>(),+ vec![json!({"cyber": "standard"}); 2],+ );+ }+ let history = test+ .codex.load_history(/*include_archived*/ true).await.expect("load persisted thread history");@@ -587,6 +656,45 @@ async fn queue_only_agent_mail_wakes_sleeping_root_with_previous_turn_context()))}));++ if parent.is_none() {+ return Ok(());+ }+ let followup =+ responses::mount_sse_once(&server, responses::sse_completed("resp-followup")).await;+ test.codex+ .submit(Op::InterAgentCommunication {+ communication: InterAgentCommunication::new(+ AgentPath::try_from("/root/worker").expect("worker path should parse"),+ AgentPath::root(),+ Vec::new(),+ "start different work".to_string(),+ /*trigger_turn*/ true,+ ),+ start_options: TurnStartOptions {+ turn_trigger: Some("composer".to_string()),+ parent_turn_id: Some("new-parent".to_string()),+ root_turn_id: Some("new-root".to_string()),+ ..Default::default()+ },+ })+ .await?;+ wait_for_turn_complete(&test.codex).await;+ let followup: Value = serde_json::from_str(+ &followup+ .single_request()+ .header("x-codex-turn-metadata")+ .expect("metadata"),+ )?;+ assert_eq!(+ (+ followup["turn_trigger"].as_str(),+ followup["parent_turn_id"].as_str(),+ followup["root_turn_id"].as_str(),+ ),+ (Some("composer"), Some("new-parent"), Some("new-root")),+ );+ Ok(())}#[tokio::test(flavor = "multi_thread", worker_threads = 2)]diff --git a/codex-rs/core/tests/suite/subagent_notifications.rs b/codex-rs/core/tests/suite/subagent_notifications.rsindex 04b3026a50..16ca5fa447 100644--- a/codex-rs/core/tests/suite/subagent_notifications.rs+++ b/codex-rs/core/tests/suite/subagent_notifications.rs@@ -2794,8 +2794,12 @@ async fn plaintext_multi_agent_v2_completion_sends_agent_message(Ok(())}+#[test_case(false; "live")]+#[test_case(true; "reloaded_sleep")]#[tokio::test(flavor = "multi_thread", worker_threads = 2)]-async fn multi_agent_v2_peer_followup_completion_notifies_initiating_turn() -> Result<()> {+async fn multi_agent_v2_peer_followup_completion_notifies_initiating_turn(+ reload_sleeping_worker: bool,+) -> Result<()> {const SPAWN_WORKER_PROMPT: &str = "spawn the completion-routing worker";const SPAWN_REQUESTER_PROMPT: &str = "spawn the completion-routing requester";const READ_RESULT_PROMPT: &str = "read the completion-routing worker result";@@ -2877,7 +2881,7 @@ async fn multi_agent_v2_peer_followup_completion_notifies_initiating_turn() -> Rsubmit_turn_with_trigger(&test, SPAWN_WORKER_PROMPT, "automation_cron_scheduled").await?;let worker_thread_id = created_threads.recv().await?;- let worker_thread = test.thread_manager.get_thread(worker_thread_id).await?;+ let mut worker_thread = test.thread_manager.get_thread(worker_thread_id).await?;wait_for_event(worker_thread.as_ref(), |event| {matches!(event, EventMsg::TurnComplete(_))})@@ -2995,7 +2999,7 @@ async fn multi_agent_v2_peer_followup_completion_notifies_initiating_turn() -> R}).await;- let worker_followup_turn_id = worker_followup_request+ let mut worker_followup_turn_id = worker_followup_request.requests().into_iter().find_map(|request| {@@ -3017,6 +3021,52 @@ async fn multi_agent_v2_peer_followup_completion_notifies_initiating_turn() -> R})}).expect("worker follow-up model request");+ if reload_sleeping_worker {+ worker_thread.shutdown_and_wait().await?;+ test.thread_manager.remove_thread(&worker_thread_id).await;+ test.thread_manager+ .ensure_multi_agent_v2_child_loaded(worker_thread_id)+ .await?;+ worker_thread = test.thread_manager.get_thread(worker_thread_id).await?;+ // Simulate the extension restoring durable sleep; Core owns the+ // queue-only wake and completion routing exercised below.+ worker_thread+ .thread_extension_data()+ .insert(codex_extension_items::sleep::SleepItem {+ id: "peer-worker-sleep".to_string(),+ duration_ms: 60_000,+ });+ let wake_request = mount_sse_once_match(+ &server,+ |request: &wiremock::Request| body_contains(request, "wake sleeping peer work"),+ sse(vec![+ ev_response_created("resp-peer-worker-wake"),+ ev_assistant_message("msg-peer-worker-wake", "peer follow-up finished"),+ ev_completed("resp-peer-worker-wake"),+ ]),+ )+ .await;+ worker_thread+ .submit(Op::InterAgentCommunication {+ communication: codex_protocol::protocol::InterAgentCommunication::new(+ codex_protocol::AgentPath::root(),+ codex_protocol::AgentPath::try_from("/root/worker").expect("worker path"),+ Vec::new(),+ "wake sleeping peer work".to_string(),+ /*trigger_turn*/ false,+ ),+ start_options: TurnStartOptions::default(),+ })+ .await?;+ worker_followup_turn_id =+ wait_for_event_match(worker_thread.as_ref(), |event| match event {+ EventMsg::TurnComplete(completed) => Some(completed.turn_id.clone()),+ _ => None,+ })+ .await;+ let request = wake_request.single_request();+ assert_parent_turn(&request.body_json(), Some(&requester_turn_id))?;+ }let completed = timeout(Duration::from_secs(5),wait_for_event_match(requester_thread.as_ref(), |event| match event {@@ -3026,6 +3076,7 @@ async fn multi_agent_v2_peer_followup_completion_notifies_initiating_turn() -> RTurnItem::SubAgentActivity(activity)if activity.kind == SubAgentActivityKind::Completed&& activity.agent_thread_id == worker_thread_id+ && activity.id == format!("subagent-completed-{worker_followup_turn_id}")) =>{Some(completed.clone())