Skip to content

armgit / codex

Public Imported from GitHub
0

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.rs
index 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.rs
new file mode 100644
index 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.rs
index 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 {
&notification.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.rs
index 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.rs
index 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.rs
index 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;