@code-yeongyu/senpi 2026.11.15-2 → 2026.11.15-3

package/dist/core/tools/read-core.js

@@ -0,0 +1,180 @@
+import { selectedReadFolder } from "@earendil-works/pi-agent-core/read-folders";
+import { Type } from "typebox";
+import { detectSupportedImageMimeType, IMAGE_TYPE_SNIFF_BYTES } from "../../utils/image-mime.js";
+import { decodeUtf8, encodeBase64 } from "./encoding.js";
+import { lexicalCanonicalPath, resolvePosixToolPath, resolveReadPathVariants, } from "./file-tool-host.js";
+import { wrapToolDefinition } from "./tool-definition-wrapper.js";
+import { shapeTextRead } from "./read-text.js";
+import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES } from "./truncate.js";
+const readSchema = Type.Object({
+    path: Type.String({ description: "Path to the file to read (relative or absolute)" }),
+    offset: Type.Optional(Type.Number({ description: "Line number to start reading from (1-indexed)" })),
+    limit: Type.Optional(Type.Number({ description: "Maximum number of lines to read" })),
+});
+export const readToolSystemPromptContribution = {
+    snippet: "Read file contents",
+    guidelines: ["Files: read, not cat/sed."],
+    fullGuidelines: ["Use read to examine files instead of cat or sed."],
+};
+const LOCAL_URI_SCHEME = /^local:\/\//i;
+const LOCAL_URI_GUIDANCE = "local:// URIs resolve only inside eval cells via the kernel read()/write() helpers; the read tool takes filesystem paths. Re-read this with the eval read() helper, or retry with the plain absolute file path.";
+const INLINE_IMAGE_TYPES = new Set(["image/png", "image/jpeg", "image/gif", "image/webp"]);
+const inlineImageAsIs = async (bytes, mimeType) => INLINE_IMAGE_TYPES.has(mimeType)
+    ? { ok: true, data: encodeBase64(bytes), mimeType, hints: [] }
+    : { ok: false, message: "[Image omitted: could not be converted to a supported inline image format.]" };
+function machineReadPath(machine) {
+    const exists = (path) => machine.ops.files.stat({ path }, machine.context(undefined)).then(() => true, () => false);
+    return (path, cwd) => resolveReadPathVariants(path, cwd, resolvePosixToolPath, exists);
+}
+/** The default read operations: the shared operation layer, called with the context of one admitted call. */
+function machineReadOperations(machine, signal, detectImageMimeType) {
+    const ctx = machine.context(signal);
+    return {
+        readFile: async (path) => (await machine.ops.files.read({ path }, ctx)).bytes,
+        access: async (path) => {
+            await machine.ops.files.stat({ path, access: "read" }, ctx);
+        },
+        detectImageMimeType: detectImageMimeType ??
+            (async (path) => {
+                const head = await machine.ops.files.read({ path, offset: 0, limitBytes: IMAGE_TYPE_SNIFF_BYTES }, ctx);
+                return detectSupportedImageMimeType(head.bytes);
+            }),
+    };
+}
+function getNonVisionImageNote(model) {
+    if (!model || model.input.includes("image")) {
+        return undefined;
+    }
+    return "[Current model does not support images. The image will be omitted from this request.]";
+}
+export function createCoreReadToolDefinition(cwd, options) {
+    const autoResizeImages = options.autoResizeImages ?? true;
+    const fallbackResizeOptions = options.resizeOptions;
+    const contextModel = options.contextModel ?? true;
+    const customOps = options.operations;
+    const machine = options.machine;
+    const filesystemPolicy = options.filesystemPolicy;
+    const resolveReadPath = options.resolveReadPath ?? machineReadPath(machine);
+    const canonicalizePath = options.canonicalizePath ?? lexicalCanonicalPath;
+    const processImage = options.processImage ?? inlineImageAsIs;
+    return {
+        name: "read",
+        workspaceEffect: "read",
+        label: "read",
+        description: `Read the contents of a file. Supports text files and images (jpg, png, gif, webp, bmp). Images are sent as attachments. For text files, output is truncated to ${DEFAULT_MAX_LINES} lines or ${DEFAULT_MAX_BYTES / 1024}KB (whichever is hit first). Use offset/limit for large files. When you need the full file, continue with offset until complete. A .js or .json file of 100+ lines read without offset/limit may come back folded: bodies are replaced by markers and a footer lists the offset/limit ranges to reread; markers are not source, so reread those ranges before quoting or editing them.`,
+        promptSnippet: readToolSystemPromptContribution.snippet,
+        promptGuidelines: [...readToolSystemPromptContribution.guidelines],
+        fullPromptGuidelines: [...readToolSystemPromptContribution.fullGuidelines],
+        parameters: readSchema,
+        constrainedSampling: { type: "json_schema", strict: "prefer" },
+        async execute(_toolCallId, { path, offset, limit }, signal, _onUpdate, ctx) {
+            if (LOCAL_URI_SCHEME.test(path)) {
+                throw new Error(LOCAL_URI_GUIDANCE);
+            }
+            return new Promise((resolve, reject) => {
+                if (signal?.aborted) {
+                    reject(new Error("Operation aborted"));
+                    return;
+                }
+                let aborted = false;
+                const onAbort = () => {
+                    aborted = true;
+                    reject(new Error("Operation aborted"));
+                };
+                signal?.addEventListener("abort", onAbort, { once: true });
+                (async () => {
+                    try {
+                        const admitted = machine.begin("files.read", { path, offset, limit }, signal);
+                        if (admitted !== undefined)
+                            await admitted;
+                        if (aborted)
+                            return;
+                        const ops = customOps ?? machineReadOperations(machine, signal, options.detectImageMimeType);
+                        const absolutePath = await resolveReadPath(path, ctx?.cwd || cwd);
+                        if (aborted)
+                            return;
+                        if (filesystemPolicy) {
+                            const decision = await filesystemPolicy({
+                                operation: "read",
+                                canonicalPath: await canonicalizePath(absolutePath),
+                                toolName: "read",
+                            });
+                            if (!decision.allow)
+                                throw new Error(decision.reason);
+                            if (aborted)
+                                return;
+                        }
+                        // Check if file exists and is readable.
+                        await ops.access(absolutePath);
+                        if (aborted)
+                            return;
+                        const mimeType = ops.detectImageMimeType ? await ops.detectImageMimeType(absolutePath) : undefined;
+                        let content;
+                        let details;
+                        const model = contextModel ? ctx?.model : undefined;
+                        const nonVisionImageNote = getNonVisionImageNote(model);
+                        if (mimeType) {
+                            // Read image as binary.
+                            const buffer = await ops.readFile(absolutePath);
+                            const processed = await processImage(buffer, mimeType, {
+                                autoResizeImages,
+                                resizeOptions: model?.inputLimits?.images?.resize ?? fallbackResizeOptions,
+                            });
+                            if (!processed.ok) {
+                                let textNote = `Read image file [${mimeType}]\n${processed.message}`;
+                                if (nonVisionImageNote)
+                                    textNote += `\n${nonVisionImageNote}`;
+                                content = [{ type: "text", text: textNote }];
+                            }
+                            else {
+                                let textNote = `Read image file [${processed.mimeType}]`;
+                                if (processed.hints.length > 0)
+                                    textNote += `\n${processed.hints.join("\n")}`;
+                                if (nonVisionImageNote)
+                                    textNote += `\n${nonVisionImageNote}`;
+                                content = [
+                                    { type: "text", text: textNote },
+                                    { type: "image", data: processed.data, mimeType: processed.mimeType },
+                                ];
+                            }
+                        }
+                        else {
+                            // Read text content.
+                            const buffer = await ops.readFile(absolutePath);
+                            if (aborted)
+                                return;
+                            const shaped = await shapeTextRead({
+                                path,
+                                absolutePath,
+                                textContent: decodeUtf8(buffer),
+                                offset,
+                                limit,
+                                folder: options.folder,
+                                isAborted: () => aborted,
+                            });
+                            if (shaped === undefined)
+                                return;
+                            content = shaped.content;
+                            details = shaped.details;
+                        }
+                        if (aborted)
+                            return;
+                        signal?.removeEventListener("abort", onAbort);
+                        resolve({ content, details });
+                    }
+                    catch (error) {
+                        signal?.removeEventListener("abort", onAbort);
+                        if (!aborted)
+                            reject(error);
+                    }
+                })();
+            });
+        },
+    };
+}
+/** The read tool for a host whose only effect channel is `machine`; reads fold like the local tool's by default. */
+export function createCoreReadTool(cwd, options) {
+    return wrapToolDefinition(createCoreReadToolDefinition(cwd, { folder: selectedReadFolder, ...options }));
+}
+export { readSchema };
+//# sourceMappingURL=read-core.js.map

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

