@oh-my-pi/pi-coding-agent 13.14.0 → 13.15.2

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

@@ -0,0 +1,531 @@
+import type {
+	SessionNotification,
+	SessionUpdate,
+	ToolCallContent,
+	ToolCallLocation,
+	ToolKind,
+} from "@agentclientprotocol/sdk";
+import type { AgentSessionEvent } from "../../session/agent-session";
+import type { TodoStatus } from "../../tools/todo-write";
+
+interface ContentArrayContainer {
+	content?: unknown;
+}
+
+interface TypedValue {
+	type?: unknown;
+}
+
+interface TextLikeContent extends TypedValue {
+	text?: unknown;
+}
+
+interface BinaryLikeContent extends TypedValue {
+	data?: unknown;
+	mimeType?: unknown;
+}
+
+interface PathContainer {
+	path?: unknown;
+}
+
+interface OldPathContainer {
+	oldPath?: unknown;
+}
+
+interface NewPathContainer {
+	newPath?: unknown;
+}
+
+interface CommandContainer {
+	command?: unknown;
+}
+
+interface PatternContainer {
+	pattern?: unknown;
+}
+
+interface QueryContainer {
+	query?: unknown;
+}
+
+interface ErrorMessageContainer {
+	errorMessage?: unknown;
+}
+
+interface MessageContainer {
+	message?: unknown;
+}
+
+interface ResourceLinkLikeContent extends TypedValue {
+	uri?: unknown;
+	name?: unknown;
+	title?: unknown;
+	description?: unknown;
+	mimeType?: unknown;
+	size?: unknown;
+}
+
+interface BlobResourceLike {
+	uri?: unknown;
+	blob?: unknown;
+	mimeType?: unknown;
+}
+
+interface TextResourceLike {
+	uri?: unknown;
+	text?: unknown;
+	mimeType?: unknown;
+}
+
+interface EmbeddedResourceLikeContent extends TypedValue {
+	resource?: unknown;
+}
+
+interface TextMessageLike {
+	role?: unknown;
+}
+
+const ACP_TEXT_LIMIT = 4_000;
+
+export function mapToolKind(toolName: string): ToolKind {
+	switch (toolName) {
+		case "read":
+			return "read";
+		case "write":
+		case "edit":
+			return "edit";
+		case "delete":
+			return "delete";
+		case "move":
+			return "move";
+		case "bash":
+		case "python":
+			return "execute";
+		case "grep":
+		case "find":
+		case "ast_grep":
+			return "search";
+		case "fetch":
+		case "web_search":
+			return "fetch";
+		case "todo_write":
+			return "think";
+		default:
+			return "other";
+	}
+}
+
+export function mapAgentSessionEventToAcpSessionUpdates(
+	event: AgentSessionEvent,
+	sessionId: string,
+): SessionNotification[] {
+	switch (event.type) {
+		case "message_update":
+			return mapAssistantMessageUpdate(event, sessionId);
+		case "tool_execution_start": {
+			const update: SessionUpdate = {
+				sessionUpdate: "tool_call",
+				toolCallId: event.toolCallId,
+				title: buildToolTitle(event.toolName, event.args, event.intent),
+				kind: mapToolKind(event.toolName),
+				status: "pending",
+				rawInput: event.args,
+			};
+			const locations = extractToolLocations(event.args);
+			if (locations.length > 0) {
+				update.locations = locations;
+			}
+			return [toSessionNotification(sessionId, update)];
+		}
+		case "tool_execution_update": {
+			const content = extractToolCallContent(event.partialResult);
+			const update: SessionUpdate = {
+				sessionUpdate: "tool_call_update",
+				toolCallId: event.toolCallId,
+				status: "in_progress",
+				rawOutput: event.partialResult,
+			};
+			if (content.length > 0) {
+				update.content = content;
+			}
+			return [toSessionNotification(sessionId, update)];
+		}
+		case "tool_execution_end": {
+			const content = extractToolCallContent(event.result);
+			const update: SessionUpdate = {
+				sessionUpdate: "tool_call_update",
+				toolCallId: event.toolCallId,
+				status: event.isError ? "failed" : "completed",
+				rawOutput: event.result,
+			};
+			if (content.length > 0) {
+				update.content = content;
+			}
+			return [toSessionNotification(sessionId, update)];
+		}
+		case "todo_reminder": {
+			const entries = event.todos.map(todo => ({
+				content: todo.content,
+				priority: "medium" as const,
+				status: mapTodoStatus(todo.status),
+			}));
+			return [toSessionNotification(sessionId, { sessionUpdate: "plan", entries })];
+		}
+		case "todo_auto_clear":
+			return [toSessionNotification(sessionId, { sessionUpdate: "plan", entries: [] })];
+		default:
+			return [];
+	}
+}
+
+function mapAssistantMessageUpdate(
+	event: Extract<AgentSessionEvent, { type: "message_update" }>,
+	sessionId: string,
+): SessionNotification[] {
+	if (!isAssistantMessage(event.message)) {
+		return [];
+	}
+
+	let sessionUpdate: "agent_message_chunk" | "agent_thought_chunk";
+	let text: string;
+	switch (event.assistantMessageEvent.type) {
+		case "text_delta":
+			sessionUpdate = "agent_message_chunk";
+			text = event.assistantMessageEvent.delta;
+			break;
+		case "thinking_delta":
+			sessionUpdate = "agent_thought_chunk";
+			text = event.assistantMessageEvent.delta;
+			break;
+		case "error":
+			sessionUpdate = "agent_message_chunk";
+			text = event.assistantMessageEvent.error.errorMessage ?? "Unknown error";
+			break;
+		default:
+			return [];
+	}
+	if (text.length === 0) {
+		return [];
+	}
+
+	return [
+		toSessionNotification(sessionId, {
+			sessionUpdate,
+			content: { type: "text", text },
+		}),
+	];
+}
+
+function toSessionNotification(sessionId: string, update: SessionUpdate): SessionNotification {
+	return { sessionId, update };
+}
+
+const todoStatusMap: Record<TodoStatus, "pending" | "in_progress" | "completed"> = {
+	pending: "pending",
+	in_progress: "in_progress",
+	completed: "completed",
+	abandoned: "completed",
+};
+
+function mapTodoStatus(status: TodoStatus): "pending" | "in_progress" | "completed" {
+	return todoStatusMap[status];
+}
+
+function buildToolTitle(toolName: string, args: unknown, intent: string | undefined): string {
+	const trimmedIntent = intent?.trim();
+	if (trimmedIntent) {
+		return trimmedIntent;
+	}
+
+	const subject =
+		extractStringProperty<PathContainer>(args, "path") ??
+		extractStringProperty<CommandContainer>(args, "command") ??
+		extractStringProperty<PatternContainer>(args, "pattern") ??
+		extractStringProperty<QueryContainer>(args, "query");
+	if (subject) {
+		return `${toolName}: ${subject}`;
+	}
+
+	return toolName;
+}
+
+function extractToolLocations(args: unknown): ToolCallLocation[] {
+	const locations: ToolCallLocation[] = [];
+	const path = extractStringProperty<PathContainer>(args, "path");
+	if (path) {
+		locations.push({ path });
+	}
+
+	const oldPath = extractStringProperty<OldPathContainer>(args, "oldPath");
+	if (oldPath && oldPath !== path) {
+		locations.push({ path: oldPath });
+	}
+
+	const newPath = extractStringProperty<NewPathContainer>(args, "newPath");
+	if (newPath && newPath !== path && newPath !== oldPath) {
+		locations.push({ path: newPath });
+	}
+
+	return locations;
+}
+
+function extractToolCallContent(value: unknown): ToolCallContent[] {
+	const richContent = extractStructuredToolCallContent(value);
+	const fallbackText = extractReadableText(value);
+	if (!fallbackText) {
+		return richContent;
+	}
+	if (hasEquivalentTextContent(richContent, fallbackText)) {
+		return richContent;
+	}
+	return [...richContent, textToolCallContent(fallbackText)];
+}
+
+function extractStructuredToolCallContent(value: unknown): ToolCallContent[] {
+	const blocks = getContentBlocks(value);
+	if (!blocks) {
+		return [];
+	}
+
+	const content: ToolCallContent[] = [];
+	for (const block of blocks) {
+		const toolCallContent = toToolCallContent(block);
+		if (toolCallContent) {
+			content.push(toolCallContent);
+		}
+	}
+	return content;
+}
+
+function getContentBlocks(value: unknown): unknown[] | undefined {
+	if (Array.isArray(value)) {
+		return value;
+	}
+	if (typeof value !== "object" || value === null || !("content" in value)) {
+		return undefined;
+	}
+	const content = (value as ContentArrayContainer).content;
+	return Array.isArray(content) ? content : undefined;
+}
+
+function toToolCallContent(value: unknown): ToolCallContent | undefined {
+	const type = getContentType(value);
+	if (!type) {
+		return undefined;
+	}
+
+	switch (type) {
+		case "text": {
+			const text = extractStructuredText(value);
+			return text ? textToolCallContent(text) : undefined;
+		}
+		case "image":
+		case "audio": {
+			const data = extractStringProperty<BinaryLikeContent>(value, "data");
+			const mimeType = extractStringProperty<BinaryLikeContent>(value, "mimeType");
+			if (!data || !mimeType) {
+				return undefined;
+			}
+			return {
+				type: "content",
+				content: {
+					type,
+					data,
+					mimeType,
+				},
+			};
+		}
+		case "resource_link": {
+			const uri = extractStringProperty<ResourceLinkLikeContent>(value, "uri");
+			const name = extractStringProperty<ResourceLinkLikeContent>(value, "name");
+			if (!uri || !name) {
+				return undefined;
+			}
+			const resourceLinkContent: {
+				type: "resource_link";
+				uri: string;
+				name: string;
+				title?: string;
+				description?: string;
+				mimeType?: string;
+				size?: number;
+			} = {
+				type: "resource_link",
+				uri,
+				name,
+			};
+			const title = extractStringProperty<ResourceLinkLikeContent>(value, "title");
+			if (title) {
+				resourceLinkContent.title = title;
+			}
+			const description = extractStringProperty<ResourceLinkLikeContent>(value, "description");
+			if (description) {
+				resourceLinkContent.description = description;
+			}
+			const mimeType = extractStringProperty<ResourceLinkLikeContent>(value, "mimeType");
+			if (mimeType) {
+				resourceLinkContent.mimeType = mimeType;
+			}
+			const size = extractNumberProperty<ResourceLinkLikeContent>(value, "size");
+			if (size !== undefined) {
+				resourceLinkContent.size = size;
+			}
+			return {
+				type: "content",
+				content: resourceLinkContent,
+			};
+		}
+		case "resource": {
+			const resource = extractEmbeddedResource(value);
+			return resource
+				? {
+						type: "content",
+						content: {
+							type: "resource",
+							resource,
+						},
+					}
+				: undefined;
+		}
+		default:
+			return undefined;
+	}
+}
+
+function extractEmbeddedResource(
+	value: unknown,
+): { uri: string; text: string; mimeType?: string } | { uri: string; blob: string; mimeType?: string } | undefined {
+	if (typeof value !== "object" || value === null || !("resource" in value)) {
+		return undefined;
+	}
+
+	const resource = (value as EmbeddedResourceLikeContent).resource;
+	if (typeof resource !== "object" || resource === null) {
+		return undefined;
+	}
+
+	const uri = extractStringProperty<TextResourceLike>(resource, "uri");
+	if (!uri) {
+		return undefined;
+	}
+
+	const text = extractStringProperty<TextResourceLike>(resource, "text");
+	if (text) {
+		const mimeType = extractStringProperty<TextResourceLike>(resource, "mimeType");
+		return mimeType ? { uri, text, mimeType } : { uri, text };
+	}
+
+	const blob = extractStringProperty<BlobResourceLike>(resource, "blob");
+	if (!blob) {
+		return undefined;
+	}
+	const mimeType = extractStringProperty<BlobResourceLike>(resource, "mimeType");
+	return mimeType ? { uri, blob, mimeType } : { uri, blob };
+}
+
+function textToolCallContent(text: string): ToolCallContent {
+	return {
+		type: "content",
+		content: {
+			type: "text",
+			text,
+		},
+	};
+}
+
+function hasEquivalentTextContent(content: ToolCallContent[], text: string): boolean {
+	return content.some(item => item.type === "content" && item.content.type === "text" && item.content.text === text);
+}
+
+function extractReadableText(value: unknown): string | undefined {
+	if (typeof value === "string") {
+		return normalizeText(value);
+	}
+	if (value instanceof Error) {
+		return normalizeText(value.message);
+	}
+	if (typeof value !== "object" || value === null) {
+		return undefined;
+	}
+
+	const directText =
+		extractStringProperty<TextLikeContent>(value, "text") ??
+		extractStringProperty<ErrorMessageContainer>(value, "errorMessage") ??
+		extractStringProperty<MessageContainer>(value, "message");
+	if (directText) {
+		return normalizeText(directText);
+	}
+
+	const contentBlocks = getContentBlocks(value);
+	if (contentBlocks) {
+		const text = contentBlocks
+			.map(block => extractStructuredText(block))
+			.filter((chunk): chunk is string => typeof chunk === "string" && chunk.length > 0)
+			.join("\n");
+		if (text.length > 0) {
+			return normalizeText(text);
+		}
+	}
+
+	const serialized = safeJsonStringify(value);
+	return normalizeText(serialized);
+}
+
+function extractStructuredText(value: unknown): string | undefined {
+	const text = extractStringProperty<TextLikeContent>(value, "text");
+	if (!text) {
+		return undefined;
+	}
+	return limitText(text);
+}
+
+function getContentType(value: unknown): string | undefined {
+	if (typeof value !== "object" || value === null || !("type" in value)) {
+		return undefined;
+	}
+	const type = (value as TypedValue).type;
+	return typeof type === "string" ? type : undefined;
+}
+
+function extractStringProperty<T extends object>(value: unknown, key: keyof T): string | undefined {
+	if (typeof value !== "object" || value === null || !(key in value)) {
+		return undefined;
+	}
+	const property = (value as T)[key];
+	return typeof property === "string" && property.length > 0 ? property : undefined;
+}
+
+function extractNumberProperty<T extends object>(value: unknown, key: keyof T): number | undefined {
+	if (typeof value !== "object" || value === null || !(key in value)) {
+		return undefined;
+	}
+	const property = (value as T)[key];
+	return typeof property === "number" && Number.isFinite(property) ? property : undefined;
+}
+
+function isAssistantMessage(value: unknown): boolean {
+	return (
+		typeof value === "object" && value !== null && "role" in value && (value as TextMessageLike).role === "assistant"
+	);
+}
+
+function normalizeText(text: string | undefined): string | undefined {
+	if (!text) {
+		return undefined;
+	}
+	const normalized = text.trim();
+	return normalized.length > 0 ? limitText(normalized) : undefined;
+}
+
+function limitText(text: string): string {
+	return text.length > ACP_TEXT_LIMIT ? `${text.slice(0, ACP_TEXT_LIMIT - 1)}…` : text;
+}
+
+function safeJsonStringify(value: unknown): string | undefined {
+	try {
+		return JSON.stringify(value);
+	} catch {
+		return undefined;
+	}
+}

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

