@oh-my-pi/pi-coding-agent 16.1.13 → 16.1.14

package/src/modes/controllers/input-controller.ts

@@ -530,10 +530,7 @@ export class InputController {
 			// model continues the prior intent rather than second-guessing the interrupt.
 			if (text === "." || text === "c") {
 				if (this.ctx.onInputCallback) {
-					this.ctx.editor.setText("");
-					this.ctx.pendingImages = [];
-					this.ctx.pendingImageLinks = [];
-					this.ctx.editor.imageLinks = undefined;
+					this.ctx.editor.clearDraft();
 					this.ctx.onInputCallback({
 						text: manualContinuePrompt,
 						cancelled: false,
@@ -546,16 +543,14 @@ export class InputController {
 			}
 
 			const runner = this.ctx.session.extensionRunner;
-			let inputImages = this.ctx.pendingImages.length > 0 ? [...this.ctx.pendingImages] : undefined;
-			let inputImageLinks = this.ctx.pendingImageLinks.length > 0 ? [...this.ctx.pendingImageLinks] : undefined;
+			let inputImages = this.ctx.editor.pendingImages.length > 0 ? [...this.ctx.editor.pendingImages] : undefined;
+			let inputImageLinks =
+				this.ctx.editor.pendingImageLinks.length > 0 ? [...this.ctx.editor.pendingImageLinks] : undefined;
 
 			if (runner?.hasHandlers("input")) {
 				const result = await runner.emitInput(text, inputImages, "interactive");
 				if (result?.handled) {
-					this.ctx.editor.setText("");
-					this.ctx.pendingImages = [];
-					this.ctx.pendingImageLinks = [];
-					this.ctx.editor.imageLinks = undefined;
+					this.ctx.editor.clearDraft();
 					return;
 				}
 				if (result?.text !== undefined) {
@@ -603,12 +598,8 @@ export class InputController {
 					this.ctx.showStatus("This collab link is read-only — prompting is disabled");
 					return;
 				}
-				this.ctx.editor.addToHistory(text);
-				this.ctx.editor.setText("");
-				this.ctx.editor.imageLinks = undefined;
 				const images = inputImages && inputImages.length > 0 ? [...inputImages] : undefined;
-				this.ctx.pendingImages = [];
-				this.ctx.pendingImageLinks = [];
+				this.ctx.editor.clearDraft(text);
 				// No local render: the prompt comes back from the host as a
 				// collab-prompt event/entry and renders with the author badge.
 				this.ctx.collabGuest.sendPrompt(text, images);
@@ -680,8 +671,8 @@ export class InputController {
 				this.ctx.editor.setText("");
 				this.ctx.editor.imageLinks = undefined;
 				const images = inputImages && inputImages.length > 0 ? [...inputImages] : undefined;
-				this.ctx.pendingImages = [];
-				this.ctx.pendingImageLinks = [];
+				this.ctx.editor.pendingImages = [];
+				this.ctx.editor.pendingImageLinks = [];
 				// Record the signature so the queued message's eventual delivery
 				// (a user-role `message_start` event) leaves any draft the user has
 				// typed since queuing intact. Same protection as #783, applied to
@@ -744,8 +735,8 @@ export class InputController {
 				// Include any pending images from clipboard paste
 				this.ctx.editor.imageLinks = undefined;
 				const images = inputImages && inputImages.length > 0 ? [...inputImages] : undefined;
-				this.ctx.pendingImages = [];
-				this.ctx.pendingImageLinks = [];
+				this.ctx.editor.pendingImages = [];
+				this.ctx.editor.pendingImageLinks = [];
 
 				// Render user message immediately, then let session events catch up.
 				// Tag the submission as "steer": this is a normal Enter the controller
@@ -771,8 +762,8 @@ export class InputController {
 				// semantics instead of throwing AgentBusyError.
 				this.ctx.editor.imageLinks = undefined;
 				const images = inputImages && inputImages.length > 0 ? [...inputImages] : undefined;
-				this.ctx.pendingImages = [];
-				this.ctx.pendingImageLinks = [];
+				this.ctx.editor.pendingImages = [];
+				this.ctx.editor.pendingImageLinks = [];
 				try {
 					await this.ctx.withLocalSubmission(
 						text,
@@ -787,9 +778,11 @@ export class InputController {
 					// extension command).
 					this.ctx.editor.setText(text);
 					if (images && images.length > 0) {
-						this.ctx.pendingImages = [...images];
-						this.ctx.pendingImageLinks = inputImageLinks ? [...inputImageLinks] : images.map(() => undefined);
-						this.ctx.editor.imageLinks = this.ctx.pendingImageLinks;
+						this.ctx.editor.pendingImages = [...images];
+						this.ctx.editor.pendingImageLinks = inputImageLinks
+							? [...inputImageLinks]
+							: images.map(() => undefined);
+						this.ctx.editor.imageLinks = this.ctx.editor.pendingImageLinks;
 					}
 					this.ctx.showError(error instanceof Error ? error.message : String(error));
 				}
@@ -816,12 +809,8 @@ export class InputController {
 			this.ctx.showStatus("Commands run in the main session — press ←← to return first");
 			return; // editor text not cleared: Editor does not auto-clear on submit
 		}
-		const images = this.ctx.pendingImages.length > 0 ? [...this.ctx.pendingImages] : undefined;
-		this.ctx.editor.addToHistory(text);
-		this.ctx.editor.setText("");
-		this.ctx.editor.imageLinks = undefined;
-		this.ctx.pendingImages = [];
-		this.ctx.pendingImageLinks = [];
+		const images = this.ctx.editor.pendingImages.length > 0 ? [...this.ctx.editor.pendingImages] : undefined;
+		this.ctx.editor.clearDraft(text);
 		try {
 			// prompt() handles idle (new turn) and streaming (queues per streamingBehavior).
 			await this.ctx.withLocalSubmission(text, () => target.prompt(text, { streamingBehavior, images }), {
@@ -989,10 +978,7 @@ export class InputController {
 		}
 		const didRetry = await this.ctx.viewSession.retry();
 		if (didRetry) {
-			this.ctx.editor.setText("");
-			this.ctx.pendingImages = [];
-			this.ctx.pendingImageLinks = [];
-			this.ctx.editor.imageLinks = undefined;
+			this.ctx.editor.clearDraft();
 		} else {
 			this.ctx.showStatus("Nothing to retry");
 		}
@@ -1016,7 +1002,7 @@ export class InputController {
 		// the queued entry is later re-parsed into a skill invocation is a
 		// separate concern owned by the compaction-resume path.
 		if (this.ctx.session.isCompacting) {
-			const images = this.ctx.pendingImages.length > 0 ? [...this.ctx.pendingImages] : undefined;
+			const images = this.ctx.editor.pendingImages.length > 0 ? [...this.ctx.editor.pendingImages] : undefined;
 			this.ctx.queueCompactionMessage(text, "followUp", images);
 			return;
 		}
@@ -1040,14 +1026,10 @@ export class InputController {
 
 		// Forward any pending clipboard-pasted images alongside the queued text;
 		// otherwise the follow-up would drop the image (mirrors the Enter/steer path).
-		const images = this.ctx.pendingImages.length > 0 ? [...this.ctx.pendingImages] : undefined;
+		const images = this.ctx.editor.pendingImages.length > 0 ? [...this.ctx.editor.pendingImages] : undefined;
 
 		if (this.ctx.session.isStreaming) {
-			this.ctx.editor.addToHistory(text);
-			this.ctx.editor.setText("");
-			this.ctx.editor.imageLinks = undefined;
-			this.ctx.pendingImages = [];
-			this.ctx.pendingImageLinks = [];
+			this.ctx.editor.clearDraft(text);
 			await this.ctx.withLocalSubmission(
 				text,
 				() => this.ctx.session.prompt(text, { streamingBehavior: "followUp", images }),
@@ -1059,11 +1041,7 @@ export class InputController {
 		}
 
 		// Not streaming — just submit normally
-		this.ctx.editor.addToHistory(text);
-		this.ctx.editor.setText("");
-		this.ctx.editor.imageLinks = undefined;
-		this.ctx.pendingImages = [];
-		this.ctx.pendingImageLinks = [];
+		this.ctx.editor.clearDraft(text);
 		await this.ctx.withLocalSubmission(text, () => this.ctx.session.prompt(text, { images }), {
 			imageCount: images?.length ?? 0,
 		});
@@ -1108,7 +1086,7 @@ export class InputController {
 		let queuedText: string;
 		if (queuedImages.length > 0) {
 			const parts: string[] = [];
-			let imageOffset = this.ctx.pendingImages.length;
+			let imageOffset = this.ctx.editor.pendingImages.length;
 			for (const entry of allQueued) {
 				parts.push(shiftImageMarkers(entry.text, imageOffset));
 				if (entry.images && entry.images.length > 0) imageOffset += entry.images.length;
@@ -1124,9 +1102,9 @@ export class InputController {
 		// re-materialized lazily; the restored text already carries the
 		// renumbered `[Image #N, WxH]` markers).
 		if (queuedImages.length > 0) {
-			this.ctx.pendingImages.push(...queuedImages);
-			this.ctx.pendingImageLinks.push(...queuedImages.map(() => undefined));
-			this.ctx.editor.imageLinks = this.ctx.pendingImageLinks;
+			this.ctx.editor.pendingImages.push(...queuedImages);
+			this.ctx.editor.pendingImageLinks.push(...queuedImages.map(() => undefined));
+			this.ctx.editor.imageLinks = this.ctx.editor.pendingImageLinks;
 		}
 		this.ctx.updatePendingMessagesDisplay();
 		if (options?.abort) {
@@ -1148,14 +1126,14 @@ export class InputController {
 				this.ctx.sessionManager.putBlob.bind(this.ctx.sessionManager),
 			)
 		)?.[0];
-		this.ctx.pendingImages.push({
+		this.ctx.editor.pendingImages.push({
 			type: "image",
 			data: imageData.data,
 			mimeType: imageData.mimeType,
 		});
-		this.ctx.pendingImageLinks.push(imageLink);
-		this.ctx.editor.imageLinks = this.ctx.pendingImageLinks;
-		const imageNum = this.ctx.pendingImages.length;
+		this.ctx.editor.pendingImageLinks.push(imageLink);
+		this.ctx.editor.imageLinks = this.ctx.editor.pendingImageLinks;
+		const imageNum = this.ctx.editor.pendingImages.length;
 		const dims = await this.#imageDimensions(imageData);
 		const label = dims ? `[Image #${imageNum}, ${dims.width}x${dims.height}]` : `[Image #${imageNum}]`;
 		this.ctx.editor.insertText(`${label} `);

package/src/modes/interactive-mode.ts

@@ -408,8 +408,6 @@ export class InteractiveMode implements InteractiveModeContext {
 	todoPhases: TodoPhase[] = [];
 	hideThinkingBlock = false;
 	proseOnlyThinking = true;
-	pendingImages: ImageContent[] = [];
-	pendingImageLinks: (string | undefined)[] = [];
 	compactionQueuedMessages: CompactionQueuedMessage[] = [];
 	pendingTools = new Map<string, ToolExecutionHandle>();
 	pendingBashComponents: BashExecutionComponent[] = [];
@@ -1094,7 +1092,7 @@ export class InteractiveMode implements InteractiveModeContext {
 		if (this.#goalSuppressNextContinuation) return;
 		if (this.#pendingSubmittedInput) return;
 		if (this.editor.getText().trim().length > 0) return;
-		if ((this.pendingImages?.length ?? 0) > 0) return;
+		if ((this.editor.pendingImages?.length ?? 0) > 0) return;
 		const state = this.session.getGoalModeState();
 		if (!state?.enabled || state.goal.status !== "active") return;
 		const prompt = this.session.goalRuntime.buildContinuationPrompt();
@@ -1113,7 +1111,7 @@ export class InteractiveMode implements InteractiveModeContext {
 			if (this.#isAutoSubmitBlocked()) return;
 			if (this.#pendingSubmittedInput) return;
 			if (this.editor.getText().trim().length > 0) return;
-			if ((this.pendingImages?.length ?? 0) > 0) return;
+			if ((this.editor.pendingImages?.length ?? 0) > 0) return;
 			const latestState = this.session.getGoalModeState();
 			if (!latestState?.enabled || latestState.goal.status !== "active") return;
 			this.#goalContinuationTurnInFlight = true;
@@ -1338,9 +1336,9 @@ export class InteractiveMode implements InteractiveModeContext {
 			this.#stopLoadingAnimation(true);
 		}
 		if (!submission.customType) {
-			this.pendingImages = submission.images ? [...submission.images] : [];
-			this.pendingImageLinks = submission.imageLinks ? [...submission.imageLinks] : [];
-			this.editor.imageLinks = this.pendingImageLinks;
+			this.editor.pendingImages = submission.images ? [...submission.images] : [];
+			this.editor.pendingImageLinks = submission.imageLinks ? [...submission.imageLinks] : [];
+			this.editor.imageLinks = this.editor.pendingImageLinks;
 			this.rebuildChatFromMessages();
 			this.editor.setText(submission.text);
 		}

package/src/modes/theme/theme.ts

@@ -169,6 +169,7 @@ export type SymbolKey =
 	| "lang.cpp"
 	| "lang.csharp"
 	| "lang.ruby"
+	| "lang.julia"
 	| "lang.php"
 	| "lang.swift"
 	| "lang.kotlin"
@@ -369,6 +370,7 @@ const UNICODE_SYMBOLS: SymbolMap = {
 	"lang.cpp": "➕",
 	"lang.csharp": "♯",
 	"lang.ruby": "💎",
+	"lang.julia": "Ⓙ",
 	"lang.php": "🐘",
 	"lang.swift": "🕊",
 	"lang.kotlin": "🅺",
@@ -673,6 +675,7 @@ const NERD_SYMBOLS: SymbolMap = {
 	"lang.cpp": "\u{E61D}",
 	"lang.csharp": "\u{E7BC}",
 	"lang.ruby": "\u{E791}",
+	"lang.julia": "\u{E624}",
 	"lang.php": "\u{E608}",
 	"lang.swift": "\u{E755}",
 	"lang.kotlin": "\u{E634}",
@@ -870,6 +873,7 @@ const ASCII_SYMBOLS: SymbolMap = {
 	"lang.cpp": "cpp",
 	"lang.csharp": "cs",
 	"lang.ruby": "rb",
+	"lang.julia": "jl",
 	"lang.php": "php",
 	"lang.swift": "swift",
 	"lang.kotlin": "kt",
@@ -1335,6 +1339,8 @@ const langMap: Record<string, SymbolKey> = {
 	cs: "lang.csharp",
 	ruby: "lang.ruby",
 	rb: "lang.ruby",
+	julia: "lang.julia",
+	jl: "lang.julia",
 	php: "lang.php",
 	swift: "lang.swift",
 	kotlin: "lang.kotlin",
@@ -1406,6 +1412,20 @@ const langMap: Record<string, SymbolKey> = {
 	bin: "lang.binary",
 };
 
+/**
+ * Brand colors for language icons, keyed by the resolved `lang.*` SymbolKey.
+ * Used by {@link Theme.getLangIconStyled} so eval-kernel cell headers tint each
+ * language with its recognizable hue (JS yellow, Ruby red, Julia purple, Python
+ * blue) instead of a flat muted gray. Applied as truecolor/256 per the active
+ * color mode; languages without an entry fall back to the muted theme color.
+ */
+const LANG_BRAND_COLORS: Partial<Record<SymbolKey, string>> = {
+	"lang.javascript": "#f7df1e",
+	"lang.python": "#3776ab",
+	"lang.ruby": "#cc342d",
+	"lang.julia": "#9558b2",
+};
+
 /**
  * Resolve a theme color value (hex string or 256-color index) to a CSS hex string.
  * Empty string represents the default terminal color.
@@ -1874,6 +1894,21 @@ export class Theme {
 		const key = langMap[normalized];
 		return key ? this.#symbols[key] : this.#symbols["lang.default"];
 	}
+
+	/**
+	 * Language icon tinted with the language's brand color (see
+	 * {@link LANG_BRAND_COLORS}). Falls back to the muted theme color for
+	 * languages without a brand entry, and returns the bare (possibly empty)
+	 * icon when the active symbol preset has none.
+	 */
+	getLangIconStyled(lang: string | undefined): string {
+		const icon = this.getLangIcon(lang);
+		if (!icon) return icon;
+		const key = lang ? langMap[lang.toLowerCase()] : undefined;
+		const hex = key ? LANG_BRAND_COLORS[key] : undefined;
+		if (!hex) return this.fg("muted", icon);
+		return `${colorToAnsi(hex, this.mode)}${icon}\x1b[39m`;
+	}
 }
 
 // ============================================================================

package/src/modes/types.ts

@@ -160,8 +160,6 @@ export interface InteractiveModeContext {
 	planModePlanFilePath?: string;
 	hideThinkingBlock: boolean;
 	proseOnlyThinking: boolean;
-	pendingImages: ImageContent[];
-	pendingImageLinks: (string | undefined)[];
 	compactionQueuedMessages: CompactionQueuedMessage[];
 	pendingTools: Map<string, ToolExecutionHandle>;
 	pendingBashComponents: BashExecutionComponent[];

package/src/modes/utils/copy-targets.ts

@@ -22,7 +22,7 @@ export type MessageBlock = ({ kind: "code" } & CodeBlock) | ({ kind: "quote" } &
 export interface LastCommand {
 	kind: "bash" | "eval";
 	code: string;
-	/** Highlight language: "bash" for bash, "python"/"javascript" for eval. */
+	/** Highlight language: "bash" for bash, or the resolved eval language ("python"/"javascript"/"ruby"/"julia"). */
 	language: string;
 }
 
@@ -139,7 +139,8 @@ function extractEvalCode(args: unknown): { code: string; language: string } | un
 		if (typeof code !== "string" || code.length === 0) continue;
 		codeBlocks.push(code);
 		if (!languageResolved) {
-			language = (cell as { language?: unknown }).language === "js" ? "javascript" : "python";
+			const lang = (cell as { language?: unknown }).language;
+			language = lang === "js" ? "javascript" : lang === "rb" ? "ruby" : lang === "jl" ? "julia" : "python";
 			languageResolved = true;
 		}
 	}

package/src/modes/utils/interactive-context-helpers.ts

@@ -0,0 +1,27 @@
+/**
+ * Small helpers over {@link InteractiveModeContext} shared between
+ * {@link UiHelpers} and the input/event controllers, so the live chat surfaces
+ * construct components and reset editor state identically.
+ */
+import type { AssistantMessage } from "@oh-my-pi/pi-ai";
+import { AssistantMessageComponent } from "../components/assistant-message";
+import type { InteractiveModeContext } from "../types";
+
+/**
+ * Construct an {@link AssistantMessageComponent} wired to the live context's
+ * thinking/image settings. `message` is omitted for the streaming placeholder
+ * component and supplied when rendering a persisted turn.
+ */
+export function createAssistantMessageComponent(
+	ctx: InteractiveModeContext,
+	message?: AssistantMessage,
+): AssistantMessageComponent {
+	return new AssistantMessageComponent(
+		message,
+		ctx.hideThinkingBlock,
+		() => ctx.ui.requestRender(),
+		ctx.viewSession.extensionRunner?.getAssistantThinkingRenderers(),
+		ctx.ui.imageBudget,
+		ctx.proseOnlyThinking,
+	);
+}

package/src/modes/utils/transcript-render-helpers.ts

@@ -0,0 +1,157 @@
+/**
+ * Render helpers shared between the live transcript ({@link UiHelpers}) and the
+ * file/remote-backed {@link ChatTranscriptBuilder}. Both surfaces build the same
+ * transcript rows from persisted message entries; holding the row construction
+ * here keeps the two byte-for-byte identical.
+ */
+import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
+import { type Component, Text } from "@oh-my-pi/pi-tui";
+import { formatBytes, formatDuration } from "@oh-my-pi/pi-utils";
+import { type CustomMessage, type FileMentionMessage, isSilentAbort, resolveAbortLabel } from "../../session/messages";
+import { createIrcMessageCard } from "../../tools/irc";
+import { canonicalizeMessage } from "../../utils/thinking-display";
+import { TranscriptBlock } from "../components/transcript-container";
+import { theme } from "../theme/theme";
+
+type CustomOrHookMessage = Extract<AgentMessage, { role: "custom" | "hookMessage" }>;
+type AssistantAgentMessage = Extract<AgentMessage, { role: "assistant" }>;
+
+/**
+ * Render an `async-result` custom message (a completed background bash/task job,
+ * or a batch of them) as a transcript block of one "Background job completed"
+ * row per job.
+ */
+export function buildAsyncResultBlock(message: CustomOrHookMessage): TranscriptBlock {
+	const details = (
+		message as CustomMessage<{
+			jobId?: string;
+			type?: "bash" | "task";
+			label?: string;
+			durationMs?: number;
+			jobs?: Array<{ jobId?: string; type?: "bash" | "task"; label?: string; durationMs?: number }>;
+		}>
+	).details;
+	const jobs =
+		details?.jobs && details.jobs.length > 0
+			? details.jobs
+			: [
+					{
+						jobId: details?.jobId,
+						type: details?.type,
+						label: details?.label,
+						durationMs: details?.durationMs,
+					},
+				];
+	const block = new TranscriptBlock();
+	for (const job of jobs) {
+		const jobId = job.jobId ?? "unknown";
+		const typeLabel = job.type ? `[${job.type}]` : "[job]";
+		const duration = typeof job.durationMs === "number" ? formatDuration(job.durationMs) : undefined;
+		const line = [
+			theme.fg("success", `${theme.status.done} Background job completed`),
+			theme.fg("dim", typeLabel),
+			theme.fg("accent", jobId),
+			duration ? theme.fg("dim", `(${duration})`) : undefined,
+		]
+			.filter(Boolean)
+			.join(" ");
+		block.addChild(new Text(line, 1, 0));
+	}
+	return block;
+}
+
+/**
+ * Render a live IRC traffic custom message (`irc:incoming` / `irc:autoreply` /
+ * `irc:relay`) as a transcript card. `getExpanded` supplies the live
+ * expanded-state getter for the cached card.
+ */
+export function buildIrcMessageCard(message: CustomOrHookMessage, getExpanded: () => boolean): Component {
+	const details = (
+		message as CustomMessage<{ from?: string; to?: string; message?: string; body?: string; replyTo?: string }>
+	).details;
+	const kind =
+		message.customType === "irc:incoming"
+			? ("incoming" as const)
+			: message.customType === "irc:autoreply"
+				? ("autoreply" as const)
+				: ("relay" as const);
+	return createIrcMessageCard(
+		{
+			kind,
+			from: details?.from,
+			to: details?.to,
+			body: kind === "incoming" ? details?.message : details?.body,
+			replyTo: details?.replyTo,
+			timestamp: message.timestamp,
+		},
+		getExpanded,
+		theme,
+	);
+}
+
+/**
+ * Render a `fileMention` message's files as a transcript block of "Read <path>"
+ * rows. `indent` sets the left pad: the live chat renders within an outer gutter
+ * (0), the transcript viewer renders body rows without one so rows own their pad
+ * (1).
+ */
+export function buildFileMentionBlock(files: FileMentionMessage["files"], indent: number): TranscriptBlock {
+	const block = new TranscriptBlock();
+	for (const file of files) {
+		let suffix: string;
+		if (file.skippedReason === "tooLarge") {
+			const size = typeof file.byteSize === "number" ? formatBytes(file.byteSize) : "unknown size";
+			suffix = `(skipped: ${size})`;
+		} else {
+			suffix = file.image
+				? "(image)"
+				: file.lineCount === undefined
+					? "(unknown lines)"
+					: `(${file.lineCount} lines)`;
+		}
+		const text = `${theme.fg("dim", `${theme.tree.last} `)}${theme.fg("muted", "Read")} ${theme.fg(
+			"accent",
+			file.path,
+		)} ${theme.fg("dim", suffix)}`;
+		block.addChild(new Text(text, indent, 0));
+	}
+	return block;
+}
+
+/**
+ * Whether an assistant turn has visible text or thinking content (after
+ * canonicalization) — i.e. content that closes the current read-tool run.
+ */
+export function assistantHasVisibleContent(message: AssistantAgentMessage): boolean {
+	return message.content.some(
+		content =>
+			(content.type === "text" && canonicalizeMessage(content.text)) ||
+			(content.type === "thinking" && canonicalizeMessage(content.thinking)),
+	);
+}
+
+/**
+ * Normalize raw tool-call arguments to a plain record, collapsing non-object or
+ * array values to an empty object.
+ */
+export function normalizeToolArgs(args: unknown): Record<string, unknown> {
+	return args && typeof args === "object" && !Array.isArray(args) ? (args as Record<string, unknown>) : {};
+}
+
+/**
+ * Resolve the inline error label, if any, for a turn-ending assistant message.
+ * Silent aborts yield no label. `retryAttempt` tunes the abort label wording.
+ */
+export function resolveAssistantErrorMessage(
+	message: AssistantAgentMessage,
+	retryAttempt = 0,
+): { hasErrorStop: boolean; errorMessage: string | null } {
+	const isAbortedSilently = message.stopReason === "aborted" && isSilentAbort(message.errorMessage);
+	const hasErrorStop = !isAbortedSilently && (message.stopReason === "aborted" || message.stopReason === "error");
+	const errorMessage = hasErrorStop
+		? message.stopReason === "aborted"
+			? resolveAbortLabel(message.errorMessage, retryAttempt)
+			: message.errorMessage || "Error"
+		: null;
+	return { hasErrorStop, errorMessage };
+}