Lightweight coding agent that runs in your terminal
Rust
Interrupt active code-mode cells with their turn (#37483)
pakrym-oai509565820f90
diff --git a/codex-rs/core/config.schema.json b/codex-rs/core/config.schema.jsonindex 4f07e475b2..9790905468 100644--- a/codex-rs/core/config.schema.json+++ b/codex-rs/core/config.schema.json@@ -486,6 +486,9 @@"code_mode_host": {"$ref": "#/definitions/FeatureToml_for_CodeModeHostConfigToml"},+ "code_mode_interrupt": {+ "type": "boolean"+ },"code_mode_only": {"type": "boolean"},@@ -5148,6 +5151,9 @@"code_mode_host": {"$ref": "#/definitions/FeatureToml_for_CodeModeHostConfigToml"},+ "code_mode_interrupt": {+ "type": "boolean"+ },"code_mode_only": {"type": "boolean"},diff --git a/codex-rs/core/src/tasks/mod.rs b/codex-rs/core/src/tasks/mod.rsindex 75506c4e85..0a2b39c49c 100644--- a/codex-rs/core/src/tasks/mod.rs+++ b/codex-rs/core/src/tasks/mod.rs@@ -876,6 +876,18 @@ impl Session {.complete_task_end(&sub_id);trace!(task_kind = ?task.kind, sub_id, "aborting running task");task.cancellation_token.cancel();+ if reason == TurnAbortReason::Interrupted+ && task+ .turn_context+ .config+ .features+ .enabled(Feature::CodeModeInterrupt)+ {+ self.services+ .code_mode_service+ .interrupt_active_cells()+ .await;+ }task.turn_context.turn_metadata_state.cancel_git_enrichment_task();diff --git a/codex-rs/core/src/tools/code_mode/delegate.rs b/codex-rs/core/src/tools/code_mode/delegate.rsindex 70defb2421..bb46a06e74 100644--- a/codex-rs/core/src/tools/code_mode/delegate.rs+++ b/codex-rs/core/src/tools/code_mode/delegate.rs@@ -45,6 +45,15 @@ impl CodeModeDispatchBroker {remove_dispatch_gate(&self.dispatch_gates, cell_id);}+ pub(super) fn active_cell_ids(&self) -> Vec<CellId> {+ self.dispatch_gates+ .lock()+ .unwrap_or_else(std::sync::PoisonError::into_inner)+ .keys()+ .cloned()+ .collect()+ }+pub(super) fn start_turn_worker(&self,exec: ExecContext,@@ -105,12 +114,13 @@ impl CodeModeDispatchBroker {}let host = Arc::clone(&host);tokio::spawn(async move {+ let invocation =+ host.invoke_tool(invocation, cancellation_token.clone());+ tokio::pin!(invocation);let response = tokio::select! {- response = host.invoke_tool(- invocation,- cancellation_token.clone(),- ) => response,- _ = cancellation_token.cancelled() => return,+ biased;+ _ = cancellation_token.cancelled() => invocation.await,+ response = &mut invocation => response,};let _ = response_tx.send(response);});diff --git a/codex-rs/core/src/tools/code_mode/mod.rs b/codex-rs/core/src/tools/code_mode/mod.rsindex f6375e75c0..0ce1e66b9c 100644--- a/codex-rs/core/src/tools/code_mode/mod.rs+++ b/codex-rs/core/src/tools/code_mode/mod.rs@@ -18,6 +18,7 @@ use codex_code_mode::CodeModeSessionProvider;use codex_code_mode::CodeModeToolKind;use codex_code_mode::RuntimeResponse;use codex_protocol::models::FunctionCallOutputContentItem;+use futures::future::join_all;use serde_json::Value as JsonValue;use tokio::sync::OnceCell;use tokio_util::sync::CancellationToken;@@ -141,6 +142,23 @@ impl CodeModeService {self.session().await?.terminate(cell_id).await}+ pub(crate) async fn interrupt_active_cells(&self) {+ let Some(session) = self.session.get() else {+ return;+ };+ join_all(+ self.dispatch_broker+ .active_cell_ids()+ .into_iter()+ .map(|cell_id| async move {+ if let Err(error) = session.terminate(cell_id.clone()).await {+ tracing::warn!(%cell_id, %error, "failed to terminate interrupted code-mode cell");+ }+ }),+ )+ .await;+ }+pub(crate) async fn shutdown(&self) -> Result<(), String> {self.shutting_down.store(true, Ordering::Release);// Join any initialization already in progress without initializing an unused service.diff --git a/codex-rs/core/tests/suite/code_mode.rs b/codex-rs/core/tests/suite/code_mode.rsindex d8b6fabbb3..0fefaca196 100644--- a/codex-rs/core/tests/suite/code_mode.rs+++ b/codex-rs/core/tests/suite/code_mode.rs@@ -10,7 +10,12 @@ use codex_core::config::Config;use codex_core::config::CurrentTimeReminderConfig;use codex_extension_api::ExtensionData;use codex_extension_api::ExtensionRegistryBuilder;+use codex_extension_api::ToolCallOutcome;use codex_extension_api::ToolContributor;+use codex_extension_api::ToolFinishInput;+use codex_extension_api::ToolLifecycleContributor;+use codex_extension_api::ToolLifecycleFuture;+use codex_extension_api::ToolStartInput;use codex_features::CurrentTimeSource;use codex_features::Feature;use codex_login::CodexAuth;@@ -80,11 +85,13 @@ use std::fs;use std::io::Cursor;use std::path::Path;use std::sync::Arc;+use std::sync::Mutex;use std::sync::atomic::AtomicUsize;use std::sync::atomic::Ordering;use std::time::Duration;use std::time::Instant;use test_case::test_case;+use tokio::sync::oneshot;use wiremock::Mock;use wiremock::MockServer;use wiremock::ResponseTemplate;@@ -3246,6 +3253,208 @@ text("after yield");Ok(())}+struct InterruptedNestedToolObserver {+ started: Mutex<Option<oneshot::Sender<String>>>,+ finished: Mutex<Option<oneshot::Sender<ToolCallOutcome>>>,+}++impl ToolLifecycleContributor for InterruptedNestedToolObserver {+ fn on_tool_start<'a>(&'a self, input: ToolStartInput<'a>) -> ToolLifecycleFuture<'a> {+ Box::pin(async move {+ let codex_extension_api::ToolCallSource::CodeMode { cell_id, .. } = input.source else {+ return;+ };+ if input.tool_name.name != "test_sync_tool" {+ return;+ }+ if let Some(started) = self+ .started+ .lock()+ .unwrap_or_else(std::sync::PoisonError::into_inner)+ .take()+ {+ let _ = started.send(cell_id);+ }+ })+ }++ fn on_tool_finish<'a>(&'a self, input: ToolFinishInput<'a>) -> ToolLifecycleFuture<'a> {+ Box::pin(async move {+ if input.tool_name.name != "test_sync_tool"+ || !matches!(+ input.source,+ codex_extension_api::ToolCallSource::CodeMode { .. }+ )+ {+ return;+ }+ if let Some(finished) = self+ .finished+ .lock()+ .unwrap_or_else(std::sync::PoisonError::into_inner)+ .take()+ {+ let _ = finished.send(input.outcome);+ }+ })+ }+}++#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn code_mode_interrupt_terminates_active_cells_and_nested_tools() -> Result<()> {+ skip_if_no_network!(Ok(()));++ let (started_tx, started_rx) = oneshot::channel();+ let (finished_tx, finished_rx) = oneshot::channel();+ let mut extensions = ExtensionRegistryBuilder::<Config>::new();+ extensions.tool_lifecycle_contributor(Arc::new(InterruptedNestedToolObserver {+ started: Mutex::new(Some(started_tx)),+ finished: Mutex::new(Some(finished_tx)),+ }));++ let server = responses::start_mock_server().await;+ let mut builder = test_codex()+ .with_model("test-gpt-5.1-codex")+ .with_extensions(Arc::new(extensions.build()))+ .with_config(|config| {+ let _ = config.features.enable(Feature::CodeMode);+ let _ = config.features.enable(Feature::CodeModeInterrupt);+ });+ let test = builder.build_with_auto_env(&server).await?;++ let setup = responses::mount_sse_sequence(+ &server,+ vec![+ sse(vec![+ ev_response_created("resp-store"),+ ev_custom_tool_call("call-store", "exec", r#"store("persisted", "preserved");"#),+ ev_completed("resp-store"),+ ]),+ sse(vec![+ ev_assistant_message("msg-store", "stored"),+ ev_completed("resp-store-complete"),+ ]),+ sse(vec![+ ev_response_created("resp-background"),+ ev_custom_tool_call(+ "call-background",+ "exec",+ "yield_control(); await new Promise(() => {});",+ ),+ ev_completed("resp-background"),+ ]),+ sse(vec![+ ev_assistant_message("msg-background", "running"),+ ev_completed("resp-background-complete"),+ ]),+ ],+ )+ .await;++ test.submit_turn("store a value in the reusable code-mode session")+ .await?;+ test.submit_turn("start a background code-mode cell")+ .await?;+ let background_response = setup+ .last_request()+ .expect("background cell should be returned to the model");+ let background_items = custom_tool_output_items(&background_response, "call-background");+ assert!(+ text_item(&background_items, /*index*/ 0).starts_with("Script running with cell ID "),+ "background cell should remain active: {background_items:?}"+ );+ let background_cell_id =+ extract_running_cell_id(text_item(&background_items, /*index*/ 0));++ responses::mount_sse_once(+ &server,+ sse(vec![+ ev_response_created("resp-interrupted"),+ ev_custom_tool_call(+ "call-interrupted",+ "exec",+ "await tools.test_sync_tool({ sleep_after_ms: 60_000 });",+ ),+ ev_completed("resp-interrupted"),+ ]),+ )+ .await;++ test.codex+ .submit(Op::UserInput {+ items: vec![UserInput::Text {+ text: "start a long-running nested tool".to_string(),+ text_elements: Vec::new(),+ }],+ final_output_json_schema: None,+ responsesapi_client_metadata: None,+ additional_context: Default::default(),+ thread_settings: Default::default(),+ })+ .await?;+ let active_cell_id = tokio::time::timeout(Duration::from_secs(10), started_rx).await??;++ test.codex.submit(Op::Interrupt).await?;+ wait_for_event(&test.codex, |event| {+ matches!(event, EventMsg::TurnAborted(_))+ })+ .await;+ let nested_outcome = tokio::time::timeout(Duration::from_secs(10), finished_rx).await??;+ assert_eq!(nested_outcome, ToolCallOutcome::Aborted);++ let recovery = responses::mount_sse_sequence(+ &server,+ vec![+ sse(vec![+ ev_response_created("resp-wait-background"),+ responses::ev_function_call(+ "call-wait-background",+ "wait",+ &serde_json::to_string(&serde_json::json!({+ "cell_id": background_cell_id,+ "yield_time_ms": 1,+ }))?,+ ),+ ev_completed("resp-wait-background"),+ ]),+ sse(vec![+ ev_response_created("resp-wait-active"),+ responses::ev_function_call(+ "call-wait-active",+ "wait",+ &serde_json::to_string(&serde_json::json!({+ "cell_id": active_cell_id,+ "yield_time_ms": 1,+ }))?,+ ),+ ev_completed("resp-wait-active"),+ ]),+ sse(vec![+ ev_response_created("resp-recovery"),+ ev_custom_tool_call("call-recovery", "exec", r#"text(load("persisted"));"#),+ ev_completed("resp-recovery"),+ ]),+ sse(vec![+ ev_assistant_message("msg-recovery", "recovered"),+ ev_completed("resp-recovery-complete"),+ ]),+ ],+ )+ .await;++ test.submit_turn("verify interrupted cells and reuse their session")+ .await?;+ let requests = recovery.requests();+ let background_output = function_tool_output_items(&requests[1], "call-wait-background");+ assert!(text_item(&background_output, /*index*/ 1).contains("not found"));+ let active_output = function_tool_output_items(&requests[2], "call-wait-active");+ assert!(text_item(&active_output, /*index*/ 1).contains("not found"));+ let recovery_items = custom_tool_output_items(&requests[3], "call-recovery");+ assert_eq!(text_item(&recovery_items, /*index*/ 1), "preserved");++ Ok(())+}+#[cfg_attr(windows, ignore = "no exec_command on Windows")]#[tokio::test(flavor = "multi_thread", worker_threads = 2)]async fn code_mode_wait_uses_its_own_max_tokens_budget() -> Result<()> {diff --git a/codex-rs/features/src/lib.rs b/codex-rs/features/src/lib.rsindex a861529b39..d0b1847977 100644--- a/codex-rs/features/src/lib.rs+++ b/codex-rs/features/src/lib.rs@@ -103,6 +103,8 @@ pub enum Feature {CodeModeBufferedExec,/// Run JavaScript code mode in the standalone host process.CodeModeHost,+ /// Terminate active code mode cells when their turn is interrupted.+ CodeModeInterrupt,/// Restrict model-visible tools to code mode entrypoints (`exec`, `wait`).CodeModeOnly,/// Use the single unified PTY-backed exec tool.@@ -933,6 +935,12 @@ pub const FEATURES: &[FeatureSpec] = &[stage: Stage::Stable,default_enabled: true,},+ FeatureSpec {+ id: Feature::CodeModeInterrupt,+ key: "code_mode_interrupt",+ stage: Stage::UnderDevelopment,+ default_enabled: false,+ },FeatureSpec {id: Feature::CodeModeOnly,key: "code_mode_only",