diff --git a/codex-rs/core/src/session/tests.rs b/codex-rs/core/src/session/tests.rs index 15d9047222..65a8ab0d66 100644 --- a/codex-rs/core/src/session/tests.rs +++ b/codex-rs/core/src/session/tests.rs @@ -8268,6 +8268,48 @@ async fn start_task_does_not_overwrite_racing_active_task() { sess.abort_all_tasks(TurnAbortReason::Interrupted).await; } +#[tokio::test] +async fn start_task_does_not_drain_input_while_another_start_is_claiming_turn() { + let (sess, tc, _rx) = make_session_and_context_with_rx().await; + let mut active_turn = ActiveTurn::default(); + active_turn.task_starting = true; + *sess.active_turn.lock().await = Some(active_turn); + + let queued_item = ResponseInputItem::Message { + role: "assistant".to_string(), + content: vec![ContentItem::InputText { + text: "queued before wake".to_string(), + }], + phase: None, + }; + sess.input_queue + .queue_response_items_for_next_turn(vec![queued_item]) + .await; + + sess.start_task( + tc, + Vec::new(), + NeverEndingTask { + kind: TaskKind::Regular, + listen_to_cancellation_token: true, + }, + ) + .await; + + assert!( + sess.input_queue + .has_queued_response_items_for_next_turn() + .await + ); + assert!( + sess.active_turn + .lock() + .await + .as_ref() + .is_some_and(|active_turn| active_turn.task.is_none()) + ); +} + #[tokio::test] async fn idle_interrupt_does_not_wake_queued_next_turn_items() { let (sess, _tc, _rx) = make_session_and_context_with_rx().await; diff --git a/codex-rs/core/src/state/turn.rs b/codex-rs/core/src/state/turn.rs index fe09235197..18efe8c5a6 100644 --- a/codex-rs/core/src/state/turn.rs +++ b/codex-rs/core/src/state/turn.rs @@ -28,6 +28,8 @@ use codex_protocol::protocol::TokenUsage; /// Metadata about the currently running turn. pub(crate) struct ActiveTurn { pub(crate) task: Option, + /// A task claimed this turn state and is still wiring up turn-start side effects. + pub(crate) task_starting: bool, pub(crate) turn_state: Arc>, } @@ -56,6 +58,7 @@ impl Default for ActiveTurn { fn default() -> Self { Self { task: None, + task_starting: false, turn_state: Arc::new(Mutex::new(TurnState::default())), } } diff --git a/codex-rs/core/src/tasks/mod.rs b/codex-rs/core/src/tasks/mod.rs index 6af3d3013a..528070db02 100644 --- a/codex-rs/core/src/tasks/mod.rs +++ b/codex-rs/core/src/tasks/mod.rs @@ -320,6 +320,15 @@ impl Session { let task: Arc = Arc::new(task); let task_kind = task.kind(); let span_name = task.span_name(); + let turn_state = { + let mut active = self.active_turn.lock().await; + let turn = active.get_or_insert_with(ActiveTurn::default); + if turn.task.is_some() || turn.task_starting { + return; + } + turn.task_starting = true; + Arc::clone(&turn.turn_state) + }; let started_at = Instant::now(); let turn_started_at_unix_ms = turn_context .turn_timing_state @@ -339,14 +348,6 @@ impl Session { .await .clear_turn(&turn_context.sub_id); - let turn_state = { - let mut active = self.active_turn.lock().await; - let turn = active.get_or_insert_with(ActiveTurn::default); - if turn.task.is_some() { - return; - } - Arc::clone(&turn.turn_state) - }; let queued_response_items = self .input_queue .take_queued_response_items_for_next_turn() @@ -366,8 +367,11 @@ impl Session { let turn_extension_data = Arc::clone(&turn_context.extension_data); let mut active = self.active_turn.lock().await; - let turn = active.get_or_insert_with(ActiveTurn::default); - if turn.task.is_some() { + let Some(turn) = active.as_mut() else { + return; + }; + if !Arc::ptr_eq(&turn.turn_state, &turn_state) || !turn.task_starting || turn.task.is_some() + { return; } let done_clone = Arc::clone(&done); @@ -443,6 +447,7 @@ impl Session { turn_extension_data, _timer: timer, }; + turn.task_starting = false; turn.task = Some(running_task); }