@selesai/code 0.13.39 → 0.14.0

package/dist/core/tools/edit.js

@@ -1,7 +1,8 @@
 import { constants } from "fs";
 import { access as fsAccess, readFile as fsReadFile, writeFile as fsWriteFile } from "fs/promises";
 import { Type } from "typebox";
-import { applyEditsToNormalizedContent, detectLineEnding, generateDiffString, generateUnifiedPatch, normalizeToLF, restoreLineEndings, stripBom, } from "./edit-diff.js";
+import { splitBom } from "../../utils/text.js";
+import { applyEditsToNormalizedContent, detectLineEnding, generateDiffString, generateUnifiedPatch, normalizeToLF, restoreLineEndings, } from "./edit-diff.js";
 import { withFileMutationQueue } from "./file-mutation-queue.js";
 import { resolveToCwd } from "./path-utils.js";
 import { editRenderers } from "./renderers/edit.js";
@@ -18,6 +19,22 @@ const editSchema = Type.Object({
         description: "One or more targeted replacements. Each edit is matched against the original file, not incrementally. Do not include overlapping or nested edits. If two changes touch the same block or nearby lines, merge them into one edit instead.",
     }),
 }, {});
+export const editToolSystemPromptContribution = {
+    snippet: "Make precise file edits with exact text replacement, including multiple disjoint edits in one call",
+    guidelines: [
+        "Use edit for precise changes (edits[].oldText must match exactly)",
+        "When changing multiple separate locations in one file, use one edit call with multiple entries in edits[] instead of multiple edit calls",
+        "Each edits[].oldText is matched against the original file, not after earlier edits are applied. Do not emit overlapping or nested edits. Merge nearby changes into one edit.",
+        "Keep edits[].oldText as small as possible while still being unique in the file. Do not pad with large unchanged regions.",
+    ],
+};
+function isSingleEditInput(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return false;
+    }
+    const edit = value;
+    return typeof edit.oldText === "string" && typeof edit.newText === "string";
+}
 const defaultEditOperations = {
     readFile: (path) => fsReadFile(path),
     writeFile: (path, content) => fsWriteFile(path, content, "utf-8"),
@@ -28,15 +45,23 @@ function prepareEditArguments(input) {
         return input;
     }
     const args = input;
-    // Some models (Opus 4.6, GLM-5.1) send edits as a JSON string instead of an array
+    // Some models (Opus 4.6, GLM-5.1) send edits as a JSON string instead of an array.
+    // Others send a single edit object instead of a one-element edits array.
     if (typeof args.edits === "string") {
         try {
             const parsed = JSON.parse(args.edits);
-            if (Array.isArray(parsed))
+            if (Array.isArray(parsed)) {
                 args.edits = parsed;
+            }
+            else if (isSingleEditInput(parsed)) {
+                args.edits = [parsed];
+            }
         }
         catch { }
     }
+    else if (isSingleEditInput(args.edits)) {
+        args.edits = [args.edits];
+    }
     const legacy = args;
     if (typeof legacy.oldText !== "string" || typeof legacy.newText !== "string") {
         return args;
@@ -58,13 +83,8 @@ export function createEditToolDefinition(cwd, options) {
         name: "edit",
         label: "edit",
         description: "Edit a single file using exact text replacement. Every edits[].oldText must match a unique, non-overlapping region of the original file. If two changes affect the same block or nearby lines, merge them into one edit instead of emitting overlapping edits. Do not include large unchanged regions just to connect distant changes.",
-        promptSnippet: "Make precise file edits with exact text replacement, including multiple disjoint edits in one call",
-        promptGuidelines: [
-            "Use edit for precise changes (edits[].oldText must match exactly)",
-            "When changing multiple separate locations in one file, use one edit call with multiple entries in edits[] instead of multiple edit calls",
-            "Each edits[].oldText is matched against the original file, not after earlier edits are applied. Do not emit overlapping or nested edits. Merge nearby changes into one edit.",
-            "Keep edits[].oldText as small as possible while still being unique in the file. Do not pad with large unchanged regions.",
-        ],
+        promptSnippet: editToolSystemPromptContribution.snippet,
+        promptGuidelines: [...editToolSystemPromptContribution.guidelines],
         parameters: editSchema,
         constrainedSampling: { type: "json_schema", strict: "prefer" },
         renderShell: "self",
@@ -97,7 +117,7 @@ export function createEditToolDefinition(cwd, options) {
                 const rawContent = buffer.toString("utf-8");
                 throwIfAborted();
                 // Strip BOM before matching. The model will not include an invisible BOM in oldText.
-                const { bom, text: content } = stripBom(rawContent);
+                const { bom, text: content } = splitBom(rawContent);
                 const originalEnding = detectLineEnding(content);
                 const normalizedContent = normalizeToLF(content);
                 const { baseContent, newContent } = applyEditsToNormalizedContent(normalizedContent, edits, path);

package/dist/core/tools/find.d.ts

@@ -1,12 +1,19 @@
 import type { AgentTool } from "@earendil-works/pi-agent-core";
+import path from "path";
 import { type Static, Type } from "typebox";
 import type { ToolDefinition } from "../extensions/types.ts";
 import { type TruncationResult } from "./truncate.ts";
+/** Relativize a find result against the search root and normalize it to posix separators. */
+export declare function relativizeFindResultPath(resultPath: string, searchPath: string, pathModule?: path.PlatformPath): string;
 declare const findSchema: Type.TObject<{
     pattern: Type.TString;
     path: Type.TOptional<Type.TString>;
     limit: Type.TOptional<Type.TNumber>;
 }>;
+export declare const findToolSystemPromptContribution: {
+    readonly snippet: "Find files by glob pattern (respects .gitignore)";
+    readonly guidelines: readonly [];
+};
 export type FindToolInput = Static<typeof findSchema>;
 export interface FindToolDetails {
     truncation?: TruncationResult;

package/dist/core/tools/find.js

@@ -7,8 +7,12 @@ import { pathExists, resolveToCwd } from "./path-utils.js";
 import { findRenderers } from "./renderers/find.js";
 import { wrapToolDefinition } from "./tool-definition-wrapper.js";
 import { DEFAULT_MAX_BYTES, formatSize, truncateHead } from "./truncate.js";
-function toPosixPath(value) {
-    return value.split(path.sep).join("/");
+/** Relativize a find result against the search root and normalize it to posix separators. */
+export function relativizeFindResultPath(resultPath, searchPath, pathModule = path) {
+    const hadTrailingSeparator = resultPath.endsWith(pathModule.sep) || (pathModule.sep === "\\" && resultPath.endsWith("/"));
+    const relativePath = pathModule.isAbsolute(resultPath) ? pathModule.relative(searchPath, resultPath) : resultPath;
+    const posixPath = relativePath.split(pathModule.sep).join("/");
+    return hadTrailingSeparator && !posixPath.endsWith("/") ? `${posixPath}/` : posixPath;
 }
 const findSchema = Type.Object({
     pattern: Type.String({
@@ -17,6 +21,10 @@ const findSchema = Type.Object({
     path: Type.Optional(Type.String({ description: "Directory to search in (default: current directory)" })),
     limit: Type.Optional(Type.Number({ description: "Maximum number of results (default: 1000)" })),
 });
+export const findToolSystemPromptContribution = {
+    snippet: "Find files by glob pattern (respects .gitignore)",
+    guidelines: [],
+};
 const DEFAULT_LIMIT = 1000;
 const defaultFindOperations = {
     exists: pathExists,
@@ -29,7 +37,7 @@ export function createFindToolDefinition(cwd, options) {
         name: "find",
         label: "find",
         description: `Search for files by glob pattern. Returns matching file paths relative to the search directory. Respects .gitignore. Output is truncated to ${DEFAULT_LIMIT} results or ${DEFAULT_MAX_BYTES / 1024}KB (whichever is hit first).`,
-        promptSnippet: "Find files by glob pattern (respects .gitignore)",
+        promptSnippet: findToolSystemPromptContribution.snippet,
         parameters: findSchema,
         async execute(_toolCallId, { pattern, path: searchDir, limit }, signal, _onUpdate, ctx) {
             return new Promise((resolve, reject) => {
@@ -83,11 +91,7 @@ export function createFindToolDefinition(cwd, options) {
                                 return;
                             }
                             // Relativize paths against the search root for stable output.
-                            const relativized = results.map((p) => {
-                                if (p.startsWith(searchPath))
-                                    return toPosixPath(p.slice(searchPath.length + 1));
-                                return toPosixPath(path.relative(searchPath, p));
-                            });
+                            const relativized = results.map((p) => relativizeFindResultPath(p, searchPath));
                             const resultLimitReached = relativized.length >= effectiveLimit;
                             const rawOutput = relativized.join("\n");
                             const truncation = truncateHead(rawOutput, { maxLines: Number.MAX_SAFE_INTEGER });
@@ -149,6 +153,9 @@ export function createFindToolDefinition(cwd, options) {
                             if (!pattern.startsWith("/") && !pattern.startsWith("**/") && pattern !== "**") {
                                 effectivePattern = `**/${pattern}`;
                             }
+                            // fd matches full paths using native separators on Windows.
+                            if (process.platform === "win32")
+                                effectivePattern = effectivePattern.replaceAll("/", String.raw `[/\\]`);
                         }
                         args.push("--", effectivePattern, searchPath);
                         const child = spawn(fdPath, args, { stdio: ["ignore", "pipe", "pipe"] });
@@ -199,17 +206,7 @@ export function createFindToolDefinition(cwd, options) {
                                 const line = rawLine.replace(/\r$/, "").trim();
                                 if (!line)
                                     continue;
-                                const hadTrailingSlash = line.endsWith("/") || line.endsWith("\\");
-                                let relativePath = line;
-                                if (line.startsWith(searchPath)) {
-                                    relativePath = line.slice(searchPath.length + 1);
-                                }
-                                else {
-                                    relativePath = path.relative(searchPath, line);
-                                }
-                                if (hadTrailingSlash && !relativePath.endsWith("/"))
-                                    relativePath += "/";
-                                relativized.push(toPosixPath(relativePath));
+                                relativized.push(relativizeFindResultPath(line, searchPath));
                             }
                             const resultLimitReached = relativized.length >= effectiveLimit;
                             const rawOutput = relativized.join("\n");

package/dist/core/tools/grep.d.ts

@@ -11,6 +11,10 @@ declare const grepSchema: Type.TObject<{
     context: Type.TOptional<Type.TNumber>;
     limit: Type.TOptional<Type.TNumber>;
 }>;
+export declare const grepToolSystemPromptContribution: {
+    readonly snippet: "Search file contents for patterns (respects .gitignore)";
+    readonly guidelines: readonly [];
+};
 export type GrepToolInput = Static<typeof grepSchema>;
 export interface GrepToolDetails {
     truncation?: TruncationResult;

package/dist/core/tools/grep.js

@@ -17,6 +17,10 @@ const grepSchema = Type.Object({
     context: Type.Optional(Type.Number({ description: "Number of lines to show before and after each match (default: 0)" })),
     limit: Type.Optional(Type.Number({ description: "Maximum number of matches to return (default: 100)" })),
 });
+export const grepToolSystemPromptContribution = {
+    snippet: "Search file contents for patterns (respects .gitignore)",
+    guidelines: [],
+};
 const DEFAULT_LIMIT = 100;
 const defaultGrepOperations = {
     isDirectory: async (p) => (await fsStat(p)).isDirectory(),
@@ -28,7 +32,7 @@ export function createGrepToolDefinition(cwd, options) {
         name: "grep",
         label: "grep",
         description: `Search file contents for a pattern. Returns matching lines with file paths and line numbers. Respects .gitignore. Output is truncated to ${DEFAULT_LIMIT} matches or ${DEFAULT_MAX_BYTES / 1024}KB (whichever is hit first). Long lines are truncated to ${GREP_MAX_LINE_LENGTH} chars.`,
-        promptSnippet: "Search file contents for patterns (respects .gitignore)",
+        promptSnippet: grepToolSystemPromptContribution.snippet,
         parameters: grepSchema,
         async execute(_toolCallId, { pattern, path: searchDir, glob, ignoreCase, literal, context, limit, }, signal, _onUpdate, ctx) {
             return new Promise((resolve, reject) => {

package/dist/core/tools/index.d.ts

@@ -1,10 +1,10 @@
 export { type BashOperations, type BashSpawnContext, type BashSpawnHook, type BashToolDetails, type BashToolInput, type BashToolOptions, createBashTool, createBashToolDefinition, createLocalBashOperations, } from "./bash.ts";
-export { createLocalPowerShellOperations, createPowerShellTool, createPowerShellToolDefinition, type PowerShellOperations, type PowerShellSpawnContext, type PowerShellSpawnHook, type PowerShellToolDetails, type PowerShellToolInput, type PowerShellToolOptions, } from "./powershell.ts";
 export { createEditTool, createEditToolDefinition, type EditOperations, type EditToolDetails, type EditToolInput, type EditToolOptions, } from "./edit.ts";
 export { withFileMutationQueue } from "./file-mutation-queue.ts";
 export { createFindTool, createFindToolDefinition, type FindOperations, type FindToolDetails, type FindToolInput, type FindToolOptions, } from "./find.ts";
 export { createGrepTool, createGrepToolDefinition, type GrepOperations, type GrepToolDetails, type GrepToolInput, type GrepToolOptions, } from "./grep.ts";
 export { createLsTool, createLsToolDefinition, type LsOperations, type LsToolDetails, type LsToolInput, type LsToolOptions, } from "./ls.ts";
+export { createLocalPowerShellOperations, createPowerShellTool, createPowerShellToolDefinition, type PowerShellOperations, type PowerShellSpawnContext, type PowerShellSpawnHook, type PowerShellToolDetails, type PowerShellToolInput, type PowerShellToolOptions, } from "./powershell.ts";
 export { createReadTool, createReadToolDefinition, type ReadOperations, type ReadToolDetails, type ReadToolInput, type ReadToolOptions, } from "./read.ts";
 export { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize, type TruncationOptions, type TruncationResult, truncateHead, truncateLine, truncateTail, } from "./truncate.ts";
 export { createWriteTool, createWriteToolDefinition, type WriteOperations, type WriteToolInput, type WriteToolOptions, } from "./write.ts";

package/dist/core/tools/index.js

@@ -1,10 +1,10 @@
 export { createBashTool, createBashToolDefinition, createLocalBashOperations, } from "./bash.js";
-export { createLocalPowerShellOperations, createPowerShellTool, createPowerShellToolDefinition, } from "./powershell.js";
 export { createEditTool, createEditToolDefinition, } from "./edit.js";
 export { withFileMutationQueue } from "./file-mutation-queue.js";
 export { createFindTool, createFindToolDefinition, } from "./find.js";
 export { createGrepTool, createGrepToolDefinition, } from "./grep.js";
 export { createLsTool, createLsToolDefinition, } from "./ls.js";
+export { createLocalPowerShellOperations, createPowerShellTool, createPowerShellToolDefinition, } from "./powershell.js";
 export { createReadTool, createReadToolDefinition, } from "./read.js";
 export { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize, truncateHead, truncateLine, truncateTail, } from "./truncate.js";
 export { createWriteTool, createWriteToolDefinition, } from "./write.js";
@@ -16,7 +16,16 @@ import { createLsTool, createLsToolDefinition } from "./ls.js";
 import { createPowerShellTool, createPowerShellToolDefinition } from "./powershell.js";
 import { createReadTool, createReadToolDefinition } from "./read.js";
 import { createWriteTool, createWriteToolDefinition } from "./write.js";
-export const allToolNames = new Set(["read", "bash", "powershell", "edit", "write", "grep", "find", "ls"]);
+export const allToolNames = new Set([
+    "read",
+    "bash",
+    "powershell",
+    "edit",
+    "write",
+    "grep",
+    "find",
+    "ls",
+]);
 export function createToolDefinition(toolName, cwd, options) {
     switch (toolName) {
         case "read":

package/dist/core/tools/ls.d.ts

@@ -6,6 +6,10 @@ declare const lsSchema: Type.TObject<{
     path: Type.TOptional<Type.TString>;
     limit: Type.TOptional<Type.TNumber>;
 }>;
+export declare const lsToolSystemPromptContribution: {
+    readonly snippet: "List directory contents";
+    readonly guidelines: readonly [];
+};
 export type LsToolInput = Static<typeof lsSchema>;
 export interface LsToolDetails {
     truncation?: TruncationResult;

package/dist/core/tools/ls.js

@@ -9,6 +9,10 @@ const lsSchema = Type.Object({
     path: Type.Optional(Type.String({ description: "Directory to list (default: current directory)" })),
     limit: Type.Optional(Type.Number({ description: "Maximum number of entries to return (default: 500)" })),
 });
+export const lsToolSystemPromptContribution = {
+    snippet: "List directory contents",
+    guidelines: [],
+};
 const DEFAULT_LIMIT = 500;
 const defaultLsOperations = {
     exists: pathExists,
@@ -21,7 +25,7 @@ export function createLsToolDefinition(cwd, options) {
         name: "ls",
         label: "ls",
         description: `List directory contents. Returns entries sorted alphabetically, with '/' suffix for directories. Includes dotfiles. Output is truncated to ${DEFAULT_LIMIT} entries or ${DEFAULT_MAX_BYTES / 1024}KB (whichever is hit first).`,
-        promptSnippet: "List directory contents",
+        promptSnippet: lsToolSystemPromptContribution.snippet,
         parameters: lsSchema,
         async execute(_toolCallId, { path, limit }, signal, _onUpdate, ctx) {
             return new Promise((resolve, reject) => {

package/dist/core/tools/output-accumulator.d.ts

@@ -9,6 +9,11 @@ export interface OutputSnapshot {
     truncation: TruncationResult;
     fullOutputPath?: string;
 }
+export interface FullOutput {
+    content: string;
+    /** Whether `content` omits part of the output. */
+    truncated: boolean;
+}
 /**
  * Incrementally tracks streaming output with bounded memory.
  *
@@ -42,6 +47,12 @@ export declare class OutputAccumulator {
         persistIfTruncated?: boolean;
     }): OutputSnapshot;
     closeTempFile(): Promise<void>;
+    /**
+     * The complete output, for callers that can take more than the display snapshot. Call after
+     * `finish()` and `closeTempFile()`. Output longer than `maxBytes` raw bytes keeps its first and
+     * last `maxBytes / 2` bytes around an omission marker.
+     */
+    readFullOutput(maxBytes: number): Promise<FullOutput>;
     getLastLineBytes(): number;
     private appendDecodedText;
     private trimTail;

package/dist/core/tools/output-accumulator.js

@@ -1,12 +1,6 @@
-import { randomBytes } from "node:crypto";
-import { createWriteStream } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
+import { open } from "node:fs/promises";
+import { createOutputFileStream } from "../../utils/output-files.js";
 import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, truncateTail } from "./truncate.js";
-function defaultTempFilePath(prefix) {
-    const id = randomBytes(8).toString("hex");
-    return join(tmpdir(), `${prefix}-${id}.log`);
-}
 function byteLength(text) {
     return Buffer.byteLength(text, "utf-8");
 }
@@ -113,6 +107,41 @@ export class OutputAccumulator {
             stream.end();
         });
     }
+    /**
+     * The complete output, for callers that can take more than the display snapshot. Call after
+     * `finish()` and `closeTempFile()`. Output longer than `maxBytes` raw bytes keeps its first and
+     * last `maxBytes / 2` bytes around an omission marker.
+     */
+    async readFullOutput(maxBytes) {
+        if (!this.tempFilePath) {
+            return { content: new TextDecoder().decode(Buffer.concat(this.rawChunks)), truncated: false };
+        }
+        const file = await open(this.tempFilePath, "r");
+        try {
+            const size = (await file.stat()).size;
+            if (size <= maxBytes) {
+                return { content: new TextDecoder().decode(await file.readFile()), truncated: false };
+            }
+            const headBytes = Math.floor(maxBytes / 2);
+            const tailBytes = maxBytes - headBytes;
+            const head = Buffer.alloc(headBytes);
+            const tail = Buffer.alloc(tailBytes);
+            await file.read(head, 0, headBytes, 0);
+            await file.read(tail, 0, tailBytes, size - tailBytes);
+            // Cut at character boundaries: streaming decode holds back an incomplete trailing sequence,
+            // and the tail skips leading continuation bytes.
+            const headText = new TextDecoder().decode(head, { stream: true });
+            let tailStart = 0;
+            while (tailStart < tail.length && (tail[tailStart] & 0xc0) === 0x80)
+                tailStart++;
+            const tailText = new TextDecoder().decode(tail.subarray(tailStart));
+            const omitted = size - headBytes - tailBytes;
+            return { content: `${headText}\n\n[... ${omitted} bytes omitted ...]\n\n${tailText}`, truncated: true };
+        }
+        finally {
+            await file.close();
+        }
+    }
     getLastLineBytes() {
         return this.currentLineBytes;
     }
@@ -173,8 +202,9 @@ export class OutputAccumulator {
         if (this.tempFilePath) {
             return;
         }
-        this.tempFilePath = defaultTempFilePath(this.tempFilePrefix);
-        this.tempFileStream = createWriteStream(this.tempFilePath);
+        const { path, stream } = createOutputFileStream(this.tempFilePrefix, ".log");
+        this.tempFilePath = path;
+        this.tempFileStream = stream;
         for (const chunk of this.rawChunks) {
             this.tempFileStream.write(chunk);
         }

package/dist/core/tools/read.d.ts

@@ -1,5 +1,5 @@
 import type { AgentTool } from "@earendil-works/pi-agent-core";
-import type { ImageContent } from "@earendil-works/pi-ai";
+import type { ImageContent, ModelImageResizeOptions } from "@earendil-works/pi-ai";
 import { type Static, Type } from "typebox";
 import type { ExtensionContext, ToolDefinition } from "../extensions/types.ts";
 import { type TruncationResult } from "./truncate.ts";
@@ -13,6 +13,19 @@ export declare const readToolSystemPromptContribution: {
     readonly guidelines: readonly ["Use read to examine files instead of cat or sed."];
 };
 export type ReadToolInput = Static<typeof readSchema>;
+/**
+ * Result for programmatic callers such as codemode scripts: the text for text files, and an image
+ * block for images that codemode's `image()` accepts. `note` is the text that goes with the image,
+ * such as resize hints. Property descriptions are left out so the type stays on one line in tool
+ * descriptions.
+ */
+declare const readOutputSchema: Type.TUnion<[Type.TString, Type.TObject<{
+    type: Type.TLiteral<"image">;
+    data: Type.TString;
+    mimeType: Type.TString;
+    note: Type.TString;
+}>]>;
+export type ReadToolOutput = Static<typeof readOutputSchema>;
 export interface ReadToolDetails {
     truncation?: TruncationResult;
 }
@@ -29,7 +42,7 @@ export interface ReadOperations {
     detectImageMimeType?: (absolutePath: string) => Promise<string | null | undefined>;
 }
 export interface ReadToolOptions {
-    /** Whether to auto-resize images to 2000x2000 max. Default: true */
+    /** Whether to auto-resize images. Default: true */
     autoResizeImages?: boolean;
     /**
      * Vision model ("provider/modelId") used to describe images when the active
@@ -37,6 +50,8 @@ export interface ReadToolOptions {
      * the image block. Default: unset (images are omitted as before).
      */
     imageCaptionModel?: string;
+    /** Fallback resize profile when the execution context has no model metadata. */
+    resizeOptions?: ModelImageResizeOptions;
     /** Custom operations for file reading. Default: local filesystem */
     operations?: ReadOperations;
 }

package/dist/core/tools/read.js

@@ -17,11 +17,27 @@ export const readToolSystemPromptContribution = {
     snippet: "Read file contents",
     guidelines: ["Use read to examine files instead of cat or sed."],
 };
+/**
+ * Result for programmatic callers such as codemode scripts: the text for text files, and an image
+ * block for images that codemode's `image()` accepts. `note` is the text that goes with the image,
+ * such as resize hints. Property descriptions are left out so the type stays on one line in tool
+ * descriptions.
+ */
+const readOutputSchema = Type.Union([
+    Type.String(),
+    Type.Object({ type: Type.Literal("image"), data: Type.String(), mimeType: Type.String(), note: Type.String() }),
+]);
 const defaultReadOperations = {
     readFile: (path) => fsReadFile(path),
     access: (path) => fsAccess(path, constants.R_OK),
     detectImageMimeType: detectSupportedImageMimeTypeFromFile,
 };
+/** The image block and its note, or the text for text files and images that could not be processed. */
+function toReadOutput(content) {
+    const text = content.find((block) => block.type === "text")?.text ?? "";
+    const image = content.find((block) => block.type === "image");
+    return image ? { type: "image", data: image.data, mimeType: image.mimeType, note: text } : text;
+}
 function getNonVisionImageNote(model) {
     if (!model || model.input.includes("image")) {
         return undefined;
@@ -61,6 +77,7 @@ export async function captionImage(image, captionModelId, ctx, signal) {
 export function createReadToolDefinition(cwd, options) {
     const autoResizeImages = options?.autoResizeImages ?? true;
     const imageCaptionModel = options?.imageCaptionModel;
+    const fallbackResizeOptions = options?.resizeOptions;
     const ops = options?.operations ?? defaultReadOperations;
     return {
         name: "read",
@@ -69,6 +86,7 @@ export function createReadToolDefinition(cwd, options) {
         promptSnippet: readToolSystemPromptContribution.snippet,
         promptGuidelines: [...readToolSystemPromptContribution.guidelines],
         parameters: readSchema,
+        outputSchema: readOutputSchema,
         constrainedSampling: { type: "json_schema", strict: "prefer" },
         async execute(_toolCallId, { path, offset, limit }, signal, _onUpdate, ctx) {
             return new Promise((resolve, reject) => {
@@ -98,7 +116,10 @@ export function createReadToolDefinition(cwd, options) {
                         if (mimeType) {
                             // Read image as binary.
                             const buffer = await ops.readFile(absolutePath);
-                            const processed = await processImage(buffer, mimeType, { autoResizeImages });
+                            const processed = await processImage(buffer, mimeType, {
+                                autoResizeImages,
+                                resizeOptions: ctx?.model?.inputLimits?.images?.resize ?? fallbackResizeOptions,
+                            });
                             if (!processed.ok) {
                                 let textNote = `Read image file [${mimeType}]\n${processed.message}`;
                                 if (nonVisionImageNote)
@@ -204,7 +225,7 @@ export function createReadToolDefinition(cwd, options) {
                             reject(error);
                     }
                 })();
-            });
+            }).then((result) => ({ ...result, structuredContent: toReadOutput(result.content) }));
         },
         ...readRenderers,
     };

package/dist/core/tools/render-utils.d.ts

@@ -17,6 +17,12 @@ export type ToolRenderResultLike<TDetails> = {
     content: (TextContent | ImageContent)[];
     details: TDetails;
 };
+/**
+ * Generic tool call header: the title followed by the arguments. Collapsed, they are `key=value`
+ * pairs on the title line, cut to {@link COLLAPSED_ARGS_CHARS}. Expanded, each is a `key: value`
+ * line below the title, with strings shown raw and continuation lines indented.
+ */
+export declare function formatToolCallWithArgs(title: string, args: unknown, theme: Theme, expanded: boolean): string;
 export declare function invalidArgText(theme: Theme): string;
 export declare function renderToolPath(rawPath: string | null, theme: Theme, cwd: string, options?: {
     emptyFallback?: string;

package/dist/core/tools/render-utils.js

@@ -51,6 +51,32 @@ export function getTextOutput(result, showImages) {
     }
     return output;
 }
+const COLLAPSED_ARGS_CHARS = 100;
+/**
+ * Generic tool call header: the title followed by the arguments. Collapsed, they are `key=value`
+ * pairs on the title line, cut to {@link COLLAPSED_ARGS_CHARS}. Expanded, each is a `key: value`
+ * line below the title, with strings shown raw and continuation lines indented.
+ */
+export function formatToolCallWithArgs(title, args, theme, expanded) {
+    const header = theme.fg("toolTitle", theme.bold(title));
+    if (args == null)
+        return header;
+    const entries = typeof args === "object" && !Array.isArray(args)
+        ? Object.entries(args)
+        : [["args", args]];
+    if (entries.length === 0)
+        return header;
+    if (expanded) {
+        const lines = entries.map(([key, value]) => {
+            const text = typeof value === "string" ? value : (JSON.stringify(value, null, 2) ?? String(value));
+            return `  ${key}: ${replaceTabs(text).replace(/\r/g, "").split("\n").join("\n    ")}`;
+        });
+        return `${header}\n${theme.fg("muted", lines.join("\n"))}`;
+    }
+    const pairs = entries.map(([key, value]) => `${key}=${JSON.stringify(value) ?? String(value)}`).join(" ");
+    const preview = pairs.length > COLLAPSED_ARGS_CHARS ? `${pairs.slice(0, COLLAPSED_ARGS_CHARS - 3)}...` : pairs;
+    return `${header} ${theme.fg("muted", preview)}`;
+}
 export function invalidArgText(theme) {
     return theme.fg("error", "[invalid arg]");
 }

package/dist/core/tools/renderers/bash.js

@@ -5,21 +5,14 @@
  * load the execution path or its typebox parameter schema. `bash.ts` spreads these into the shell
  * tool definition, so the tool's public shape is unchanged.
  */
-import { Container, Text, truncateToWidth } from "@earendil-works/pi-tui";
+import { Container, Spacer, Text } from "@earendil-works/pi-tui";
 import { keyHint } from "../../../modes/interactive/components/keybinding-hints.js";
-import { truncateToVisualLines } from "../../../modes/interactive/components/visual-truncate.js";
+import { VisualLinePreview } from "../../../modes/interactive/components/visual-truncate.js";
 import { theme } from "../../../modes/interactive/theme/theme.js";
 import { getTextOutput, invalidArgText, str } from "../render-utils.js";
 import { DEFAULT_MAX_BYTES, formatSize } from "../truncate.js";
 const BASH_PREVIEW_LINES = 5;
 export const BASH_UPDATE_THROTTLE_MS = 100;
-class BashResultRenderComponent extends Container {
-    state = {
-        cachedWidth: undefined,
-        cachedLines: undefined,
-        cachedSkipped: undefined,
-    };
-}
 function formatDuration(ms) {
     const seconds = ms / 1000;
     if (seconds < 60)
@@ -38,8 +31,7 @@ function formatShellCall(args, prompt) {
     const commandDisplay = command === null ? invalidArgText(theme) : command ? command : theme.fg("toolOutput", "...");
     return theme.fg("toolTitle", theme.bold(`${prompt} ${commandDisplay}`)) + timeoutSuffix;
 }
-function rebuildBashResultRenderComponent(component, result, options, showImages, startedAt, endedAt) {
-    const state = component.state;
+function rebuildBashResultRenderComponent(component, result, options, showImages, startedAt, endedAt, durationMs) {
     component.clear();
     let output = getTextOutput(result, showImages).trim();
     const truncation = result.details?.truncation;
@@ -59,27 +51,14 @@ function rebuildBashResultRenderComponent(component, result, options, showImages
             component.addChild(new Text(`\n${styledOutput}`, 0, 0));
         }
         else {
-            component.addChild({
-                render: (width) => {
-                    if (state.cachedLines === undefined || state.cachedWidth !== width) {
-                        const preview = truncateToVisualLines(styledOutput, BASH_PREVIEW_LINES, width);
-                        state.cachedLines = preview.visualLines;
-                        state.cachedSkipped = preview.skippedCount;
-                        state.cachedWidth = width;
-                    }
-                    if (state.cachedSkipped && state.cachedSkipped > 0) {
-                        const hint = theme.fg("muted", `... (${state.cachedSkipped} earlier lines,`) +
-                            ` ${keyHint("app.tools.expand", "to expand")}${theme.fg("muted", ")")}`;
-                        return ["", truncateToWidth(hint, width, "..."), ...(state.cachedLines ?? [])];
-                    }
-                    return ["", ...(state.cachedLines ?? [])];
-                },
-                invalidate: () => {
-                    state.cachedWidth = undefined;
-                    state.cachedLines = undefined;
-                    state.cachedSkipped = undefined;
-                },
-            });
+            component.addChild(new Spacer(1));
+            component.addChild(new VisualLinePreview({
+                text: styledOutput,
+                maxVisualLines: BASH_PREVIEW_LINES,
+                keep: "end",
+                formatHint: (hidden) => theme.fg("muted", `... (${hidden} earlier lines,`) +
+                    ` ${keyHint("app.tools.expand", "to expand")}${theme.fg("muted", ")")}`,
+            }));
         }
     }
     if (truncation?.truncated || fullOutputPath) {
@@ -97,7 +76,12 @@ function rebuildBashResultRenderComponent(component, result, options, showImages
         }
         component.addChild(new Text(`\n${theme.fg("warning", `[${warnings.join(". ")}]`)}`, 0, 0));
     }
-    if (startedAt !== undefined) {
+    // A final result's recorded duration wins: it is monotonic and survives reloads. The renderer's own clock is the
+    // fallback for live progress and for results stored without one.
+    if (!options.isPartial && durationMs !== undefined) {
+        component.addChild(new Text(`\n${theme.fg("muted", `Took ${formatDuration(durationMs)}`)}`, 0, 0));
+    }
+    else if (startedAt !== undefined) {
         const label = options.isPartial ? "Elapsed" : "Took";
         const endTime = endedAt ?? Date.now();
         component.addChild(new Text(`\n${theme.fg("muted", `${label} ${formatDuration(endTime - startedAt)}`)}`, 0, 0));
@@ -128,8 +112,8 @@ export function createShellRenderers(prompt) {
                     state.interval = undefined;
                 }
             }
-            const component = context.lastComponent ?? new BashResultRenderComponent();
-            rebuildBashResultRenderComponent(component, result, options, context.showImages, state.startedAt, state.endedAt);
+            const component = context.lastComponent ?? new Container();
+            rebuildBashResultRenderComponent(component, result, options, context.showImages, state.startedAt, state.endedAt, context.durationMs);
             component.invalidate();
             return component;
         },