diff --git a/codex-rs/core/src/tasks/mod.rs b/codex-rs/core/src/tasks/mod.rs index f6a5224641..fd9ab58317 100644 --- a/codex-rs/core/src/tasks/mod.rs +++ b/codex-rs/core/src/tasks/mod.rs @@ -1176,24 +1176,23 @@ impl Session { turn_context: &TurnContext, cause: Option<&CodexErrorInfo>, ) { - let Some(marker) = interrupted_turn_history_marker( + if let Some(marker) = interrupted_turn_history_marker( InterruptedTurnHistoryMarker::from_config_and_version( turn_context.config.as_ref(), turn_context.multi_agent_version, ), cause, - ) else { - return; - }; - self.record_conversation_items( - turn_context, - turn_context.model_info(), - std::slice::from_ref(&marker), - ) - .await; + ) { + self.record_conversation_items( + turn_context, + turn_context.model_info(), + std::slice::from_ref(&marker), + ) + .await; + } // Clients may re-read the rollout as soon as they receive the terminal event. if let Err(err) = self.flush_rollout().await { - warn!("failed to flush interrupted-turn marker before terminal event: {err}"); + warn!("failed to flush interrupted-turn history before terminal event: {err}"); } } @@ -1270,6 +1269,36 @@ impl Session { .await; if reason == TurnAbortReason::Interrupted { + // Injection acknowledges queueing. Preserve accepted agent mail before + // teardown discards pending input and the host observes TurnAborted. + let mut pending_mail = Vec::new(); + let mut remaining_input = Vec::new(); + for input in self + .input_queue + .take_pending_input_for_turn_state(turn_state) + .await + { + match input { + TurnInput::ResponseItem(item) + if matches!(item.item, ResponseItem::AgentMessage { .. }) => + { + pending_mail.push(item); + } + input => remaining_input.push(input), + } + } + // Existing cleanup requeues native terminal results from this input. + self.input_queue + .extend_pending_input_for_turn_state(turn_state, remaining_input) + .await; + if !pending_mail.is_empty() { + self.record_annotated_conversation_items( + &task.turn_context, + &task.turn_context.capture_current_model_info(), + pending_mail, + ) + .await; + } self.record_interrupted_turn_history( &task.turn_context, error diff --git a/codex-rs/core/tests/suite/host_turn_admission.rs b/codex-rs/core/tests/suite/host_turn_admission.rs index b8c4a2bd80..68a73f6b91 100644 --- a/codex-rs/core/tests/suite/host_turn_admission.rs +++ b/codex-rs/core/tests/suite/host_turn_admission.rs @@ -346,6 +346,93 @@ async fn interrupt_before_admission_skips_submit_hook_and_uninspected_prompt() - Ok(()) } +#[tokio::test(flavor = "multi_thread", worker_threads = 2)] +async fn injected_child_final_survives_parent_interrupt() -> Result<()> { + let server = responses::start_mock_server().await; + let sampling = Arc::new(Notify::new()); + let sampled = Arc::clone(&sampling); + let model = responses::mount_response_handler(&server, move |request| { + let response = responses::sse_response(responses::sse_completed("done")); + if request + .message_input_texts("user") + .iter() + .any(|text| text == "Continue work.") + { + response + } else { + sampled.notify_one(); + response.set_delay(Duration::from_secs(60)) + } + }) + .await; + let builder = test_codex().with_config(|config| { + config + .features + .disable(Feature::InstantInterrupt) + .expect("keep mail queued during sampling"); + // Mail must be durable even when no interruption marker is written. + config.agent_interrupt_message_enabled = false; + }); + let (test, mut attempts) = + root_with_admission(&server, builder, /*session_reader*/ None).await?; + let (_, grant) = start(&test, &mut attempts, "Start work.").await?; + assert!(grant.send(Ok(AgentExecutionGuard::new(()))).is_ok()); + sampling.notified().await; + let message: ResponseItem = serde_json::from_value(json!({ + "type": "agent_message", "id": "agent_child-final", "author": "/root/worker", "recipient": "/root", + "content": [{"type": "input_text", "text": "Message Type: FINAL_ANSWER\nTask name: /root\nSender: /root/worker\nPayload:\nThe worker finished."}] + }))?; + // Injection has acknowledged the final, but the blocked sample has not consumed it. + test.codex + .inject_response_items(vec![message.clone()]) + .await?; + test.codex.submit(Op::Interrupt).await?; + wait_for_event(&test.codex, |event| { + matches!(event, EventMsg::TurnAborted(_)) + }) + .await; + let history = test + .thread_store + .load_latest_model_context(LoadThreadHistoryParams { + thread_id: test.session_configured.thread_id, + include_archived: false, + }) + .await?; + let persisted = history + .items + .into_iter() + .filter_map(|item| match item { + RolloutItem::ResponseItem(envelope) + if matches!(envelope.item, ResponseItem::AgentMessage { .. }) => + { + Some(responses::strip_metadata(envelope.item)) + } + _ => None, + }) + .collect::>(); + assert_eq!(persisted, vec![message.clone()]); + + let (_, grant) = start(&test, &mut attempts, "Continue work.").await?; + assert!(grant.send(Ok(AgentExecutionGuard::new(()))).is_ok()); + wait_for_successful_turn(&test.codex).await; + let mail = model + .requests() + .iter() + .map(|request| request.inputs_of_type("agent_message")) + .collect::>(); + assert_eq!( + responses::strip_metadata_from_json(json!(mail)), + json!([[], [message]]) + ); + insta::assert_snapshot!(context_snapshot::format_request_history_snapshot( + "An acknowledged child final queued during parent sampling survives interruption and appears once in the next request.", + &responses::received_responses_requests(&server).await, + &ContextSnapshotOptions::default().rewrite_known_segments(), + )); + test.codex.shutdown_and_wait().await?; + Ok(()) +} + #[tokio::test(flavor = "multi_thread", worker_threads = 2)] async fn suspending_root_during_admission_preserves_the_recoverable_prompt() -> Result<()> { skip_if_no_network!(Ok(())); diff --git a/codex-rs/core/tests/suite/snapshots/all__suite__scenarios__host_turn_admission__injected_child_final_survives_parent_interrupt.snap b/codex-rs/core/tests/suite/snapshots/all__suite__scenarios__host_turn_admission__injected_child_final_survives_parent_interrupt.snap new file mode 100644 index 0000000000..0268db9119 --- /dev/null +++ b/codex-rs/core/tests/suite/snapshots/all__suite__scenarios__host_turn_admission__injected_child_final_survives_parent_interrupt.snap @@ -0,0 +1,25 @@ +--- +source: core/tests/suite/host_turn_admission.rs +assertion_line: 397 +expression: "context_snapshot::format_request_history_snapshot(\"An acknowledged child final queued during parent sampling survives interruption and appears once in the next request.\",\n&responses::received_responses_requests(&server).await,\n&ContextSnapshotOptions::default().rewrite_known_segments(),)" +--- +Scenario: An acknowledged child final queued during parent sampling survives interruption and appears once in the next request. + +## Window 1 +-- request 1 (turn) -- +00:message/developer: + +01:message/developer[2]: + [01] + [02] + Deferred tool namespaces: + - multi_agent_v1: Tools for spawning and managing sub-agents. + +02:message/user: + +03:message/user: + Start work. +-- request 2 (turn) -- +04:agent_message +05:message/user: + Continue work.