Lightweight coding agent that runs in your terminal
Rust
Keep spawned children provisional until the spawn result returns (#53654)
jif4e7ef7d19d59
diff --git a/codex-rs/core/src/agent/api.rs b/codex-rs/core/src/agent/api.rsindex 1a498228b6..622c451343 100644--- a/codex-rs/core/src/agent/api.rs+++ b/codex-rs/core/src/agent/api.rs@@ -53,6 +53,9 @@ pub trait AgentControl: Send + Sync {) -> BoxFuture<'a, Result<ThreadId>>;/// Start a child and accept its initial input, returning its effective settings.+ /// Retain provisional-child ownership until this future returns its acceptance receipt.+ /// Once returned, caller cancellation does not retract the accepted child. Subsequent+ /// tool-result or transport publication belongs to the caller, outside this boundary./// V2 snapshots resolve effort against captured startup metadata without changing the/// child's configured effort (for example, Ultra still enables proactive behavior).fn spawn(diff --git a/codex-rs/core/src/agent/control/spawn.rs b/codex-rs/core/src/agent/control/spawn.rsindex cca217e8d0..70cf8b7ef0 100644--- a/codex-rs/core/src/agent/control/spawn.rs+++ b/codex-rs/core/src/agent/control/spawn.rs@@ -954,6 +954,13 @@ impl LocalAgentControl {}}let input_admission = input_admission_started_at.elapsed();+ // Keep provisional ownership through the final awaits. Commit and return to the+ // backend caller in one poll; later tool-result publication is outside this boundary.+ let status = self.get_status(new_thread.thread_id).await;+ let config = match spawn_config {+ Some(config) => config,+ None => new_thread.thread.config_snapshot().await,+ };reservation.commit(agent_metadata.clone());if let Some(residency_slot) = residency_slot {residency_slot.commit(new_thread.thread_id);@@ -981,11 +988,7 @@ impl LocalAgentControl {let agent = LiveAgent {thread_id: new_thread.thread_id,metadata: agent_metadata,- status: self.get_status(new_thread.thread_id).await,- };- let config = match spawn_config {- Some(config) => config,- None => new_thread.thread.config_snapshot().await,+ status,};let session_telemetry = new_thread.threaddiff --git a/codex-rs/core/src/agent/control/spawn_guard.rs b/codex-rs/core/src/agent/control/spawn_guard.rsindex d8befedd40..c9095893b1 100644--- a/codex-rs/core/src/agent/control/spawn_guard.rs+++ b/codex-rs/core/src/agent/control/spawn_guard.rs@@ -1,4 +1,4 @@-//! Owns a spawned child until its initial input is accepted.+//! Owns a provisional child until the spawn result can be returned without yielding.use super::AgentTreeMembership;use crate::thread_manager::ThreadManagerState;diff --git a/codex-rs/core/src/agent/control_tests.rs b/codex-rs/core/src/agent/control_tests.rsindex d22fb97d29..6d97eceb2e 100644--- a/codex-rs/core/src/agent/control_tests.rs+++ b/codex-rs/core/src/agent/control_tests.rs@@ -820,6 +820,69 @@ async fn spawn_failure_context_preserves_shutdown_during_child_startup() {.expect("spawn releases its membership");}+#[tokio::test]+async fn cancelled_spawn_after_input_admission_discards_child() {+ let harness = AgentControlHarness::new().await;+ let state = harness.control.runtime.upgrade().expect("live manager");+ let parent_id = ThreadId::new();+ let mut spawn = harness.control.spawn(SpawnRequest {+ caller: parent_id,+ config: harness.config.clone(),+ input: AgentInput::UserInput(text_input("child task")),+ source: SessionSource::SubAgent(SubAgentSource::ThreadSpawn {+ parent_thread_id: parent_id,+ depth: 1,+ agent_path: None,+ agent_nickname: None,+ agent_role: None,+ }),+ options: SpawnAgentOptions::default(),+ });+ let child = poll_fn(|cx| {+ assert!(spawn.as_mut().poll(cx).is_pending());+ let threads = state.threads.try_read().expect("uncontended manager");+ // On this single-thread runtime the session loop cannot consume the first+ // input until this poll returns. Leave spawn waiting for its admission reply.+ match threads.values().find(|thread| !thread.io.tx_sub.is_empty()) {+ Some(child) => Poll::Ready(Arc::clone(child)),+ None => Poll::Pending,+ }+ })+ .await;+ let child_id = child.session.thread_id();+ // This no-op goes through the same FIFO submission loop. Its receipt proves the+ // earlier input has been admitted, without polling the spawn future again.+ child+ .update_thread_settings(ThreadSettingsOverrides::default())+ .await+ .expect("input admission completed before the settings barrier");+ {+ // Only the final status lookup now needs the manager lock. Cancel there,+ // after input admission but before the backend can return its receipt.+ let _threads = state.threads.write().await;+ assert!(+ spawn+ .as_mut()+ .poll(&mut Context::from_waker(Waker::noop()))+ .is_pending()+ );+ drop(spawn);+ }+ assert!(+ harness.control.get_agent_metadata(child_id).is_none(),+ "cancelled spawn must not leave an accepted child registered"+ );+ child.wait_until_terminated().await;+ assert_thread_not_loaded(&harness.manager, child_id).await;+ harness+ .control+ .runtime+ .request_shutdown()+ .wait()+ .await+ .expect("provisional cleanup releases tree membership");+}+#[tokio::test]async fn spawn_agent_errors_when_manager_dropped() {let control = LocalAgentControl::default();diff --git a/codex-rs/core/tests/suite/pending_input_persistence.rs b/codex-rs/core/tests/suite/pending_input_persistence.rsindex f12d89372c..0ebb340663 100644--- a/codex-rs/core/tests/suite/pending_input_persistence.rs+++ b/codex-rs/core/tests/suite/pending_input_persistence.rs@@ -595,8 +595,16 @@ async fn local_preparation_is_durable_before_first_input_and_survives_restart(Ok(())}+#[derive(Clone, Copy)]+enum SpawnCaller {+ NativeV1,+ NativeV2,+}++#[test_case(SpawnCaller::NativeV1; "native_v1")]+#[test_case(SpawnCaller::NativeV2; "native_v2")]#[tokio::test(flavor = "multi_thread", worker_threads = 2)]-async fn cancelled_spawn_discards_provisional_child() -> anyhow::Result<()> {+async fn cancelled_spawn_discards_provisional_child(caller: SpawnCaller) -> anyhow::Result<()> {let server = responses::start_mock_server().await;let (checkpoints, mut checkpoint_requests) = mpsc::unbounded_channel();let store = Arc::new(GatedCheckpointStore {@@ -610,8 +618,14 @@ async fn cancelled_spawn_discards_provisional_child() -> anyhow::Result<()> {let test = test_codex().with_thread_store(store).with_history_mode(ThreadHistoryMode::Legacy)- .with_config(|config| {+ .with_config(move |config| {config.agent_max_depth = 1;+ if matches!(caller, SpawnCaller::NativeV2) {+ config+ .features+ .enable(Feature::MultiAgentV2)+ .expect("enable V2");+ }config.features.enable(Feature::Collab)@@ -619,15 +633,24 @@ async fn cancelled_spawn_discards_provisional_child() -> anyhow::Result<()> {}).build_with_auto_env(&server).await?;+ let (namespace, arguments) = match caller {+ SpawnCaller::NativeV1 => (+ "multi_agent_v1",+ json!({"message":"child startup task", "task_name":"worker", "fork_context":true}),+ ),+ SpawnCaller::NativeV2 => (+ "collaboration",+ json!({"message":"child startup task", "task_name":"worker", "fork_turns":"all"}),+ ),+ };responses::mount_sse_once(&server,responses::sse(vec![responses::ev_function_call_with_namespace("spawn-checkpoint",- "multi_agent_v1",+ namespace,"spawn_agent",- &json!({"message":"child startup task", "task_name":"worker", "fork_context":true})- .to_string(),+ &arguments.to_string(),),responses::ev_completed("parent-spawn"),]),