@@ -0,0 +1,23 @@
+import { type ReadFolder } from "@earendil-works/pi-agent-core/read-folders";
+import type { TextContent } from "@earendil-works/pi-ai";
+import { type TruncationResult } from "./truncate.ts";
+export interface ReadToolDetails {
+    truncation?: TruncationResult;
+}
+/**
+ * What the model sees for a text file: the selected lines, folded or truncated, with a continuation notice for the
+ * model alone. Undefined when the read was aborted meanwhile.
+ */
+export declare function shapeTextRead(input: {
+    path: string;
+    absolutePath: string;
+    textContent: string;
+    offset: number | undefined;
+    limit: number | undefined;
+    folder: ReadFolder | undefined;
+    isAborted: () => boolean;
+}): Promise<{
+    content: TextContent[];
+    details: ReadToolDetails | undefined;
+} | undefined>;
+//# sourceMappingURL=read-text.d.ts.map

package/dist/core/tools/read-text.js

@@ -0,0 +1,90 @@
+import { createDefaultReadSummary, prepareReadFolder, } from "@earendil-works/pi-agent-core/read-folders";
+import { utf8ByteLength } from "./encoding.js";
+import { modelOnlyText } from "./model-only-text.js";
+import { DEFAULT_MAX_BYTES, formatSize, truncateHead } from "./truncate.js";
+/**
+ * What the model sees for a text file: the selected lines, folded or truncated, with a continuation notice for the
+ * model alone. Undefined when the read was aborted meanwhile.
+ */
+export async function shapeTextRead(input) {
+    const { path, absolutePath, textContent, offset, limit, folder, isAborted } = input;
+    let details;
+    const allLines = textContent.split("\n");
+    const totalFileLines = allLines.length;
+    // Apply offset if specified. Convert from 1-indexed input to 0-indexed array access.
+    const startLine = offset ? Math.max(0, offset - 1) : 0;
+    const startLineDisplay = startLine + 1;
+    // Check if offset is out of bounds.
+    if (startLine >= allLines.length) {
+        throw new Error(`Offset ${offset} is beyond end of file (${allLines.length} lines total)`);
+    }
+    let selectedContent;
+    let userLimitedLines;
+    // If limit is specified by the user, honor it first. Otherwise truncateHead decides.
+    if (limit !== undefined) {
+        const endLine = Math.min(startLine + limit, allLines.length);
+        selectedContent = allLines.slice(startLine, endLine).join("\n");
+        userLimitedLines = endLine - startLine;
+    }
+    else {
+        selectedContent = allLines.slice(startLine).join("\n");
+    }
+    // Apply truncation, respecting both line and byte limits.
+    const truncation = truncateHead(selectedContent);
+    // A selected grammar loads lazily here, on the first structural read for its language.
+    const prepared = await prepareReadFolder(absolutePath, folder);
+    if (isAborted())
+        return undefined;
+    const summary = createDefaultReadSummary({
+        path: absolutePath,
+        text: textContent,
+        offset,
+        limit,
+        folder: prepared,
+        truncated: truncation.truncated,
+    });
+    let outputText;
+    let notice;
+    if (summary) {
+        outputText = summary.text;
+    }
+    else if (truncation.firstLineExceedsLimit) {
+        // First line alone exceeds the byte limit. Point the model at a bash fallback.
+        const firstLineSize = formatSize(utf8ByteLength(allLines[startLine] ?? ""));
+        outputText = "";
+        notice = `[Line ${startLineDisplay} is ${firstLineSize}, exceeds ${formatSize(DEFAULT_MAX_BYTES)} limit. Use bash: sed -n '${startLineDisplay}p' ${path} | head -c ${DEFAULT_MAX_BYTES}]`;
+        details = { truncation };
+    }
+    else if (truncation.truncated) {
+        // Truncation occurred. Build an actionable continuation notice.
+        const endLineDisplay = startLineDisplay + truncation.outputLines - 1;
+        const nextOffset = endLineDisplay + 1;
+        outputText = truncation.content;
+        if (truncation.truncatedBy === "lines") {
+            notice = `[Showing lines ${startLineDisplay}-${endLineDisplay} of ${totalFileLines}. Use offset=${nextOffset} to continue.]`;
+        }
+        else {
+            notice = `[Showing lines ${startLineDisplay}-${endLineDisplay} of ${totalFileLines} (${formatSize(DEFAULT_MAX_BYTES)} limit). Use offset=${nextOffset} to continue.]`;
+        }
+        details = { truncation };
+    }
+    else if (userLimitedLines !== undefined && startLine + userLimitedLines < allLines.length) {
+        // User-specified limit stopped early, but the file still has more content.
+        const remaining = allLines.length - (startLine + userLimitedLines);
+        const nextOffset = startLine + userLimitedLines + 1;
+        outputText = truncation.content;
+        notice = `[${remaining} more lines in file. Use offset=${nextOffset} to continue.]`;
+    }
+    else {
+        // No truncation and no remaining user-limited content.
+        outputText = truncation.content;
+    }
+    // Text adapters join parts with a newline; retain the original blank line.
+    const content = outputText || notice === undefined
+        ? [{ type: "text", text: notice === undefined ? outputText : `${outputText}\n` }]
+        : [];
+    if (notice !== undefined)
+        content.push(modelOnlyText(notice));
+    return { content, details };
+}
+//# sourceMappingURL=read-text.js.map

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

