diff --git a/codex-rs/core/src/session/turn.rs b/codex-rs/core/src/session/turn.rs index 02314340c8..0deab079e8 100644 --- a/codex-rs/core/src/session/turn.rs +++ b/codex-rs/core/src/session/turn.rs @@ -119,7 +119,6 @@ use codex_protocol::protocol::ReasoningContentDeltaEvent; use codex_protocol::protocol::ReasoningRawContentDeltaEvent; use codex_protocol::protocol::SafetyBufferingEvent; use codex_protocol::protocol::SessionSource; -use codex_protocol::protocol::TurnDiffEvent; use codex_protocol::protocol::WarningEvent; use codex_protocol::user_input::UserInput; use codex_skills::ToolMentionKind; @@ -523,11 +522,14 @@ pub(crate) async fn run_turn( let mut last_agent_message: Option = None; let mut stop_hook_active = false; - // Although from the perspective of codex.rs, TurnDiffTracker has the lifecycle of a Task which contains - // many turns, from the perspective of the user, it is a single turn. - let turn_diff_tracker = Arc::new(tokio::sync::Mutex::new( - TurnDiffTracker::with_environment_display_roots(display_roots), - )); + // A steer can reopen sampling within the same turn. Keep its aggregate until the turn ends. + let turn_diff_tracker = turn_context + .extension_data + .get_or_init(|| tokio::sync::Mutex::new(TurnDiffTracker::new())); + turn_diff_tracker + .lock() + .await + .update_environment_display_roots(display_roots); // `ModelClientSession` is turn-scoped and caches WebSocket + sticky routing state, so we reuse // one instance across retries within this turn. @@ -1974,7 +1976,7 @@ async fn run_sampling_request( let _code_mode_worker = sess.services.code_mode_service.start_turn_worker( &sess, Arc::clone(&step_context), - Arc::clone(&turn_diff_tracker), + turn_diff_tracker, ); let max_retries = turn_context.provider.info().stream_max_retries(); let incremental_tools = sess @@ -2072,7 +2074,6 @@ async fn run_sampling_request( Arc::clone(&turn_store), client_session, &responses_metadata, - Arc::clone(&turn_diff_tracker), prompt, pending_audio, input_item_count, @@ -2944,7 +2945,6 @@ async fn try_run_sampling_request( turn_store: Arc, client_session: &mut ModelClientSession, responses_metadata: &CodexResponsesMetadata, - turn_diff_tracker: SharedTurnDiffTracker, prompt: Prompt, mut pending_audio: Option, input_item_count: usize, @@ -3063,7 +3063,6 @@ async fn try_run_sampling_request( String, Box, )> = None; - let mut should_emit_turn_diff = false; let mut should_emit_token_count = false; const MAX_ANALYTICS_TOOL_CALL_IDS_PER_RESPONSE: usize = 256; let mut analytics_tool_call_ids = Vec::new(); @@ -3616,7 +3615,6 @@ async fn try_run_sampling_request( ) .await; should_emit_token_count = true; - should_emit_turn_diff = true; if let Err(err) = budget_result { break Err(err); } @@ -3832,17 +3830,6 @@ async fn try_run_sampling_request( return Err(CodexErr::TurnAborted); } - if should_emit_turn_diff { - let unified_diff = { - let tracker = turn_diff_tracker.lock().await; - tracker.get_unified_diff() - }; - if let Some(unified_diff) = unified_diff { - let msg = EventMsg::TurnDiff(TurnDiffEvent { unified_diff }); - sess.clone().send_event(&turn_context, msg).await; - } - } - outcome } diff --git a/codex-rs/core/src/tasks/mod.rs b/codex-rs/core/src/tasks/mod.rs index a00369c736..9debf1956e 100644 --- a/codex-rs/core/src/tasks/mod.rs +++ b/codex-rs/core/src/tasks/mod.rs @@ -42,6 +42,7 @@ use crate::state::ActiveTurn; use crate::state::RunningTask; use crate::state::TaskKind; use crate::state::TurnState; +use crate::turn_diff_tracker::TurnDiffTracker; use codex_analytics::TurnProfileFact; use codex_analytics::TurnTokenUsageFact; use codex_context_fragments::RenderedFragment; @@ -61,6 +62,7 @@ use codex_protocol::protocol::TokenUsage; use codex_protocol::protocol::TurnAbortReason; use codex_protocol::protocol::TurnAbortedEvent; use codex_protocol::protocol::TurnCompleteEvent; +use codex_protocol::protocol::TurnDiffEvent; use codex_protocol::protocol::WarningEvent; use codex_protocol::turn_input::NotSubmittedReason; use codex_protocol::turn_input::TurnInputSubmission; @@ -1015,6 +1017,7 @@ impl Session { }; let saved_guardian_completion = matches!(event, EventMsg::TurnComplete(_)) && self.is_private_guardian_reviewer().await; + self.finish_turn_diff(&turn_context, &event).await; if !saved_guardian_completion { self.send_event(turn_context.as_ref(), event.clone()).await; } @@ -1050,6 +1053,18 @@ impl Session { None } + async fn finish_turn_diff(&self, turn: &TurnContext, terminal_event: &EventMsg) { + let tracker = turn.extension_data.remove::>(); + let (EventMsg::TurnComplete(_), Some(tracker)) = (terminal_event, tracker) else { + return; + }; + let unified_diff = tracker.lock().await.get_unified_diff(); + if let Some(unified_diff) = unified_diff { + self.send_event(turn, EventMsg::TurnDiff(TurnDiffEvent { unified_diff })) + .await; + } + } + async fn take_active_turn(&self, reason: &TurnAbortReason) -> Option { let mut active = self.active_turn.lock().await; if matches!( @@ -1223,6 +1238,7 @@ impl Session { completed_at, duration_ms, }); + self.finish_turn_diff(&task.turn_context, &event).await; self.send_event(task.turn_context.as_ref(), event).await; // Regular items were flushed before this terminal event was appended; buffering // thread writers may not flush it without another explicit barrier. diff --git a/codex-rs/core/src/turn_diff_tracker.rs b/codex-rs/core/src/turn_diff_tracker.rs index 06a2cd022e..9db4d66b83 100644 --- a/codex-rs/core/src/turn_diff_tracker.rs +++ b/codex-rs/core/src/turn_diff_tracker.rs @@ -81,12 +81,23 @@ impl TurnDiffTracker { Self::default() } - pub fn with_environment_display_roots( + /// Use each environment's first display root for the whole turn so a steer cannot + /// change what an already published relative path refers to. + pub(crate) fn update_environment_display_roots( + &mut self, display_roots: impl IntoIterator, - ) -> Self { - let mut tracker = Self::new(); - tracker.display_roots_by_environment = display_roots.into_iter().collect(); - tracker + ) { + let previous_environment_count = self.display_roots_by_environment.len(); + for (id, root) in display_roots { + self.display_roots_by_environment.entry(id).or_insert(root); + } + if self.display_roots_by_environment.len() != previous_environment_count + && !self.rendered_diffs.is_empty() + { + // Adding an environment can add an environment ID prefix to existing headers. + self.rendered_diffs.clear(); + self.refresh_unified_diff(); + } } pub fn track_delta(&mut self, environment_id: &str, delta: &AppliedPatchDelta) { diff --git a/codex-rs/core/src/turn_diff_tracker_tests.rs b/codex-rs/core/src/turn_diff_tracker_tests.rs index 27af3ff32b..46da03b0bb 100644 --- a/codex-rs/core/src/turn_diff_tracker_tests.rs +++ b/codex-rs/core/src/turn_diff_tracker_tests.rs @@ -47,10 +47,12 @@ async fn apply_verified_patch(root: &Path, patch: &str) -> AppliedPatchDelta { } fn tracker_with_root(root: &Path) -> TurnDiffTracker { - TurnDiffTracker::with_environment_display_roots([( + let mut tracker = TurnDiffTracker::new(); + tracker.update_environment_display_roots([( "".to_string(), PathUri::from_host_native_path(root).expect("absolute display root"), - )]) + )]); + tracker } #[tokio::test] @@ -113,18 +115,12 @@ async fn tracks_same_absolute_path_across_multiple_environments() { ) .await; - let mut tracker = TurnDiffTracker::with_environment_display_roots([ - ( - "local".to_string(), - PathUri::from_host_native_path(dir.path()).expect("absolute local display root"), - ), - ( - "remote".to_string(), - PathUri::from_host_native_path(dir.path()).expect("absolute remote display root"), - ), - ]); - tracker.track_delta("remote", &add); + let mut tracker = TurnDiffTracker::new(); + let root = PathUri::from_host_native_path(dir.path()).expect("absolute display root"); + tracker.update_environment_display_roots([("local".to_string(), root.clone())]); tracker.track_delta("local", &add); + tracker.update_environment_display_roots([("remote".to_string(), root)]); + tracker.track_delta("remote", &add); let right_oid = git_blob_sha1_hex("content\n"); let expected = format!( @@ -149,7 +145,8 @@ index {ZERO_OID}..{right_oid} #[test] fn displays_foreign_paths_relative_to_their_environment_root() { - let tracker = TurnDiffTracker::with_environment_display_roots([( + let mut tracker = TurnDiffTracker::new(); + tracker.update_environment_display_roots([( "windows".to_string(), PathUri::parse("file:///C:/workspace/project").expect("valid Windows display root"), )]); diff --git a/codex-rs/core/tests/suite/apply_patch_cli.rs b/codex-rs/core/tests/suite/apply_patch_cli.rs index 3681a7ed22..ebdc8c90b5 100644 --- a/codex-rs/core/tests/suite/apply_patch_cli.rs +++ b/codex-rs/core/tests/suite/apply_patch_cli.rs @@ -2455,26 +2455,34 @@ async fn apply_patch_aggregates_diff_across_multiple_tool_calls() -> Result<()> ev_apply_patch_custom_tool_call(call2, patch2), ev_completed("resp-2"), ]); - let s3 = sse(vec![ + let mut continue_sampling = ev_completed("resp-3"); + continue_sampling["response"]["end_turn"] = json!(false); + let s3 = sse(vec![ev_response_created("resp-3"), continue_sampling]); + let s4 = sse(vec![ ev_assistant_message("msg-1", "ok"), - ev_completed("resp-3"), + ev_completed("resp-4"), ]); - mount_sse_sequence(harness.server(), vec![s1, s2, s3]).await; + mount_sse_sequence(harness.server(), vec![s1, s2, s3, s4]).await; submit_without_wait(&harness, "aggregate diffs").await?; - let mut last_diff: Option = None; - wait_for_event(&codex, |event| match event { - EventMsg::TurnDiff(ev) => { - last_diff = Some(ev.unified_diff.clone()); - false + let mut saw_final_answer = false; + let mut diffs = Vec::new(); + wait_for_event(&codex, |event| { + match event { + EventMsg::TurnDiff(ev) => diffs.push((saw_final_answer, ev.unified_diff.clone())), + EventMsg::AgentMessage(message) if message.message == "ok" => saw_final_answer = true, + _ => {} } - EventMsg::TurnComplete(_) => true, - _ => false, + matches!(event, EventMsg::TurnComplete(_)) }) .await; - let diff = last_diff.expect("expected TurnDiff after two patches"); + let [(false, first), (false, diff), (true, final_diff)] = diffs.as_slice() else { + anyhow::bail!("expected both patch updates and one final snapshot, got {diffs:?}"); + }; + assert!(first.contains("+v1\n")); + assert_eq!(final_diff, diff); assert!(diff.contains("agg/a.txt"), "diff missing agg/a.txt: {diff}"); assert!(diff.contains("agg/b.txt"), "diff missing agg/b.txt: {diff}"); // Final content reflects v2 for a.txt diff --git a/codex-rs/core/tests/suite/pending_input_persistence.rs b/codex-rs/core/tests/suite/pending_input_persistence.rs index 6312e5342a..277f32cce2 100644 --- a/codex-rs/core/tests/suite/pending_input_persistence.rs +++ b/codex-rs/core/tests/suite/pending_input_persistence.rs @@ -16,10 +16,15 @@ use codex_protocol::AgentPath; use codex_protocol::ThreadId; use codex_protocol::mcp::ClientMcpExtensions; use codex_protocol::models::ResponseItem; +use codex_protocol::protocol::AskForApproval; use codex_protocol::protocol::EventMsg; use codex_protocol::protocol::InterAgentCommunication; use codex_protocol::protocol::Op; +use codex_protocol::protocol::SandboxPolicy; use codex_protocol::protocol::ThreadHistoryMode; +use codex_protocol::protocol::ThreadSettingsOverrides; +use codex_protocol::protocol::TurnSettingsUpdate; +use codex_protocol::protocol::TurnSettingsUpdateOutcome; use codex_protocol::user_input::UserInput; use codex_rollout::RolloutItem; use codex_rollout::RolloutRecorder; @@ -363,26 +368,43 @@ async fn steered_input_checkpoint_controls_next_request( Ok(()) } +#[test_case(false; "read_only_steer")] +#[test_case(true; "steer_with_patch")] #[tokio::test(flavor = "multi_thread", worker_threads = 2)] -async fn steer_during_final_flush_reaches_the_model_before_turn_completion() -> anyhow::Result<()> { +async fn steer_during_final_flush_reaches_the_model_before_turn_completion( + patch_after_steer: bool, +) -> anyhow::Result<()> { let server = responses::start_mock_server().await; - let responses = responses::mount_sse_sequence( - &server, - [ - ("first", "original answer"), - ("second", "answer to the steer"), - ] - .into_iter() - .map(|(id, answer)| { - responses::sse(vec![ - responses::ev_response_created(id), - responses::ev_assistant_message(id, answer), - responses::ev_completed(id), - ]) - }) - .collect(), - ) - .await; + let patch_response = |id, patch| { + responses::sse(vec![ + responses::ev_response_created(id), + responses::ev_apply_patch_custom_tool_call(id, patch), + responses::ev_completed(id), + ]) + }; + let answer_response = |id, answer| { + responses::sse(vec![ + responses::ev_response_created(id), + responses::ev_assistant_message(id, answer), + responses::ev_completed(id), + ]) + }; + let mut sequence = vec![ + patch_response( + "patch-first", + "*** Begin Patch\n*** Add File: before.txt\n+root\n*** Add File: nested/before.txt\n+nested\n*** End Patch", + ), + answer_response("first", "original answer"), + ]; + if patch_after_steer { + sequence.push(patch_response( + "patch-second", + "*** Begin Patch\n*** Add File: later.txt\n+ok\n*** End Patch", + )); + } + sequence.push(answer_response("second", "answer to the steer")); + let expected_requests = sequence.len(); + let responses = responses::mount_sse_sequence(&server, sequence).await; let (checkpoints, _checkpoint_requests) = mpsc::unbounded_channel(); let store = Arc::new(GatedCheckpointStore { inner: InMemoryThreadStore::default(), @@ -394,6 +416,12 @@ async fn steer_during_final_flush_reaches_the_model_before_turn_completion() -> next_flush: Mutex::default(), }); let test = test_codex() + .with_config(|config| { + config + .features + .enable(Feature::CwdRelativeTurnDiffs) + .expect("enable cwd-relative turn diffs"); + }) .with_thread_store(store.clone()) .with_history_mode(ThreadHistoryMode::Legacy) .build_with_auto_env(&server) @@ -414,7 +442,13 @@ async fn steer_during_final_flush_reaches_the_model_before_turn_completion() -> root_turn_id, } = test .codex - .start_or_steer_turn(user_message("first prompt", None)) + .start_or_steer_turn(user_message("first prompt", None).with_thread_settings( + ThreadSettingsOverrides { + approval_policy: Some(AskForApproval::Never), + sandbox_policy: Some(SandboxPolicy::DangerFullAccess), + ..Default::default() + }, + )) .await? else { panic!("expected a new turn"); @@ -422,7 +456,22 @@ async fn steer_during_final_flush_reaches_the_model_before_turn_completion() -> // The regular task returned its first answer and is flushing before it completes the turn. timeout(Duration::from_secs(10), flush.wait()).await?; - assert_eq!(responses.requests().len(), 1); + assert_eq!(responses.requests().len(), 2); + let mut environment = test.executor_environment().request(); + environment.cwd = environment.cwd.join("nested")?; + environment.workspace_roots = vec![environment.cwd.clone()]; + let (reply, outcome) = oneshot::channel(); + test.codex + .submit(Op::TurnSettings { + turn_id: turn_id.clone(), + update: TurnSettingsUpdate { + environments: Some(vec![environment]), + ..Default::default() + }, + reply, + }) + .await?; + assert_eq!(outcome.await?, TurnSettingsUpdateOutcome::Applied); let steer = timeout( Duration::from_secs(10), test.codex @@ -438,11 +487,19 @@ async fn steer_during_final_flush_reaches_the_model_before_turn_completion() -> } ); + let mut saw_steered_answer = false; + let mut final_diff = String::new(); let mut starts = 0; let mut client_ids = Vec::new(); let EventMsg::TurnComplete(completed) = wait_for_event(&test.codex, |event| { match event { EventMsg::TurnStarted(_) => starts += 1, + EventMsg::AgentMessage(message) if message.message == "answer to the steer" => { + saw_steered_answer = true; + } + EventMsg::TurnDiff(event) if saw_steered_answer => { + final_diff.clone_from(&event.unified_diff); + } EventMsg::UserMessage(message) if message.message == "late steer" => { client_ids.push(message.client_id.clone()); } @@ -459,12 +516,26 @@ async fn steer_during_final_flush_reaches_the_model_before_turn_completion() -> completed.last_agent_message.as_deref(), Some("answer to the steer") ); + let mut expected_headers = vec![ + "diff --git a/before.txt b/before.txt", + "diff --git a/nested/before.txt b/nested/before.txt", + ]; + if patch_after_steer { + expected_headers.push("diff --git a/nested/later.txt b/nested/later.txt"); + } + assert_eq!( + final_diff + .lines() + .filter(|line| line.starts_with("diff --git")) + .collect::>(), + expected_headers, + ); assert_eq!(starts, 1); assert_eq!(client_ids, [Some("steer-id".to_string())]); let requests = responses.requests(); - assert_eq!(requests.len(), 2); + assert_eq!(requests.len(), expected_requests); assert_eq!( - requests[1] + requests[2] .message_input_texts("user") .iter() .filter(|text| *text == "late steer")