@gajae-code/coding-agent 0.11.11 → 0.12.1

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

@@ -198,7 +198,10 @@ export function mapAgentSessionEventToAcpSessionUpdates(
 		}
 		case "tool_execution_end": {
 			const args = getToolExecutionEndArgs(event, options);
-			const resultContent = [...extractDiffToolCallContent(event.result), ...extractToolCallContent(event.result)];
+			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",
@@ -207,8 +210,9 @@ export function mapAgentSessionEventToAcpSessionUpdates(
 				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)}`;
-				update.kind = "other";
 			}
 			if (content.length > 0) {
 				update.content = content;
@@ -713,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 [];
@@ -721,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;
@@ -738,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 ?? "",
 	};
@@ -859,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/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", "gajae")), 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();
 	}
 }