@selesai/code 0.13.39 → 0.14.0

package/dist/utils/clipboard-image.js

@@ -150,25 +150,22 @@ async function readClipboardImageViaXclip() {
     const targets = await runClipboardCommand("xclip", ["-selection", "clipboard", "-t", "TARGETS", "-o"], {
         timeoutMs: DEFAULT_LIST_TIMEOUT_MS,
     });
-    let candidateTypes = [];
-    if (targets !== undefined) {
-        candidateTypes = targets
-            .toString("utf-8")
-            .split(/\r?\n/)
-            .map((t) => t.trim())
-            .filter(Boolean);
-    }
+    if (targets === undefined)
+        return undefined;
+    const candidateTypes = targets
+        .toString("utf-8")
+        .split(/\r?\n/)
+        .map((t) => t.trim())
+        .filter(Boolean);
     const preferred = selectPreferredImageMimeType(candidateTypes);
-    if (targets !== undefined && !preferred)
+    if (!preferred)
         return null;
-    const tryTypes = new Set(preferred ? [preferred, ...SUPPORTED_IMAGE_MIME_TYPES] : SUPPORTED_IMAGE_MIME_TYPES);
-    for (const mimeType of tryTypes) {
-        const data = await runClipboardCommand("xclip", ["-selection", "clipboard", "-t", mimeType, "-o"]);
-        if (data !== undefined && data.length > 0) {
-            return { bytes: data, mimeType: baseMimeType(mimeType) };
-        }
-    }
-    return undefined;
+    const data = await runClipboardCommand("xclip", ["-selection", "clipboard", "-t", preferred, "-o"]);
+    if (data === undefined)
+        return undefined;
+    if (data.length === 0)
+        return null;
+    return { bytes: data, mimeType: baseMimeType(preferred) };
 }
 async function readClipboardImageViaNativeClipboard() {
     const bytes = await getNativeClipboard()?.getImage();

package/dist/utils/clipboard.d.ts

@@ -1,3 +1,5 @@
 /** Read plain text from the system clipboard. */
 export declare function readClipboardText(): Promise<string | null>;
+/** Read file paths, such as Finder file copies, from the native clipboard. */
+export declare function readClipboardFilePaths(): Promise<string[] | null>;
 export declare function copyToClipboard(text: string): Promise<void>;

package/dist/utils/clipboard.js

@@ -51,20 +51,21 @@ async function copyViaWindowsClipboard(text) {
 }
 /** Read plain text from the system clipboard. */
 export async function readClipboardText() {
+    const commands = [];
+    // Termux reports platform "android", not "linux" (#10391).
+    if (process.env.TERMUX_VERSION)
+        commands.push(["termux-clipboard-get", []]);
     if (platform() === "linux") {
-        const commands = [];
-        if (process.env.TERMUX_VERSION)
-            commands.push(["termux-clipboard-get", []]);
         if (process.env.WAYLAND_DISPLAY)
             commands.push(["wl-paste", ["--no-newline", "--type", "text"]]);
         if (process.env.DISPLAY) {
             commands.push(["xclip", ["-selection", "clipboard", "-out"]], ["xsel", ["--clipboard", "--output"]]);
         }
-        for (const [command, args] of commands) {
-            const bytes = await runClipboardCommand(command, args, { timeoutMs: 5000 });
-            if (bytes !== undefined)
-                return bytes.toString("utf8") || null;
-        }
+    }
+    for (const [command, args] of commands) {
+        const bytes = await runClipboardCommand(command, args, { timeoutMs: 5000 });
+        if (bytes !== undefined)
+            return bytes.toString("utf8") || null;
     }
     try {
         return (await getNativeClipboard()?.getText()) || null;
@@ -73,6 +74,11 @@ export async function readClipboardText() {
         return null;
     }
 }
+/** Read file paths, such as Finder file copies, from the native clipboard. */
+export async function readClipboardFilePaths() {
+    const paths = await getNativeClipboard()?.getFilePaths?.();
+    return paths?.length ? paths : null;
+}
 export async function copyToClipboard(text) {
     const p = platform();
     const env = process.env;
@@ -135,10 +141,10 @@ export async function copyToClipboard(text) {
         return;
     if (oversized)
         throw new Error("Clipboard unavailable: text exceeds the OSC 52 size limit");
+    if (env.TERMUX_VERSION) {
+        throw new Error("Clipboard unavailable: install the Termux:API app and `termux-api` package");
+    }
     if (p === "linux") {
-        if (env.TERMUX_VERSION) {
-            throw new Error("Clipboard unavailable: install the Termux:API app and `termux-api` package");
-        }
         if (env.WAYLAND_DISPLAY) {
             throw new Error("Clipboard unavailable: install `wl-clipboard` (`wl-copy`) or check Wayland access");
         }

package/dist/utils/frontmatter.js

@@ -1,7 +1,8 @@
 import { parse } from "yaml";
+import { stripBom } from "./text.js";
 const normalizeNewlines = (value) => value.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
 const extractFrontmatter = (content) => {
-    const normalized = normalizeNewlines(content);
+    const normalized = normalizeNewlines(stripBom(content));
     if (!normalized.startsWith("---")) {
         return { yamlString: null, body: normalized };
     }

package/dist/utils/image-convert.d.ts

@@ -1,3 +1,4 @@
+import { type ImageTranscoder } from "@earendil-works/pi-tui";
 export declare function convertImageBytesToPng(bytes: Uint8Array): Promise<Uint8Array | null>;
 /**
  * Convert image to PNG format for terminal display.
@@ -7,3 +8,14 @@ export declare function convertToPng(base64Data: string, mimeType: string): Prom
     data: string;
     mimeType: string;
 } | null>;
+/**
+ * Load photon and return a synchronous PNG transcoder for pi-tui's Kitty image rendering.
+ * Returns undefined if photon cannot be loaded.
+ */
+export declare function loadPngTranscoder(): Promise<ImageTranscoder | undefined>;
+/**
+ * On Kitty-protocol terminals, register photon as pi-tui's image transcoder so non-PNG images render.
+ * Loads photon once. `onRegistered` runs after registration so callers can re-render images that
+ * showed text fallbacks; it is not called if the transcoder was already registered or cannot load.
+ */
+export declare function ensurePngTranscoder(onRegistered: () => void): void;

package/dist/utils/image-convert.js

@@ -1,11 +1,7 @@
+import { getCapabilities, setImageTranscoder } from "@earendil-works/pi-tui";
 import { applyExifOrientation } from "./exif-orientation.js";
 import { loadPhoton } from "./photon.js";
-export async function convertImageBytesToPng(bytes) {
-    const photon = await loadPhoton();
-    if (!photon) {
-        // Photon not available, can't convert
-        return null;
-    }
+function encodePng(photon, bytes) {
     try {
         const rawImage = photon.PhotonImage.new_from_byteslice(bytes);
         const image = applyExifOrientation(photon, rawImage, bytes);
@@ -23,6 +19,14 @@ export async function convertImageBytesToPng(bytes) {
         return null;
     }
 }
+export async function convertImageBytesToPng(bytes) {
+    const photon = await loadPhoton();
+    if (!photon) {
+        // Photon not available, can't convert
+        return null;
+    }
+    return encodePng(photon, bytes);
+}
 /**
  * Convert image to PNG format for terminal display.
  * Kitty graphics protocol requires PNG format (f=100).
@@ -42,3 +46,38 @@ export async function convertToPng(base64Data, mimeType) {
         mimeType: "image/png",
     };
 }
+/**
+ * Load photon and return a synchronous PNG transcoder for pi-tui's Kitty image rendering.
+ * Returns undefined if photon cannot be loaded.
+ */
+export async function loadPngTranscoder() {
+    const photon = await loadPhoton();
+    if (!photon)
+        return undefined;
+    return (base64Data) => {
+        const pngBytes = encodePng(photon, new Uint8Array(Buffer.from(base64Data, "base64")));
+        return pngBytes ? Buffer.from(pngBytes).toString("base64") : null;
+    };
+}
+let pngTranscoderLoad;
+let pngTranscoderRegistered = false;
+/**
+ * On Kitty-protocol terminals, register photon as pi-tui's image transcoder so non-PNG images render.
+ * Loads photon once. `onRegistered` runs after registration so callers can re-render images that
+ * showed text fallbacks; it is not called if the transcoder was already registered or cannot load.
+ */
+export function ensurePngTranscoder(onRegistered) {
+    if (pngTranscoderRegistered || getCapabilities().images !== "kitty")
+        return;
+    pngTranscoderLoad ??= loadPngTranscoder().then((transcoder) => {
+        if (!transcoder)
+            return false;
+        setImageTranscoder(transcoder);
+        pngTranscoderRegistered = true;
+        return true;
+    });
+    void pngTranscoderLoad.then((registered) => {
+        if (registered)
+            onRegistered();
+    });
+}

package/dist/utils/image-resize-core.d.ts

@@ -13,6 +13,18 @@ export interface ResizedImage {
     height: number;
     wasResized: boolean;
 }
+/**
+ * Tag on image resize worker replies. Node can post its own messages on the worker channel
+ * (for example `{ "watch:require": [...] }` under `node --watch`), so replies must be identifiable.
+ */
+export declare const IMAGE_RESIZE_WORKER_RESPONSE_TYPE = "pi:image-resize-response";
+export type ResizeImageWorkerResponse = {
+    type: typeof IMAGE_RESIZE_WORKER_RESPONSE_TYPE;
+    result: ResizedImage | null;
+} | {
+    type: typeof IMAGE_RESIZE_WORKER_RESPONSE_TYPE;
+    error: string;
+};
 /**
  * Resize an image to fit within the specified max dimensions and encoded file size.
  * Returns null if the image cannot be resized below maxBytes.

package/dist/utils/image-resize-core.js

@@ -1,5 +1,10 @@
 import { applyExifOrientation } from "./exif-orientation.js";
 import { loadPhoton } from "./photon.js";
+/**
+ * Tag on image resize worker replies. Node can post its own messages on the worker channel
+ * (for example `{ "watch:require": [...] }` under `node --watch`), so replies must be identifiable.
+ */
+export const IMAGE_RESIZE_WORKER_RESPONSE_TYPE = "pi:image-resize-response";
 // 4.5MB of base64 payload. Provides headroom below Anthropic's 5MB limit.
 const DEFAULT_MAX_BYTES = 4.5 * 1024 * 1024;
 const DEFAULT_OPTIONS = {

package/dist/utils/image-resize-worker.js

@@ -1,5 +1,5 @@
 import { parentPort } from "node:worker_threads";
-import { resizeImageInProcess } from "./image-resize-core.js";
+import { IMAGE_RESIZE_WORKER_RESPONSE_TYPE, resizeImageInProcess, } from "./image-resize-core.js";
 function isResizeImageWorkerRequest(value) {
     if (!value || typeof value !== "object")
         return false;
@@ -17,11 +17,12 @@ port.once("message", (message) => {
                 throw new Error("Invalid image resize worker request");
             }
             const result = await resizeImageInProcess(message.inputBytes, message.mimeType, message.options);
-            const response = { result };
+            const response = { type: IMAGE_RESIZE_WORKER_RESPONSE_TYPE, result };
             port.postMessage(response);
         }
         catch (error) {
             const response = {
+                type: IMAGE_RESIZE_WORKER_RESPONSE_TYPE,
                 error: error instanceof Error ? error.message : String(error),
             };
             port.postMessage(response);

package/dist/utils/image-resize.js

@@ -1,12 +1,12 @@
 import { Worker } from "node:worker_threads";
-import { resizeImageInProcess } from "./image-resize-core.js";
+import { IMAGE_RESIZE_WORKER_RESPONSE_TYPE, resizeImageInProcess, } from "./image-resize-core.js";
 function toTransferableBytes(input) {
     // Transfer detaches the buffer, so transfer a worker-owned copy and leave the
     // caller's bytes intact.
     return new Uint8Array(input);
 }
 function isResizeImageWorkerResponse(value) {
-    return value !== null && typeof value === "object";
+    return (value !== null && typeof value === "object" && "type" in value && value.type === IMAGE_RESIZE_WORKER_RESPONSE_TYPE);
 }
 function createResizeWorker(workerSpecifier) {
     return new Worker(workerSpecifier);
@@ -29,16 +29,15 @@ async function resizeImageInWorker(workerSpecifier, inputBytes, mimeType, option
                 settled = true;
                 reject(error);
             };
-            worker.once("message", (message) => {
-                if (!isResizeImageWorkerResponse(message)) {
-                    fail(new Error("Invalid image resize worker response"));
+            worker.on("message", (message) => {
+                // Ignore messages Node posts on the worker channel itself, such as
+                // `{ "watch:require": [...] }` under `node --watch` (nodejs/node#65044).
+                if (!isResizeImageWorkerResponse(message))
                     return;
-                }
-                if (message.error) {
+                if ("error" in message)
                     fail(new Error(message.error));
-                    return;
-                }
-                settle(message.result ?? null);
+                else
+                    settle(message.result);
             });
             worker.once("error", fail);
             worker.once("exit", (code) => {

package/dist/utils/mime.js

@@ -8,7 +8,7 @@ export function detectSupportedImageMimeType(buffer) {
     if (startsWith(buffer, PNG_SIGNATURE)) {
         return isPng(buffer) && !isAnimatedPng(buffer) ? "image/png" : null;
     }
-    if (startsWithAscii(buffer, 0, "GIF")) {
+    if (startsWithAscii(buffer, 0, "GIF87a") || startsWithAscii(buffer, 0, "GIF89a")) {
         return "image/gif";
     }
     if (startsWithAscii(buffer, 0, "RIFF") && startsWithAscii(buffer, 8, "WEBP")) {

package/dist/utils/output-files.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Output files: files pi writes so the model can use output it was not shown in full, such as the
+ * full text of truncated tool output, binary MCP resources, and images shown by codemode scripts.
+ * Every output file is created here, so where they are stored can change in one place. Today they
+ * go to the OS temp directory.
+ */
+import { type WriteStream } from "node:fs";
+/** Write `data` to a new output file and return its path. */
+export declare function writeOutputFile(prefix: string, extension: string, data: string | Uint8Array): Promise<string>;
+/** Open a new output file for streamed output. */
+export declare function createOutputFileStream(prefix: string, extension: string): {
+    path: string;
+    stream: WriteStream;
+};

package/dist/utils/output-files.js

@@ -0,0 +1,29 @@
+/**
+ * Output files: files pi writes so the model can use output it was not shown in full, such as the
+ * full text of truncated tool output, binary MCP resources, and images shown by codemode scripts.
+ * Every output file is created here, so where they are stored can change in one place. Today they
+ * go to the OS temp directory.
+ */
+import { randomBytes } from "node:crypto";
+import { createWriteStream } from "node:fs";
+import { writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+/** Output can carry private data, so only the user may read the files. */
+const OUTPUT_FILE_MODE = 0o600;
+/** A new, unused path: `<dir>/<prefix>-<random hex><extension>`. `extension` includes the dot. */
+function createOutputFilePath(prefix, extension) {
+    return join(tmpdir(), `${prefix}-${randomBytes(8).toString("hex")}${extension}`);
+}
+/** Write `data` to a new output file and return its path. */
+export async function writeOutputFile(prefix, extension, data) {
+    const path = createOutputFilePath(prefix, extension);
+    // `wx` never follows a link someone else placed at the path.
+    await writeFile(path, data, { mode: OUTPUT_FILE_MODE, flag: "wx" });
+    return path;
+}
+/** Open a new output file for streamed output. */
+export function createOutputFileStream(prefix, extension) {
+    const path = createOutputFilePath(prefix, extension);
+    return { path, stream: createWriteStream(path, { mode: OUTPUT_FILE_MODE, flags: "wx" }) };
+}

package/dist/utils/paths.d.ts

@@ -17,12 +17,15 @@ export interface PathInputOptions {
  * entries.
  */
 export declare function canonicalizePath(path: string): string;
+export declare function getFileRevision(path: string): string | undefined;
 /**
- * Returns true if the value is NOT a package source (npm:, git:, etc.)
- * or a remote URL protocol. Bare names, relative paths, and file: URLs
- * are considered local.
+ * Returns true if the value is NOT a package source (npm:, git:, etc.),
+ * a built-in extension (builtin:), or a remote URL protocol. Bare names,
+ * relative paths, and file: URLs are considered local.
  */
 export declare function isLocalPath(value: string): boolean;
+/** Convert Git Bash, MSYS, Cygwin, and WSL drive paths to a form native Windows APIs accept. */
+export declare function normalizeWindowsShellPath(filePath: string): string;
 export declare function normalizePath(input: string, options?: PathInputOptions): string;
 export declare function resolvePath(input: string, baseDir?: string, options?: PathInputOptions): string;
 export declare function getCwdRelativePath(filePath: string, cwd: string): string | undefined;

package/dist/utils/paths.js

@@ -1,4 +1,4 @@
-import { realpathSync } from "node:fs";
+import { realpathSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { isAbsolute, join, resolve as nodeResolvePath, relative, sep } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -18,10 +18,19 @@ export function canonicalizePath(path) {
         return path;
     }
 }
+export function getFileRevision(path) {
+    try {
+        const stats = statSync(path, { bigint: true });
+        return `${stats.dev}:${stats.ino}:${stats.size}:${stats.mtimeNs}:${stats.ctimeNs}`;
+    }
+    catch {
+        return undefined;
+    }
+}
 /**
- * Returns true if the value is NOT a package source (npm:, git:, etc.)
- * or a remote URL protocol. Bare names, relative paths, and file: URLs
- * are considered local.
+ * Returns true if the value is NOT a package source (npm:, git:, etc.),
+ * a built-in extension (builtin:), or a remote URL protocol. Bare names,
+ * relative paths, and file: URLs are considered local.
  */
 export function isLocalPath(value) {
     const trimmed = value.trim();
@@ -31,11 +40,22 @@ export function isLocalPath(value) {
         trimmed.startsWith("github:") ||
         trimmed.startsWith("http:") ||
         trimmed.startsWith("https:") ||
-        trimmed.startsWith("ssh:")) {
+        trimmed.startsWith("ssh:") ||
+        trimmed.startsWith("builtin:")) {
         return false;
     }
     return true;
 }
+/** Convert Git Bash, MSYS, Cygwin, and WSL drive paths to a form native Windows APIs accept. */
+export function normalizeWindowsShellPath(filePath) {
+    if (!filePath.startsWith("/") || filePath.startsWith("//") || filePath.includes("\\"))
+        return filePath;
+    const match = filePath.match(/^\/(?:mnt\/|cygdrive\/)?([a-z])(?:\/(.*))?$/i);
+    if (!match)
+        return filePath;
+    const suffix = match[2]?.replaceAll("/", "\\");
+    return `${match[1].toUpperCase()}:\\${suffix ?? ""}`;
+}
 export function normalizePath(input, options = {}) {
     let normalized = options.trim ? input.trim() : input;
     if (options.normalizeUnicodeSpaces) {
@@ -44,6 +64,9 @@ export function normalizePath(input, options = {}) {
     if (options.stripAtPrefix && normalized.startsWith("@")) {
         normalized = normalized.slice(1);
     }
+    if (process.platform === "win32") {
+        normalized = normalizeWindowsShellPath(normalized);
+    }
     if (options.expandTilde ?? true) {
         const home = options.homeDir ?? homedir();
         if (normalized === "~")

package/dist/utils/shell.d.ts

@@ -19,9 +19,7 @@ export declare function getShellEnv(): NodeJS.ProcessEnv;
  * Sanitize binary output for display/storage.
  * Removes characters that crash string-width or cause display issues:
  * - Control characters (except tab, newline, carriage return)
- * - Lone surrogates
- * - Unicode Format characters (crash string-width due to a bug)
- * - Characters with undefined code points
+ * - Unicode interlinear annotation characters U+FFF9..U+FFFB (crash string-width due to a bug)
  */
 export declare function sanitizeBinaryOutput(str: string): string;
 export declare function trackDetachedChildPid(pid: number): void;

package/dist/utils/shell.js

@@ -128,38 +128,11 @@ export function getShellEnv() {
  * Sanitize binary output for display/storage.
  * Removes characters that crash string-width or cause display issues:
  * - Control characters (except tab, newline, carriage return)
- * - Lone surrogates
- * - Unicode Format characters (crash string-width due to a bug)
- * - Characters with undefined code points
+ * - Unicode interlinear annotation characters U+FFF9..U+FFFB (crash string-width due to a bug)
  */
 export function sanitizeBinaryOutput(str) {
-    // Use Array.from to properly iterate over code points (not code units)
-    // This handles surrogate pairs correctly and catches edge cases where
-    // codePointAt() might return undefined
-    return Array.from(str)
-        .filter((char) => {
-        // Filter out characters that cause string-width to crash
-        // This includes:
-        // - Unicode format characters
-        // - Lone surrogates (already filtered by Array.from)
-        // - Control chars except \t \n \r
-        // - Characters with undefined code points
-        const code = char.codePointAt(0);
-        // Skip if code point is undefined (edge case with invalid strings)
-        if (code === undefined)
-            return false;
-        // Allow tab, newline, carriage return
-        if (code === 0x09 || code === 0x0a || code === 0x0d)
-            return true;
-        // Filter out control characters (0x00-0x1F, except 0x09, 0x0a, 0x0x0d)
-        if (code <= 0x1f)
-            return false;
-        // Filter out Unicode format characters
-        if (code >= 0xfff9 && code <= 0xfffb)
-            return false;
-        return true;
-    })
-        .join("");
+    // All removed characters are single UTF-16 code units, so surrogate pairs are never split.
+    return str.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\uFFF9-\uFFFB]/g, "");
 }
 /**
  * Detached child processes must be tracked so they can be killed on parent

package/dist/utils/syntax-highlight.d.ts

@@ -1,3 +1,4 @@
+export declare function loadAllHighlightLanguages(): Promise<void>;
 export type HighlightFormatter = (text: string) => string;
 export type HighlightTheme = Partial<Record<string, HighlightFormatter>>;
 export interface HighlightOptions {

package/dist/utils/syntax-highlight.js

@@ -1,5 +1,66 @@
-import hljs from "highlight.js/lib/index.js";
+import hljs from "highlight.js/lib/core.js";
+import bash from "highlight.js/lib/languages/bash.js";
+import c from "highlight.js/lib/languages/c.js";
+import cpp from "highlight.js/lib/languages/cpp.js";
+import csharp from "highlight.js/lib/languages/csharp.js";
+import dart from "highlight.js/lib/languages/dart.js";
+import go from "highlight.js/lib/languages/go.js";
+import groovy from "highlight.js/lib/languages/groovy.js";
+import java from "highlight.js/lib/languages/java.js";
+import javascript from "highlight.js/lib/languages/javascript.js";
+import json from "highlight.js/lib/languages/json.js";
+import kotlin from "highlight.js/lib/languages/kotlin.js";
+import lua from "highlight.js/lib/languages/lua.js";
+import nix from "highlight.js/lib/languages/nix.js";
+import perl from "highlight.js/lib/languages/perl.js";
+import php from "highlight.js/lib/languages/php.js";
+import python from "highlight.js/lib/languages/python.js";
+import ruby from "highlight.js/lib/languages/ruby.js";
+import rust from "highlight.js/lib/languages/rust.js";
+import scala from "highlight.js/lib/languages/scala.js";
+import swift from "highlight.js/lib/languages/swift.js";
+import typescript from "highlight.js/lib/languages/typescript.js";
 import { decodeHtmlEntityAt } from "./html.js";
+const eagerLanguages = {
+    python,
+    java,
+    go,
+    javascript,
+    json,
+    cpp,
+    typescript,
+    php,
+    ruby,
+    c,
+    csharp,
+    nix,
+    bash,
+    rust,
+    scala,
+    kotlin,
+    swift,
+    dart,
+    groovy,
+    perl,
+    lua,
+};
+for (const [name, language] of Object.entries(eagerLanguages)) {
+    hljs.registerLanguage(name, language);
+}
+let allLanguagesPromise;
+export function loadAllHighlightLanguages() {
+    if (!allLanguagesPromise) {
+        allLanguagesPromise = new Promise((resolve) => {
+            setImmediate(() => {
+                void import("highlight.js/lib/index.js").then(() => resolve(), () => {
+                    // Eager languages and plaintext fallback remain available.
+                    resolve();
+                });
+            });
+        });
+    }
+    return allLanguagesPromise;
+}
 const SPAN_CLOSE = "</span>";
 const HIGHLIGHT_CLASS_PREFIX = "hljs-";
 function getScopeFromSpanTag(tag) {
@@ -65,7 +126,12 @@ export function renderHighlightedHtml(html, theme = {}) {
             return;
         }
         const formatter = getActiveFormatter(scopes, theme);
-        output += formatter ? formatter(textBuffer) : textBuffer;
+        output += formatter
+            ? textBuffer
+                .split("\n")
+                .map((line) => (line ? formatter(line) : line))
+                .join("\n")
+            : textBuffer;
         textBuffer = "";
     };
     let index = 0;

package/dist/utils/tool-result-images.d.ts

@@ -0,0 +1,20 @@
+import type { ImageContent, ModelImageResizeOptions, TextContent } from "@earendil-works/pi-ai";
+export type ToolResultContent = TextContent | ImageContent;
+export interface NormalizeToolResultImagesOptions {
+    /** Whether oversized images are resized to inline provider limits. Default: true */
+    autoResizeImages?: boolean;
+    /** Model-specific resize profile. Uses the conservative built-in defaults when omitted. */
+    resizeOptions?: ModelImageResizeOptions;
+}
+/**
+ * Normalize image blocks returned by tool results.
+ *
+ * The `read` tool and `@file` CLI attachments run their images through `processImage`, but tools
+ * that produce images themselves (extensions, MCP bridges, screenshot tools) hand back arbitrary
+ * base64 payloads that go straight into session history and every subsequent provider request.
+ * Oversized images make the provider reject the whole conversation, not just the offending turn,
+ * so normalize them once as they enter history.
+ *
+ * Returns the original array when nothing changed so callers can skip rewriting the result.
+ */
+export declare function normalizeToolResultImages(content: ToolResultContent[], options?: NormalizeToolResultImagesOptions): Promise<ToolResultContent[]>;

package/dist/utils/tool-result-images.js

@@ -0,0 +1,47 @@
+import { processImage } from "./image-process.js";
+/**
+ * Normalize image blocks returned by tool results.
+ *
+ * The `read` tool and `@file` CLI attachments run their images through `processImage`, but tools
+ * that produce images themselves (extensions, MCP bridges, screenshot tools) hand back arbitrary
+ * base64 payloads that go straight into session history and every subsequent provider request.
+ * Oversized images make the provider reject the whole conversation, not just the offending turn,
+ * so normalize them once as they enter history.
+ *
+ * Returns the original array when nothing changed so callers can skip rewriting the result.
+ */
+export async function normalizeToolResultImages(content, options) {
+    if (!content.some((block) => block.type === "image")) {
+        return content;
+    }
+    const autoResizeImages = options?.autoResizeImages ?? true;
+    const normalized = [];
+    let changed = false;
+    for (const block of content) {
+        if (block.type !== "image") {
+            normalized.push(block);
+            continue;
+        }
+        const processed = await processImage(Buffer.from(block.data, "base64"), block.mimeType, {
+            autoResizeImages,
+            resizeOptions: options?.resizeOptions,
+        });
+        if (!processed.ok) {
+            // Unlike `read`, keep the original block. The tool already produced this image and the
+            // failure may just be an unavailable image backend, so passing it through preserves the
+            // behavior tools have today instead of silently deleting their output.
+            normalized.push(block);
+            continue;
+        }
+        if (processed.data === block.data && processed.mimeType === block.mimeType && processed.hints.length === 0) {
+            normalized.push(block);
+            continue;
+        }
+        normalized.push({ type: "image", data: processed.data, mimeType: processed.mimeType });
+        if (processed.hints.length > 0) {
+            normalized.push({ type: "text", text: processed.hints.join("\n") });
+        }
+        changed = true;
+    }
+    return changed ? normalized : content;
+}