Skip to content

armgit / codex

Public Imported from GitHub
0

Lightweight coding agent that runs in your terminal

Rust

Drain WebSocket responses on mailbox preemption (#55969)

jif02c6a2d3f1a0
diff --git a/codex-rs/core/src/session/turn.rs b/codex-rs/core/src/session/turn.rs
index bba5b0e12c..9d72858972 100644
--- a/codex-rs/core/src/session/turn.rs
+++ b/codex-rs/core/src/session/turn.rs
@@ -1785,6 +1785,7 @@ async fn run_sampling_request(
)
.await?;
}
+ let mut draining_for_mailbox = false;
let err = match try_run_sampling_request(
tool_runtime.clone(),
Arc::clone(&sess),
@@ -1795,6 +1796,7 @@ async fn run_sampling_request(
Arc::clone(&turn_diff_tracker),
&prompt,
cancellation_token.child_token(),
+ &mut draining_for_mailbox,
)
.await
{
@@ -1834,7 +1836,9 @@ async fn run_sampling_request(
if cancellation_token.is_cancelled() {
return Err(CodexErr::TurnAborted);
}
- if preempt.is_cancelled() {
+ // Recover typed errors (including filter guidance) before handing queued mail back
+ // to the turn loop. Terminal errors and exhausted retries must still propagate.
+ if preempt.is_cancelled() || (draining_for_mailbox && matches!(retry, Ok(Ok(())))) {
return Ok((
SamplingRequestResult {
needs_follow_up: true,
@@ -2640,6 +2644,7 @@ async fn try_run_sampling_request(
turn_diff_tracker: SharedTurnDiffTracker,
prompt: &Prompt,
cancellation_token: CancellationToken,
+ draining_for_mailbox: &mut bool,
) -> CodexResult<SamplingRequestResult> {
let turn_context = Arc::clone(&step_context.turn);
feedback_tags!(
@@ -2804,6 +2809,10 @@ async fn try_run_sampling_request(
let event = match event {
Ok(Ok(event)) => event,
Ok(Err(_)) => {
+ if *draining_for_mailbox {
+ preempt = CancellationToken::new();
+ continue;
+ }
if let Some(interrupt) = stream.interrupt.take() {
if step_context.settings.model_info.use_responses_lite {
let _ = interrupt.send(codex_api::ResponseInterrupt::Drain);
@@ -2830,9 +2839,13 @@ async fn try_run_sampling_request(
break Err(CodexErr::TurnAborted);
}
- let event = match event {
- Some(Ok(event)) => event,
- Some(Err(err)) => {
+ let event = match event.unwrap_or_else(|| {
+ Err(CodexErr::Stream(
+ "stream closed before response.completed".into(),
+ ))
+ }) {
+ Ok(event) => event,
+ Err(err) => {
if let CodexErrorDetails::ResponseIncomplete(incomplete) = err.details() {
request_token_usage = incomplete.token_usage.clone();
sess.record_incomplete_response_usage(
@@ -2843,13 +2856,16 @@ async fn try_run_sampling_request(
.await;
should_emit_token_count |= incomplete.token_usage.is_some();
}
+ if *draining_for_mailbox && matches!(err.details(), CodexErrorDetails::Stream(_)) {
+ // Mail already requires a follow-up, even if the producer exited before
+ // receiving the interrupt. Do not retry without that pending input.
+ break Ok(SamplingRequestResult {
+ needs_follow_up: true,
+ last_agent_message,
+ });
+ }
break Err(err);
}
- None => {
- break Err(CodexErr::Stream(
- "stream closed before response.completed".into(),
- ));
- }
};
sess.services
@@ -2930,9 +2946,14 @@ async fn try_run_sampling_request(
step_context: Arc::clone(&step_context),
turn_store: Arc::clone(&turn_store),
tool_runtime: tool_runtime.clone(),
- defer_tool_dispatch,
+ defer_tool_dispatch: defer_tool_dispatch || *draining_for_mailbox,
cancellation_token: cancellation_token.child_token(),
};
+ if *draining_for_mailbox {
+ // Retain buffered calls in history, but use the existing pre-dispatch
+ // cancellation path so they cannot run ahead of the queued mail.
+ ctx.cancellation_token.cancel();
+ }
let preempt_for_mailbox_mail = match &item {
ResponseItem::Message { role, phase, .. } => {
@@ -2979,6 +3000,7 @@ async fn try_run_sampling_request(
// Hosts can keep the current response intact and deliver mail before the next
// model request instead of cutting off its remaining tool calls.
if preempt_for_mailbox_mail
+ && !*draining_for_mailbox
&& !turn_context
.config
.features
@@ -2993,6 +3015,18 @@ async fn try_run_sampling_request(
conversation.id = %sess.thread_id,
turn.id = %turn_context.sub_id,
);
+ if step_context.settings.model_info.use_responses_lite
+ && let Some(interrupt) = stream.interrupt.take()
+ {
+ // A closed receiver can mean completion is already buffered. Drain it
+ // too; a transport failure below still takes the mailbox follow-up.
+ let _ = interrupt.send(codex_api::ResponseInterrupt::Drain);
+ // Retain completed items and the response ID for incremental continuation.
+ // Further item boundaries must not drop the stream while it drains.
+ *draining_for_mailbox = true;
+ needs_follow_up = true;
+ continue;
+ }
break Ok(SamplingRequestResult {
needs_follow_up: true,
last_agent_message,
@@ -3003,12 +3037,13 @@ async fn try_run_sampling_request(
assign_missing_streamed_response_item_id(&mut item, /*active_item*/ None);
sess.reserve_assistant_message_order(&turn_context, &item)
.await;
- if let ResponseItem::CustomToolCall {
- call_id,
- name,
- namespace,
- ..
- } = &item
+ if !*draining_for_mailbox
+ && let ResponseItem::CustomToolCall {
+ call_id,
+ name,
+ namespace,
+ ..
+ } = &item
{
let tool_name = ToolName::new(namespace.clone(), name.as_str());
active_tool_argument_diff_consumer = tool_runtime
@@ -3026,7 +3061,10 @@ async fn try_run_sampling_request(
.await
{
let mut turn_item = turn_item;
- let stream_item_to_client = !defer_streamed_turn_items_for_contributors;
+ // An interrupted response may discard its partial item. Only expose
+ // items received during this drain once OutputItemDone confirms them.
+ let stream_item_to_client =
+ !*draining_for_mailbox && !defer_streamed_turn_items_for_contributors;
let mut seeded_parsed: Option<ParsedAssistantTextDelta> = None;
let mut seeded_item_id: Option<String> = None;
if stream_item_to_client
diff --git a/codex-rs/core/src/stream_events_utils.rs b/codex-rs/core/src/stream_events_utils.rs
index 18c66090d7..1b668ea4bb 100644
--- a/codex-rs/core/src/stream_events_utils.rs
+++ b/codex-rs/core/src/stream_events_utils.rs
@@ -350,7 +350,7 @@ pub(crate) async fn handle_output_item_done(
let cancellation_token = ctx.cancellation_token.child_token();
let runtime = ctx.tool_runtime.clone();
// handle_tool_call dispatches immediately, not when its future is polled.
- // With a synchronous post-model hook, dispatch only when the turn drains tools.
+ // Defer for post-model hooks or to cancel buffered calls during mailbox drains.
let tool_future: InFlightFuture<'static> = if ctx.defer_tool_dispatch {
Box::pin(async move {
if cancellation_token.is_cancelled() {
diff --git a/codex-rs/core/src/tools/parallel.rs b/codex-rs/core/src/tools/parallel.rs
index 70ff50c5e4..cc8beb4e30 100644
--- a/codex-rs/core/src/tools/parallel.rs
+++ b/codex-rs/core/src/tools/parallel.rs
@@ -375,7 +375,7 @@ impl ToolCallRuntime {
fn abort_message(call: &ToolCall, elapsed_secs: Option<f32>) -> String {
let Some(secs) = elapsed_secs else {
- return "aborted by user before dispatch".to_string();
+ return "aborted before dispatch".to_string();
};
if call.tool_name.is_default_namespace() && call.tool_name.name == "exec_command" {
format!("Wall time: {secs:.1} seconds\naborted by user")
diff --git a/codex-rs/core/tests/common/responses.rs b/codex-rs/core/tests/common/responses.rs
index 645b423c56..25e0078f39 100644
--- a/codex-rs/core/tests/common/responses.rs
+++ b/codex-rs/core/tests/common/responses.rs
@@ -1,5 +1,6 @@
#![allow(clippy::unwrap_used)]
+use std::collections::HashMap;
use std::collections::VecDeque;
use std::sync::Arc;
use std::sync::Mutex;
@@ -588,6 +589,7 @@ pub struct WebSocketConnectionConfig {
pub struct WebSocketTestServer {
uri: String,
+ response_gates: Arc<Mutex<HashMap<String, oneshot::Receiver<()>>>>,
connections: Arc<Mutex<Vec<Vec<WebSocketRequest>>>>,
handshakes: Arc<Mutex<Vec<WebSocketHandshake>>>,
request_log_updated: Arc<Notify>,
@@ -597,6 +599,20 @@ pub struct WebSocketTestServer {
}
impl WebSocketTestServer {
+ /// Pause before the next matching event until the sender is released.
+ /// Install the gate before submitting the request that produces the event.
+ pub fn gate_response_event(&self, event: &Value) -> oneshot::Sender<()> {
+ let (release, gate) = oneshot::channel();
+ assert!(
+ self.response_gates
+ .lock()
+ .unwrap()
+ .insert(event.to_string(), gate)
+ .is_none()
+ );
+ release
+ }
+
pub fn uri(&self) -> &str {
&self.uri
}
@@ -1244,6 +1260,8 @@ pub async fn start_websocket_server_with_headers(
let connections_log = Arc::new(Mutex::new(Vec::new()));
let handshakes_log = Arc::new(Mutex::new(Vec::new()));
let request_log_updated = Arc::new(Notify::new());
+ let response_gates = Arc::new(Mutex::new(HashMap::new()));
+ let gates = Arc::clone(&response_gates);
let (closed_tx, closed_connections) = watch::channel(0);
let requests = Arc::clone(&connections_log);
let handshakes = Arc::clone(&handshakes_log);
@@ -1325,7 +1343,9 @@ pub async fn start_websocket_server_with_headers(
log.len() - 1
};
let close_after_requests = connection.close_after_requests;
- for request_events in connection.requests {
+ let mut response_complete = false;
+ let mut batches = connection.requests.into_iter().peekable();
+ while let Some(request_events) = batches.peek() {
let message = tokio::select! {
_ = &mut shutdown_rx => return,
message = ws_stream.next() => message,
@@ -1334,6 +1354,7 @@ pub async fn start_websocket_server_with_headers(
break;
};
if let Some(body) = parse_ws_request_body(message) {
+ let late_interrupt = response_complete && body["type"] == "response.interrupt";
let mut log = requests.lock().unwrap();
if let Some(connection_log) = log.get_mut(connection_index) {
connection_log.push(WebSocketRequest { body });
@@ -1367,6 +1388,10 @@ pub async fn start_websocket_server_with_headers(
);
}
request_log.notify_waiters();
+ // A late interrupt cannot consume the next response's script.
+ if late_interrupt {
+ continue;
+ }
}
eprintln!(
@@ -1382,14 +1407,26 @@ pub async fn start_websocket_server_with_headers(
.iter()
.find_map(|event| event.get("delta").and_then(Value::as_str)),
);
- for event in &request_events {
+ for event in request_events {
let Ok(payload) = serde_json::to_string(event) else {
continue;
};
+ let gate = gates.lock().unwrap().remove(&payload);
+ if let Some(gate) = gate {
+ tokio::select! {
+ _ = &mut shutdown_rx => return,
+ _ = gate => {},
+ }
+ }
if ws_stream.send(Message::Text(payload.into())).await.is_err() {
break;
}
+ response_complete = matches!(
+ event["type"].as_str(),
+ Some("response.completed" | "response.incomplete" | "response.failed")
+ );
}
+ batches.next();
}
if close_after_requests {
@@ -1408,6 +1445,7 @@ pub async fn start_websocket_server_with_headers(
WebSocketTestServer {
uri,
+ response_gates,
connections: connections_log,
handshakes: handshakes_log,
request_log_updated,
diff --git a/codex-rs/core/tests/suite/hooks.rs b/codex-rs/core/tests/suite/hooks.rs
index 5fa16c0392..e60331cc94 100644
--- a/codex-rs/core/tests/suite/hooks.rs
+++ b/codex-rs/core/tests/suite/hooks.rs
@@ -6234,7 +6234,7 @@ async fn model_request_post_hook_orders_tool_dispatch(
.single_request()
.custom_tool_call_output_content_and_success("call")
.context("aborted custom tool output")?;
- assert_eq!(output.as_deref(), Some("aborted by user before dispatch"));
+ assert_eq!(output.as_deref(), Some("aborted before dispatch"));
} else {
fs::write(release, "")?;
wait_for_event(&test.codex, |event| {
diff --git a/codex-rs/core/tests/suite/scenarios_mailbox_preemption_tests.rs b/codex-rs/core/tests/suite/scenarios_mailbox_preemption_tests.rs
index ecf4029eeb..7474c1d774 100644
--- a/codex-rs/core/tests/suite/scenarios_mailbox_preemption_tests.rs
+++ b/codex-rs/core/tests/suite/scenarios_mailbox_preemption_tests.rs
@@ -1,7 +1,8 @@
-//! Mailbox scheduling preserves the current response when deferral is enabled.
-//! Queued mail still reaches the next request, alongside completed tool results.
+//! Mailbox scheduling preserves deferred responses and drains graceful interrupts.
+//! Queued mail reaches the next request without losing completed response items.
use codex_core::TurnInputRequest;
+use codex_core::TurnInputSubmission;
use codex_features::Feature;
use codex_protocol::AgentPath;
use codex_protocol::protocol::EventMsg;
@@ -13,6 +14,7 @@ use core_test_support::context_snapshot::SnapshotEntry;
use core_test_support::responses;
use core_test_support::streaming_sse::StreamingSseChunk;
use core_test_support::streaming_sse::start_streaming_sse_server;
+use core_test_support::test_codex::TestCodex;
use core_test_support::test_codex::test_codex;
use core_test_support::wait_for_event;
use pretty_assertions::assert_eq;
@@ -198,3 +200,374 @@ async fn mailbox_preemption_preserves_response_when_deferred(
streaming.shutdown().await;
Ok(())
}
+
+#[derive(Clone, Copy, PartialEq, Eq)]
+enum MailboxDrain {
+ CompleteWithoutAcknowledgement,
+ CompleteBeforeInterrupt,
+ BufferedItems,
+ UserSteering,
+}
+
+#[test_case(MailboxDrain::CompleteWithoutAcknowledgement; "without_acknowledgement")]
+#[test_case(MailboxDrain::CompleteBeforeInterrupt; "completion_already_buffered")]
+#[test_case(MailboxDrain::BufferedItems; "buffered_items")]
+#[test_case(MailboxDrain::UserSteering; "user_steering_during_drain")]
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn mailbox_preemption_drains_websocket(scenario: MailboxDrain) -> anyhow::Result<()> {
+ core_test_support::skip_if_no_network!(Ok(()));
+
+ let boundary = responses::ev_reasoning_item("boundary", &["Preparing the next action"], &[]);
+ let mut exchanges = mailbox_initial_responses(&boundary);
+ let mut completed = responses::ev_completed_with_tokens("first", /*total_tokens*/ 42);
+ let mut expected = expected_mailbox_input();
+ let trailing = match scenario {
+ // The bridge can finish its single item without acknowledging the interrupt.
+ MailboxDrain::CompleteWithoutAcknowledgement | MailboxDrain::CompleteBeforeInterrupt => {
+ vec![completed]
+ }
+ MailboxDrain::BufferedItems | MailboxDrain::UserSteering => {
+ let mut call = responses::ev_function_call(
+ "buffered-tool",
+ "update_plan",
+ r#"{"plan":[{"step":"Must not run before reading mail","status":"in_progress"}]}"#,
+ );
+ call["item"]["id"] = json!("buffered-tool-item");
+ completed["type"] = json!("response.incomplete");
+ completed["response"]["status"] = json!("incomplete");
+ completed["response"]["incomplete_details"] = json!({"reason": "interrupted"});
+ // The completed call remains in server history, paired with an aborted output.
+ expected.insert(
+ 0,
+ json!({
+ "type": "function_call_output", "call_id": "buffered-tool",
+ "output": "aborted before dispatch",
+ }),
+ );
+ vec![
+ json!({"type": "response.interrupt.accepted", "response_id": "first"}),
+ responses::ev_reasoning_item_added("buffered", &[]),
+ responses::ev_reasoning_item("buffered", &["Already completed"], &[]),
+ call,
+ responses::ev_reasoning_item_added("discarded", &[]),
+ responses::ev_reasoning_summary_text_delta("Unfinished reasoning"),
+ json!({"type": "response.output_item.interrupted", "item_id": "discarded", "output_index": 3}),
+ completed,
+ ]
+ }
+ };
+ if scenario == MailboxDrain::CompleteBeforeInterrupt {
+ exchanges[1].extend(trailing);
+ } else {
+ exchanges.push(trailing);
+ }
+ exchanges.push(vec![
+ responses::ev_response_created("follow-up"),
+ responses::ev_assistant_message("answer", "The worker updates are included."),
+ responses::ev_completed("follow-up"),
+ ]);
+ let server = responses::start_websocket_server(vec![exchanges]).await;
+ let release = server.gate_response_event(&boundary);
+ let release_drain = (scenario == MailboxDrain::UserSteering).then(|| {
+ server.gate_response_event(
+ &json!({"type": "response.interrupt.accepted", "response_id": "first"}),
+ )
+ });
+ let test = start_mailbox_preemption(&server, release).await?;
+ if let Some(release_drain) = release_drain {
+ server
+ .wait_for_request(/*connection_index*/ 0, /*request_index*/ 2)
+ .await;
+ let steering = "Use both worker updates.";
+ let submission = test
+ .codex
+ .start_or_steer_turn(TurnInputRequest::user_input(vec![super::text(steering)]))
+ .await?;
+ assert!(matches!(submission, TurnInputSubmission::Steered { .. }));
+ // Steering must remain queued while the interrupted response is still draining.
+ assert!(
+ tokio::time::timeout(
+ std::time::Duration::from_secs(1),
+ wait_for_event(&test.codex, |event| {
+ assert!(
+ !matches!(event, EventMsg::Error(_) | EventMsg::StreamError(_)),
+ "{event:?}"
+ );
+ matches!(event, EventMsg::UserMessage(_))
+ }),
+ )
+ .await
+ .is_err(),
+ "steering must not abandon the mailbox drain"
+ );
+ expected.insert(
+ 1,
+ json!({
+ "type": "message", "role": "user",
+ "content": [{"type": "input_text", "text": steering}],
+ }),
+ );
+ release_drain.send(()).expect("release mailbox drain");
+ }
+ finish_mailbox_preemption(test).await?;
+
+ let requests = server.single_connection();
+ assert_eq!(requests[0].body_json()["generate"], false);
+ if scenario != MailboxDrain::CompleteBeforeInterrupt {
+ assert_eq!(requests.len(), 4);
+ assert_eq!(
+ requests[2].body_json(),
+ json!({
+ "type": "response.interrupt", "response_id": "first", "mode": "discard_partial_items",
+ })
+ );
+ }
+ let follow_up = requests.last().expect("follow-up request").body_json();
+ assert_eq!(follow_up["type"], "response.create");
+ assert_eq!(follow_up["previous_response_id"], "first");
+ let input = responses::strip_response_item_ids_from_json(responses::strip_metadata_from_json(
+ follow_up["input"].clone(),
+ ));
+ assert_eq!(input, json!(expected));
+ server.shutdown().await;
+ Ok(())
+}
+
+#[test_case(2; "disconnect_before_interrupt")]
+#[test_case(3; "disconnect_after_interrupt")]
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn mailbox_preemption_recovers_from_disconnect(
+ requests_before_disconnect: usize,
+) -> anyhow::Result<()> {
+ core_test_support::skip_if_no_network!(Ok(()));
+
+ let boundary = responses::ev_reasoning_item("boundary", &["Preparing the next action"], &[]);
+ let mut first_connection = mailbox_initial_responses(&boundary);
+ // Close after the boundary, or after receiving the interrupt, without completing.
+ first_connection.resize(requests_before_disconnect, Vec::new());
+ let server = responses::start_websocket_server(vec![
+ first_connection,
+ vec![vec![
+ responses::ev_response_created("follow-up"),
+ responses::ev_assistant_message("answer", "The worker updates are included."),
+ responses::ev_completed("follow-up"),
+ ]],
+ ])
+ .await;
+ let release = server.gate_response_event(&boundary);
+ let test = start_mailbox_preemption(&server, release).await?;
+ finish_mailbox_preemption(test).await?;
+
+ // The first request after reconnect must include mail, rather than retry without it.
+ let connections = server.connections();
+ assert_eq!(connections.len(), 2);
+ assert_eq!(connections[0].len(), requests_before_disconnect);
+ assert_eq!(connections[1].len(), 1);
+ let follow_up = connections[1][0].body_json();
+ assert_eq!(follow_up["type"], "response.create");
+ assert_eq!(follow_up["previous_response_id"], Value::Null);
+ let input = responses::strip_response_item_ids_from_json(responses::strip_metadata_from_json(
+ follow_up["input"].clone(),
+ ));
+ let mail = input
+ .as_array()
+ .expect("input array")
+ .iter()
+ .filter(|item| item["type"] == "agent_message")
+ .cloned()
+ .collect::<Vec<_>>();
+ assert_eq!(mail, expected_mailbox_input());
+ server.shutdown().await;
+ Ok(())
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn mailbox_preemption_preserves_mail_on_content_filter_retry() -> anyhow::Result<()> {
+ core_test_support::skip_if_no_network!(Ok(()));
+
+ let boundary = responses::ev_reasoning_item("boundary", &["Preparing the next action"], &[]);
+ let mut first_connection = mailbox_initial_responses(&boundary);
+ first_connection.push(vec![json!({
+ "type": "response.incomplete",
+ "response": {"id": "first", "incomplete_details": {"reason": "content_filter"}},
+ })]);
+ let server = responses::start_websocket_server(vec![
+ first_connection,
+ vec![
+ vec![
+ responses::ev_response_created("recovery"),
+ responses::ev_function_call(
+ "planned-action",
+ "update_plan",
+ r#"{"plan":[{"step":"Reply after reading mail","status":"in_progress"}]}"#,
+ ),
+ responses::ev_completed("recovery"),
+ ],
+ vec![
+ responses::ev_response_created("follow-up"),
+ responses::ev_assistant_message("answer", "The worker updates are included."),
+ responses::ev_completed("follow-up"),
+ ],
+ ],
+ ])
+ .await;
+ let release = server.gate_response_event(&boundary);
+ let test = start_mailbox_preemption(&server, release).await?;
+ let mut plan_updates = 0;
+ wait_for_event(&test.codex, |event| {
+ assert!(!matches!(event, EventMsg::Error(_)), "{event:?}");
+ if let EventMsg::StreamError(error) = event {
+ assert_eq!(error.additional_details.as_deref(), Some(
+ "stream disconnected before completion: Incomplete response returned, reason: content_filter"
+ ));
+ }
+ if matches!(event, EventMsg::PlanUpdate(_)) {
+ plan_updates += 1;
+ }
+ matches!(event, EventMsg::TurnComplete(_))
+ })
+ .await;
+ assert_eq!(plan_updates, 1);
+ test.codex.shutdown_and_wait().await?;
+
+ let connections = server.connections();
+ assert_eq!(connections.len(), 2);
+ assert_eq!(connections[0].len(), 3);
+ assert_eq!(connections[1].len(), 2);
+ // The tool-first retry must already contain both queued mail and filter guidance.
+ let recovery = connections[1][0].body_json();
+ let input = responses::strip_response_item_ids_from_json(responses::strip_metadata_from_json(
+ recovery["input"].clone(),
+ ));
+ let input = input.as_array().expect("recovery input");
+ let mail = input
+ .iter()
+ .filter(|item| item["type"] == "agent_message")
+ .cloned()
+ .collect::<Vec<_>>();
+ assert_eq!(mail, expected_mailbox_input());
+ assert_eq!(
+ input
+ .iter()
+ .filter(|item| item["role"] == "developer")
+ .filter(|item| item["content"][0]["text"]
+ .as_str()
+ .is_some_and(|text| text.contains("<content_filter_guidance>")))
+ .count(),
+ 1,
+ );
+ server.shutdown().await;
+ Ok(())
+}
+
+fn mailbox_initial_responses(boundary: &Value) -> Vec<Vec<Value>> {
+ vec![
+ vec![
+ responses::ev_response_created("warmup"),
+ responses::ev_completed("warmup"),
+ ],
+ vec![
+ responses::ev_response_created("first"),
+ responses::ev_reasoning_item_added("boundary", &["Preparing the next action"]),
+ boundary.clone(),
+ ],
+ ]
+}
+
+fn expected_mailbox_input() -> Vec<Value> {
+ ["Worker found the result.", "Worker checked the result."]
+ .into_iter()
+ .map(|message| {
+ json!({
+ "type": "agent_message", "author": "/root/worker", "recipient": "/root",
+ "content": [{"type": "input_text", "text": message}],
+ })
+ })
+ .collect()
+}
+
+async fn start_mailbox_preemption(
+ server: &responses::WebSocketTestServer,
+ release: oneshot::Sender<()>,
+) -> anyhow::Result<TestCodex> {
+ let base_url = format!("{}/v1", server.uri());
+ let config_server = responses::start_mock_server().await;
+ let test = test_codex()
+ .with_model("gpt-5.4")
+ .with_model_info_override("gpt-5.4", |model_info| {
+ model_info.use_responses_lite = true;
+ })
+ .with_config(move |config| {
+ config
+ .features
+ .enable(Feature::InstantInterrupt)
+ .expect("enable InstantInterrupt feature");
+ config.update_plan_enabled = true;
+ config.model_provider.base_url = Some(base_url);
+ config.model_provider.supports_websockets = true;
+ })
+ .build_with_auto_env(&config_server)
+ .await?;
+ test.codex
+ .start_or_steer_turn(TurnInputRequest::user_input(vec![super::text(
+ "Plan the next action while the worker finishes.",
+ )]))
+ .await?;
+ wait_for_event(&test.codex, |event| {
+ assert!(!matches!(event, EventMsg::Error(_)), "{event:?}");
+ matches!(event, EventMsg::ItemStarted(item) if item.item.id() == "boundary")
+ })
+ .await;
+ for message in ["Worker found the result.", "Worker checked the result."] {
+ test.codex
+ .submit(Op::InterAgentCommunication {
+ communication: InterAgentCommunication::new(
+ AgentPath::root().join("worker").expect("worker path"),
+ AgentPath::root(),
+ Vec::new(),
+ message.to_string(),
+ /*trigger_turn*/ false,
+ ),
+ start_options: Default::default(),
+ })
+ .await?;
+ }
+ // The barrier confirms that both messages were queued before finishing the item.
+ test.codex
+ .submit(Op::RealtimeConversationListVoices)
+ .await?;
+ wait_for_event(&test.codex, |event| {
+ matches!(event, EventMsg::RealtimeConversationListVoicesResponse(_))
+ })
+ .await;
+ release.send(()).expect("release response");
+ Ok(test)
+}
+
+async fn finish_mailbox_preemption(test: TestCodex) -> anyhow::Result<()> {
+ let mut started_items = Vec::new();
+ let mut completed_items = Vec::new();
+ wait_for_event(&test.codex, |event| {
+ assert!(
+ !matches!(event, EventMsg::Error(_) | EventMsg::StreamError(_)),
+ "{event:?}"
+ );
+ assert!(
+ !matches!(event, EventMsg::PlanUpdate(_)),
+ "buffered tool must not run"
+ );
+ match event {
+ EventMsg::ItemStarted(item) => started_items.push(item.item.id()),
+ EventMsg::ItemCompleted(item) => completed_items.push(item.item.id()),
+ EventMsg::ReasoningContentDelta(delta) => assert_ne!(delta.item_id, "discarded"),
+ _ => {}
+ }
+ matches!(event, EventMsg::TurnComplete(_))
+ })
+ .await;
+ // The boundary's start was consumed above. Every newly exposed item must finish.
+ completed_items.retain(|id| id != "boundary");
+ assert_eq!(started_items, completed_items);
+ test.codex.shutdown_and_wait().await?;
+ Ok(())
+}