@@ -0,0 +1,13 @@
+import * as stream from "node:stream";
+import { AgentSideConnection, ndJsonStream } from "@agentclientprotocol/sdk";
+import type { AgentSession } from "../../session/agent-session";
+import { AcpAgent } from "./acp-agent";
+
+export async function runAcpMode(session: AgentSession): Promise<never> {
+	const input = stream.Writable.toWeb(process.stdout);
+	const output = stream.Readable.toWeb(process.stdin);
+	const transport = ndJsonStream(input, output);
+	const connection = new AgentSideConnection(conn => new AcpAgent(conn, session), transport);
+	await connection.closed;
+	process.exit(0);
+}

package/src/modes/acp/index.ts

@@ -0,0 +1,2 @@
+export * from "./acp-agent";
+export * from "./acp-mode";

package/src/modes/components/agent-dashboard.ts

@@ -50,6 +50,7 @@ import { discoverAgents } from "../../task/discovery";
 import type { AgentDefinition, AgentSource } from "../../task/types";
 import { shortenPath } from "../../tools/render-utils";
 import { theme } from "../theme/theme";
+import { matchesAppInterrupt } from "../utils/keybinding-matchers";
 import { DynamicBorder } from "./dynamic-border";
 
 type SourceTabId = "all" | AgentSource;
