@sayknow-cli/coding-agent 0.4.7 → 0.5.1

package/src/modes/acp/acp-event-mapper.ts

@@ -197,21 +197,30 @@ export function mapAgentSessionEventToAcpSessionUpdates(
 			return [toSessionNotification(sessionId, update)];
 		}
 		case "tool_execution_end": {
-			const resultContent = [...extractDiffToolCallContent(event.result), ...extractToolCallContent(event.result)];
-			const content = mergeToolUpdateContent(
-				buildToolStartContent(event.toolName, getToolExecutionEndArgs(event, options)),
-				resultContent,
-			);
+			const args = getToolExecutionEndArgs(event, options);
+			const resultContent = [
+				...extractDiffToolCallContent(event.result, options.cwd),
+				...extractToolCallContent(event.result),
+			];
+			const content = mergeToolUpdateContent(buildToolStartContent(event.toolName, args), resultContent);
 			const update: SessionUpdate = {
 				sessionUpdate: "tool_call_update",
 				toolCallId: event.toolCallId,
 				status: event.isError ? "failed" : "completed",
 				rawOutput: event.result,
 			};
+			if (event.isError) {
+				// Failure is carried by `status`; `kind` stays the tool's real category so
+				// clients keep the icon/treatment established by the initial `tool_call`.
+				update.title = `Failed: ${buildToolTitle(event.toolName, args, undefined)}`;
+			}
 			if (content.length > 0) {
 				update.content = content;
 			}
-			const locations = extractToolLocationsFromResult(event.result, options.cwd);
+			const locations = mergeToolLocations(
+				extractToolLocations(args, options.cwd),
+				extractToolLocationsFromResult(event.result, options.cwd),
+			);
 			if (locations.length > 0) {
 				update.locations = locations;
 			}
@@ -295,14 +304,83 @@ export function mapAgentSessionEventToAcpSessionUpdates(
 			return [toSessionNotification(sessionId, { sessionUpdate: "session_info_update", _meta: meta })];
 		}
 		case "auto_retry_start":
+			return [
+				toSessionNotification(sessionId, {
+					sessionUpdate: "session_info_update",
+					_meta: {
+						skcPhase: "retrying",
+						skcRetryState: "waiting",
+						skcRetryAttempt: event.attempt,
+						skcRetryMaxAttempts: event.maxAttempts,
+						skcRetryDelayMs: event.delayMs,
+						skcRetryErrorMessage: event.errorMessage,
+						skcRetryUnbounded: event.unbounded ?? false,
+						running: true,
+						skcRunning: true,
+					},
+				}),
+			];
 		case "auto_retry_end":
+			return [
+				toSessionNotification(sessionId, {
+					sessionUpdate: "session_info_update",
+					_meta: {
+						skcPhase: event.success ? "responding" : "retry_failed",
+						skcRetryState: event.success ? "succeeded" : "failed",
+						skcRetryAttempt: event.attempt,
+						...(event.finalError ? { skcRetryFinalError: event.finalError } : {}),
+						running: true,
+						skcRunning: true,
+					},
+				}),
+			];
 		case "ttsr_triggered":
+			return [
+				toSessionNotification(sessionId, {
+					sessionUpdate: "session_info_update",
+					_meta: {
+						skcTtsrTriggered: true,
+						skcTtsrRuleCount: event.rules.length,
+					},
+				}),
+			];
 		case "irc_message":
 		case "subagent_steer_message":
+			return [];
 		case "notice":
+			return [
+				toSessionNotification(sessionId, {
+					sessionUpdate: "agent_thought_chunk",
+					content: {
+						type: "text",
+						text: `[${event.level}${event.source ? `:${event.source}` : ""}] ${event.message}\n`,
+					},
+				}),
+			];
 		case "thinking_level_changed":
+			return [
+				toSessionNotification(sessionId, {
+					sessionUpdate: "session_info_update",
+					_meta: { skcThinkingLevel: event.thinkingLevel ?? "off" },
+				}),
+			];
 		case "goal_updated":
-			return [];
+			return [
+				toSessionNotification(sessionId, {
+					sessionUpdate: "session_info_update",
+					_meta: {
+						skcGoalActive: event.goal !== null,
+						...(event.goal
+							? {
+									skcGoalId: event.goal.id,
+									skcGoalStatus: event.goal.status,
+									skcGoalObjective: event.goal.objective,
+								}
+							: {}),
+						...(event.state ? { skcGoalModeState: event.state } : {}),
+					},
+				}),
+			];
 		default:
 			return assertNeverAcp(event);
 	}
