@@ -1,21 +1,138 @@
11 import * as c from "yoctocolors";
2+import { createHighlighter, type Highlighter } from "yoctomarkdown";
3+
24 import { buildAbortMessages, isAbortError } from "../agent/agent-helpers.ts";
35 import type { CoreMessage } from "../llm-api/turn.ts";
46 import type { TurnEvent } from "../llm-api/types.ts";
5-import { LiveReasoningBlock } from "./live-reasoning.ts";
6-import { G, RenderedError, renderError, writeln } from "./output.ts";
7+
8+import { G, RenderedError, renderError, write, writeln } from "./output.ts";
79 import {
810 normalizeReasoningDelta,
911 normalizeReasoningText,
1012 } from "./reasoning.ts";
1113 import type { Spinner } from "./spinner.ts";
12-import { StreamRenderContent } from "./stream-render-content.ts";
14+import { terminal } from "./terminal-io.ts";
1315 import {
1416 buildToolCallLine,
1517 renderToolCall,
1618 renderToolResult,
1719 } from "./tool-render.ts";
1820
21+// ─── Inline reasoning rendering ──────────────────────────────────────────────
22+
23+function styleReasoning(text: string): string {
24+ return c.italic(c.dim(text));
25+}
26+
27+function writeReasoningDelta(
28+ delta: string,
29+ state: { blockOpen: boolean; lineOpen: boolean },
30+): void {
31+ if (!delta) return;
32+ if (!state.blockOpen) {
33+ writeln(`${G.info} ${c.dim("reasoning")}`);
34+ state.blockOpen = true;
35+ }
36+ const lines = delta.split("\n");
37+ for (const [i, line] of lines.entries()) {
38+ if (line) {
39+ if (!state.lineOpen) {
40+ write(" ");
41+ state.lineOpen = true;
42+ }
43+ write(styleReasoning(line));
44+ }
45+ if (i < lines.length - 1) {
46+ if (!state.lineOpen) write(" ");
47+ writeln();
48+ state.lineOpen = false;
49+ }
50+ }
51+}
52+
53+function finishReasoning(state: {
54+ blockOpen: boolean;
55+ lineOpen: boolean;
56+}): void {
57+ if (!state.blockOpen) return;
58+ if (state.lineOpen) writeln();
59+ state.blockOpen = false;
60+ state.lineOpen = false;
61+}
62+
63+// ─── Inline text streaming ───────────────────────────────────────────────────
64+
65+function appendTextDelta(
66+ delta: string | undefined,
67+ state: {
68+ inText: boolean;
69+ text: string;
70+ highlighter: Highlighter | undefined;
71+ },
72+ spinner: Spinner,
73+ quiet: boolean,
74+ renderedVisibleOutput: boolean,
75+): boolean {
76+ let chunk = delta ?? "";
77+ if (!chunk) return state.inText;
78+ if (!state.inText) {
79+ chunk = chunk.trimStart();
80+ if (!chunk) return false;
81+ if (!quiet) {
82+ spinner.stop();
83+ if (renderedVisibleOutput) writeln();
84+ write(`${G.reply} `);
85+ }
86+ state.inText = true;
87+ if (!quiet && terminal.isStdoutTTY) {
88+ state.highlighter = createHighlighter();
89+ }
90+ }
91+ const isFirstLine = !state.text.includes("\n");
92+ state.text += chunk;
93+ if (quiet) return state.inText;
94+ spinner.stop();
95+ if (state.highlighter) {
96+ let colored = state.highlighter.write(chunk);
97+ if (colored) {
98+ if (isFirstLine && colored.startsWith("\x1b[2K\r")) {
99+ colored = `\x1b[2K\r${G.reply} ${colored.slice(5)}`;
100+ }
101+ write(colored);
102+ }
103+ } else {
104+ write(chunk);
105+ }
106+ return state.inText;
107+}
108+
109+function flushText(
110+ state: {
111+ inText: boolean;
112+ text: string;
113+ highlighter: Highlighter | undefined;
114+ },
115+ quiet: boolean,
116+): void {
117+ if (!state.inText) return;
118+ if (!quiet) {
119+ if (state.highlighter) {
120+ let finalColored = state.highlighter.end();
121+ if (finalColored) {
122+ const isFirstLine = !state.text.includes("\n");
123+ if (isFirstLine && finalColored.startsWith("\x1b[2K\r")) {
124+ finalColored = `\x1b[2K\r${G.reply} ${finalColored.slice(5)}`;
125+ }
126+ write(finalColored);
127+ }
128+ }
129+ writeln();
130+ }
131+ state.inText = false;
132+}
133+
134+// ─── Main render loop ────────────────────────────────────────────────────────
135+
19136 export async function renderTurn(
20137 events: AsyncIterable<TurnEvent>,
21138 spinner: Spinner,
@@ -30,23 +147,35 @@ export async function renderTurn(
30147 const quiet = opts?.quiet ?? false;
31148 const showReasoning = !quiet && (opts?.showReasoning ?? true);
32149 const verboseOutput = opts?.verboseOutput ?? false;
33- const content = new StreamRenderContent(spinner, quiet);
34- const liveReasoning = new LiveReasoningBlock();
35150
151+ // Text state
152+ const textState = {
153+ inText: false,
154+ text: "",
155+ highlighter: undefined as Highlighter | undefined,
156+ };
157+
158+ // Reasoning state
159+ let reasoningRaw = "";
160+ let reasoningComputed = false;
161+ let reasoningText = "";
162+ const reasoningState = { blockOpen: false, lineOpen: false };
163+
164+ // Tool state
165+ const startedToolCalls = new Set<string>();
166+ const toolCallInfo = new Map<string, { toolName: string; label: string }>();
167+ let parallelCallCount = 0;
168+
169+ // Output tracking
36170 let inputTokens = 0;
37171 let outputTokens = 0;
38172 let contextTokens = 0;
39173 let newMessages: CoreMessage[] = [];
40- const startedToolCalls = new Set<string>();
41- const toolCallInfo = new Map<string, { toolName: string; label: string }>();
42- let parallelCallCount = 0;
43174 let renderedVisibleOutput = false;
44175
45- let reasoningComputed = false;
46- let reasoningText = "";
47176 const getReasoningText = (): string => {
48177 if (!reasoningComputed) {
49- reasoningText = normalizeReasoningText(content.getReasoning());
178+ reasoningText = normalizeReasoningText(reasoningRaw);
50179 reasoningComputed = true;
51180 }
52181 return reasoningText;
@@ -55,30 +184,49 @@ export async function renderTurn(
55184 for await (const event of events) {
56185 switch (event.type) {
57186 case "text-delta": {
58- liveReasoning.finish();
59- content.appendTextDelta(event.delta, renderedVisibleOutput);
60- if (content.hasOpenContent()) renderedVisibleOutput = true;
187+ finishReasoning(reasoningState);
188+ textState.inText = appendTextDelta(
189+ event.delta,
190+ textState,
191+ spinner,
192+ quiet,
193+ renderedVisibleOutput,
194+ );
195+ if (textState.inText) renderedVisibleOutput = true;
61196 break;
62197 }
198+
63199 case "reasoning-delta": {
64- content.flushOpenContent();
65- const delta = content.appendReasoningDelta(
66- normalizeReasoningDelta(event.delta),
67- );
200+ flushText(textState, quiet);
201+ let appended = normalizeReasoningDelta(event.delta);
202+ if (
203+ reasoningRaw.endsWith("**") &&
204+ appended.startsWith("**") &&
205+ !reasoningRaw.endsWith("\n")
206+ ) {
207+ appended = `\n${appended}`;
208+ }
209+ reasoningRaw += appended;
68210 reasoningComputed = false;
69- if (showReasoning && delta) {
211+ if (showReasoning && appended) {
70212 spinner.stop();
71- if (renderedVisibleOutput && !liveReasoning.isOpen()) writeln();
72- liveReasoning.append(delta);
213+ if (renderedVisibleOutput && !reasoningState.blockOpen) writeln();
214+ writeReasoningDelta(appended, reasoningState);
73215 renderedVisibleOutput = true;
74216 }
75217 break;
76218 }
77219
220+ case "tool-input-delta": {
221+ if (quiet) break;
222+ finishReasoning(reasoningState);
223+ flushText(textState, quiet);
224+ spinner.start(`composing ${event.toolName}…`);
225+ break;
226+ }
227+
78228 case "tool-call-start": {
79- if (startedToolCalls.has(event.toolCallId)) {
80- break;
81- }
229+ if (startedToolCalls.has(event.toolCallId)) break;
82230 const isConsecutiveToolCall =
83231 startedToolCalls.size > 0 && toolCallInfo.size > 0;
84232 startedToolCalls.add(event.toolCallId);
@@ -89,12 +237,14 @@ export async function renderTurn(
89237 if (toolCallInfo.size > 1) {
90238 parallelCallCount = toolCallInfo.size;
91239 }
92- liveReasoning.finish();
93- content.flushOpenContent();
240+ finishReasoning(reasoningState);
241+ flushText(textState, quiet);
94242 if (!quiet) {
95243 spinner.stop();
96- if (renderedVisibleOutput && !isConsecutiveToolCall) writeln();
97- renderToolCall(event.toolName, event.args);
244+ if (renderedVisibleOutput && !isConsecutiveToolCall) {
245+ writeln();
246+ }
247+ renderToolCall(event.toolName, event.args, { verboseOutput });
98248 renderedVisibleOutput = true;
99249 spinner.start(event.toolName);
100250 }
@@ -105,11 +255,11 @@ export async function renderTurn(
105255 startedToolCalls.delete(event.toolCallId);
106256 const callInfo = toolCallInfo.get(event.toolCallId);
107257 toolCallInfo.delete(event.toolCallId);
108- liveReasoning.finish();
258+ finishReasoning(reasoningState);
109259 if (!quiet) {
110260 spinner.stop();
111261 if (parallelCallCount > 1 && callInfo) {
112- writeln(` ${c.dim("↳")} ${callInfo.label}`);
262+ writeln(`${c.dim("↳")} ${callInfo.label}`);
113263 }
114264 if (toolCallInfo.size === 0) parallelCallCount = 0;
115265 renderToolResult(event.toolName, event.result, event.isError, {
@@ -124,8 +274,8 @@ export async function renderTurn(
124274 }
125275
126276 case "context-pruned": {
127- liveReasoning.finish();
128- content.flushOpenContent();
277+ finishReasoning(reasoningState);
278+ flushText(textState, quiet);
129279 if (!quiet) {
130280 spinner.stop();
131281 const removedKb = (event.removedBytes / 1024).toFixed(1);
@@ -133,13 +283,14 @@ export async function renderTurn(
133283 `${G.info} ${c.dim("context pruned")} ${c.dim(`–${event.removedMessageCount} messages`)} ${c.dim(`–${removedKb} KB`)}`,
134284 );
135285 renderedVisibleOutput = true;
286+ spinner.start("thinking");
136287 }
137288 break;
138289 }
139290
140291 case "turn-complete": {
141- liveReasoning.finish();
142- content.flushOpenContent();
292+ finishReasoning(reasoningState);
293+ flushText(textState, quiet);
143294 spinner.stop();
144295 if (!quiet && !renderedVisibleOutput) writeln();
145296 inputTokens = event.inputTokens;
@@ -150,8 +301,8 @@ export async function renderTurn(
150301 }
151302
152303 case "turn-error": {
153- liveReasoning.finish();
154- content.flushOpenContent();
304+ finishReasoning(reasoningState);
305+ flushText(textState, quiet);
155306 spinner.stop();
156307 inputTokens = event.inputTokens;
157308 outputTokens = event.outputTokens;
@@ -159,7 +310,7 @@ export async function renderTurn(
159310 if (isAbortError(event.error)) {
160311 newMessages = buildAbortMessages(
161312 event.partialMessages,
162- content.getText(),
313+ textState.text,
163314 );
164315 } else {
165316 renderError(event.error, "turn");