xonecas.io
64875
Mc

mini-coder / commit 90739e8

feat: stream tool-call construction in ui

xonecas2026-04-08 90739e87805202dc1cc483cad0a264419858535d parent fa9b964

7 files changed

TODO.md+13−3
@@ -5,11 +5,21 @@ Don't keep completed items bloating the file.
55 Keep the file structured and minimal.
66 The spec.md and code are the sources of truth, not this file, don't assume anything because it's documented here.
77
8-## Plugins and API drift (deferred until core/spec alignment is done)
8+## Open items
99
10-- [ ] **Reconcile the plugin tool execution API with the spec/docs** (`plugins.ts`, `index.ts`, `spec.md`) — the implementation currently needs an undocumented `toolHandlers` map in addition to `tools`, so plugin tools are not actually self-describing the way the spec says.
10+- [ ] **Refresh git state after each completed turn** (`ui/agent.ts`) — git state is refreshed before a turn starts but not after agent actions mutate the repo, so the status bar and next prompt footer can go stale.
11+
12+## Low priority (deffered until further notice)
13+
14+- [ ] **Prevent `/session` from switching sessions mid-run** (`ui/commands.ts`, `ui/agent.ts`) — selecting a session while a turn is active can desync UI state from the session the loop is still writing to.
15+- [ ] **XML-escape generated skill catalog fields** (`skills.ts`) — skill names, descriptions, and paths containing XML metacharacters can break the `<available_skills>` prompt block.
16+
17+## Plugin related (documented only, no plugin related work is planned right now)
18+
19+- [ ] **Reconcile the plugin tool execution API with the spec/docs** (`plugins.ts`, `index.ts`, `spec.md`) — the implementation currently needs an undocumented `toolHandlers` map in addition to `tools`, so spec-shaped plugin tools can be advertised to the model but still fail at runtime.
1120 - [ ] **Current plugin `AgentContext.messages` is stale** (`index.ts`) — plugin context currently gets a startup snapshot instead of the live current session messages.
12-- [ ] **Package-name plugin imports do not work** (`plugins.ts`) — plugin config says `module` can be a package name or path, but current loading always resolves as a filesystem path.
21+- [ ] **Package-name and config-relative plugin imports do not work** (`plugins.ts`) — plugin config says `module` can be a package name or path, but current loading always resolves as a filesystem path from the process CWD.
22+- [ ] **Prefix plugin tool rendering with `plugin/tool` in the log** (`index.ts`, `ui/conversation.ts`) — generic plugin tool blocks currently show only the bare tool name, so collisions are ambiguous and the UI does not match the spec.
1323
1424 ## Future ideas
1525
src/agent.test.ts+189−0
@@ -376,6 +376,195 @@ describe("agent loop", () => {
376376 ]);
377377 });
378378
379+ test("emits streamed tool-call construction events before execution starts", async () => {
380+ const api = "toolcall-stream-test";
381+ const sourceId = "toolcall-stream-test-source";
382+ const model: Model<string> = {
383+ id: "toolcall-stream-model",
384+ name: "Tool Call Stream Model",
385+ api,
386+ provider: "test",
387+ baseUrl: "http://localhost:0",
388+ reasoning: false,
389+ input: ["text"],
390+ cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
391+ contextWindow: 128000,
392+ maxTokens: 4096,
393+ };
394+
395+ let callCount = 0;
396+ const finalToolCall = fauxToolCall(
397+ "shell",
398+ { command: "echo streamed-tool" },
399+ { id: "tool-1" },
400+ );
401+ const buildProviderStream = () => {
402+ callCount += 1;
403+ const stream = createAssistantMessageEventStream();
404+
405+ if (callCount === 1) {
406+ const finalMessage: AssistantMessage = {
407+ role: "assistant",
408+ content: [finalToolCall],
409+ api,
410+ provider: model.provider,
411+ model: model.id,
412+ usage: ZERO_USAGE,
413+ stopReason: "toolUse",
414+ timestamp: Date.now(),
415+ };
416+ const partialStart: AssistantMessage = {
417+ ...finalMessage,
418+ content: [fauxToolCall("shell", {}, { id: "tool-1" })],
419+ };
420+ const partialDelta: AssistantMessage = {
421+ ...finalMessage,
422+ content: [
423+ fauxToolCall(
424+ "shell",
425+ { command: "echo streamed" },
426+ { id: "tool-1" },
427+ ),
428+ ],
429+ };
430+
431+ queueMicrotask(() => {
432+ stream.push({
433+ type: "toolcall_start",
434+ contentIndex: 0,
435+ partial: partialStart,
436+ });
437+ stream.push({
438+ type: "toolcall_delta",
439+ contentIndex: 0,
440+ delta: '{"command":"echo streamed"}',
441+ partial: partialDelta,
442+ });
443+ stream.push({
444+ type: "toolcall_end",
445+ contentIndex: 0,
446+ toolCall: finalToolCall,
447+ partial: finalMessage,
448+ });
449+ stream.push({
450+ type: "done",
451+ reason: "toolUse",
452+ message: finalMessage,
453+ });
454+ stream.end(finalMessage);
455+ });
456+
457+ return stream;
458+ }
459+
460+ const finalMessage = fauxAssistantMessage("Done.");
461+ queueMicrotask(() => {
462+ stream.push({
463+ type: "done",
464+ reason: "stop",
465+ message: finalMessage,
466+ });
467+ stream.end(finalMessage);
468+ });
469+
470+ return stream;
471+ };
472+
473+ registerApiProvider(
474+ {
475+ api,
476+ stream: (_model, _context, _options) => buildProviderStream(),
477+ streamSimple: (_model, _context, _options) => buildProviderStream(),
478+ },
479+ sourceId,
480+ );
481+
482+ try {
483+ const events: AgentEvent[] = [];
484+ const session = createSession(db, { cwd: tmp });
485+ const userMsg = makeUser("hi");
486+ const turn = appendMessage(db, session.id, userMsg);
487+
488+ await runAgentLoop({
489+ db,
490+ sessionId: session.id,
491+ turn,
492+ model,
493+ systemPrompt: "Test",
494+ tools: [shellTool],
495+ toolHandlers: new Map<string, ToolHandler>([
496+ [
497+ "shell",
498+ () => ({
499+ content: [{ type: "text", text: "tool output" }],
500+ isError: false,
501+ }),
502+ ],
503+ ]),
504+ messages: [userMsg],
505+ cwd: tmp,
506+ onEvent: (event) => events.push(event),
507+ });
508+
509+ const toolCallStart = events.find(
510+ (event) => event.type === "toolcall_start",
511+ );
512+ const toolCallDelta = events.find(
513+ (event) => event.type === "toolcall_delta",
514+ );
515+ const toolCallEnd = events.find((event) => event.type === "toolcall_end");
516+ const assistantMessage = events.find(
517+ (event) => event.type === "assistant_message",
518+ );
519+ const toolStart = events.find((event) => event.type === "tool_start");
520+
521+ expect(toolCallStart).toBeDefined();
522+ expect(toolCallDelta).toBeDefined();
523+ expect(toolCallEnd).toBeDefined();
524+ expect(assistantMessage).toBeDefined();
525+ expect(toolStart).toBeDefined();
526+
527+ if (
528+ !toolCallStart ||
529+ toolCallStart.type !== "toolcall_start" ||
530+ !toolCallDelta ||
531+ toolCallDelta.type !== "toolcall_delta" ||
532+ !toolCallEnd ||
533+ toolCallEnd.type !== "toolcall_end" ||
534+ !assistantMessage ||
535+ assistantMessage.type !== "assistant_message" ||
536+ !toolStart ||
537+ toolStart.type !== "tool_start"
538+ ) {
539+ throw new Error(
540+ "Expected streamed tool-call, assistant-message, and tool-start events",
541+ );
542+ }
543+
544+ expect(toolCallStart.toolCallId).toBe("tool-1");
545+ expect(toolCallStart.name).toBe("shell");
546+ expect(toolCallStart.args).toEqual({});
547+ expect(toolCallDelta.args).toEqual({ command: "echo streamed" });
548+ expect(toolCallEnd.args).toEqual({ command: "echo streamed-tool" });
549+ expect(toolCallEnd.content).toEqual([finalToolCall]);
550+ expect(assistantMessage.message.stopReason).toBe("toolUse");
551+ expect(toolStart.args).toEqual({ command: "echo streamed-tool" });
552+
553+ const toolCallStartIndex = events.indexOf(toolCallStart);
554+ const toolCallDeltaIndex = events.indexOf(toolCallDelta);
555+ const toolCallEndIndex = events.indexOf(toolCallEnd);
556+ const assistantMessageIndex = events.indexOf(assistantMessage);
557+ const toolStartIndex = events.indexOf(toolStart);
558+
559+ expect(toolCallStartIndex).toBeLessThan(toolCallDeltaIndex);
560+ expect(toolCallDeltaIndex).toBeLessThan(toolCallEndIndex);
561+ expect(toolCallEndIndex).toBeLessThan(assistantMessageIndex);
562+ expect(assistantMessageIndex).toBeLessThan(toolStartIndex);
563+ } finally {
564+ unregisterApiProviders(sourceId);
565+ }
566+ });
567+
379568 test("reconstructs thinking content when the final done message omits it", async () => {
380569 const api = "reasoning-drop-test";
381570 const sourceId = "reasoning-drop-test-source";
src/agent.ts+123−24
@@ -11,6 +11,7 @@
1111 import type { Database } from "bun:sqlite";
1212 import type {
1313 AssistantMessage,
14+ AssistantMessageEvent,
1415 Message,
1516 Model,
1617 ThinkingLevel,
@@ -56,6 +57,28 @@ export type AgentEvent =
5657 delta: string;
5758 content: AssistantMessage["content"];
5859 }
60+ | {
61+ type: "toolcall_start";
62+ toolCallId: string;
63+ name: string;
64+ args: Record<string, unknown>;
65+ content: AssistantMessage["content"];
66+ }
67+ | {
68+ type: "toolcall_delta";
69+ toolCallId: string;
70+ name: string;
71+ args: Record<string, unknown>;
72+ delta: string;
73+ content: AssistantMessage["content"];
74+ }
75+ | {
76+ type: "toolcall_end";
77+ toolCallId: string;
78+ name: string;
79+ args: Record<string, unknown>;
80+ content: AssistantMessage["content"];
81+ }
5982 | { type: "assistant_message"; message: AssistantMessage }
6083 | {
6184 type: "tool_start";
@@ -255,6 +278,104 @@ function buildStreamOptions(
255278 };
256279 }
257280
281+interface StreamedToolCallEventPayload {
282+ toolCallId: string;
283+ name: string;
284+ args: Record<string, unknown>;
285+ content: AssistantMessage["content"];
286+}
287+
288+function buildStreamedToolCallEventPayload(
289+ partial: AssistantMessage,
290+ contentIndex: number,
291+ toolCall?: ToolCall,
292+): StreamedToolCallEventPayload | null {
293+ const block = toolCall ?? partial.content[contentIndex];
294+ if (!block || block.type !== "toolCall") {
295+ return null;
296+ }
297+
298+ return {
299+ toolCallId: block.id,
300+ name: block.name,
301+ args: structuredClone(block.arguments),
302+ content: cloneAssistantContent(partial.content),
303+ };
304+}
305+
306+function handleAssistantStreamEvent(
307+ event: AssistantMessageEvent,
308+ onEvent: RunAgentOpts["onEvent"],
309+): AssistantMessage | null {
310+ switch (event.type) {
311+ case "text_delta":
312+ onEvent?.({
313+ type: "text_delta",
314+ delta: event.delta,
315+ content: cloneAssistantContent(event.partial.content),
316+ });
317+ return null;
318+ case "thinking_delta":
319+ onEvent?.({
320+ type: "thinking_delta",
321+ delta: event.delta,
322+ content: cloneAssistantContent(event.partial.content),
323+ });
324+ return null;
325+ case "toolcall_start": {
326+ const payload = buildStreamedToolCallEventPayload(
327+ event.partial,
328+ event.contentIndex,
329+ );
330+ if (payload) {
331+ onEvent?.({
332+ type: "toolcall_start",
333+ ...payload,
334+ });
335+ }
336+ return null;
337+ }
338+ case "toolcall_delta": {
339+ const payload = buildStreamedToolCallEventPayload(
340+ event.partial,
341+ event.contentIndex,
342+ );
343+ if (payload) {
344+ onEvent?.({
345+ type: "toolcall_delta",
346+ delta: event.delta,
347+ ...payload,
348+ });
349+ }
350+ return null;
351+ }
352+ case "toolcall_end": {
353+ const payload = buildStreamedToolCallEventPayload(
354+ event.partial,
355+ event.contentIndex,
356+ event.toolCall,
357+ );
358+ if (payload) {
359+ onEvent?.({
360+ type: "toolcall_end",
361+ ...payload,
362+ });
363+ }
364+ return null;
365+ }
366+ case "done":
367+ return event.message;
368+ case "error":
369+ return event.error;
370+ case "start":
371+ case "text_start":
372+ case "text_end":
373+ case "thinking_start":
374+ case "thinking_end":
375+ return null;
376+ }
377+}
378+
258379 async function streamAssistantMessage(
259380 opts: Pick<
260381 RunAgentOpts,
@@ -281,30 +402,8 @@ async function streamAssistantMessage(
281402 partialAssistantMessage = event.partial;
282403 }
283404
284- switch (event.type) {
285- case "text_delta":
286- opts.onEvent?.({
287- type: "text_delta",
288- delta: event.delta,
289- content: cloneAssistantContent(event.partial.content),
290- });
291- continue;
292- case "thinking_delta":
293- opts.onEvent?.({
294- type: "thinking_delta",
295- delta: event.delta,
296- content: cloneAssistantContent(event.partial.content),
297- });
298- continue;
299- case "done":
300- assistantMessage = event.message;
301- continue;
302- case "error":
303- assistantMessage = event.error;
304- continue;
305- case "toolcall_end":
306- continue;
307- }
405+ assistantMessage =
406+ handleAssistantStreamEvent(event, opts.onEvent) ?? assistantMessage;
308407 }
309408
310409 const finalAssistantMessage =
src/ui.test.ts+158−0
@@ -945,6 +945,164 @@ describe("ui rendering", () => {
945945 }
946946 });
947947
948+ test("streamed tool call arguments stay visible before execution begins", async () => {
949+ const api = "ui-streaming-toolcall-test";
950+ const sourceId = "ui-streaming-toolcall-test-source";
951+ const model: Model<string> = {
952+ id: "ui-streaming-toolcall-model",
953+ name: "UI Streaming Tool Call Model",
954+ api,
955+ provider: "test",
956+ baseUrl: "http://localhost:0",
957+ reasoning: false,
958+ input: ["text"],
959+ cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
960+ contextWindow: 128000,
961+ maxTokens: 4096,
962+ };
963+
964+ let callCount = 0;
965+ const finalToolCall = fauxToolCall(
966+ "shell",
967+ { command: "echo staged-command" },
968+ { id: "tool-1" },
969+ );
970+ const buildProviderStream = () => {
971+ callCount += 1;
972+ const stream = createAssistantMessageEventStream();
973+
974+ if (callCount === 1) {
975+ const finalMessage: AssistantMessage = {
976+ role: "assistant",
977+ content: [finalToolCall],
978+ api,
979+ provider: model.provider,
980+ model: model.id,
981+ usage: {
982+ input: 0,
983+ output: 0,
984+ cacheRead: 0,
985+ cacheWrite: 0,
986+ totalTokens: 0,
987+ cost: {
988+ input: 0,
989+ output: 0,
990+ cacheRead: 0,
991+ cacheWrite: 0,
992+ total: 0,
993+ },
994+ },
995+ stopReason: "toolUse",
996+ timestamp: Date.now(),
997+ };
998+ const partialStart: AssistantMessage = {
999+ ...finalMessage,
1000+ content: [fauxToolCall("shell", {}, { id: "tool-1" })],
1001+ };
1002+ const partialDelta: AssistantMessage = {
1003+ ...finalMessage,
1004+ content: [
1005+ fauxToolCall(
1006+ "shell",
1007+ { command: "echo staged-command" },
1008+ { id: "tool-1" },
1009+ ),
1010+ ],
1011+ };
1012+
1013+ queueMicrotask(() => {
1014+ stream.push({
1015+ type: "toolcall_start",
1016+ contentIndex: 0,
1017+ partial: partialStart,
1018+ });
1019+ setTimeout(() => {
1020+ stream.push({
1021+ type: "toolcall_delta",
1022+ contentIndex: 0,
1023+ delta: '{"command":"echo staged-command"}',
1024+ partial: partialDelta,
1025+ });
1026+ setTimeout(() => {
1027+ stream.push({
1028+ type: "toolcall_end",
1029+ contentIndex: 0,
1030+ toolCall: finalToolCall,
1031+ partial: finalMessage,
1032+ });
1033+ setTimeout(() => {
1034+ stream.push({
1035+ type: "done",
1036+ reason: "toolUse",
1037+ message: finalMessage,
1038+ });
1039+ stream.end(finalMessage);
1040+ }, 150);
1041+ }, 30);
1042+ }, 30);
1043+ });
1044+
1045+ return stream;
1046+ }
1047+
1048+ const finalMessage = fauxAssistantMessage("Done.");
1049+ queueMicrotask(() => {
1050+ stream.push({
1051+ type: "done",
1052+ reason: "stop",
1053+ message: finalMessage,
1054+ });
1055+ stream.end(finalMessage);
1056+ });
1057+
1058+ return stream;
1059+ };
1060+
1061+ registerApiProvider(
1062+ {
1063+ api,
1064+ stream: (_model, _context, _options) => buildProviderStream(),
1065+ streamSimple: (_model, _context, _options) => buildProviderStream(),
1066+ },
1067+ sourceId,
1068+ );
1069+
1070+ const state = createTestState();
1071+ state.cwd = process.cwd();
1072+ state.canonicalCwd = process.cwd();
1073+ state.model = model;
1074+
1075+ try {
1076+ handleInput("hello", state);
1077+
1078+ await waitFor(() => {
1079+ const logText = collectText({
1080+ type: "vstack",
1081+ props: {},
1082+ children: buildConversationLog(state),
1083+ });
1084+ return (
1085+ state.running &&
1086+ logText.includes("$ echo staged-command") &&
1087+ logText.includes("Preparing...")
1088+ );
1089+ });
1090+
1091+ const logText = collectText({
1092+ type: "vstack",
1093+ props: {},
1094+ children: buildConversationLog(state),
1095+ });
1096+
1097+ expect(logText).toContain("$ echo staged-command");
1098+ expect(logText).toContain("Preparing...");
1099+ } finally {
1100+ await stopRunningTurn(state);
1101+ unregisterApiProviders(sourceId);
1102+ state.db.close();
1103+ }
1104+ });
1105+
9481106 test("completed tool results stay visible before the full loop finishes", async () => {
9491107 const api = "ui-streaming-tool-result-test";
9501108 const sourceId = "ui-streaming-tool-result-test-source";
src/ui/agent.ts+3−5
@@ -276,12 +276,10 @@ export function createUiAgentController(
276276 const handleAgentEvent = (event: AgentEvent, state: AppState): void => {
277277 switch (event.type) {
278278 case "text_delta":
279- streamingContent = event.content;
280- runtime.scrollConversationToBottom();
281- runtime.render();
282- break;
283-
284279 case "thinking_delta":
280+ case "toolcall_start":
281+ case "toolcall_delta":
282+ case "toolcall_end":
285283 streamingContent = event.content;
286284 runtime.scrollConversationToBottom();
287285 runtime.render();
src/ui/conversation.test.ts+16−0
@@ -4,6 +4,7 @@ import {
44 fauxAssistantMessage,
55 fauxText,
66 fauxThinking,
7+ fauxToolCall,
78 } from "@mariozechner/pi-ai";
89 import { DEFAULT_THEME, type Theme } from "../theme.ts";
910 import {
@@ -168,6 +169,21 @@ describe("ui/conversation", () => {
168169 expect(text).toContain("Thinking... 1 line.");
169170 });
170171
172+ test("renderAssistantMessage shows streamed tool call arguments before execution begins", () => {
173+ const node = renderAssistantMessage(
174+ {
175+ content: [
176+ fauxToolCall("shell", { command: "echo hi" }, { id: "tool-1" }),
177+ ],
178+ },
179+ RENDER_OPTS,
180+ );
181+ const text = collectText(node);
182+
183+ expect(text).toContain("$ echo hi");
184+ expect(text).toContain("Preparing...");
185+ });
186+
171187 test("renderAssistantMessage shows partial tool output before the tool finishes", () => {
172188 const node = renderAssistantMessage(
173189 {
src/ui/conversation.ts+67−13
@@ -136,6 +136,12 @@ function getPendingToolCalls(
136136 return assistant.pendingToolCalls ?? [];
137137 }
138138
139+function isStreamingAssistant(
140+ assistant: AssistantMessage | AssistantRenderState,
141+): assistant is AssistantRenderState {
142+ return !("role" in assistant);
143+}
144+
139145 function renderThinkingBlock(
140146 thinking: string,
141147 opts: ConversationRenderOpts,
@@ -163,6 +169,7 @@ function renderThinkingBlock(
163169 function renderAssistantContentBlock(
164170 block: AssistantMessage["content"][number],
165171 opts: ConversationRenderOpts,
172+ isStreaming: boolean,
166173 ): Node[] {
167174 if (block.type === "text" && block.text) {
168175 return renderMarkdownContent(block.text);
@@ -170,6 +177,9 @@ function renderAssistantContentBlock(
170177 if (block.type === "thinking" && block.thinking) {
171178 return [renderThinkingBlock(block.thinking, opts)];
172179 }
180+ if (block.type === "toolCall" && isStreaming) {
181+ return [renderStreamingToolCall(block, opts)];
182+ }
173183 return [];
174184 }
175185
@@ -184,8 +194,9 @@ export function renderAssistantMessage(
184194 assistant: AssistantMessage | AssistantRenderState,
185195 opts: ConversationRenderOpts,
186196 ): Node | null {
197+ const streaming = isStreamingAssistant(assistant);
187198 const children = assistant.content.flatMap((block) => {
188- return renderAssistantContentBlock(block, opts);
199+ return renderAssistantContentBlock(block, opts, streaming);
189200 });
190201
191202 for (const toolCall of getPendingToolCalls(assistant)) {
@@ -501,25 +512,68 @@ function buildPendingRunningLines(done: boolean): ToolRenderLine[] {
501512 ];
502513 }
503514
504-function buildPendingToolHeader(toolCall: PendingToolCall): ToolRenderLine {
505- if (toolCall.name === "shell") {
506- return {
507- kind: "command",
508- text: `$ ${getToolArgString(toolCall.args, "command")}`,
509- };
515+function buildToolHeader(
516+ toolName: string,
517+ args: Record<string, unknown>,
518+): ToolRenderLine {
519+ if (toolName === "shell") {
520+ const command = getToolArgString(args, "command");
521+ if (command) {
522+ return {
523+ kind: "command",
524+ text: `$ ${command}`,
525+ };
526+ }
510527 }
511- if (toolCall.name === "edit") {
512- return {
513- kind: "path",
514- text: `~ ${getToolArgString(toolCall.args, "path")}`,
515- };
528+ if (toolName === "edit") {
529+ const filePath = getToolArgString(args, "path");
530+ if (filePath) {
531+ return {
532+ kind: "path",
533+ text: `~ ${filePath}`,
534+ };
535+ }
516536 }
517537 return {
518538 kind: "toolName",
519- text: toolCall.name,
539+ text: toolName,
520540 };
521541 }
522542
543+function buildToolArgumentPreviewLines(
544+ args: Record<string, unknown>,
545+ verbose: boolean,
546+): ToolRenderLine[] {
547+ const text = JSON.stringify(args, null, 2);
548+ if (!text || text === "{}") {
549+ return [];
550+ }
551+
552+ return previewToolRenderLines(splitToolTextLines(text, "text"), verbose);
553+}
554+
555+function buildPendingToolHeader(toolCall: PendingToolCall): ToolRenderLine {
556+ return buildToolHeader(toolCall.name, toolCall.args);
557+}
558+
559+function renderStreamingToolCall(
560+ toolCall: Extract<AssistantMessage["content"][number], { type: "toolCall" }>,
561+ opts: Pick<ConversationRenderOpts, "verbose" | "theme">,
562+): Node {
563+ const header = buildToolHeader(toolCall.name, toolCall.arguments);
564+ const lines: ToolRenderLine[] = [header];
565+
566+ if (header.kind === "toolName") {
567+ lines.push(
568+ ...buildToolArgumentPreviewLines(toolCall.arguments, opts.verbose),
569+ );
570+ }
571+
572+ lines.push({ kind: "summary", text: "Preparing..." });
573+
574+ return renderToolBlock(lines, opts.theme);
575+}
576+
523577 function buildPendingToolResultLines(
524578 toolCall: PendingToolCall,
525579 verbose: boolean,