@@ -1,53 +1,12 @@
-import { type AgentTool, type ReadFolder } from "@earendil-works/pi-agent-core";
-import type { ModelImageResizeOptions } from "@earendil-works/pi-ai";
-import { type Static, Type } from "typebox";
-import type { FilesystemPolicyChecker, ToolDefinition } from "../extensions/types.ts";
-import { type ToolMachine } from "./machine.ts";
+import { type AgentTool } from "@earendil-works/pi-agent-core";
+import type { ToolDefinition } from "../extensions/types.ts";
+import { type CoreReadToolOptions, type ReadToolDetails, type readSchema } from "./read-core.ts";
 import { type ReadRenderState } from "./renderers/read.ts";
-import { type TruncationResult } from "./truncate.ts";
-declare const readSchema: Type.TObject<{
-    path: Type.TString;
-    offset: Type.TOptional<Type.TNumber>;
-    limit: Type.TOptional<Type.TNumber>;
-}>;
-export declare const readToolSystemPromptContribution: {
-    readonly snippet: "Read file contents";
-    readonly guidelines: readonly ["Files: read, not cat/sed."];
-    readonly fullGuidelines: readonly ["Use read to examine files instead of cat or sed."];
-};
-export type ReadToolInput = Static<typeof readSchema>;
-export interface ReadToolDetails {
-    truncation?: TruncationResult;
-}
-/**
- * Pluggable operations for the read tool.
- * Override these to delegate file reading to remote systems (for example SSH).
- */
-export interface ReadOperations {
-    /** Read file contents as a Buffer */
-    readFile: (absolutePath: string) => Promise<Buffer>;
-    /** Check if file is readable (throw if not) */
-    access: (absolutePath: string) => Promise<void>;
-    /** Detect image MIME type, return null or undefined for non-images */
-    detectImageMimeType?: (absolutePath: string) => Promise<string | null | undefined>;
-}
-export interface ReadToolOptions {
-    /** Structural folder. Default options select the measured folder; omit here for verbatim reads. */
-    folder?: ReadFolder;
-    /** Whether to auto-resize images. Default: true */
-    autoResizeImages?: boolean;
-    /** Fallback resize profile when the execution context has no model metadata. */
-    resizeOptions?: ModelImageResizeOptions;
-    /** Read the model from the execution context. False for a runtime without a session, whose context refuses `model` (senpi#5223). Default: true */
-    contextModel?: boolean;
-    /** Custom operations for file reading. Default: local filesystem */
-    operations?: ReadOperations;
-    /** Extension-registered filesystem policy checker. */
-    filesystemPolicy?: FilesystemPolicyChecker;
+export { type ReadOperations, type ReadToolDetails, type ReadToolInput, readToolSystemPromptContribution, } from "./read-core.ts";
+export interface ReadToolOptions extends Pick<CoreReadToolOptions, "folder" | "autoResizeImages" | "resizeOptions" | "contextModel" | "operations" | "filesystemPolicy"> {
     /** Operation layer and policy gate. Default: the process-wide local machine. */
-    machine?: ToolMachine;
+    machine?: CoreReadToolOptions["machine"];
 }
 export declare function createReadToolDefinition(cwd: string, options?: ReadToolOptions): ToolDefinition<typeof readSchema, ReadToolDetails | undefined, ReadRenderState>;
 export declare function createReadTool(cwd: string, options?: ReadToolOptions): AgentTool<typeof readSchema>;
-export {};
 //# sourceMappingURL=read.d.ts.map

package/dist/core/tools/read.js

@@ -1,229 +1,24 @@
-import { createDefaultReadSummary, prepareReadFolder, selectedReadFolder, } from "@earendil-works/pi-agent-core";
-import { Type } from "typebox";
+import { selectedReadFolder } from "@earendil-works/pi-agent-core";
 import { processImage } from "../../utils/image-process.js";
 import { detectSupportedImageMimeTypeFromFile } from "../../utils/mime.js";
 import { canonicalizeFilesystemPath } from "./filesystem-policy.js";
-import { asBuffer, defaultToolMachine } from "./machine.js";
-import { modelOnlyText } from "./model-only-text.js";
+import { defaultToolMachine } from "./machine.js";
 import { resolveReadPathAsync } from "./path-utils.js";
+import { createCoreReadToolDefinition, } from "./read-core.js";
 import { readRenderers } from "./renderers/read.js";
 import { wrapToolDefinition } from "./tool-definition-wrapper.js";
-import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize, truncateHead } from "./truncate.js";
-const readSchema = Type.Object({
-    path: Type.String({ description: "Path to the file to read (relative or absolute)" }),
-    offset: Type.Optional(Type.Number({ description: "Line number to start reading from (1-indexed)" })),
-    limit: Type.Optional(Type.Number({ description: "Maximum number of lines to read" })),
-});
-export const readToolSystemPromptContribution = {
-    snippet: "Read file contents",
-    guidelines: ["Files: read, not cat/sed."],
-    fullGuidelines: ["Use read to examine files instead of cat or sed."],
-};
-const LOCAL_URI_SCHEME = /^local:\/\//i;
-const LOCAL_URI_GUIDANCE = "local:// URIs resolve only inside eval cells via the kernel read()/write() helpers; the read tool takes filesystem paths. Re-read this with the eval read() helper, or retry with the plain absolute file path.";
-/** The default read operations: the shared operation layer, called with the context of one admitted call. */
-function machineReadOperations(machine, signal) {
-    const ctx = machine.context(signal);
-    return {
-        readFile: async (path) => asBuffer((await machine.ops.files.read({ path }, ctx)).bytes),
-        access: async (path) => {
-            await machine.ops.files.stat({ path, access: "read" }, ctx);
-        },
-        detectImageMimeType: detectSupportedImageMimeTypeFromFile,
-    };
-}
-function getNonVisionImageNote(model) {
-    if (!model || model.input.includes("image")) {
-        return undefined;
-    }
-    return "[Current model does not support images. The image will be omitted from this request.]";
-}
+export { readToolSystemPromptContribution, } from "./read-core.js";
 export function createReadToolDefinition(cwd, options = { folder: selectedReadFolder }) {
-    const autoResizeImages = options?.autoResizeImages ?? true;
-    const fallbackResizeOptions = options?.resizeOptions;
-    const contextModel = options?.contextModel ?? true;
-    const customOps = options?.operations;
-    const machine = options?.machine ?? defaultToolMachine();
-    const filesystemPolicy = options?.filesystemPolicy;
     return {
-        ...(options?.operations !== undefined || filesystemPolicy !== undefined ? { serverPinned: true } : {}),
-        name: "read",
-        workspaceEffect: "read",
-        label: "read",
-        description: `Read the contents of a file. Supports text files and images (jpg, png, gif, webp, bmp). Images are sent as attachments. For text files, output is truncated to ${DEFAULT_MAX_LINES} lines or ${DEFAULT_MAX_BYTES / 1024}KB (whichever is hit first). Use offset/limit for large files. When you need the full file, continue with offset until complete. A .js or .json file of 100+ lines read without offset/limit may come back folded: bodies are replaced by markers and a footer lists the offset/limit ranges to reread; markers are not source, so reread those ranges before quoting or editing them.`,
-        promptSnippet: readToolSystemPromptContribution.snippet,
-        promptGuidelines: [...readToolSystemPromptContribution.guidelines],
-        fullPromptGuidelines: [...readToolSystemPromptContribution.fullGuidelines],
-        parameters: readSchema,
-        constrainedSampling: { type: "json_schema", strict: "prefer" },
-        async execute(_toolCallId, { path, offset, limit }, signal, _onUpdate, ctx) {
-            if (LOCAL_URI_SCHEME.test(path)) {
-                throw new Error(LOCAL_URI_GUIDANCE);
-            }
-            return new Promise((resolve, reject) => {
-                if (signal?.aborted) {
-                    reject(new Error("Operation aborted"));
-                    return;
-                }
-                let aborted = false;
-                const onAbort = () => {
-                    aborted = true;
-                    reject(new Error("Operation aborted"));
-                };
-                signal?.addEventListener("abort", onAbort, { once: true });
-                (async () => {
-                    try {
-                        const admitted = machine.begin("files.read", { path, offset, limit }, signal);
-                        if (admitted !== undefined)
-                            await admitted;
-                        if (aborted)
-                            return;
-                        const ops = customOps ?? machineReadOperations(machine, signal);
-                        const absolutePath = await resolveReadPathAsync(path, ctx?.cwd || cwd);
-                        if (aborted)
-                            return;
-                        if (filesystemPolicy) {
-                            const decision = await filesystemPolicy({
-                                operation: "read",
-                                canonicalPath: await canonicalizeFilesystemPath(absolutePath),
-                                toolName: "read",
-                            });
-                            if (!decision.allow)
-                                throw new Error(decision.reason);
-                            if (aborted)
-                                return;
-                        }
-                        // Check if file exists and is readable.
-                        await ops.access(absolutePath);
-                        if (aborted)
-                            return;
-                        const mimeType = ops.detectImageMimeType ? await ops.detectImageMimeType(absolutePath) : undefined;
-                        let content;
-                        let details;
-                        const model = contextModel ? ctx?.model : undefined;
-                        const nonVisionImageNote = getNonVisionImageNote(model);
-                        if (mimeType) {
-                            // Read image as binary.
-                            const buffer = await ops.readFile(absolutePath);
-                            const processed = await processImage(buffer, mimeType, {
-                                autoResizeImages,
-                                resizeOptions: model?.inputLimits?.images?.resize ?? fallbackResizeOptions,
-                            });
-                            if (!processed.ok) {
-                                let textNote = `Read image file [${mimeType}]\n${processed.message}`;
-                                if (nonVisionImageNote)
-                                    textNote += `\n${nonVisionImageNote}`;
-                                content = [{ type: "text", text: textNote }];
-                            }
-                            else {
-                                let textNote = `Read image file [${processed.mimeType}]`;
-                                if (processed.hints.length > 0)
-                                    textNote += `\n${processed.hints.join("\n")}`;
-                                if (nonVisionImageNote)
-                                    textNote += `\n${nonVisionImageNote}`;
-                                content = [
-                                    { type: "text", text: textNote },
-                                    { type: "image", data: processed.data, mimeType: processed.mimeType },
-                                ];
-                            }
-                        }
-                        else {
-                            // Read text content.
-                            const buffer = await ops.readFile(absolutePath);
-                            if (aborted)
-                                return;
-                            const textContent = buffer.toString("utf-8");
-                            const allLines = textContent.split("\n");
-                            const totalFileLines = allLines.length;
-                            // Apply offset if specified. Convert from 1-indexed input to 0-indexed array access.
-                            const startLine = offset ? Math.max(0, offset - 1) : 0;
-                            const startLineDisplay = startLine + 1;
-                            // Check if offset is out of bounds.
-                            if (startLine >= allLines.length) {
-                                throw new Error(`Offset ${offset} is beyond end of file (${allLines.length} lines total)`);
-                            }
-                            let selectedContent;
-                            let userLimitedLines;
-                            // If limit is specified by the user, honor it first. Otherwise truncateHead decides.
-                            if (limit !== undefined) {
-                                const endLine = Math.min(startLine + limit, allLines.length);
-                                selectedContent = allLines.slice(startLine, endLine).join("\n");
-                                userLimitedLines = endLine - startLine;
-                            }
-                            else {
-                                selectedContent = allLines.slice(startLine).join("\n");
-                            }
-                            // Apply truncation, respecting both line and byte limits.
-                            const truncation = truncateHead(selectedContent);
-                            // A selected grammar loads lazily here, on the first structural read for its language.
-                            const folder = await prepareReadFolder(absolutePath, options.folder);
-                            if (aborted)
-                                return;
-                            const summary = createDefaultReadSummary({
-                                path: absolutePath,
-                                text: textContent,
-                                offset,
-                                limit,
-                                folder,
-                                truncated: truncation.truncated,
-                            });
-                            let outputText;
-                            let notice;
-                            if (summary) {
-                                outputText = summary.text;
-                            }
-                            else if (truncation.firstLineExceedsLimit) {
-                                // First line alone exceeds the byte limit. Point the model at a bash fallback.
-                                const firstLineSize = formatSize(Buffer.byteLength(allLines[startLine], "utf-8"));
-                                outputText = "";
-                                notice = `[Line ${startLineDisplay} is ${firstLineSize}, exceeds ${formatSize(DEFAULT_MAX_BYTES)} limit. Use bash: sed -n '${startLineDisplay}p' ${path} | head -c ${DEFAULT_MAX_BYTES}]`;
-                                details = { truncation };
-                            }
-                            else if (truncation.truncated) {
-                                // Truncation occurred. Build an actionable continuation notice.
-                                const endLineDisplay = startLineDisplay + truncation.outputLines - 1;
-                                const nextOffset = endLineDisplay + 1;
-                                outputText = truncation.content;
-                                if (truncation.truncatedBy === "lines") {
-                                    notice = `[Showing lines ${startLineDisplay}-${endLineDisplay} of ${totalFileLines}. Use offset=${nextOffset} to continue.]`;
-                                }
-                                else {
-                                    notice = `[Showing lines ${startLineDisplay}-${endLineDisplay} of ${totalFileLines} (${formatSize(DEFAULT_MAX_BYTES)} limit). Use offset=${nextOffset} to continue.]`;
-                                }
-                                details = { truncation };
-                            }
-                            else if (userLimitedLines !== undefined && startLine + userLimitedLines < allLines.length) {
-                                // User-specified limit stopped early, but the file still has more content.
-                                const remaining = allLines.length - (startLine + userLimitedLines);
-                                const nextOffset = startLine + userLimitedLines + 1;
-                                outputText = truncation.content;
-                                notice = `[${remaining} more lines in file. Use offset=${nextOffset} to continue.]`;
-                            }
-                            else {
-                                // No truncation and no remaining user-limited content.
-                                outputText = truncation.content;
-                            }
-                            // Text adapters join parts with a newline; retain the original blank line.
-                            content =
-                                outputText || notice === undefined
-                                    ? [{ type: "text", text: notice === undefined ? outputText : `${outputText}\n` }]
-                                    : [];
-                            if (notice !== undefined)
-                                content.push(modelOnlyText(notice));
-                        }
-                        if (aborted)
-                            return;
-                        signal?.removeEventListener("abort", onAbort);
-                        resolve({ content, details });
-                    }
-                    catch (error) {
-                        signal?.removeEventListener("abort", onAbort);
-                        if (!aborted)
-                            reject(error);
-                    }
-                })();
-            });
-        },
+        ...(options.operations !== undefined || options.filesystemPolicy !== undefined ? { serverPinned: true } : {}),
+        ...createCoreReadToolDefinition(cwd, {
+            ...options,
+            machine: options.machine ?? defaultToolMachine(),
+            resolveReadPath: resolveReadPathAsync,
+            canonicalizePath: canonicalizeFilesystemPath,
+            detectImageMimeType: detectSupportedImageMimeTypeFromFile,
+            processImage,
+        }),
         ...readRenderers,
     };
 }

