Lightweight coding agent that runs in your terminal
Rust
Prevent duplicate assistant messages around interleaved commands (#54365)
Felipe Couryc313eb75fd93
diff --git a/codex-rs/tui/src/app/tests.rs b/codex-rs/tui/src/app/tests.rsindex 6c8b9a4965..ea58190284 100644--- a/codex-rs/tui/src/app/tests.rs+++ b/codex-rs/tui/src/app/tests.rs@@ -97,6 +97,8 @@ mod startup_frame_tests;mod startup_warnings_tests;#[path = "tests/stream_animation_tests.rs"]mod stream_animation_tests;+#[path = "tests/streaming_interleave_e2e.rs"]+mod streaming_interleave_e2e;#[path = "tests/thread_usage.rs"]mod thread_usage;#[path = "tests/transcript_composer.rs"]diff --git a/codex-rs/tui/src/app/tests/streaming_interleave_e2e.rs b/codex-rs/tui/src/app/tests/streaming_interleave_e2e.rsnew file mode 100644index 0000000000..f763f65e72--- /dev/null+++ b/codex-rs/tui/src/app/tests/streaming_interleave_e2e.rs@@ -0,0 +1,247 @@+//! Real Responses-to-app-server-to-TUI coverage for interleaved assistant output and commands.++use super::*;+use crate::chatwidget::tests::helpers::normalize_completion_timestamps;+use app_test_support::MockResponsesConfig;+use codex_app_server_client::AppServerEvent;+use codex_app_server_protocol::CommandExecutionStatus;+use codex_model_provider_info::ModelProviderInfo;+use core_test_support::responses;+use core_test_support::streaming_sse::StreamingSseChunk;+use core_test_support::streaming_sse::start_streaming_sse_server;+use pretty_assertions::assert_eq;+use std::time::Duration;+use tokio::sync::oneshot;+use tokio::time::timeout;++const PREAMBLE: &str = "I’ll inspect the relevant streaming path first.";++#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn command_start_before_message_completion_does_not_duplicate_preamble() -> Result<()> {+ core_test_support::skip_if_no_network!(Ok(()));++ let (release_completion, completion_gate) = oneshot::channel();+ let (model_server, _completions) = start_streaming_sse_server(vec![+ vec![+ StreamingSseChunk {+ gate: None,+ body: responses::sse(vec![+ responses::ev_response_created("response-1"),+ responses::ev_message_item_added("message-1", ""),+ responses::ev_output_text_delta(PREAMBLE),+ responses::ev_function_call(+ "command-1",+ "exec_command",+ r#"{"cmd":"echo fixture-output","login":false}"#,+ ),+ ]),+ },+ StreamingSseChunk {+ gate: Some(completion_gate),+ body: responses::sse(vec![responses::ev_assistant_message("message-1", PREAMBLE)]),+ },+ StreamingSseChunk {+ gate: None,+ body: responses::sse(vec![responses::ev_completed("response-1")]),+ },+ ],+ vec![StreamingSseChunk {+ gate: None,+ body: responses::sse(vec![+ responses::ev_response_created("response-2"),+ responses::ev_assistant_message("message-2", "Finished."),+ responses::ev_completed("response-2"),+ ]),+ }],+ ])+ .await;++ let (mut app, mut app_events, _ops) = make_test_app_with_channels().await;+ let codex_home = tempdir()?;+ MockResponsesConfig::new(model_server.uri())+ .with_sandbox_mode("danger-full-access")+ .write(codex_home.path())?;+ app.config.codex_home = codex_home.path().to_path_buf().abs();+ app.config.cwd = codex_home.path().abs();+ app.config.sqlite = codex_state::SqliteConfig::new_for_testing(codex_home.path().abs());+ app.config+ .permissions+ .approval_policy+ .set(codex_protocol::protocol::AskForApproval::Never)?;+ app.config+ .permissions+ .set_permission_profile(codex_protocol::models::PermissionProfile::Disabled)?;+ app.config.model = Some("mock-model".to_string());+ app.config.model_provider_id = "mock_provider".to_string();+ app.config.model_provider = ModelProviderInfo {+ name: "Mock provider for test".to_string(),+ base_url: Some(format!("{}/v1", model_server.uri())),+ request_max_retries: Some(0),+ stream_max_retries: Some(0),+ ..ModelProviderInfo::default()+ };++ let mut tui = crate::tui::test_support::make_test_tui()?;+ let mut app_server = Box::pin(crate::start_embedded_app_server_for_picker(&app.config)).await?;+ let started = app_server.start_thread(&app.config).await?;+ let thread_id = started.session.thread_id;+ app.replace_chat_widget_with_app_server_thread(+ &mut tui,+ started,+ super::super::session_lifecycle::ThreadAttachPresentation::Fresh,+ /*initial_user_message*/ None,+ )+ .await?;+ while app_events.try_recv().is_ok() {}++ app.chat_widget+ .restore_user_message_to_composer("inspect the stream".into());+ app.chat_widget+ .handle_key_event(crossterm::event::KeyEvent::new(+ crossterm::event::KeyCode::Enter,+ crossterm::event::KeyModifiers::NONE,+ ));+ let turn = std::iter::from_fn(|| app_events.try_recv().ok())+ .find_map(|event| match event {+ AppEvent::CodexOp(turn @ Op::UserTurn { .. }) => Some(turn),+ _ => None,+ })+ .expect("composer submission should emit a user turn");+ app.submit_thread_op(&mut app_server, thread_id, turn)+ .await?;++ let mut release_completion = Some(release_completion);+ let mut completed_command = None;+ let mut observed_order = Vec::new();+ timeout(Duration::from_secs(/*secs*/ 15), async {+ loop {+ tokio::select! {+ event = app_server.next_event() => {+ let event = event.expect("embedded app-server should stay connected");+ let turn_completed = matches!(&event, AppServerEvent::ServerNotification(notification)+ if matches!(notification.as_ref(), ServerNotification::TurnCompleted(_)));+ if let AppServerEvent::ServerNotification(notification) = &event {+ match notification.as_ref() {+ ServerNotification::AgentMessageDelta(delta) if delta.delta == PREAMBLE => {+ observed_order.push("agent delta");+ }+ ServerNotification::ItemStarted(started)+ if matches!(&started.item, ThreadItem::CommandExecution { .. }) =>+ {+ observed_order.push("command started");+ release_completion.take().expect("first command start").send(()).expect("completion gate should remain open");+ }+ ServerNotification::ItemCompleted(completed)+ if matches!(&completed.item, ThreadItem::AgentMessage { text, .. } if text == PREAMBLE) =>+ {+ observed_order.push("agent completed");+ }+ ServerNotification::ItemCompleted(completed) => {+ if let ThreadItem::CommandExecution {+ status,+ aggregated_output,+ exit_code,+ ..+ } = &completed.item+ {+ completed_command = Some((+ status.clone(),+ *exit_code,+ aggregated_output+ .as_deref()+ .map(str::trim)+ .map(str::to_owned),+ ));+ }+ }+ _ => {}+ }+ }+ app.handle_app_server_event(&app_server, event).await;+ app.drain_active_thread_events(&mut tui).await?;+ if turn_completed {+ break Ok::<_, color_eyre::Report>(());+ }+ }+ event = app_events.recv() => {+ let event = event.expect("TUI event stream should stay open");+ app.handle_event(&mut tui, &mut app_server, event).await?;+ }+ }+ }+ })+ .await??;+ while let Ok(event) = app_events.try_recv() {+ app.handle_event(&mut tui, &mut app_server, event).await?;+ }++ assert_eq!(+ observed_order,+ vec!["agent delta", "command started", "agent completed"]+ );+ assert_eq!(+ completed_command,+ Some((+ CommandExecutionStatus::Completed,+ Some(0),+ Some("fixture-output".to_string()),+ ))+ );+ for replay in [false, true] {+ if replay {+ app.store_active_thread_receiver().await;+ let (receiver, snapshot) = app+ .activate_thread_for_replay(thread_id)+ .await+ .expect("thread should retain its buffered notifications");+ app.active_thread_rx = Some(receiver);+ app.render_thread_snapshot(+ &mut tui,+ &app_server,+ thread_id,+ snapshot,+ /*resume_restored_queue*/ false,+ )?;+ while let Ok(event) = app_events.try_recv() {+ app.handle_event(&mut tui, &mut app_server, event).await?;+ }+ }+ let transcript_snapshot = app+ .transcript_cells+ .iter()+ // Replay also restores the session header and submitted user prompt.+ .filter(|cell| {+ !cell.as_any().is::<crate::history_cell::SessionInfoCell>()+ && !cell.as_any().is::<crate::history_cell::UserHistoryCell>()+ })+ .map(|cell| {+ let lines = cell.display_lines(/*width*/ 80);+ if cell.as_any().is::<crate::exec_cell::ExecCell>() {+ lines.first().map(ToString::to_string).unwrap_or_default()+ } else {+ normalize_completion_timestamps(+ cell.as_ref(),+ lines+ .into_iter()+ .map(|line| line.to_string())+ .collect::<Vec<_>>()+ .join("\n"),+ )+ }+ })+ .collect::<Vec<_>>()+ .join("\n");+ insta::allow_duplicates! {+ insta::assert_snapshot!(transcript_snapshot, @r"+ • I’ll inspect the relevant streaming path first.+ • Ran echo fixture-output+ • Finished.+ Worked for [duration] • [completion time]+ ");+ }+ }++ app_server.shutdown().await?;+ model_server.shutdown().await;+ Ok(())+}diff --git a/codex-rs/tui/src/chatwidget/protocol.rs b/codex-rs/tui/src/chatwidget/protocol.rsindex b68e13a2dd..5bd2254d86 100644--- a/codex-rs/tui/src/chatwidget/protocol.rs+++ b/codex-rs/tui/src/chatwidget/protocol.rs@@ -128,6 +128,8 @@ impl ChatWidget {¬ification.item_id,)){+ self.transcript.active_streamed_agent_message =+ Some((notification.turn_id, notification.item_id));self.on_agent_message_delta(notification.delta);}}diff --git a/codex-rs/tui/src/chatwidget/streaming.rs b/codex-rs/tui/src/chatwidget/streaming.rsindex 1957cc4b37..7dee87c171 100644--- a/codex-rs/tui/src/chatwidget/streaming.rs+++ b/codex-rs/tui/src/chatwidget/streaming.rs@@ -6,6 +6,10 @@use super::*;use crate::markdown_render::ListSpacing;+fn streamed_message_matches_completed(streamed: &str, completed: &str) -> bool {+ streamed == completed || streamed.strip_suffix('\n') == Some(completed)+}+fn latest_summary_line(text: &str) -> Option<String> {text.lines().rev().find_map(|line| {let line = line.trim();@@ -97,7 +101,7 @@ impl ChatWidget {return true;};// Stream finalization supplies one trailing newline when the last delta omitted it.- streamed != completed && streamed.strip_suffix('\n') != Some(completed)+ !streamed_message_matches_completed(streamed, completed)});let scrollback_reflow = if needs_scrollback_reflow || completed_message_differs {crate::app_event::ConsolidationScrollbackReflow::Required@@ -120,6 +124,13 @@ impl ChatWidget {};// Consolidate the run of streaming AgentMessageCells into a single AgentMarkdownCell// that can re-render from source on resize.+ if completed_message.is_none() {+ self.transcript.last_flushed_agent_message = self+ .transcript+ .active_streamed_agent_message+ .take()+ .zip(streamed_source.clone());+ }let copy_source = completed_message.map(str::to_owned).or(streamed_source);let source = copy_source.as_deref().map(|source| {parse_assistant_markdown(source, self.config.cwd.as_path()).visible_markdown@@ -149,6 +160,10 @@ impl ChatWidget {if had_stream_controller {self.request_pending_usage_output_insertion_after_stream_shutdown();}+ if completed_message.is_some() {+ self.transcript.active_streamed_agent_message = None;+ self.transcript.last_flushed_agent_message = None;+ }}pub(super) fn stream_controllers_idle(&self) -> bool {@@ -187,10 +202,21 @@ impl ChatWidget {self.status_state.pending_status_indicator_restore = false;}+ fn completed_agent_message_was_flushed(&self, message: &str) -> bool {+ self.transcript+ .last_completed_agent_message+ .as_ref()+ .zip(self.transcript.last_flushed_agent_message.as_ref())+ .is_some_and(|(completed, (flushed, streamed))| {+ completed == flushed && streamed_message_matches_completed(streamed, message)+ })+ }+pub(super) fn finalize_completed_assistant_message(&mut self, message: Option<&str>) {if self.stream_controller.is_none()&& let Some(message) = message&& !message.is_empty()+ && !self.completed_agent_message_was_flushed(message){let displayed =parse_assistant_markdown(message, self.config.cwd.as_path()).visible_markdown;@@ -429,7 +455,11 @@ impl ChatWidget {}}let parsed = parse_assistant_markdown(&message, self.config.cwd.as_path());- if from_replay && self.stream_controller.is_none() && !parsed.visible_markdown.is_empty() {+ if from_replay+ && self.stream_controller.is_none()+ && !parsed.visible_markdown.is_empty()+ && !self.completed_agent_message_was_flushed(&message)+ {self.prepare_assistant_message();self.mark_safety_buffering_agent_message_started();self.bottom_pane.hide_status_indicator();diff --git a/codex-rs/tui/src/chatwidget/tests/app_server.rs b/codex-rs/tui/src/chatwidget/tests/app_server.rsindex 8e83ad083a..7017aca6c1 100644--- a/codex-rs/tui/src/chatwidget/tests/app_server.rs+++ b/codex-rs/tui/src/chatwidget/tests/app_server.rs@@ -1748,6 +1748,47 @@ async fn live_app_server_turn_completion_repairs_dropped_message_deltas() {));}+#[tokio::test]+async fn live_app_server_interleaved_flush_repairs_mismatched_completion() {+ for (completed_item_id, completed) in [+ ("msg-1", "The transport kept this.\nAnd dropped this."),+ ("msg-2", "The transport kept this."),+ ] {+ let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;++ handle_turn_started(&mut chat, "turn-1");+ while rx.try_recv().is_ok() {}+ handle_agent_message_delta(&mut chat, "The transport kept this.");+ chat.flush_answer_stream_with_separator();+ while rx.try_recv().is_ok() {}++ complete_assistant_message(+ &mut chat,+ completed_item_id,+ completed,+ Some(MessagePhase::FinalAnswer),+ );++ let consolidations = std::iter::from_fn(|| rx.try_recv().ok())+ .filter_map(|event| match event {+ AppEvent::ConsolidateAgentMessage {+ source,+ scrollback_reflow,+ ..+ } => Some((source, scrollback_reflow)),+ _ => None,+ })+ .collect::<Vec<_>>();+ assert_eq!(+ consolidations,+ vec![(+ completed.to_string(),+ crate::app_event::ConsolidationScrollbackReflow::IfResizeReflowRan,+ )]+ );+ }+}+#[tokio::test]async fn live_app_server_stream_recovery_restores_previous_status_header() {let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;diff --git a/codex-rs/tui/src/chatwidget/transcript.rs b/codex-rs/tui/src/chatwidget/transcript.rsindex f055cd1b7b..ef2aba3bd0 100644--- a/codex-rs/tui/src/chatwidget/transcript.rs+++ b/codex-rs/tui/src/chatwidget/transcript.rs@@ -48,6 +48,10 @@ pub(super) struct TranscriptState {/// Latest `/status` card and fields, retained across copying until a later turn or command.pub(super) last_status_copy_targets: Option<StatusCopySource>,pub(super) last_completed_agent_message: Option<(String, String)>,+ /// Turn and item IDs for the agent message currently supplying streamed deltas.+ pub(super) active_streamed_agent_message: Option<(String, String)>,+ /// Turn/item identity and raw source of the latest interleaved stream flush.+ pub(super) last_flushed_agent_message: Option<((String, String), String)>,/// Raw markdown of the most recently completed proposed plan.pub(super) latest_proposed_plan_markdown: Option<String>,/// Whether this turn already produced a copyable response.@@ -107,6 +111,8 @@ impl TranscriptState {pub(super) fn reset_turn_flags(&mut self) {self.saw_copy_source_this_turn = false;self.last_completed_agent_message = None;+ self.active_streamed_agent_message = None;+ self.last_flushed_agent_message = None;self.saw_plan_update_this_turn = false;self.saw_plan_item_this_turn = false;self.latest_proposed_plan_markdown = None;