@oh-my-pi/pi-coding-agent 13.3.10 → 13.3.13

package/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 ## [Unreleased]
 
+## [13.3.11] - 2026-02-28
+
+### Fixed
+
+- Restored inline rendering for `read` tool image results in assistant transcript components, including streaming and rebuilt session history paths.
+- Fixed shell-escaped read paths (for example, pasted `\ `-escaped screenshot filenames) by resolving unescaped fallback candidates before macOS filename normalization variants.
+
 ## [13.3.8] - 2026-02-28
 
 ### Added

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "13.3.10",
+	"version": "13.3.13",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://github.com/can1357/oh-my-pi",
 	"author": "Can Boluk",
@@ -41,12 +41,12 @@
 	},
 	"dependencies": {
 		"@mozilla/readability": "^0.6",
-		"@oh-my-pi/omp-stats": "13.3.10",
-		"@oh-my-pi/pi-agent-core": "13.3.10",
-		"@oh-my-pi/pi-ai": "13.3.10",
-		"@oh-my-pi/pi-natives": "13.3.10",
-		"@oh-my-pi/pi-tui": "13.3.10",
-		"@oh-my-pi/pi-utils": "13.3.10",
+		"@oh-my-pi/omp-stats": "13.3.13",
+		"@oh-my-pi/pi-agent-core": "13.3.13",
+		"@oh-my-pi/pi-ai": "13.3.13",
+		"@oh-my-pi/pi-natives": "13.3.13",
+		"@oh-my-pi/pi-tui": "13.3.13",
+		"@oh-my-pi/pi-utils": "13.3.13",
 		"@sinclair/typebox": "^0.34",
 		"@xterm/headless": "^6.0",
 		"ajv": "^8.18",

package/src/ipy/gateway-coordinator.ts

@@ -110,7 +110,7 @@ async function withGatewayLock<T>(handler: () => Promise<T>): Promise<T> {
 	while (true) {
 		let fd: fs.promises.FileHandle | undefined;
 		try {
-			fd = await fs.promises.open(lockPath, fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_EXCL);
+			fd = await fs.promises.open(lockPath, "wx");
 			let heartbeatRunning = true;
 			const heartbeat = (async () => {
 				while (heartbeatRunning) {

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

@@ -1,5 +1,5 @@
-import type { AssistantMessage } from "@oh-my-pi/pi-ai";
-import { Container, Markdown, Spacer, TERMINAL, Text } from "@oh-my-pi/pi-tui";
+import type { AssistantMessage, ImageContent } from "@oh-my-pi/pi-ai";
+import { Container, Image, ImageProtocol, Markdown, Spacer, TERMINAL, Text } from "@oh-my-pi/pi-tui";
 import { logger } from "@oh-my-pi/pi-utils";
 import { hasPendingMermaid, prerenderMermaid } from "../../modes/theme/mermaid-cache";
 import { getMarkdownTheme, theme } from "../../modes/theme/theme";
@@ -11,6 +11,7 @@ export class AssistantMessageComponent extends Container {
 	#contentContainer: Container;
 	#lastMessage?: AssistantMessage;
 	#prerenderInFlight = false;
+	#toolImagesByCallId = new Map<string, ImageContent[]>();
 
 	constructor(
 		message?: AssistantMessage,
@@ -38,6 +39,42 @@ export class AssistantMessageComponent extends Container {
 		this.hideThinkingBlock = hide;
 	}
 
+	setToolResultImages(toolCallId: string, images: ImageContent[]): void {
+		if (!toolCallId) return;
+		const validImages = images.filter(img => img.type === "image" && img.data && img.mimeType);
+		if (validImages.length === 0) {
+			this.#toolImagesByCallId.delete(toolCallId);
+		} else {
+			this.#toolImagesByCallId.set(toolCallId, validImages);
+		}
+		if (this.#lastMessage) {
+			this.updateContent(this.#lastMessage);
+		}
+	}
+
+	#renderToolImages(): void {
+		const images = Array.from(this.#toolImagesByCallId.values()).flat();
+		if (images.length === 0) return;
+
+		this.#contentContainer.addChild(new Spacer(1));
+		for (const image of images) {
+			if (
+				TERMINAL.imageProtocol &&
+				(TERMINAL.imageProtocol !== ImageProtocol.Kitty || image.mimeType === "image/png")
+			) {
+				this.#contentContainer.addChild(
+					new Image(
+						image.data,
+						image.mimeType,
+						{ fallbackColor: (text: string) => theme.fg("toolOutput", text) },
+						{ maxWidthCells: 60 },
+					),
+				);
+				continue;
+			}
+			this.#contentContainer.addChild(new Text(theme.fg("toolOutput", `[Image: ${image.mimeType}]`), 1, 0));
+		}
+	}
 	#triggerMermaidPrerender(message: AssistantMessage): void {
 		if (!TERMINAL.imageProtocol || this.#prerenderInFlight) return;
 
@@ -119,6 +156,7 @@ export class AssistantMessageComponent extends Container {
 			}
 		}
 
+		this.#renderToolImages();
 		// Check if aborted - show after partial content
 		// But only if there are no tool calls (tool execution components will show the error)
 		const hasToolCalls = message.content.some(c => c.type === "toolCall");

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

@@ -1,4 +1,5 @@
 import { INTENT_FIELD } from "@oh-my-pi/pi-agent-core";
+import type { ImageContent } from "@oh-my-pi/pi-ai";
 import { Loader, TERMINAL, Text } from "@oh-my-pi/pi-tui";
 import { settings } from "../../config/settings";
 import { AssistantMessageComponent } from "../../modes/components/assistant-message";
@@ -17,7 +18,9 @@ export class EventController {
 	#renderedCustomMessages = new Set<string>();
 	#lastIntent: string | undefined = undefined;
 	#backgroundToolCallIds = new Set<string>();
-
+	#readToolCallArgs = new Map<string, Record<string, unknown>>();
+	#readToolCallAssistantComponents = new Map<string, AssistantMessageComponent>();
+	#lastAssistantComponent: AssistantMessageComponent | undefined = undefined;
 	constructor(private ctx: InteractiveModeContext) {}
 
 	#resetReadGroup(): void {
@@ -35,6 +38,39 @@ export class EventController {
 		return this.#lastReadGroup;
 	}
 
+	#trackReadToolCall(toolCallId: string, args: unknown): void {
+		if (!toolCallId) return;
+		const normalizedArgs =
+			args && typeof args === "object" && !Array.isArray(args) ? (args as Record<string, unknown>) : {};
+		this.#readToolCallArgs.set(toolCallId, normalizedArgs);
+		const assistantComponent = this.ctx.streamingComponent ?? this.#lastAssistantComponent;
+		if (assistantComponent) {
+			this.#readToolCallAssistantComponents.set(toolCallId, assistantComponent);
+		}
+	}
+
+	#clearReadToolCall(toolCallId: string): void {
+		this.#readToolCallArgs.delete(toolCallId);
+		this.#readToolCallAssistantComponents.delete(toolCallId);
+	}
+
+	#inlineReadToolImages(
+		toolCallId: string,
+		result: { content: Array<{ type: string; data?: string; mimeType?: string }> },
+	): boolean {
+		if (!settings.get("terminal.showImages")) return false;
+		const assistantComponent = this.#readToolCallAssistantComponents.get(toolCallId);
+		if (!assistantComponent) return false;
+		const images: ImageContent[] = result.content
+			.filter(
+				(content): content is ImageContent =>
+					content.type === "image" && typeof content.data === "string" && typeof content.mimeType === "string",
+			)
+			.map(content => ({ type: "image", data: content.data, mimeType: content.mimeType }));
+		if (images.length === 0) return false;
+		assistantComponent.setToolResultImages(toolCallId, images);
+		return true;
+	}
 	#updateWorkingMessageFromIntent(intent: string | undefined): void {
 		const trimmed = intent?.trim();
 		if (!trimmed || trimmed === this.#lastIntent) return;
@@ -59,6 +95,9 @@ export class EventController {
 		switch (event.type) {
 			case "agent_start":
 				this.#lastIntent = undefined;
+				this.#readToolCallArgs.clear();
+				this.#readToolCallAssistantComponents.clear();
+				this.#lastAssistantComponent = undefined;
 				if (this.ctx.retryEscapeHandler) {
 					this.ctx.editor.onEscape = this.ctx.retryEscapeHandler;
 					this.ctx.retryEscapeHandler = undefined;
@@ -132,15 +171,20 @@ export class EventController {
 
 					for (const content of this.ctx.streamingMessage.content) {
 						if (content.type !== "toolCall") continue;
-
-						if (!this.ctx.pendingTools.has(content.id)) {
-							if (content.name === "read") {
+						if (content.name === "read") {
+							this.#trackReadToolCall(content.id, content.arguments);
+							const component = this.ctx.pendingTools.get(content.id);
+							if (component) {
+								component.updateArgs(content.arguments, content.id);
+							} else {
 								const group = this.#getReadGroup();
 								group.updateArgs(content.arguments, content.id);
 								this.ctx.pendingTools.set(content.id, group);
-								continue;
 							}
+							continue;
+						}
 
+						if (!this.ctx.pendingTools.has(content.id)) {
 							this.#resetReadGroup();
 							this.ctx.chatContainer.addChild(new Text("", 0, 0));
 							const tool = this.ctx.session.getToolByName(content.name);
@@ -207,6 +251,7 @@ export class EventController {
 							component.setArgsComplete(toolCallId);
 						}
 					}
+					this.#lastAssistantComponent = this.ctx.streamingComponent;
 					this.ctx.streamingComponent = undefined;
 					this.ctx.streamingMessage = undefined;
 					this.ctx.statusLine.invalidate();
@@ -219,9 +264,15 @@ export class EventController {
 				this.#updateWorkingMessageFromIntent(event.intent);
 				if (!this.ctx.pendingTools.has(event.toolCallId)) {
 					if (event.toolName === "read") {
-						const group = this.#getReadGroup();
-						group.updateArgs(event.args, event.toolCallId);
-						this.ctx.pendingTools.set(event.toolCallId, group);
+						this.#trackReadToolCall(event.toolCallId, event.args);
+						const component = this.ctx.pendingTools.get(event.toolCallId);
+						if (component) {
+							component.updateArgs(event.args, event.toolCallId);
+						} else {
+							const group = this.#getReadGroup();
+							group.updateArgs(event.args, event.toolCallId);
+							this.ctx.pendingTools.set(event.toolCallId, group);
+						}
 						this.ctx.ui.requestRender();
 						break;
 					}
@@ -269,22 +320,66 @@ export class EventController {
 			}
 
 			case "tool_execution_end": {
-				const component = this.ctx.pendingTools.get(event.toolCallId);
-				if (component) {
-					const asyncState = (event.result.details as { async?: { state?: string } } | undefined)?.async?.state;
-					const isBackgroundRunning = asyncState === "running";
-					component.updateResult(
-						{ ...event.result, isError: event.isError },
-						isBackgroundRunning,
-						event.toolCallId,
-					);
-					if (isBackgroundRunning) {
-						this.#backgroundToolCallIds.add(event.toolCallId);
+				if (event.toolName === "read") {
+					if (this.#inlineReadToolImages(event.toolCallId, event.result)) {
+						const component = this.ctx.pendingTools.get(event.toolCallId);
+						if (component) {
+							component.updateResult({ ...event.result, isError: event.isError }, false, event.toolCallId);
+							this.ctx.pendingTools.delete(event.toolCallId);
+						}
+						const asyncState = (event.result.details as { async?: { state?: string } } | undefined)?.async?.state;
+						if (asyncState === "running") {
+							this.#backgroundToolCallIds.add(event.toolCallId);
+						} else {
+							this.#backgroundToolCallIds.delete(event.toolCallId);
+							this.#clearReadToolCall(event.toolCallId);
+						}
+						this.ctx.ui.requestRender();
 					} else {
-						this.ctx.pendingTools.delete(event.toolCallId);
-						this.#backgroundToolCallIds.delete(event.toolCallId);
+						let component = this.ctx.pendingTools.get(event.toolCallId);
+						if (!component) {
+							const group = this.#getReadGroup();
+							const args = this.#readToolCallArgs.get(event.toolCallId);
+							if (args) {
+								group.updateArgs(args, event.toolCallId);
+							}
+							component = group;
+							this.ctx.pendingTools.set(event.toolCallId, group);
+						}
+						const asyncState = (event.result.details as { async?: { state?: string } } | undefined)?.async?.state;
+						const isBackgroundRunning = asyncState === "running";
+						component.updateResult(
+							{ ...event.result, isError: event.isError },
+							isBackgroundRunning,
+							event.toolCallId,
+						);
+						if (isBackgroundRunning) {
+							this.#backgroundToolCallIds.add(event.toolCallId);
+						} else {
+							this.ctx.pendingTools.delete(event.toolCallId);
+							this.#backgroundToolCallIds.delete(event.toolCallId);
+							this.#clearReadToolCall(event.toolCallId);
+						}
+						this.ctx.ui.requestRender();
+					}
+				} else {
+					const component = this.ctx.pendingTools.get(event.toolCallId);
+					if (component) {
+						const asyncState = (event.result.details as { async?: { state?: string } } | undefined)?.async?.state;
+						const isBackgroundRunning = asyncState === "running";
+						component.updateResult(
+							{ ...event.result, isError: event.isError },
+							isBackgroundRunning,
+							event.toolCallId,
+						);
+						if (isBackgroundRunning) {
+							this.#backgroundToolCallIds.add(event.toolCallId);
+						} else {
+							this.ctx.pendingTools.delete(event.toolCallId);
+							this.#backgroundToolCallIds.delete(event.toolCallId);
+						}
+						this.ctx.ui.requestRender();
 					}
-					this.ctx.ui.requestRender();
 				}
 				// Update todo display when todo_write tool completes
 				if (event.toolName === "todo_write" && !event.isError) {
@@ -329,6 +424,9 @@ export class EventController {
 				this.#backgroundToolCallIds = new Set(
 					Array.from(this.#backgroundToolCallIds).filter(toolCallId => this.ctx.pendingTools.has(toolCallId)),
 				);
+				this.#readToolCallArgs.clear();
+				this.#readToolCallAssistantComponents.clear();
+				this.#lastAssistantComponent = undefined;
 				this.ctx.ui.requestRender();
 				this.sendCompletionNotification();
 				break;

package/src/modes/utils/ui-helpers.ts

@@ -1,5 +1,5 @@
 import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
-import type { AssistantMessage, Message } from "@oh-my-pi/pi-ai";
+import type { AssistantMessage, ImageContent, Message } from "@oh-my-pi/pi-ai";
 import { Spacer, Text, TruncatedText } from "@oh-my-pi/pi-tui";
 import { settings } from "../../config/settings";
 import { AssistantMessageComponent } from "../../modes/components/assistant-message";
@@ -217,10 +217,14 @@ export class UiHelpers {
 		}
 
 		let readGroup: ReadToolGroupComponent | null = null;
+		const readToolCallArgs = new Map<string, Record<string, unknown>>();
+		const readToolCallAssistantComponents = new Map<string, AssistantMessageComponent>();
 		for (const message of sessionContext.messages) {
 			// Assistant messages need special handling for tool calls
 			if (message.role === "assistant") {
 				this.ctx.addMessageToChat(message);
+				const lastChild = this.ctx.chatContainer.children[this.ctx.chatContainer.children.length - 1];
+				const assistantComponent = lastChild instanceof AssistantMessageComponent ? lastChild : undefined;
 				readGroup = null;
 				const hasErrorStop = message.stopReason === "aborted" || message.stopReason === "error";
 				const errorMessage = hasErrorStop
@@ -241,20 +245,27 @@ export class UiHelpers {
 					}
 
 					if (content.name === "read") {
-						if (!readGroup) {
-							readGroup = new ReadToolGroupComponent();
-							readGroup.setExpanded(this.ctx.toolOutputExpanded);
-							this.ctx.chatContainer.addChild(readGroup);
-						}
-						readGroup.updateArgs(content.arguments, content.id);
 						if (hasErrorStop && errorMessage) {
+							if (!readGroup) {
+								readGroup = new ReadToolGroupComponent();
+								readGroup.setExpanded(this.ctx.toolOutputExpanded);
+								this.ctx.chatContainer.addChild(readGroup);
+							}
+							readGroup.updateArgs(content.arguments, content.id);
 							readGroup.updateResult(
 								{ content: [{ type: "text", text: errorMessage }], isError: true },
 								false,
 								content.id,
 							);
 						} else {
-							this.ctx.pendingTools.set(content.id, readGroup);
+							const normalizedArgs =
+								content.arguments && typeof content.arguments === "object" && !Array.isArray(content.arguments)
+									? (content.arguments as Record<string, unknown>)
+									: {};
+							readToolCallArgs.set(content.id, normalizedArgs);
+							if (assistantComponent) {
+								readToolCallAssistantComponents.set(content.id, assistantComponent);
+							}
 						}
 						continue;
 					}
@@ -287,6 +298,41 @@ export class UiHelpers {
 					}
 				}
 			} else if (message.role === "toolResult") {
+				if (message.toolName === "read") {
+					const assistantComponent = readToolCallAssistantComponents.get(message.toolCallId);
+					const images: ImageContent[] = message.content.filter(
+						(content): content is ImageContent => content.type === "image",
+					);
+					if (images.length > 0 && assistantComponent && settings.get("terminal.showImages")) {
+						assistantComponent.setToolResultImages(message.toolCallId, images);
+						const hasText = message.content.some(c => c.type === "text");
+						if (!hasText) {
+							readToolCallArgs.delete(message.toolCallId);
+							readToolCallAssistantComponents.delete(message.toolCallId);
+							continue;
+						}
+					}
+					let component = this.ctx.pendingTools.get(message.toolCallId);
+					if (!component) {
+						if (!readGroup) {
+							readGroup = new ReadToolGroupComponent();
+							readGroup.setExpanded(this.ctx.toolOutputExpanded);
+							this.ctx.chatContainer.addChild(readGroup);
+						}
+						const args = readToolCallArgs.get(message.toolCallId);
+						if (args) {
+							readGroup.updateArgs(args, message.toolCallId);
+						}
+						component = readGroup;
+						this.ctx.pendingTools.set(message.toolCallId, readGroup);
+					}
+					component.updateResult(message, false, message.toolCallId);
+					this.ctx.pendingTools.delete(message.toolCallId);
+					readToolCallArgs.delete(message.toolCallId);
+					readToolCallAssistantComponents.delete(message.toolCallId);
+					continue;
+				}
+
 				// Match tool results to pending tool components
 				const component = this.ctx.pendingTools.get(message.toolCallId);
 				if (component) {

package/src/tools/path-utils.ts

@@ -24,6 +24,11 @@ function tryCurlyQuoteVariant(filePath: string): string {
 	return filePath.replace(/'/g, "\u2019");
 }
 
+function tryShellEscapedPath(filePath: string): string {
+	if (!filePath.includes("\\") || !filePath.includes("/")) return filePath;
+	return filePath.replace(/\\([ \t"'(){}[\]])/g, "$1");
+}
+
 function fileExists(filePath: string): boolean {
 	try {
 		fs.accessSync(filePath, fs.constants.F_OK);
@@ -124,33 +129,39 @@ export function parseSearchPath(filePath: string): ParsedSearchPath {
 
 export function resolveReadPath(filePath: string, cwd: string): string {
 	const resolved = resolveToCwd(filePath, cwd);
+	const shellEscapedVariant = tryShellEscapedPath(resolved);
+	const baseCandidates = shellEscapedVariant !== resolved ? [resolved, shellEscapedVariant] : [resolved];
 
-	if (fileExists(resolved)) {
-		return resolved;
-	}
-
-	// Try macOS AM/PM variant (narrow no-break space before AM/PM)
-	const amPmVariant = tryMacOSScreenshotPath(resolved);
-	if (amPmVariant !== resolved && fileExists(amPmVariant)) {
-		return amPmVariant;
-	}
-
-	// Try NFD variant (macOS stores filenames in NFD form)
-	const nfdVariant = tryNFDVariant(resolved);
-	if (nfdVariant !== resolved && fileExists(nfdVariant)) {
-		return nfdVariant;
-	}
-
-	// Try curly quote variant (macOS uses U+2019 in screenshot names)
-	const curlyVariant = tryCurlyQuoteVariant(resolved);
-	if (curlyVariant !== resolved && fileExists(curlyVariant)) {
-		return curlyVariant;
+	for (const baseCandidate of baseCandidates) {
+		if (fileExists(baseCandidate)) {
+			return baseCandidate;
+		}
 	}
 
-	// Try combined NFD + curly quote (for French macOS screenshots like "Capture d'écran")
-	const nfdCurlyVariant = tryCurlyQuoteVariant(nfdVariant);
-	if (nfdCurlyVariant !== resolved && fileExists(nfdCurlyVariant)) {
-		return nfdCurlyVariant;
+	for (const baseCandidate of baseCandidates) {
+		// Try macOS AM/PM variant (narrow no-break space before AM/PM)
+		const amPmVariant = tryMacOSScreenshotPath(baseCandidate);
+		if (amPmVariant !== baseCandidate && fileExists(amPmVariant)) {
+			return amPmVariant;
+		}
+
+		// Try NFD variant (macOS stores filenames in NFD form)
+		const nfdVariant = tryNFDVariant(baseCandidate);
+		if (nfdVariant !== baseCandidate && fileExists(nfdVariant)) {
+			return nfdVariant;
+		}
+
+		// Try curly quote variant (macOS uses U+2019 in screenshot names)
+		const curlyVariant = tryCurlyQuoteVariant(baseCandidate);
+		if (curlyVariant !== baseCandidate && fileExists(curlyVariant)) {
+			return curlyVariant;
+		}
+
+		// Try combined NFD + curly quote (for French macOS screenshots like "Capture d'écran")
+		const nfdCurlyVariant = tryCurlyQuoteVariant(nfdVariant);
+		if (nfdCurlyVariant !== baseCandidate && fileExists(nfdCurlyVariant)) {
+			return nfdCurlyVariant;
+		}
 	}
 
 	return resolved;

package/src/tools/submit-result.ts

@@ -4,7 +4,7 @@
  * Subagents must call this tool to finish and return structured JSON output.
  */
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
-import { enforceStrictSchema, sanitizeSchemaForStrictMode } from "@oh-my-pi/pi-ai/utils/typebox-helpers";
+import { sanitizeSchemaForStrictMode } from "@oh-my-pi/pi-ai/utils/typebox-helpers";
 import type { Static, TSchema } from "@sinclair/typebox";
 import { Type } from "@sinclair/typebox";
 import Ajv, { type ErrorObject, type ValidateFunction } from "ajv";
@@ -179,8 +179,7 @@ export class SubmitResultTool implements AgentTool<TSchema, SubmitResultDetails>
 				});
 			}
 			parameters = createParameters(dataSchema);
-			const strictParameters = enforceStrictSchema(parameters as unknown as Record<string, unknown>);
-			JSON.stringify(strictParameters);
+			JSON.stringify(parameters);
 			// Verify the final parameters compile with AJV (catches unresolved $ref, etc.)
 			ajv.compile(parameters as Record<string, unknown>);
 		} catch (err) {

package/src/web/search/providers/jina.ts

@@ -46,8 +46,8 @@ async function callJinaSearch(apiKey: string, query: string): Promise<JinaSearch
 		throw new SearchProviderError("jina", `Jina API error (${response.status}): ${errorText}`, response.status);
 	}
 
-	const data = (await response.json()) as unknown;
-	return Array.isArray(data) ? (data as JinaSearchResponse) : [];
+	const payload = (await response.json()) as { data?: JinaSearchResponse } | null;
+	return Array.isArray(payload?.data) ? payload.data : [];
 }
 
 /** Execute Jina web search. */