@oh-my-pi/pi-coding-agent 15.9.3 → 15.9.67

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

@@ -6,7 +6,6 @@ import {
 	getEnvApiKey,
 	getProviderDetails,
 	type ProviderDetails,
-	type ToolCall,
 	type UsageLimit,
 	type UsageReport,
 } from "@oh-my-pi/pi-ai";
@@ -239,121 +238,6 @@ export class CommandController {
 		}
 	}
 
-	handleCopyCommand(sub?: string) {
-		switch (sub) {
-			case "code":
-				return this.#copyCode();
-			case "all":
-				return this.#copyAllCode();
-			case "cmd":
-				return this.#copyLastCommand();
-			case "last":
-			case undefined:
-				return this.#copyLastMessage();
-			default:
-				this.ctx.showError(`Unknown subcommand: ${sub}. Use code, all, cmd, or last.`);
-		}
-	}
-
-	#copyLastMessage() {
-		const assistantText = this.ctx.session.getLastAssistantText();
-		if (assistantText) {
-			this.#doCopy(assistantText, "Copied last agent message to clipboard");
-			return;
-		}
-
-		if (!this.ctx.session.hasCopyCandidateAssistantMessage()) {
-			const handoffText = this.ctx.session.getLastVisibleHandoffText();
-			if (handoffText) {
-				this.#doCopy(handoffText, "Copied handoff context to clipboard");
-				return;
-			}
-		}
-
-		this.ctx.showError("No agent messages to copy yet.");
-	}
-
-	#copyCode() {
-		const text = this.ctx.session.getLastAssistantText();
-		if (!text) {
-			this.ctx.showError("No agent messages to copy yet.");
-			return;
-		}
-		const matches = [...text.matchAll(/^```[^\n]*\n([\s\S]*?)^```/gm)];
-		const lastMatch = matches.at(-1);
-		if (!lastMatch) {
-			this.ctx.showWarning("No code block found in the last agent message.");
-			return;
-		}
-		this.#doCopy(lastMatch[1].replace(/\n$/, ""), "Copied last code block to clipboard");
-	}
-
-	#copyAllCode() {
-		const text = this.ctx.session.getLastAssistantText();
-		if (!text) {
-			this.ctx.showError("No agent messages to copy yet.");
-			return;
-		}
-		const matches = [...text.matchAll(/^```[^\n]*\n([\s\S]*?)^```/gm)];
-		if (matches.length === 0) {
-			this.ctx.showWarning("No code blocks found in the last agent message.");
-			return;
-		}
-		const combined = matches.map(m => m[1].replace(/\n$/, "")).join("\n\n");
-		this.#doCopy(combined, `Copied ${matches.length} code block${matches.length > 1 ? "s" : ""} to clipboard`);
-	}
-
-	#extractEvalCode(args: unknown): string | undefined {
-		if (!args || typeof args !== "object") return undefined;
-		const cells = (args as { cells?: unknown }).cells;
-		if (!Array.isArray(cells)) return undefined;
-
-		const codeBlocks: string[] = [];
-		for (const cell of cells) {
-			if (!cell || typeof cell !== "object") continue;
-			const code = (cell as { code?: unknown }).code;
-			if (typeof code === "string" && code.length > 0) {
-				codeBlocks.push(code);
-			}
-		}
-
-		return codeBlocks.length > 0 ? codeBlocks.join("\n\n") : undefined;
-	}
-
-	#copyLastCommand() {
-		const messages = this.ctx.session.messages;
-		// Walk backwards to find the last bash/eval tool call
-		for (let i = messages.length - 1; i >= 0; i--) {
-			const msg = messages[i];
-			if (msg.role !== "assistant") continue;
-			const toolCalls = msg.content.filter((c): c is ToolCall => c.type === "toolCall");
-			for (let j = toolCalls.length - 1; j >= 0; j--) {
-				const tc = toolCalls[j];
-				if (tc.name === "bash" && typeof tc.arguments.command === "string") {
-					this.#doCopy(tc.arguments.command, "Copied last bash command to clipboard");
-					return;
-				}
-				if (tc.name === "eval") {
-					const code = this.#extractEvalCode(tc.arguments);
-					if (code) {
-						this.#doCopy(code, "Copied last eval code to clipboard");
-						return;
-					}
-				}
-			}
-		}
-		this.ctx.showWarning("No bash or eval command found in the conversation.");
-	}
-
-	#doCopy(content: string, label: string) {
-		try {
-			copyToClipboard(content);
-			this.ctx.showStatus(label);
-		} catch (error) {
-			this.ctx.showError(error instanceof Error ? error.message : String(error));
-		}
-	}
-
 	async handleSessionCommand(): Promise<void> {
 		const stats = this.ctx.session.getSessionStats();
 		const premiumRequests =

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

@@ -49,9 +49,15 @@ export class EventController {
 	#lastIntent: string | undefined = undefined;
 	#backgroundToolCallIds = new Set<string>();
 	#assistantMessageStreaming = false;
+	#agentTurnActive = false;
 	#readToolCallArgs = new Map<string, Record<string, unknown>>();
 	#readToolCallAssistantComponents = new Map<string, AssistantMessageComponent>();
 	#lastAssistantComponent: AssistantMessageComponent | undefined = undefined;
+	// Assistant component whose turn-ending error is currently mirrored in the
+	// pinned banner. Its inline `Error: …` line is suppressed while pinned and
+	// restored when the banner clears at the next `agent_start` (see
+	// #handleMessageEnd / #handleAgentStart).
+	#pinnedErrorComponent: AssistantMessageComponent | undefined = undefined;
 	#idleCompactionTimer?: NodeJS.Timeout;
 	#ircExpiryTimers = new Map<string, NodeJS.Timeout>();
 	#handlers: AgentSessionEventHandlers;
@@ -172,21 +178,21 @@ export class EventController {
 
 		const run = this.#handlers[event.type] as (e: AgentSessionEvent) => Promise<void>;
 		await run(event);
-		// While assistant text or a foreground tool is streaming, rows above the
-		// viewport can re-layout after they have already entered native scrollback
-		// (Markdown fences, wrapping, previews). Let the TUI rebuild history on
-		// those offscreen edits instead of deferring, which otherwise leaves stale
-		// tail rows duplicated above the live viewport.
-		// Background-running tools are excluded so late async updates outside the
-		// active foreground stream keep the no-yank deferral; agent_start resets
-		// the mode at every turn boundary.
+		// While an assistant turn is active, visible status chrome and foreground
+		// transcript blocks can re-render after rows have entered native scrollback
+		// (idle Working loader, Markdown fences, wrapping, tool previews). Let the
+		// TUI use its foreground live-region path instead of idle deferral, which
+		// can otherwise leave the loader/status frame frozen until the next input.
+		// Background-running tools after the turn ends are excluded so late async
+		// updates keep the no-yank deferral; agent_start/agent_end bracket the
+		// foreground turn.
 		if (STREAM_RENDER_MODE_EVENTS[event.type]) {
 			this.#refreshToolRenderMode();
 		}
 	}
 
 	#refreshToolRenderMode(): void {
-		let foregroundToolActive = this.#assistantMessageStreaming;
+		let foregroundToolActive = this.#agentTurnActive || this.#assistantMessageStreaming;
 		if (!foregroundToolActive) {
 			for (const toolCallId of this.ctx.pendingTools.keys()) {
 				if (!this.#backgroundToolCallIds.has(toolCallId)) {
@@ -199,11 +205,17 @@ export class EventController {
 	}
 
 	async #handleAgentStart(_event: Extract<AgentSessionEvent, { type: "agent_start" }>): Promise<void> {
+		this.#agentTurnActive = true;
 		this.#lastIntent = undefined;
 		this.#readToolCallArgs.clear();
 		this.#readToolCallAssistantComponents.clear();
 		this.#assistantMessageStreaming = false;
 		this.#lastAssistantComponent = undefined;
+		// Restore the previous turn's inline error in the transcript before dropping
+		// the banner, so the error stays in history once the banner is gone.
+		this.#pinnedErrorComponent?.setErrorPinned(false);
+		this.#pinnedErrorComponent = undefined;
+		this.ctx.clearPinnedError();
 		if (this.ctx.retryEscapeHandler) {
 			this.ctx.editor.onEscape = this.ctx.retryEscapeHandler;
 			this.ctx.retryEscapeHandler = undefined;
@@ -214,6 +226,7 @@ export class EventController {
 			this.ctx.statusContainer.clear();
 		}
 		this.#cancelIdleCompaction();
+		this.#refreshToolRenderMode();
 		this.ctx.ensureLoadingAnimation();
 		this.ctx.ui.requestRender();
 	}
@@ -241,16 +254,28 @@ export class EventController {
 			this.ctx.ui.requestRender();
 		} else if (event.message.role === "user") {
 			const textContent = this.ctx.getUserMessageText(event.message);
-			const imageCount =
+			const imageBlocks =
 				typeof event.message.content === "string"
-					? 0
-					: event.message.content.filter(content => content.type === "image").length;
+					? []
+					: event.message.content.filter(
+							(content): content is ImageContent =>
+								content.type === "image" &&
+								typeof content.data === "string" &&
+								typeof content.mimeType === "string",
+						);
+			const imageCount = imageBlocks.length;
 			const signature = `${textContent}\u0000${imageCount}`;
 
 			this.#resetReadGroup();
 			const wasOptimistic = this.ctx.optimisticUserMessageSignature === signature;
 			const wasLocallySubmitted = this.ctx.locallySubmittedUserSignatures.delete(signature) || wasOptimistic;
 			if (!wasOptimistic) {
+				// Append synchronously: #emit dispatches to this listener fire-and-forget
+				// (see AgentSession.#emit), so any await between the user message_start and
+				// addMessageToChat lets later events (assistant message_start, tool execution
+				// start/end) append their components first and scramble transcript order /
+				// live-region block boundaries. addMessageToChat materializes clickable image
+				// links via the synchronous putBlobSync fallback, so no await is needed here.
 				this.ctx.addMessageToChat(event.message);
 			}
 			if (wasOptimistic) {
@@ -462,11 +487,35 @@ export class EventController {
 				for (const [toolCallId, component] of this.ctx.pendingTools.entries()) {
 					component.setArgsComplete(toolCallId);
 				}
+			} else {
+				// The turn ended without running these calls (abort/error/TTSR rewind),
+				// so they will never produce a result. Seal them so they stop animating
+				// and freeze instead of pinning the transcript live region while a retry
+				// streams fresh blocks below them. Background tools keep updating.
+				for (const [toolCallId, component] of this.ctx.pendingTools.entries()) {
+					if (!this.#backgroundToolCallIds.has(toolCallId) && component instanceof ToolExecutionComponent) {
+						component.seal();
+					}
+				}
 			}
 			this.#lastAssistantComponent = this.ctx.streamingComponent;
 			this.#lastAssistantComponent.setUsageInfo(event.message.usage);
+			this.#lastAssistantComponent.markTranscriptBlockFinalized();
 			this.ctx.streamingComponent = undefined;
 			this.ctx.streamingMessage = undefined;
+			// Pin a turn-ending provider error (e.g. Anthropic content-filter block)
+			// above the editor so it survives transcript scroll. Cleared at the next
+			// turn's agent_start. Suppress the transcript's inline `Error: …` line for
+			// the same message while pinned so the error isn't rendered twice.
+			if (
+				event.message.stopReason === "error" &&
+				event.message.errorMessage &&
+				!isSilentAbort(event.message.errorMessage)
+			) {
+				this.#lastAssistantComponent?.setErrorPinned(true);
+				this.#pinnedErrorComponent = this.#lastAssistantComponent;
+				this.ctx.showPinnedError(event.message.errorMessage);
+			}
 			this.ctx.statusLine.invalidate();
 			this.ctx.updateEditorTopBorder();
 		}
@@ -612,6 +661,7 @@ export class EventController {
 		}
 	}
 	async #handleAgentEnd(_event: Extract<AgentSessionEvent, { type: "agent_end" }>): Promise<void> {
+		this.#agentTurnActive = false;
 		this.#assistantMessageStreaming = false;
 		if (this.ctx.loadingAnimation) {
 			this.ctx.loadingAnimation.stop();
@@ -626,6 +676,11 @@ export class EventController {
 		await this.ctx.flushPendingModelSwitch();
 		for (const toolCallId of Array.from(this.ctx.pendingTools.keys())) {
 			if (!this.#backgroundToolCallIds.has(toolCallId)) {
+				// A foreground tool still pending at turn end never delivered a result;
+				// seal it so it freezes (and stops animating) rather than lingering in
+				// the transcript live region as a streaming preview until the next thaw.
+				const component = this.ctx.pendingTools.get(toolCallId);
+				if (component instanceof ToolExecutionComponent) component.seal();
 				this.ctx.pendingTools.delete(toolCallId);
 			}
 		}

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

@@ -6,6 +6,7 @@ import { isSettingsInitialized, settings } from "../../config/settings";
 import { renderSegmentTrack } from "../../modes/components/segment-track";
 import { TinyTitleDownloadProgressComponent } from "../../modes/components/tiny-title-download-progress";
 import { expandEmoticons } from "../../modes/emoji-autocomplete";
+import { materializeImageReferenceLinks } from "../../modes/image-references";
 import { createPromptActionAutocompleteProvider } from "../../modes/prompt-action-autocomplete";
 import type { InteractiveModeContext } from "../../modes/types";
 import type { AgentSessionEvent } from "../../session/agent-session";
@@ -253,6 +254,8 @@ export class InputController {
 				if (this.ctx.onInputCallback) {
 					this.ctx.editor.setText("");
 					this.ctx.pendingImages = [];
+					this.ctx.pendingImageLinks = [];
+					this.ctx.editor.imageLinks = undefined;
 					this.ctx.onInputCallback({ text: "", cancelled: false, started: true });
 				}
 				return;
@@ -260,12 +263,15 @@ 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;
 
 			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;
 					return;
 				}
 				if (result?.text !== undefined) {
@@ -273,6 +279,10 @@ export class InputController {
 				}
 				if (result?.images !== undefined) {
 					inputImages = result.images;
+					inputImageLinks = await materializeImageReferenceLinks(
+						inputImages,
+						this.ctx.sessionManager.putBlob.bind(this.ctx.sessionManager),
+					);
 				}
 			}
 
@@ -356,8 +366,10 @@ export class InputController {
 			if (this.ctx.session.isStreaming) {
 				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 = [];
 				// 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
@@ -417,11 +429,17 @@ export class InputController {
 
 			if (this.ctx.onInputCallback) {
 				// 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 = [];
 
 				// Render user message immediately, then let session events catch up
-				const submission = this.ctx.startPendingSubmission({ text, images });
+				const submission = this.ctx.startPendingSubmission({
+					text,
+					images,
+					imageLinks: inputImageLinks,
+				});
 
 				this.ctx.onInputCallback(submission);
 			}
@@ -685,11 +703,25 @@ export class InputController {
 					}
 				}
 
+				const imageLink = (
+					await materializeImageReferenceLinks(
+						[
+							{
+								type: "image",
+								data: imageData.data,
+								mimeType: imageData.mimeType,
+							},
+						],
+						this.ctx.sessionManager.putBlob.bind(this.ctx.sessionManager),
+					)
+				)?.[0];
 				this.ctx.pendingImages.push({
 					type: "image",
 					data: imageData.data,
 					mimeType: imageData.mimeType,
 				});
+				this.ctx.pendingImageLinks.push(imageLink);
+				this.ctx.editor.imageLinks = this.ctx.pendingImageLinks;
 				// Insert placeholder at cursor like Claude does
 				const imageNum = this.ctx.pendingImages.length;
 				const placeholder = `[Image #${imageNum}]`;

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

@@ -37,9 +37,11 @@ import {
 	setPreferredSearchProvider,
 } from "../../tools";
 import { shortenPath } from "../../tools/render-utils";
+import { copyToClipboard } from "../../utils/clipboard";
 import { setSessionTerminalTitle } from "../../utils/title-generator";
 import { AgentDashboard } from "../components/agent-dashboard";
 import { AssistantMessageComponent } from "../components/assistant-message";
+import { CopySelectorComponent } from "../components/copy-selector";
 import { ExtensionDashboard } from "../components/extensions";
 import { HistorySearchComponent } from "../components/history-search";
 import { ModelSelectorComponent } from "../components/model-selector";
@@ -52,6 +54,8 @@ import { ToolExecutionComponent } from "../components/tool-execution";
 import { TreeSelectorComponent } from "../components/tree-selector";
 import { UserMessageSelectorComponent } from "../components/user-message-selector";
 import type { SessionObserverRegistry } from "../session-observer-registry";
+import { computeContextBreakdown } from "../utils/context-usage";
+import { buildCopyTargets } from "../utils/copy-targets";
 
 const CALLBACK_SERVER_PROVIDERS = new Set<OAuthProvider>([
 	"anthropic",
@@ -407,6 +411,7 @@ export class SelectorController {
 	}
 
 	showModelSelector(options?: { temporaryOnly?: boolean }): void {
+		const currentContextTokens = computeContextBreakdown(this.ctx.session).usedTokens;
 		this.showSelector(done => {
 			const selector = new ModelSelectorComponent(
 				this.ctx.ui,
@@ -470,7 +475,7 @@ export class SelectorController {
 					done();
 					this.ctx.ui.requestRender();
 				},
-				options,
+				{ ...options, currentContextTokens },
 			);
 			return { component: selector, focus: selector };
 		});
@@ -598,6 +603,38 @@ export class SelectorController {
 		});
 	}
 
+	showCopySelector(): void {
+		const targets = buildCopyTargets(this.ctx.session);
+		if (targets.length === 0) {
+			this.ctx.showStatus("Nothing to copy yet.");
+			return;
+		}
+
+		let overlayHandle: OverlayHandle | undefined;
+		const done = () => {
+			overlayHandle?.hide();
+			this.ctx.ui.requestRender();
+		};
+		const selector = new CopySelectorComponent(targets, {
+			onPick: target => {
+				done();
+				if (target.content === undefined) return;
+				void copyToClipboard(target.content);
+				this.ctx.showStatus(target.copyMessage ?? "Copied to clipboard");
+			},
+			onCancel: done,
+		});
+
+		overlayHandle = this.ctx.ui.showOverlay(selector, {
+			anchor: "bottom-center",
+			width: "100%",
+			maxHeight: "100%",
+			margin: 0,
+		});
+		this.ctx.ui.setFocus(selector);
+		this.ctx.ui.requestRender();
+	}
+
 	showTreeSelector(): void {
 		const tree = this.ctx.sessionManager.getTree();
 		const realLeafId = this.ctx.sessionManager.getLeafId();

package/src/modes/image-references.ts

@@ -0,0 +1,111 @@
+import type { ImageContent } from "@oh-my-pi/pi-ai";
+import { logger } from "@oh-my-pi/pi-utils";
+import { type BlobPutResult, blobExtensionForImageMimeType } from "../session/blob-store";
+import { fileHyperlink } from "../tui/hyperlink";
+
+const IMAGE_REFERENCE_REGEX = /\[Image #([1-9]\d*)\]/g;
+
+type ImageBlobWriter = (data: Buffer, options?: { extension?: string }) => Promise<BlobPutResult>;
+type ImageBlobWriterSync = (data: Buffer, options?: { extension?: string }) => BlobPutResult;
+
+export interface ImageReferenceRenderers {
+	renderText: (text: string) => string;
+	renderReference: (label: string, index: number) => string;
+}
+
+export function renderImageReferences(text: string, renderers: ImageReferenceRenderers): string {
+	IMAGE_REFERENCE_REGEX.lastIndex = 0;
+	let result = "";
+	let last = 0;
+	let matched = false;
+
+	for (;;) {
+		const match = IMAGE_REFERENCE_REGEX.exec(text);
+		if (match === null) break;
+		matched = true;
+		if (match.index > last) {
+			result += renderers.renderText(text.slice(last, match.index));
+		}
+		result += renderers.renderReference(match[0], Number(match[1]));
+		last = match.index + match[0].length;
+	}
+
+	if (!matched) {
+		return renderers.renderText(text);
+	}
+	if (last < text.length) {
+		result += renderers.renderText(text.slice(last));
+	}
+	return result;
+}
+
+export function imageReferenceHyperlink(
+	label: string,
+	index: number,
+	imageLinks: readonly (string | undefined)[] | undefined,
+	renderLabel: (text: string) => string,
+): string {
+	const rendered = renderLabel(label);
+	const target = imageLinks?.[index - 1];
+	return target ? fileHyperlink(target, rendered) : rendered;
+}
+
+async function materializeImageReferenceLinkAsync(
+	image: ImageContent,
+	index: number,
+	putBlob: ImageBlobWriter,
+): Promise<string | undefined> {
+	try {
+		const result = await putBlob(Buffer.from(image.data, "base64"), {
+			extension: blobExtensionForImageMimeType(image.mimeType),
+		});
+		return result.displayPath;
+	} catch (error) {
+		logger.warn("Failed to write image reference blob", {
+			index,
+			mimeType: image.mimeType,
+			error: error instanceof Error ? error.message : String(error),
+		});
+		return undefined;
+	}
+}
+
+function materializeImageReferenceLink(
+	image: ImageContent,
+	index: number,
+	putBlob: ImageBlobWriterSync,
+): string | undefined {
+	try {
+		const result = putBlob(Buffer.from(image.data, "base64"), {
+			extension: blobExtensionForImageMimeType(image.mimeType),
+		});
+		return result.displayPath;
+	} catch (error) {
+		logger.warn("Failed to write image reference blob", {
+			index,
+			mimeType: image.mimeType,
+			error: error instanceof Error ? error.message : String(error),
+		});
+		return undefined;
+	}
+}
+
+export async function materializeImageReferenceLinks(
+	images: readonly ImageContent[] | undefined,
+	putBlob: ImageBlobWriter,
+): Promise<(string | undefined)[] | undefined> {
+	if (!images || images.length === 0) return undefined;
+	const links = await Promise.all(
+		images.map((image, index) => materializeImageReferenceLinkAsync(image, index + 1, putBlob)),
+	);
+	return links.some(link => link !== undefined) ? links : undefined;
+}
+
+export function materializeImageReferenceLinksSync(
+	images: readonly ImageContent[] | undefined,
+	putBlob: ImageBlobWriterSync,
+): (string | undefined)[] | undefined {
+	if (!images || images.length === 0) return undefined;
+	const links = images.map((image, index) => materializeImageReferenceLink(image, index + 1, putBlob));
+	return links.some(link => link !== undefined) ? links : undefined;
+}