@@ -993,7 +994,7 @@ export class AgentDashboard extends Container {
 		}
 
 		if (this.#createSpec) {
-			if (matchesKey(data, "escape") || matchesKey(data, "esc")) {
+			if (matchesAppInterrupt(data)) {
 				this.#clearCreateFlow();
 				this.#buildLayout();
 				return;
@@ -1017,7 +1018,7 @@ export class AgentDashboard extends Container {
 		}
 
 		if (this.#createInput || this.#createGenerating) {
-			if (matchesKey(data, "escape") || matchesKey(data, "esc")) {
+			if (matchesAppInterrupt(data)) {
 				if (!this.#createGenerating) {
 					this.#clearCreateFlow();
 					this.#buildLayout();
@@ -1037,7 +1038,7 @@ export class AgentDashboard extends Container {
 		}
 
 		if (this.#editInput) {
-			if (matchesKey(data, "escape") || matchesKey(data, "esc")) {
+			if (matchesAppInterrupt(data)) {
 				this.#cancelModelEdit();
 				return;
 			}
@@ -1048,7 +1049,7 @@ export class AgentDashboard extends Container {
 			return;
 		}
 
-		if (matchesKey(data, "escape") || matchesKey(data, "esc")) {
+		if (matchesAppInterrupt(data)) {
 			if (this.#searchQuery.length > 0) {
 				this.#searchQuery = "";
 				this.#applyFilters();

package/src/modes/components/bash-execution.ts

@@ -6,13 +6,17 @@ import { sanitizeText } from "@oh-my-pi/pi-natives";
 import { Container, ImageProtocol, Loader, Spacer, TERMINAL, Text, type TUI } from "@oh-my-pi/pi-tui";
 import { getSymbolTheme, theme } from "../../modes/theme/theme";
 import { formatTruncationMetaNotice, type TruncationMeta } from "../../tools/output-meta";
-import { getSixelLineMask, sanitizeWithOptionalSixelPassthrough } from "../../utils/sixel";
+import { getSixelLineMask, isSixelPassthroughEnabled, sanitizeWithOptionalSixelPassthrough } from "../../utils/sixel";
 import { DynamicBorder } from "./dynamic-border";
 import { truncateToVisualLines } from "./visual-truncate";
 
 // Preview line limit when not expanded (matches tool execution behavior)
 const PREVIEW_LINES = 20;
+const STREAMING_LINE_CAP = PREVIEW_LINES * 5;
 const MAX_DISPLAY_LINE_CHARS = 4000;
+// Minimum interval between processing incoming chunks for display (ms).
+// Chunks arriving faster than this are accumulated and processed in one batch.
+const CHUNK_THROTTLE_MS = 50;
 
 export class BashExecutionComponent extends Container {
 	#outputLines: string[] = [];
@@ -21,7 +25,10 @@ export class BashExecutionComponent extends Container {
 	#loader: Loader;
 	#truncation?: TruncationMeta;
 	#expanded = false;
+	#displayDirty = false;
+	#chunkGate = false;
 	#contentContainer: Container;
+	#headerText: Text;
 
 	constructor(
 		private readonly command: string,
@@ -45,8 +52,8 @@ export class BashExecutionComponent extends Container {
 		this.addChild(this.#contentContainer);
 
 		// Command header
-		const header = new Text(theme.fg(colorKey, theme.bold(`$ ${command}`)), 1, 0);
-		this.#contentContainer.addChild(header);
+		this.#headerText = new Text(theme.fg(colorKey, theme.bold(`$ ${command}`)), 1, 0);
+		this.#contentContainer.addChild(this.#headerText);
 
 		// Loader
 		this.#loader = new Loader(
@@ -72,14 +79,22 @@ export class BashExecutionComponent extends Container {
 
 	override invalidate(): void {
 		super.invalidate();
+		this.#displayDirty = false;
 		this.#updateDisplay();
 	}
 
 	appendOutput(chunk: string): void {
-		const clean = sanitizeWithOptionalSixelPassthrough(chunk, sanitizeText);
-
-		// Append to output lines
-		const incomingLines = clean.split("\n");
+		// During high-throughput output (e.g. seq 1 500M), processing every
+		// chunk would saturate the event loop. Instead, accept one chunk per
+		// throttle window and drop the rest — the OutputSink captures everything
+		// for the artifact, and setComplete() replaces with the final output.
+		if (this.#chunkGate) return;
+		this.#chunkGate = true;
+		setTimeout(() => {
+			this.#chunkGate = false;
+		}, CHUNK_THROTTLE_MS);
+
+		const incomingLines = chunk.split("\n");
 		if (this.#outputLines.length > 0 && incomingLines.length > 0) {
 			const lastIndex = this.#outputLines.length - 1;
 			const mergedLines = [`${this.#outputLines[lastIndex]}${incomingLines[0]}`, ...incomingLines.slice(1)];
@@ -90,7 +105,12 @@ export class BashExecutionComponent extends Container {
 			this.#outputLines.push(...this.#clampLinesPreservingSixel(incomingLines));
 		}
 
-		this.#updateDisplay();
+		// Cap stored lines during streaming to avoid unbounded memory growth
+		if (this.#outputLines.length > STREAMING_LINE_CAP) {
+			this.#outputLines = this.#outputLines.slice(-STREAMING_LINE_CAP);
+		}
+
+		this.#displayDirty = true;
 	}
 
 	setComplete(
@@ -115,6 +135,14 @@ export class BashExecutionComponent extends Container {
 		this.#updateDisplay();
 	}
 
+	override render(width: number): string[] {
+		if (this.#displayDirty) {
+			this.#displayDirty = false;
+			this.#updateDisplay();
+		}
+		return super.render(width);
+	}
+
 	#updateDisplay(): void {
 		const availableLines = this.#outputLines;
 
@@ -122,15 +150,16 @@ export class BashExecutionComponent extends Container {
 		const previewLogicalLines = availableLines.slice(-PREVIEW_LINES);
 		const hiddenLineCount = availableLines.length - previewLogicalLines.length;
 		const sixelLineMask =
-			TERMINAL.imageProtocol === ImageProtocol.Sixel ? getSixelLineMask(availableLines) : undefined;
+			TERMINAL.imageProtocol === ImageProtocol.Sixel && isSixelPassthroughEnabled()
+				? getSixelLineMask(availableLines)
+				: undefined;
 		const hasSixelOutput = sixelLineMask?.some(Boolean) ?? false;
 
 		// Rebuild content container
 		this.#contentContainer.clear();
 
 		// Command header
-		const header = new Text(theme.fg("bashMode", theme.bold(`$ ${this.command}`)), 1, 0);
-		this.#contentContainer.addChild(header);
+		this.#contentContainer.addChild(this.#headerText);
 
 		// Output
 		if (availableLines.length > 0) {