@@ -547,6 +625,19 @@ function mergeToolUpdateContent(startContent: ToolCallContent[], resultContent:
 	return merged;
 }
 
+function mergeToolLocations(...groups: ToolCallLocation[][]): ToolCallLocation[] {
+	const locations: ToolCallLocation[] = [];
+	const seen = new Set<string>();
+	for (const group of groups) {
+		for (const location of group) {
+			if (seen.has(location.path)) continue;
+			seen.add(location.path);
+			locations.push(location);
+		}
+	}
+	return locations;
+}
+
 function isCommandToolName(toolName: string): boolean {
 	return toolName === "bash" || toolName === "shell" || toolName === "exec";
 }
@@ -626,7 +717,7 @@ function extractToolLocationsFromResult(result: unknown, cwd?: string): ToolCall
 }
 
 /** Emit a `diff` ToolCallContent for each per-file edit result that carries oldText/newText. */
-function extractDiffToolCallContent(result: unknown): ToolCallContent[] {
+function extractDiffToolCallContent(result: unknown, cwd?: string): ToolCallContent[] {
 	if (typeof result !== "object" || result === null) return [];
 	const details = (result as { details?: unknown }).details;
 	if (typeof details !== "object" || details === null) return [];
@@ -634,13 +725,13 @@ function extractDiffToolCallContent(result: unknown): ToolCallContent[] {
 	const perFile = (details as { perFileResults?: unknown }).perFileResults;
 	const entries: unknown[] = Array.isArray(perFile) ? perFile : [details];
 	for (const entry of entries) {
-		const block = buildDiffContent(entry);
+		const block = buildDiffContent(entry, cwd);
 		if (block) blocks.push(block);
 	}
 	return blocks;
 }
 
-function buildDiffContent(entry: unknown): ToolCallContent | undefined {
+function buildDiffContent(entry: unknown, cwd?: string): ToolCallContent | undefined {
 	if (typeof entry !== "object" || entry === null) return undefined;
 	const candidate = entry as { path?: unknown; oldText?: unknown; newText?: unknown; isError?: unknown };
 	if (candidate.isError === true) return undefined;
@@ -651,7 +742,8 @@ function buildDiffContent(entry: unknown): ToolCallContent | undefined {
 	if (oldText === undefined && newText === undefined) return undefined;
 	return {
 		type: "diff",
-		path,
+		// `Diff.path` is specified as an absolute path, same as ToolCallLocation.
+		path: toAcpLocationPath(path, cwd),
 		oldText: oldText ?? null,
 		newText: newText ?? "",
 	};
@@ -772,7 +864,9 @@ function toToolCallContent(value: unknown): ToolCallContent | undefined {
 				resourceLinkContent.mimeType = mimeType;
 			}
 			const size = extractNumberProperty<ResourceLinkLikeContent>(value, "size");
-			if (size !== undefined) {
+			// `ResourceLink.size` is a byte count typed as int64; drop fractional, negative,
+			// or non-representable values rather than emitting a block clients must reject.
+			if (size !== undefined && Number.isSafeInteger(size) && size >= 0) {
 				resourceLinkContent.size = size;
 			}
 			return {

package/src/modes/acp/acp-mode.ts

@@ -1,6 +1,6 @@
 import * as stream from "node:stream";
-import { AgentSideConnection, ndJsonStream, type Stream } from "@agentclientprotocol/sdk";
-import { AcpAgent } from "./acp-agent";
+import { type Agent, AgentSideConnection, ndJsonStream, type Stream } from "@agentclientprotocol/sdk";
+import { AcpAgent, acpRequestFailure } from "./acp-agent";
 import type { AcpStartupOptions } from "./startup-options";
 
 export interface AcpModeOptions {
@@ -8,8 +8,44 @@ export interface AcpModeOptions {
 	startupOptions?: AcpStartupOptions;
 }
 
+/**
+ * Every agent method reports failures to the client, and the SDK only derives a
+ * JSON-RPC code from a `RequestError` — anything else collapses to an opaque
+ * `-32603 Internal error` with the reason buried in `data`. Translating once at the
+ * connection boundary keeps that contract in one place instead of asking each method
+ * to remember it.
+ */
+function withAcpRequestFailures(agent: AcpAgent): Agent {
+	const wrapped = new Map<string | symbol, (...args: unknown[]) => unknown>();
+	return new Proxy(agent, {
+		get(target, property) {
+			// Read against the target, not the proxy: `signal`/`closed` are getters that
+			// touch private fields, and the proxy carries no private-field brand.
+			const value = Reflect.get(target, property, target);
+			if (typeof value !== "function") return value;
+			const cached = wrapped.get(property);
+			if (cached) return cached;
+			// Cache per property so repeated reads keep a stable method identity.
+			const wrapper = (...args: unknown[]) => {
+				try {
+					const result = (value as (...a: unknown[]) => unknown).apply(target, args);
+					return result instanceof Promise
+						? result.catch((error: unknown) => {
+								throw acpRequestFailure(error);
+							})
+						: result;
+				} catch (error) {
+					throw acpRequestFailure(error);
+				}
+			};
+			wrapped.set(property, wrapper);
+			return wrapper;
+		},
+	}) as unknown as Agent;
+}
+
 export function createAcpConnection(transport: Stream, options: AcpModeOptions = {}): AgentSideConnection {
-	return new AgentSideConnection(conn => new AcpAgent(conn, options), transport);
+	return new AgentSideConnection(conn => withAcpRequestFailures(new AcpAgent(conn, options)), transport);
 }
 
 export async function runAcpMode(options: AcpModeOptions = {}): Promise<never> {

package/src/modes/action-registry.ts

@@ -49,7 +49,7 @@ export const APP_ACTION_METADATA: readonly ActionMetadata[] = [
 	action("app.clipboard.copyPrompt", "Copy prompt", "Clipboard", ["composer"]),
 	action("app.session.new", "New session", "Session", ["composer"]),
 	action("app.session.tree", "Session tree", "Session", ["composer"]),
-	action("app.session.fork", "Fork session", "Session", ["composer"]),
+	action("app.session.fork", "Branch from message", "Session", ["composer"]),
 	action("app.session.resume", "Resume session", "Session", ["composer"]),
 	action("app.session.observe", "Observe sessions", "Session", ["composer"]),
 	action("app.session.dashboard", "Show sessions dashboard", "Session", ["composer"]),

package/src/modes/components/assistant-message.ts

@@ -84,8 +84,10 @@ export class AssistantMessageComponent extends Container {
 	#lastMessage?: AssistantMessage;
 	#toolImagesByCallId = new Map<string, ImageContent[]>();
 	#usageInfo?: Usage;
-	#convertedKittyImages = new Map<string, ImageContent>();
-	#kittyConversionsInFlight = new Set<string>();
+	#convertedKittyImages = new Map<string, ImageContent & { source: string }>();
+	#kittyConversionsInFlight = new Map<string, string>();
+	#toolImageGenerations = new Map<string, number>();
+
 	#responseHeader = new Text(theme.bold(theme.fg("statusLineModel", "sayknow")), 1, 0);
 	#contentBlocksCache = new WeakMap<object, { source: string; component: Component }>();
 	#lastStreaming = false;
@@ -94,11 +96,17 @@ export class AssistantMessageComponent extends Container {
 	#nextContentBlockKey = 0;
 	#reusableChildren = new WeakSet<Component>();
 	#viewportAnchorId?: string;
+	#visibleSignature = "";
+	#visibleSignatureInitialized = false;
+	#toolImagesRevision = 0;
+	#convertedToolImagesRevision = 0;
+	#disposed = false;
 	constructor(
 		message?: AssistantMessage,
 		private hideThinkingBlock = false,
 		private readonly onImageUpdate?: () => void,
 		viewportAnchorId?: string,
+		private readonly onVisibleMutation?: () => void,
 	) {
 		super();
 		this.#viewportAnchorId = viewportAnchorId;
@@ -109,6 +117,56 @@ export class AssistantMessageComponent extends Container {
 		if (message) {
 			this.updateContent(message);
 		}
+		this.#visibleSignature = this.#visibleContentSignature();
+		this.#visibleSignatureInitialized = true;
+	}
+
+	#visibleContentSignature(): string {
+		const message = this.#lastMessage;
+		const content: string[] = [];
+		let hasMarkdownContent = false;
+		for (const block of message?.content ?? []) {
+			if (block.type === "text" && block.text.trim()) {
+				content.push(`text:${block.text.trim()}`);
+				hasMarkdownContent = true;
+			} else if (block.type === "thinking" && block.thinking.trim()) {
+				content.push(
+					this.hideThinkingBlock
+						? "thinking"
+						: `thinking:${elideRunawayThinkingRepetition(block.thinking.trim())}`,
+				);
+				if (!this.hideThinkingBlock) hasMarkdownContent = true;
+			}
+		}
+		if (hasMarkdownContent) {
+			content.unshift(this.#lastStreaming ? "streaming" : "final");
+		}
+		const hasToolCalls = message?.content.some(block => block.type === "toolCall") ?? false;
+		if (!hasToolCalls && message?.stopReason === "aborted" && !isSilentAbort(message.errorMessage)) {
+			content.push(`aborted:${message.errorMessage ?? ""}`);
+		} else if (!hasToolCalls && message?.stopReason === "error") {
+			content.push(`error:${message.errorMessage ?? ""}`);
+		} else if (
+			message?.errorMessage &&
+			!isSilentAbort(message.errorMessage) &&
+			message.stopReason !== "aborted" &&
+			message.stopReason !== "error"
+		) {
+			content.push(`message-error:${message.errorMessage}`);
+		}
+		if (settings.get("display.showTokenUsage") && this.#usageInfo) {
+			const usage = this.#usageInfo;
+			content.push(`usage:${usage.input}:${usage.cacheWrite}:${usage.output}:${usage.cacheRead}`);
+		}
+		content.push(`images:${this.#toolImagesRevision}:${this.#convertedToolImagesRevision}`);
+		return content.join("\u0000");
+	}
+
+	#notifyVisibleMutation(): void {
+		const after = this.#visibleContentSignature();
+		if (after === this.#visibleSignature) return;
+		this.#visibleSignature = after;
+		if (this.#visibleSignatureInitialized) this.onVisibleMutation?.();
 	}
 
 	#contentAnchorSource(
@@ -126,22 +184,36 @@ export class AssistantMessageComponent extends Container {
 	}
 
 	setHideThinkingBlock(hide: boolean): void {
+		if (this.hideThinkingBlock === hide) return;
 		this.hideThinkingBlock = hide;
+		this.#notifyVisibleMutation();
 	}
 
 	setToolResultImages(toolCallId: string, images: ImageContent[]): void {
 		if (!toolCallId) return;
 		const validImages = images.filter(img => img.type === "image" && img.data && img.mimeType);
+		const previousImages = this.#toolImagesByCallId.get(toolCallId);
+		if (
+			(previousImages?.length ?? 0) === validImages.length &&
+			(previousImages?.every(
+				(image, index) =>
+					image.type === validImages[index]?.type &&
+					image.data === validImages[index]?.data &&
+					image.mimeType === validImages[index]?.mimeType,
+			) ??
+				true)
+		) {
+			return;
+		}
 		for (const key of Array.from(this.#convertedKittyImages.keys())) {
-			if (key.startsWith(`${toolCallId}:`)) {
-				this.#convertedKittyImages.delete(key);
-			}
+			if (key.startsWith(`${toolCallId}:`)) this.#convertedKittyImages.delete(key);
 		}
-		for (const key of Array.from(this.#kittyConversionsInFlight)) {
-			if (key.startsWith(`${toolCallId}:`)) {
-				this.#kittyConversionsInFlight.delete(key);
-			}
+		for (const key of Array.from(this.#kittyConversionsInFlight.keys())) {
+			if (key.startsWith(`${toolCallId}:`)) this.#kittyConversionsInFlight.delete(key);
 		}
+		this.#toolImageGenerations.set(toolCallId, (this.#toolImageGenerations.get(toolCallId) ?? 0) + 1);
+
+		this.#toolImagesRevision += 1;
 		if (validImages.length === 0) {
 			this.#toolImagesByCallId.delete(toolCallId);
 		} else {
@@ -153,30 +225,49 @@ export class AssistantMessageComponent extends Container {
 		}
 	}
 
+	#toolImageSource(image: ImageContent): string {
+		return `${image.mimeType}\u0000${image.data}`;
+	}
+
 	#convertToolImagesForKitty(toolCallId: string, images: ImageContent[]): void {
 		if (TERMINAL.imageProtocol !== ImageProtocol.Kitty) return;
-		for (let index = 0; index < images.length; index++) {
-			const image = images[index];
-			if (!image || image.mimeType === "image/png") continue;
+		const generation = this.#toolImageGenerations.get(toolCallId) ?? 0;
+		for (const [index, image] of images.entries()) {
+			if (image.mimeType === "image/png") continue;
 			const key = `${toolCallId}:${index}`;
-			if (this.#convertedKittyImages.has(key) || this.#kittyConversionsInFlight.has(key)) continue;
-			this.#kittyConversionsInFlight.add(key);
+			const source = this.#toolImageSource(image);
+			if (
+				this.#convertedKittyImages.get(key)?.source === source ||
+				this.#kittyConversionsInFlight.get(key) === source
+			)
+				continue;
+			this.#kittyConversionsInFlight.set(key, source);
 			new Bun.Image(Buffer.from(image.data, "base64"))
 				.png()
 				.toBase64()
 				.then(data => {
+					const currentImage = this.#toolImagesByCallId.get(toolCallId)?.[index];
+					if (
+						this.#disposed ||
+						this.#toolImageGenerations.get(toolCallId) !== generation ||
+						this.#kittyConversionsInFlight.get(key) !== source ||
+						!currentImage ||
+						this.#toolImageSource(currentImage) !== source
+					)
+						return;
 					this.#kittyConversionsInFlight.delete(key);
-					this.#convertedKittyImages.set(key, {
-						type: "image",
-						data,
-						mimeType: "image/png",
-					});
-					if (this.#lastMessage) {
-						this.updateContent(this.#lastMessage, { streaming: this.#lastStreaming });
-					}
+					this.#convertedKittyImages.set(key, { type: "image", data, mimeType: "image/png", source });
+					this.#convertedToolImagesRevision += 1;
+					if (this.#lastMessage) this.updateContent(this.#lastMessage, { streaming: this.#lastStreaming });
 					this.onImageUpdate?.();
 				})
 				.catch(() => {
+					if (
+						this.#disposed ||
+						this.#toolImageGenerations.get(toolCallId) !== generation ||
+						this.#kittyConversionsInFlight.get(key) !== source
+					)
+						return;
 					this.#kittyConversionsInFlight.delete(key);
 				});
 		}
@@ -487,5 +578,15 @@ export class AssistantMessageComponent extends Container {
 		}
 
 		this.#reconcileChildren(descriptors);
+		this.#notifyVisibleMutation();
+	}
+
+	override dispose(): void {
+		if (this.#disposed) return;
+		this.#disposed = true;
+		this.#toolImageGenerations.clear();
+		this.#kittyConversionsInFlight.clear();
+		this.#convertedKittyImages.clear();
+		super.dispose();
 	}
 }

package/src/modes/components/btw-panel.ts

@@ -1,4 +1,10 @@
 import { type Component, Container, Markdown, Spacer, Text, type TUI } from "@sayknow-cli/tui";
+import {
+	BTW_MAX_ANSWER_UTF8_BYTES,
+	BTW_MAX_CONTEXT_TURNS,
+	sanitizeBtwError,
+	truncateUtf8,
+} from "../../session/btw-contract";
 import { replaceTabs } from "../../tools/render-utils";
 import { getMarkdownTheme, theme } from "../theme/theme";
 import { DynamicBorder } from "./dynamic-border";
@@ -10,12 +16,21 @@ interface BtwPanelComponentOptions {
 	tui: TUI;
 }
 
+interface BtwTurn {
+	question: string;
+	answer: string;
+	state: BtwPanelState;
+	errorMessage?: string;
+}
+
 export class BtwPanelComponent extends Container {
 	#question: string;
 	#tui: TUI;
 	#state: BtwPanelState = "running";
 	#answer = "";
 	#errorMessage: string | undefined;
+	#completedTurns: BtwTurn[] = [];
+	#streamingContent = new Container();
 	#closed = false;
 
 	constructor(options: BtwPanelComponentOptions) {
@@ -25,16 +40,29 @@ export class BtwPanelComponent extends Container {
 		this.#rebuild();
 	}
 
+	beginTurn(question: string): void {
+		if (this.#closed) return;
+		if (this.#state === "complete") {
+			this.#completedTurns.push(this.#currentTurn());
+			if (this.#completedTurns.length > BTW_MAX_CONTEXT_TURNS) this.#completedTurns.shift();
+		}
+		this.#question = question;
+		this.#answer = "";
+		this.#errorMessage = undefined;
+		this.#state = "running";
+		this.#rebuild();
+	}
+
 	appendText(delta: string): void {
 		if (!delta || this.#closed) return;
-		this.#answer += delta;
-		this.#rebuild();
+		this.#answer = truncateUtf8(this.#answer + delta, BTW_MAX_ANSWER_UTF8_BYTES);
+		this.#updateStreamingContent();
 	}
 
 	setAnswer(text: string): void {
 		if (this.#closed) return;
-		this.#answer = text;
-		this.#rebuild();
+		this.#answer = truncateUtf8(text, BTW_MAX_ANSWER_UTF8_BYTES);
+		this.#updateStreamingContent();
 	}
 
 	markComplete(): void {
@@ -54,21 +82,33 @@ export class BtwPanelComponent extends Container {
 	markError(message: string): void {
 		if (this.#closed) return;
 		this.#state = "error";
-		this.#errorMessage = message;
+		this.#answer = "";
+		this.#errorMessage = sanitizeBtwError(message);
 		this.#rebuild();
 	}
 
 	close(): void {
 		this.#closed = true;
+		this.#question = "";
+		this.#completedTurns = [];
+		this.#answer = "";
+		this.#errorMessage = undefined;
+		this.#streamingContent.clear();
+		this.clear();
 	}
 
 	#rebuild(): void {
 		this.clear();
 		this.addChild(new DynamicBorder(str => theme.fg("dim", str)));
 		this.addChild(new Spacer(1));
+		for (const turn of this.#completedTurns) {
+			this.addChild(this.#turnComponent(turn));
+			this.addChild(new Spacer(1));
+		}
 		this.addChild(new Text(theme.fg("accent", replaceTabs(this.#question)), 1, 0));
 		this.addChild(new Spacer(1));
-		this.addChild(this.#contentComponent());
+		this.#updateStreamingContent(false);
+		this.addChild(this.#streamingContent);
 		this.addChild(new Spacer(1));
 		this.addChild(new Text(this.#footerLine(), 1, 0));
 		this.addChild(new Spacer(1));
@@ -76,29 +116,55 @@ export class BtwPanelComponent extends Container {
 		this.#tui.requestRender();
 	}
 
+	#updateStreamingContent(requestRender = true): void {
+		this.#streamingContent.clear();
+		this.#streamingContent.addChild(this.#contentComponent(this.#state, this.#answer, this.#errorMessage));
+		if (requestRender) this.#tui.requestRender();
+	}
+
+	#currentTurn(): BtwTurn {
+		return {
+			question: this.#question,
+			answer: this.#answer,
+			state: this.#state,
+			errorMessage: this.#errorMessage,
+		};
+	}
+
+	#turnComponent(turn: BtwTurn): Component {
+		const container = new Container();
+		container.addChild(new Text(theme.fg("accent", replaceTabs(turn.question)), 1, 0));
+		container.addChild(new Spacer(1));
+		container.addChild(this.#contentComponent(turn.state, turn.answer, turn.errorMessage));
+		return container;
+	}
+
 	#footerLine(): string {
 		switch (this.#state) {
 			case "running":
-				return theme.fg("muted", "Esc cancel /btw");
+				return theme.fg("muted", "Esc cancel /btw and return to main chat");
 			case "complete":
-				return theme.fg("muted", "Esc dismiss");
+				return theme.fg("muted", "Type a follow-up · Esc return to main chat");
 			case "aborted":
-				return theme.fg("warning", `${theme.status.warning} Cancelled · Esc dismiss`);
+				return theme.fg(
+					"warning",
+					`${theme.status.warning} Cancelled · Type a follow-up · Esc return to main chat`,
+				);
 			case "error":
-				return theme.fg("error", `${theme.status.error} Error · Esc dismiss`);
+				return theme.fg("error", `${theme.status.error} Error · Type a follow-up · Esc return to main chat`);
 		}
 	}
 
-	#contentComponent(): Component {
-		if (this.#state === "error") {
-			return new Text(theme.fg("error", replaceTabs(this.#errorMessage ?? "Unknown error")), 1, 0);
+	#contentComponent(state: BtwPanelState, answer: string, errorMessage: string | undefined): Component {
+		if (state === "error") {
+			return new Text(theme.fg("error", replaceTabs(errorMessage ?? "Unknown error")), 1, 0);
 		}
-		const text = replaceTabs(this.#answer).trim();
+		const text = replaceTabs(answer).trim();
 		if (!text) {
-			const waiting =
-				this.#state === "running" ? `${theme.status.pending} Waiting for response…` : "No text returned.";
+			const waiting = state === "running" ? `${theme.status.pending} Waiting for response…` : "No text returned.";
 			return new Text(theme.fg("dim", waiting), 1, 0);
 		}
+		if (state === "running") return new Text(text, 1, 0);
 		return new Markdown(text, 1, 0, getMarkdownTheme());
 	}
 }