package/dist/core/tools/renderers/bash.d.ts

@@ -6,7 +6,6 @@
  * tool definition, so the tool's public shape is unchanged.
  */
 import type { ToolDefinition } from "../../extensions/types.ts";
-export declare const BASH_UPDATE_THROTTLE_MS = 100;
 /** Shell renderers are shared by bash and powershell, which differ only in the prompt they display. */
 export declare function createShellRenderers(prompt: string): Pick<ToolDefinition<any, any>, "renderCall" | "renderResult">;
 //# sourceMappingURL=bash.d.ts.map

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

@@ -11,7 +11,6 @@ import { truncateToVisualLines } from "../../../modes/interactive/components/vis
 import { highlightCode, theme } from "../../../modes/interactive/theme/theme.js";
 import { getTextOutput, invalidArgText, normalizeDisplayText, replaceTabs, str } from "../render-utils.js";
 const BASH_PREVIEW_LINES = 5;
-export const BASH_UPDATE_THROTTLE_MS = 100;
 class BashResultRenderComponent extends Container {
     constructor() {
         super(...arguments);

package/dist/core/tools/renderers/edit.d.ts

@@ -7,7 +7,7 @@
  */
 import { Box } from "@earendil-works/pi-tui";
 import type { ToolDefinition } from "../../extensions/types.ts";
-import { type EditDiffError, type EditDiffResult } from "../edit-diff.ts";
+import type { EditDiffError, EditDiffResult } from "../edit-diff.ts";
 type EditPreview = EditDiffResult | EditDiffError;
 export type EditRenderState = {
     callComponent?: EditCallRenderComponent;

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

@@ -7,7 +7,7 @@
  */
 import { Box, Container, Spacer, Text } from "@earendil-works/pi-tui";
 import { countDiffChanges, renderToolDiff } from "../diff-render.js";
-import { computeEditsDiff } from "../edit-diff.js";
+import { computeEditsDiff } from "../edit-preview.js";
 import { renderToolPath, str } from "../render-utils.js";
 function createEditCallRenderComponent() {
     return Object.assign(new Box(1, 1, (text) => text), {

package/dist/core/tools/secret-output-redactor.js

@@ -1,3 +1,4 @@
+import { decodeBase64UrlUtf8 } from "./encoding.js";
 const REDACTED = "<redacted>";
 const TOKEN_CHAR = /[A-Za-z0-9_./+~=-]/;
 const SECRET_KEY = /(?:^|_)(?:KEY|TOKEN|SECRET|AUTH|AUTHORIZATION)$|PASSWORD/i;
@@ -32,7 +33,7 @@ function isJwt(token) {
     if (!header)
         return false;
     try {
-        const value = JSON.parse(Buffer.from(header, "base64url").toString("utf8"));
+        const value = JSON.parse(decodeBase64UrlUtf8(header));
         return typeof value === "object" && value !== null && "alg" in value && typeof value.alg === "string";
     }
     catch {