Skip to content

An agent-managed museum exhibit, built in Rust with Gajae-Code / LazyCodex — developed and maintained with no human intervention.

Rust

refactor(cli): let the emitter report the output tail it leaves behind (#3304)

黄云龙8d2c7b78b2f8
diff --git a/rust/crates/mock-anthropic-service/src/lib.rs b/rust/crates/mock-anthropic-service/src/lib.rs
index 68968eed..ada9f8eb 100644
--- a/rust/crates/mock-anthropic-service/src/lib.rs
+++ b/rust/crates/mock-anthropic-service/src/lib.rs
@@ -13,6 +13,16 @@ use tokio::task::JoinHandle;
pub const SCENARIO_PREFIX: &str = "PARITY_SCENARIO:";
pub const DEFAULT_MODEL: &str = "claude-sonnet-4-6";
+/// The assistant text the `context_window_retry` scenario finally streams, after
+/// its first request was refused with a context-overflow error. Exposed so a
+/// test can assert on the exact body instead of restating the literal.
+pub const CONTEXT_WINDOW_RETRY_TEXT: &str = "auto compact retry parity complete.";
+
+/// The partial assistant text the `stream_then_error` scenario streams before it
+/// fails the response mid-stream. Exposed so a test can assert on the exact body
+/// instead of restating the literal.
+pub const STREAM_THEN_ERROR_TEXT: &str = "partial response before the stream failed";
+
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct CapturedRequest {
pub method: String,
@@ -99,6 +109,8 @@ enum Scenario {
BashPermissionPromptDenied,
PluginToolRoundtrip,
AutoCompactTriggered,
+ ContextWindowRetry,
+ StreamThenError,
TokenCostReporting,
}
@@ -116,6 +128,8 @@ impl Scenario {
"bash_permission_prompt_denied" => Some(Self::BashPermissionPromptDenied),
"plugin_tool_roundtrip" => Some(Self::PluginToolRoundtrip),
"auto_compact_triggered" => Some(Self::AutoCompactTriggered),
+ "context_window_retry" => Some(Self::ContextWindowRetry),
+ "stream_then_error" => Some(Self::StreamThenError),
"token_cost_reporting" => Some(Self::TokenCostReporting),
_ => None,
}
@@ -134,6 +148,8 @@ impl Scenario {
Self::BashPermissionPromptDenied => "bash_permission_prompt_denied",
Self::PluginToolRoundtrip => "plugin_tool_roundtrip",
Self::AutoCompactTriggered => "auto_compact_triggered",
+ Self::ContextWindowRetry => "context_window_retry",
+ Self::StreamThenError => "stream_then_error",
Self::TokenCostReporting => "token_cost_reporting",
}
}
@@ -149,6 +165,18 @@ async fn handle_connection(
let scenario = detect_scenario(&request)
.ok_or_else(|| io::Error::new(io::ErrorKind::InvalidInput, "missing parity scenario"))?;
+ // How many times this scenario has already been served *on this endpoint*.
+ // Scenarios that need to behave differently on a retry (reject once, then
+ // succeed) key off this; counting per endpoint keeps the token-counting
+ // preflight on `/v1/messages/count_tokens` from consuming the first attempt.
+ let attempt = {
+ let served = requests.lock().await;
+ served
+ .iter()
+ .filter(|captured| captured.scenario == scenario.name() && captured.path == path)
+ .count()
+ };
+
requests.lock().await.push(CapturedRequest {
method,
path,
@@ -158,7 +186,7 @@ async fn handle_connection(
raw_body,
});
- let response = build_http_response(&request, scenario);
+ let response = build_http_response(&request, scenario, attempt);
socket.write_all(response.as_bytes()).await?;
Ok(())
}
@@ -308,7 +336,11 @@ fn flatten_tool_result_content(content: &[api::ToolResultContentBlock]) -> Strin
}
#[allow(clippy::too_many_lines)]
-fn build_http_response(request: &MessageRequest, scenario: Scenario) -> String {
+fn build_http_response(request: &MessageRequest, scenario: Scenario, attempt: usize) -> String {
+ if let Some(rejection) = context_window_rejection(scenario, attempt) {
+ return rejection;
+ }
+
let response = if request.stream {
let body = build_stream_body(request, scenario);
return http_response(
@@ -329,6 +361,37 @@ fn build_http_response(request: &MessageRequest, scenario: Scenario) -> String {
)
}
+/// The first request of [`Scenario::ContextWindowRetry`] is refused with a
+/// context-overflow error instead of a streamed answer, so the client's
+/// auto-compact recovery path runs and the *retry* is what produces the
+/// response text. Every later request against the same endpoint succeeds.
+///
+/// HTTP 400 is deliberately chosen: it is not in the client's retryable status
+/// set, so the client surfaces the error rather than silently re-sending it —
+/// which is exactly the situation a real context-overflow rejection creates.
+/// The body carries the `context_window` marker the client greps for.
+fn context_window_rejection(scenario: Scenario, attempt: usize) -> Option<String> {
+ if scenario != Scenario::ContextWindowRetry || attempt > 0 {
+ return None;
+ }
+
+ let body = json!({
+ "type": "error",
+ "error": {
+ "type": "invalid_request_error",
+ "message": "prompt is too long: context_window exceeded for this model",
+ },
+ })
+ .to_string();
+
+ Some(http_response(
+ "400 Bad Request",
+ "application/json",
+ &body,
+ &[("request-id", request_id_for(scenario))],
+ ))
+}
+
#[allow(clippy::too_many_lines)]
fn build_stream_body(request: &MessageRequest, scenario: Scenario) -> String {
match scenario {
@@ -461,6 +524,8 @@ fn build_stream_body(request: &MessageRequest, scenario: Scenario) -> String {
Scenario::AutoCompactTriggered => {
final_text_sse_with_usage("auto compact parity complete.", 50_000, 200)
}
+ Scenario::ContextWindowRetry => final_text_sse(CONTEXT_WINDOW_RETRY_TEXT),
+ Scenario::StreamThenError => stream_then_error_sse(STREAM_THEN_ERROR_TEXT),
Scenario::TokenCostReporting => {
final_text_sse_with_usage("token cost reporting parity complete.", 1_000, 500)
}
@@ -628,6 +693,12 @@ fn build_message_response(request: &MessageRequest, scenario: Scenario) -> Messa
50_000,
200,
),
+ Scenario::ContextWindowRetry => {
+ text_message_response("msg_context_window_retry", CONTEXT_WINDOW_RETRY_TEXT)
+ }
+ Scenario::StreamThenError => {
+ text_message_response("msg_stream_then_error", STREAM_THEN_ERROR_TEXT)
+ }
Scenario::TokenCostReporting => text_message_response_with_usage(
"msg_token_cost_reporting",
"token cost reporting parity complete.",
@@ -650,6 +721,8 @@ fn request_id_for(scenario: Scenario) -> &'static str {
Scenario::BashPermissionPromptDenied => "req_bash_permission_prompt_denied",
Scenario::PluginToolRoundtrip => "req_plugin_tool_roundtrip",
Scenario::AutoCompactTriggered => "req_auto_compact_triggered",
+ Scenario::ContextWindowRetry => "req_context_window_retry",
+ Scenario::StreamThenError => "req_stream_then_error",
Scenario::TokenCostReporting => "req_token_cost_reporting",
}
}
@@ -971,6 +1044,84 @@ fn final_text_sse(text: &str) -> String {
body
}
+/// Streams a text block to completion and then fails the response, which is
+/// what a provider does when it dies partway through an answer.
+///
+/// The block is closed before the failure on purpose: the client only flushes
+/// its buffered markdown to the terminal on `content_block_stop`, so without
+/// that frame the partial text would still be sitting in the renderer and the
+/// scenario would not reproduce a turn that streamed text and *then* errored.
+///
+/// The response is cut off in the middle of the failing frame rather than
+/// carrying a complete one. Two things fall out of that, both deliberate.
+///
+/// It is what a provider that dies on the socket actually looks like, and it
+/// keeps the failure in a *later* parser call than the answer text. The whole
+/// response is one `write_all` on the mock's side, so a complete trailing frame
+/// would land in the same read chunk as the deltas — and `SseParser::push`
+/// returns `Err` from inside its frame loop, which discards the events it had
+/// already parsed from that same chunk. The client would then never render the
+/// text at all, and the scenario would be exercising that parser behaviour
+/// instead of the terminal state it is meant to reproduce. A truncated tail
+/// stays in the parser's buffer, so `push` returns the deltas normally and the
+/// failure only surfaces from `finish()`, once the client has consumed every
+/// event ahead of it.
+///
+/// The failure is a frame that does not deserialize — `api::types::StreamEvent`
+/// is `#[serde(tag = "type")]` with no fallback arm, so an unknown frame type or
+/// a truncated payload is an `ApiError::Json`. That is non-retryable, and it is
+/// raised while reading the body rather than while acquiring the response, so the
+/// client reports it on the first attempt rather than retrying.
+fn stream_then_error_sse(text: &str) -> String {
+ let mut body = String::new();
+ append_sse(
+ &mut body,
+ "message_start",
+ json!({
+ "type": "message_start",
+ "message": {
+ "id": unique_message_id(),
+ "type": "message",
+ "role": "assistant",
+ "content": [],
+ "model": DEFAULT_MODEL,
+ "stop_reason": null,
+ "stop_sequence": null,
+ "usage": usage_json(14, 0)
+ }
+ }),
+ );
+ append_sse(
+ &mut body,
+ "content_block_start",
+ json!({
+ "type": "content_block_start",
+ "index": 0,
+ "content_block": {"type": "text", "text": ""}
+ }),
+ );
+ append_sse(
+ &mut body,
+ "content_block_delta",
+ json!({
+ "type": "content_block_delta",
+ "index": 0,
+ "delta": {"type": "text_delta", "text": text}
+ }),
+ );
+ append_sse(
+ &mut body,
+ "content_block_stop",
+ json!({"type": "content_block_stop", "index": 0}),
+ );
+ // No terminating blank line: the frame is still arriving when the provider
+ // drops the connection, so it stays in the client's parser buffer until the
+ // body ends. See the note above for why the failure has to trail the deltas
+ // by a parser call rather than sharing their chunk.
+ body.push_str("event: error\ndata: {\"type\":\"error\",\"error\":{\"type\":\"overloaded_");
+ body
+}
+
fn final_text_sse_with_usage(text: &str, input_tokens: u32, output_tokens: u32) -> String {
let mut body = String::new();
append_sse(
diff --git a/rust/crates/rusty-claude-cli/src/main.rs b/rust/crates/rusty-claude-cli/src/main.rs
index 7b7ead3b..6eac45b7 100644
--- a/rust/crates/rusty-claude-cli/src/main.rs
+++ b/rust/crates/rusty-claude-cli/src/main.rs
@@ -27,6 +27,7 @@ use std::net::TcpListener;
use std::ops::{Deref, DerefMut};
use std::path::{Path, PathBuf};
use std::process::Command;
+use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::mpsc::{self, Receiver, RecvTimeoutError, Sender};
use std::sync::{Arc, Mutex, OnceLock};
use std::thread::{self, JoinHandle};
@@ -7702,6 +7703,7 @@ impl LiveCli {
system_prompt.clone(),
enable_tools,
true,
+ TerminalTail::new(),
allowed_tools.clone(),
permission_mode,
None,
@@ -7783,6 +7785,7 @@ impl LiveCli {
fn prepare_turn_runtime(
&self,
emit_output: bool,
+ terminal_tail: TerminalTail,
) -> Result<(BuiltRuntime, HookAbortMonitor), Box<dyn std::error::Error>> {
let hook_abort_signal = runtime::HookAbortSignal::new();
let runtime = build_runtime(
@@ -7792,6 +7795,7 @@ impl LiveCli {
self.system_prompt.clone(),
true,
emit_output,
+ terminal_tail,
self.allowed_tools.clone(),
self.permission_mode,
None,
@@ -7809,27 +7813,39 @@ impl LiveCli {
}
fn run_turn(&mut self, input: &str) -> Result<(), Box<dyn std::error::Error>> {
- let (mut runtime, hook_abort_monitor) = self.prepare_turn_runtime(true)?;
+ let terminal_tail = TerminalTail::new();
+ let (mut runtime, hook_abort_monitor) =
+ self.prepare_turn_runtime(true, terminal_tail.clone())?;
let mut spinner = Spinner::new();
let mut stdout = io::stdout();
- spinner.tick(
- "🦀 Thinking...",
- TerminalRenderer::new().color_theme(),
- &mut stdout,
- )?;
+ // The animated frame is cursor control: it saves the cursor, rewrites the
+ // current line, and restores the cursor. None of that describes anything
+ // when stdout is a pipe — the escapes survive as literal bytes and the
+ // banner ends up glued to whatever the emitter writes next. Only animate
+ // on a terminal; the one-shot completion line below is plain text and is
+ // emitted either way.
+ if io::stdout().is_terminal() {
+ spinner.tick(
+ "🦀 Thinking...",
+ TerminalRenderer::new().color_theme(),
+ &mut stdout,
+ )?;
+ }
let mut permission_prompter = CliPermissionPrompter::new(self.permission_mode);
let result = runtime.run_turn(input, Some(&mut permission_prompter));
hook_abort_monitor.stop();
match result {
Ok(summary) => {
self.replace_runtime(runtime)?;
- // The assistant response was already streamed to the terminal live
- // during the turn (emit_output = true), so reprinting the full text
- // here would duplicate the entire message. When text was streamed,
- // emit a newline first so `spinner.finish`'s line-clear lands on a
- // fresh line instead of erasing the last streamed line.
- let final_text = final_assistant_text(&summary);
- if !final_text.is_empty() {
+ // The emitter owns the terminal during a turn: `emit_output = true`
+ // streams text deltas and echoes tool results live, so the response
+ // must not be printed again here — that was the duplicate output
+ // this PR's predecessor fixed.
+ //
+ // What the emitter may have left behind is a partial line, so ask it
+ // rather than guessing from `final_assistant_text(&summary)`: that
+ // guess is empty for tool-only turns, which still render.
+ if !terminal_tail.at_line_start() {
println!();
}
spinner.finish(
@@ -7849,6 +7865,13 @@ impl LiveCli {
}
Err(error) => {
runtime.shutdown_plugins()?;
+ // Same ownership rule as the success arm: `fail` clears the current
+ // line, so it may only do so when the emitter stopped on a line
+ // boundary. A turn that streamed text and then failed would
+ // otherwise lose its last partial line to the clear.
+ if !terminal_tail.at_line_start() {
+ println!();
+ }
spinner.fail(
"❌ Request failed",
TerminalRenderer::new().color_theme(),
@@ -7961,14 +7984,14 @@ impl LiveCli {
// Build a new runtime with the compacted session and retry
let (mut new_runtime, hook_abort_monitor) =
- self.prepare_turn_runtime(true)?;
+ self.prepare_turn_runtime(true, terminal_tail.clone())?;
drop(hook_abort_monitor);
let mut rp = CliPermissionPrompter::new(self.permission_mode);
match new_runtime.run_turn(input, Some(&mut rp)) {
Ok(summary) => {
self.replace_runtime(new_runtime)?;
- if !final_assistant_text(&summary).is_empty() {
+ if !terminal_tail.at_line_start() {
println!();
}
spinner.finish(
@@ -8053,7 +8076,8 @@ impl LiveCli {
}
fn run_prompt_compact(&mut self, input: &str) -> Result<(), Box<dyn std::error::Error>> {
- let (mut runtime, hook_abort_monitor) = self.prepare_turn_runtime(false)?;
+ let (mut runtime, hook_abort_monitor) =
+ self.prepare_turn_runtime(false, TerminalTail::new())?;
let mut permission_prompter = CliPermissionPrompter::new(self.permission_mode);
let result = runtime.run_turn(input, Some(&mut permission_prompter));
hook_abort_monitor.stop();
@@ -8066,7 +8090,8 @@ impl LiveCli {
}
fn run_prompt_compact_json(&mut self, input: &str) -> Result<(), Box<dyn std::error::Error>> {
- let (mut runtime, hook_abort_monitor) = self.prepare_turn_runtime(false)?;
+ let (mut runtime, hook_abort_monitor) =
+ self.prepare_turn_runtime(false, TerminalTail::new())?;
let mut permission_prompter = CliPermissionPrompter::new(self.permission_mode);
let result = runtime.run_turn(input, Some(&mut permission_prompter));
hook_abort_monitor.stop();
@@ -8091,7 +8116,8 @@ impl LiveCli {
}
fn run_prompt_json(&mut self, input: &str) -> Result<(), Box<dyn std::error::Error>> {
- let (mut runtime, hook_abort_monitor) = self.prepare_turn_runtime(false)?;
+ let (mut runtime, hook_abort_monitor) =
+ self.prepare_turn_runtime(false, TerminalTail::new())?;
let mut permission_prompter = CliPermissionPrompter::new(self.permission_mode);
let result = runtime.run_turn(input, Some(&mut permission_prompter));
hook_abort_monitor.stop();
@@ -8447,6 +8473,7 @@ impl LiveCli {
self.system_prompt.clone(),
true,
true,
+ TerminalTail::new(),
self.allowed_tools.clone(),
self.permission_mode,
None,
@@ -8493,6 +8520,7 @@ impl LiveCli {
self.system_prompt.clone(),
true,
true,
+ TerminalTail::new(),
self.allowed_tools.clone(),
self.permission_mode,
None,
@@ -8523,6 +8551,7 @@ impl LiveCli {
self.system_prompt.clone(),
true,
true,
+ TerminalTail::new(),
self.allowed_tools.clone(),
self.permission_mode,
None,
@@ -8565,6 +8594,7 @@ impl LiveCli {
self.system_prompt.clone(),
true,
true,
+ TerminalTail::new(),
self.allowed_tools.clone(),
self.permission_mode,
None,
@@ -8918,6 +8948,7 @@ impl LiveCli {
self.system_prompt.clone(),
true,
true,
+ TerminalTail::new(),
self.allowed_tools.clone(),
self.permission_mode,
None,
@@ -8953,6 +8984,7 @@ impl LiveCli {
self.system_prompt.clone(),
true,
true,
+ TerminalTail::new(),
self.allowed_tools.clone(),
self.permission_mode,
None,
@@ -9047,6 +9079,7 @@ impl LiveCli {
self.system_prompt.clone(),
true,
true,
+ TerminalTail::new(),
self.allowed_tools.clone(),
self.permission_mode,
None,
@@ -9067,6 +9100,7 @@ impl LiveCli {
self.system_prompt.clone(),
true,
true,
+ TerminalTail::new(),
self.allowed_tools.clone(),
self.permission_mode,
None,
@@ -9091,6 +9125,7 @@ impl LiveCli {
self.system_prompt.clone(),
enable_tools,
false,
+ TerminalTail::new(),
self.allowed_tools.clone(),
self.permission_mode,
progress,
@@ -12500,6 +12535,7 @@ fn build_runtime(
system_prompt: Vec<String>,
enable_tools: bool,
emit_output: bool,
+ terminal_tail: TerminalTail,
allowed_tools: Option<AllowedToolSet>,
permission_mode: PermissionMode,
progress_reporter: Option<InternalPromptProgressReporter>,
@@ -12512,6 +12548,7 @@ fn build_runtime(
system_prompt,
enable_tools,
emit_output,
+ terminal_tail,
allowed_tools,
permission_mode,
progress_reporter,
@@ -12528,6 +12565,7 @@ fn build_runtime_with_plugin_state(
system_prompt: Vec<String>,
enable_tools: bool,
emit_output: bool,
+ terminal_tail: TerminalTail,
allowed_tools: Option<AllowedToolSet>,
permission_mode: PermissionMode,
progress_reporter: Option<InternalPromptProgressReporter>,
@@ -12553,6 +12591,7 @@ fn build_runtime_with_plugin_state(
model,
enable_tools,
emit_output,
+ terminal_tail.clone(),
allowed_tools.clone(),
tool_registry.clone(),
progress_reporter,
@@ -12560,6 +12599,7 @@ fn build_runtime_with_plugin_state(
CliToolExecutor::new(
allowed_tools.clone(),
emit_output,
+ terminal_tail,
tool_registry.clone(),
mcp_state.clone(),
),
@@ -12655,6 +12695,76 @@ impl runtime::PermissionPrompter for CliPermissionPrompter {
}
}
+/// Tracks whether the shared terminal stream currently sits at the start of a
+/// fresh line.
+///
+/// A turn's streamed assistant text has no trailing newline, and
+/// `Spinner::finish` moves to column 0 and clears the current line — so without
+/// a guard it erases the last thing the emitter rendered. Both writers that
+/// render live during a turn (the assistant/reasoning deltas in
+/// `AnthropicRuntimeClient::consume_stream` and the tool-result blocks in
+/// `CliToolExecutor::execute`) push their bytes
+/// through a `TailTrackingWriter` sharing one of these, which lets the caller
+/// that ends the turn ask the emitter what it actually left on the terminal.
+///
+/// The previous approach inferred this from `final_assistant_text(&summary)`,
+/// which agrees today only because every *other* writer terminates its output
+/// with a newline — tool results go through `stream_markdown` (which appends
+/// one), thinking summaries are written with a trailing newline, and tool-call
+/// headers use `writeln!`. That is a property of the current renderers rather
+/// than of the streaming protocol, and the text path already violates it, so
+/// recording the fact is cheaper than depending on it. The heuristic also left
+/// the failure arm unguarded: a turn that streamed text and then errored still
+/// had that line cleared.
+#[derive(Clone, Default)]
+struct TerminalTail {
+ at_line_start: Arc<AtomicBool>,
+}
+
+impl TerminalTail {
+ fn new() -> Self {
+ Self {
+ at_line_start: Arc::new(AtomicBool::new(true)),
+ }
+ }
+
+ /// True when nothing has been written since the last newline, so clearing
+ /// the current terminal line cannot destroy rendered output.
+ fn at_line_start(&self) -> bool {
+ self.at_line_start.load(Ordering::Relaxed)
+ }
+
+ fn record(&self, written: &[u8]) {
+ if let Some(last) = written.last() {
+ self.at_line_start.store(*last == b'\n', Ordering::Relaxed);
+ }
+ }
+}
+
+/// Forwards writes to `inner` while reporting the tail byte to a `TerminalTail`.
+struct TailTrackingWriter<'a, W: Write> {
+ inner: &'a mut W,
+ tail: TerminalTail,
+}
+
+impl<'a, W: Write> TailTrackingWriter<'a, W> {
+ fn new(inner: &'a mut W, tail: TerminalTail) -> Self {
+ Self { inner, tail }
+ }
+}
+
+impl<W: Write> Write for TailTrackingWriter<'_, W> {
+ fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+ let written = self.inner.write(buf)?;
+ self.tail.record(&buf[..written]);
+ Ok(written)
+ }
+
+ fn flush(&mut self) -> io::Result<()> {
+ self.inner.flush()
+ }
+}
+
// NOTE: Despite the historical name `AnthropicRuntimeClient`, this struct
// now holds an `ApiProviderClient` which dispatches to Anthropic, xAI,
// OpenAI, or DashScope at construction time based on
@@ -12668,6 +12778,7 @@ struct AnthropicRuntimeClient {
model: String,
enable_tools: bool,
emit_output: bool,
+ terminal_tail: TerminalTail,
allowed_tools: Option<AllowedToolSet>,
tool_registry: GlobalToolRegistry,
progress_reporter: Option<InternalPromptProgressReporter>,
@@ -12680,6 +12791,7 @@ impl AnthropicRuntimeClient {
model: String,
enable_tools: bool,
emit_output: bool,
+ terminal_tail: TerminalTail,
allowed_tools: Option<AllowedToolSet>,
tool_registry: GlobalToolRegistry,
progress_reporter: Option<InternalPromptProgressReporter>,
@@ -12733,6 +12845,7 @@ impl AnthropicRuntimeClient {
model,
enable_tools,
emit_output,
+ terminal_tail,
allowed_tools,
tool_registry,
progress_reporter,
@@ -12832,8 +12945,9 @@ impl AnthropicRuntimeClient {
})?;
let mut stdout = io::stdout();
let mut sink = io::sink();
+ let mut tracked = TailTrackingWriter::new(&mut stdout, self.terminal_tail.clone());
let out: &mut dyn Write = if self.emit_output {
- &mut stdout
+ &mut tracked
} else {
&mut sink
};
@@ -13997,6 +14111,7 @@ fn prompt_cache_record_to_runtime_event(
struct CliToolExecutor {
renderer: TerminalRenderer,
emit_output: bool,
+ terminal_tail: TerminalTail,
allowed_tools: Option<AllowedToolSet>,
tool_registry: GlobalToolRegistry,
mcp_state: Option<Arc<Mutex<RuntimeMcpState>>>,
@@ -14006,12 +14121,14 @@ impl CliToolExecutor {
fn new(
allowed_tools: Option<AllowedToolSet>,
emit_output: bool,
+ terminal_tail: TerminalTail,
tool_registry: GlobalToolRegistry,
mcp_state: Option<Arc<Mutex<RuntimeMcpState>>>,
) -> Self {
Self {
renderer: TerminalRenderer::new(),
emit_output,
+ terminal_tail,
allowed_tools,
tool_registry,
mcp_state,
@@ -14105,8 +14222,11 @@ impl ToolExecutor for CliToolExecutor {
Ok(output) => {
if self.emit_output {
let markdown = format_tool_result(tool_name, &output, false);
+ let mut stdout = io::stdout();
+ let mut tracked =
+ TailTrackingWriter::new(&mut stdout, self.terminal_tail.clone());
self.renderer
- .stream_markdown(&markdown, &mut io::stdout())
+ .stream_markdown(&markdown, &mut tracked)
.map_err(|error| ToolError::new(error.to_string()))?;
}
Ok(output)
@@ -14114,8 +14234,11 @@ impl ToolExecutor for CliToolExecutor {
Err(error) => {
if self.emit_output {
let markdown = format_tool_result(tool_name, &error.to_string(), true);
+ let mut stdout = io::stdout();
+ let mut tracked =
+ TailTrackingWriter::new(&mut stdout, self.terminal_tail.clone());
self.renderer
- .stream_markdown(&markdown, &mut io::stdout())
+ .stream_markdown(&markdown, &mut tracked)
.map_err(|stream_error| ToolError::new(stream_error.to_string()))?;
}
Err(error)
@@ -14430,8 +14553,8 @@ mod tests {
CliOutputFormat, CliToolExecutor, GitOperation, GitWorkspaceSummary,
InternalPromptProgressEvent, InternalPromptProgressState, LiveCli, LocalHelpTopic,
PermissionModeProvenance, PromptHistoryEntry, SessionLifecycleKind,
- SessionLifecycleSummary, SlashCommand, StatusUsage, TmuxPaneSnapshot, DEFAULT_MODEL,
- LATEST_SESSION_REFERENCE, STUB_COMMANDS,
+ SessionLifecycleSummary, SlashCommand, StatusUsage, TerminalTail, TmuxPaneSnapshot,
+ DEFAULT_MODEL, LATEST_SESSION_REFERENCE, STUB_COMMANDS,
};
use api::{ApiError, MessageResponse, OutputContentBlock, Usage};
use plugins::{
@@ -19354,6 +19477,7 @@ UU conflicted.rs",
let mut executor = CliToolExecutor::new(
None,
false,
+ TerminalTail::new(),
state.tool_registry.clone(),
state.mcp_state.clone(),
);
@@ -19452,6 +19576,7 @@ UU conflicted.rs",
let mut executor = CliToolExecutor::new(
None,
false,
+ TerminalTail::new(),
state.tool_registry.clone(),
state.mcp_state.clone(),
);
@@ -19512,6 +19637,7 @@ UU conflicted.rs",
vec!["test system prompt".to_string()],
true,
false,
+ TerminalTail::new(),
None,
PermissionMode::DangerFullAccess,
None,
diff --git a/rust/crates/rusty-claude-cli/tests/compact_output.rs b/rust/crates/rusty-claude-cli/tests/compact_output.rs
index 948a44c8..8509474d 100644
--- a/rust/crates/rusty-claude-cli/tests/compact_output.rs
+++ b/rust/crates/rusty-claude-cli/tests/compact_output.rs
@@ -7,7 +7,9 @@ use std::process::{Command, Output, Stdio};
use std::sync::atomic::{AtomicU64, Ordering};
use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
-use mock_anthropic_service::{MockAnthropicService, SCENARIO_PREFIX};
+use mock_anthropic_service::{
+ MockAnthropicService, CONTEXT_WINDOW_RETRY_TEXT, SCENARIO_PREFIX, STREAM_THEN_ERROR_TEXT,
+};
use serde_json::Value;
static TEMP_COUNTER: AtomicU64 = AtomicU64::new(0);
@@ -189,6 +191,199 @@ fn text_prompt_mode_streams_assistant_text_once_before_spinner_completion() {
fs::remove_dir_all(&workspace).expect("workspace cleanup should succeed");
}
+#[test]
+fn text_prompt_mode_emits_the_response_body_exactly_once() {
+ // given a workspace pointed at the mock Anthropic service running the
+ // streaming_text scenario, which emits a single assistant text block
+ let runtime = tokio::runtime::Runtime::new().expect("tokio runtime should build");
+ let server = runtime
+ .block_on(MockAnthropicService::spawn())
+ .expect("mock service should start");
+ let base_url = server.base_url();
+
+ let workspace = unique_temp_dir("text-prompt-once");
+ let config_home = workspace.join("config-home");
+ let home = workspace.join("home");
+ fs::create_dir_all(&workspace).expect("workspace should exist");
+ fs::create_dir_all(&config_home).expect("config home should exist");
+ fs::create_dir_all(&home).expect("home should exist");
+
+ // when we invoke claw in normal text prompt mode
+ let prompt = format!("{SCENARIO_PREFIX}streaming_text");
+ let output = run_claw(
+ &workspace,
+ &config_home,
+ &home,
+ &base_url,
+ &[
+ "--model",
+ "sonnet",
+ "--permission-mode",
+ "read-only",
+ &prompt,
+ ],
+ );
+
+ // then the response body reaches stdout exactly once: the emitter owns the
+ // terminal while the turn runs, so the caller must not print the assistant
+ // text a second time
+ assert!(
+ output.status.success(),
+ "text prompt run should succeed\nstdout:\n{}\n\nstderr:\n{}",
+ String::from_utf8_lossy(&output.stdout),
+ String::from_utf8_lossy(&output.stderr),
+ );
+ let stdout = String::from_utf8(output.stdout).expect("stdout should be utf8");
+ let plain_stdout = strip_ansi_codes(&stdout);
+ assert_eq!(
+ plain_stdout
+ .matches("Mock streaming says hello from the parity harness.")
+ .count(),
+ 1,
+ "text prompt stdout should carry the response body exactly once ({stdout:?})"
+ );
+
+ fs::remove_dir_all(&workspace).expect("workspace cleanup should succeed");
+}
+
+#[test]
+fn text_prompt_mode_emits_retried_body_once_after_auto_compact() {
+ // given a mock service whose first answer to this scenario is a context
+ // window rejection and whose answer to the retry is a streamed response
+ let runtime = tokio::runtime::Runtime::new().expect("tokio runtime should build");
+ let server = runtime
+ .block_on(MockAnthropicService::spawn())
+ .expect("mock service should start");
+ let base_url = server.base_url();
+
+ let workspace = unique_temp_dir("text-prompt-auto-compact-retry");
+ let config_home = workspace.join("config-home");
+ let home = workspace.join("home");
+ fs::create_dir_all(&workspace).expect("workspace should exist");
+ fs::create_dir_all(&config_home).expect("config home should exist");
+ fs::create_dir_all(&home).expect("home should exist");
+
+ // when claw is rejected for context window overflow and recovers by
+ // compacting the session and retrying the same prompt
+ let prompt = format!("{SCENARIO_PREFIX}context_window_retry");
+ let output = run_claw(
+ &workspace,
+ &config_home,
+ &home,
+ &base_url,
+ &[
+ "--model",
+ "sonnet",
+ "--permission-mode",
+ "read-only",
+ &prompt,
+ ],
+ );
+
+ // then the retry succeeds and its response body is on stdout exactly once.
+ // The recovery path builds a fresh runtime with its own terminal tail, so
+ // this is where a tail that only tracked the first attempt would leave the
+ // streamed line unterminated and let `spinner.finish` clear it.
+ assert!(
+ output.status.success(),
+ "auto-compact retry should succeed\nstdout:\n{}\n\nstderr:\n{}",
+ String::from_utf8_lossy(&output.stdout),
+ String::from_utf8_lossy(&output.stderr),
+ );
+ let stdout = String::from_utf8(output.stdout).expect("stdout should be utf8");
+ let plain_stdout = strip_ansi_codes(&stdout);
+ assert_eq!(
+ plain_stdout.matches(CONTEXT_WINDOW_RETRY_TEXT).count(),
+ 1,
+ "auto-compact retry stdout should carry the response body exactly once ({stdout:?})"
+ );
+ assert!(
+ plain_stdout
+ .lines()
+ .any(|line| line == CONTEXT_WINDOW_RETRY_TEXT),
+ "the retried response body should land on its own line ({stdout:?})"
+ );
+ assert!(
+ plain_stdout.contains("✨ Done (after auto-compact)"),
+ "the retry should report the auto-compact completion ({stdout:?})"
+ );
+
+ // and the scenario really was requested twice, so the retry path ran
+ let captured = runtime.block_on(server.captured_requests());
+ let messages: Vec<_> = captured
+ .iter()
+ .filter(|request| request.path == "/v1/messages")
+ .collect();
+ assert!(
+ messages.len() >= 2,
+ "the scenario should be requested twice so the retry is exercised ({captured:?})"
+ );
+
+ fs::remove_dir_all(&workspace).expect("workspace cleanup should succeed");
+}
+
+#[test]
+fn text_prompt_mode_keeps_streamed_text_when_the_turn_fails() {
+ // given a mock service that streams part of an answer and then fails the
+ // response, so the turn ends with text already rendered on the terminal
+ let runtime = tokio::runtime::Runtime::new().expect("tokio runtime should build");
+ let server = runtime
+ .block_on(MockAnthropicService::spawn())
+ .expect("mock service should start");
+ let base_url = server.base_url();
+
+ let workspace = unique_temp_dir("text-prompt-stream-then-error");
+ let config_home = workspace.join("config-home");
+ let home = workspace.join("home");
+ fs::create_dir_all(&workspace).expect("workspace should exist");
+ fs::create_dir_all(&config_home).expect("config home should exist");
+ fs::create_dir_all(&home).expect("home should exist");
+
+ // when the turn fails after the emitter already streamed a partial line
+ let prompt = format!("{SCENARIO_PREFIX}stream_then_error");
+ let output = run_claw(
+ &workspace,
+ &config_home,
+ &home,
+ &base_url,
+ &[
+ "--model",
+ "sonnet",
+ "--permission-mode",
+ "read-only",
+ &prompt,
+ ],
+ );
+
+ // then the failed turn is reported...
+ assert!(
+ !output.status.success(),
+ "a mid-stream failure should fail the run\nstdout:\n{}\n\nstderr:\n{}",
+ String::from_utf8_lossy(&output.stdout),
+ String::from_utf8_lossy(&output.stderr),
+ );
+ let stdout = String::from_utf8(output.stdout).expect("stdout should be utf8");
+ let plain_stdout = strip_ansi_codes(&stdout);
+
+ // ...and the text the emitter already streamed survives the failure banner.
+ // `spinner.fail` moves to column 0 and clears the current line, so a caller
+ // that does not know a partial line is pending erases that text instead of
+ // printing the banner underneath it. This is the failure arm of the same
+ // ownership rule the success arm follows.
+ assert!(
+ plain_stdout
+ .lines()
+ .any(|line| line == STREAM_THEN_ERROR_TEXT),
+ "the streamed text should keep its own line despite the failure ({stdout:?})"
+ );
+ assert!(
+ plain_stdout.contains("Request failed"),
+ "the failure banner should still be reported ({stdout:?})"
+ );
+
+ fs::remove_dir_all(&workspace).expect("workspace cleanup should succeed");
+}
+
#[test]
fn compact_flag_with_json_output_emits_structured_json() {
let runtime = tokio::runtime::Runtime::new().expect("tokio runtime should build");