@ljoukov/llm 3.0.11 → 3.0.13

package/dist/index.js

@@ -2105,7 +2105,6 @@ function getGoogleAuthOptions(scopes) {
 
 // src/google/client.ts
 var GEMINI_TEXT_MODEL_IDS = [
-  "gemini-3-pro-preview",
   "gemini-3.1-pro-preview",
   "gemini-3-flash-preview",
   "gemini-2.5-pro",
@@ -3909,6 +3908,38 @@ function mergeToolOutput(value) {
     return JSON.stringify({ error: "Failed to serialize tool output", detail: message });
   }
 }
+function isLlmToolOutputContentItem(value) {
+  if (!isPlainRecord(value)) {
+    return false;
+  }
+  const itemType = typeof value.type === "string" ? value.type : "";
+  if (itemType === "input_text") {
+    return typeof value.text === "string";
+  }
+  if (itemType === "input_image") {
+    return typeof value.image_url === "string";
+  }
+  if (itemType === "input_file") {
+    const keys = ["file_data", "file_id", "file_url", "filename"];
+    for (const key of keys) {
+      const part = value[key];
+      if (part !== void 0 && part !== null && typeof part !== "string") {
+        return false;
+      }
+    }
+    return true;
+  }
+  return false;
+}
+function toOpenAiToolOutput(value) {
+  if (isLlmToolOutputContentItem(value)) {
+    return [value];
+  }
+  if (Array.isArray(value) && value.every((item) => isLlmToolOutputContentItem(item))) {
+    return value;
+  }
+  return mergeToolOutput(value);
+}
 function parseOpenAiToolArguments(raw) {
   const trimmed = raw.trim();
   if (trimmed.length === 0) {
@@ -4264,7 +4295,6 @@ function resolveGeminiThinkingConfig(modelId) {
     return void 0;
   }
   switch (modelId) {
-    case "gemini-3-pro-preview":
     case "gemini-3.1-pro-preview":
       return { includeThoughts: true };
     case "gemini-3-flash-preview":
@@ -5266,13 +5296,13 @@ async function runToolLoop(request) {
             toolOutputs.push({
               type: "custom_tool_call_output",
               call_id: entry.call.call_id,
-              output: mergeToolOutput(outputPayload)
+              output: toOpenAiToolOutput(outputPayload)
             });
           } else {
             toolOutputs.push({
               type: "function_call_output",
               call_id: entry.call.call_id,
-              output: mergeToolOutput(outputPayload)
+              output: toOpenAiToolOutput(outputPayload)
             });
           }
         }
@@ -5487,7 +5517,7 @@ async function runToolLoop(request) {
             toolOutputs.push({
               type: "custom_tool_call_output",
               call_id: entry.ids.callId,
-              output: mergeToolOutput(outputPayload)
+              output: toOpenAiToolOutput(outputPayload)
             });
           } else {
             toolOutputs.push({
@@ -5501,7 +5531,7 @@ async function runToolLoop(request) {
             toolOutputs.push({
               type: "function_call_output",
               call_id: entry.ids.callId,
-              output: mergeToolOutput(outputPayload)
+              output: toOpenAiToolOutput(outputPayload)
             });
           }
         }
@@ -7132,6 +7162,7 @@ function sleep2(ms) {
 
 // src/tools/filesystemTools.ts
 import path5 from "path";
+import { Buffer as Buffer4 } from "buffer";
 import { z as z6 } from "zod";
 
 // src/tools/applyPatch.ts
@@ -7165,6 +7196,10 @@ var InMemoryAgentFilesystem = class {
     }
     return file.content;
   }
+  async readBinaryFile(filePath) {
+    const content = await this.readTextFile(filePath);
+    return Buffer.from(content, "utf8");
+  }
   async writeTextFile(filePath, content) {
     const absolutePath = path3.resolve(filePath);
     const parentPath = path3.dirname(absolutePath);
@@ -7277,6 +7312,7 @@ var InMemoryAgentFilesystem = class {
 function createNodeAgentFilesystem() {
   return {
     readTextFile: async (filePath) => fs3.readFile(filePath, "utf8"),
+    readBinaryFile: async (filePath) => fs3.readFile(filePath),
     writeTextFile: async (filePath, content) => fs3.writeFile(filePath, content, "utf8"),
     deleteFile: async (filePath) => fs3.unlink(filePath),
     ensureDir: async (directoryPath) => {
@@ -7832,29 +7868,66 @@ function formatSummary(added, modified, deleted) {
 
 // src/tools/filesystemTools.ts
 var DEFAULT_READ_FILE_LINE_LIMIT = 2e3;
-var DEFAULT_READ_FILES_LINE_LIMIT = 200;
-var DEFAULT_READ_FILES_CHAR_LIMIT = 4e3;
 var DEFAULT_LIST_DIR_LIMIT = 25;
 var DEFAULT_LIST_DIR_DEPTH = 2;
 var DEFAULT_GREP_LIMIT = 100;
 var MAX_GREP_LIMIT = 2e3;
+var MAX_VIEW_IMAGE_BYTES = 10 * 1024 * 1024;
 var DEFAULT_MAX_LINE_LENGTH = 500;
 var DEFAULT_GREP_MAX_SCANNED_FILES = 2e4;
-var DEFAULT_TAB_WIDTH = 4;
+var SUPPORTED_IMAGE_MIME_TYPES = /* @__PURE__ */ new Set(["image/png", "image/jpeg", "image/webp", "image/gif"]);
+var IMAGE_MIME_BY_EXTENSION = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".webp": "image/webp",
+  ".gif": "image/gif"
+};
+function parseOptionalString(value) {
+  if (value === null || value === void 0) {
+    return void 0;
+  }
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  if (trimmed.length === 0) {
+    return void 0;
+  }
+  return trimmed;
+}
 var codexReadFileInputSchema = z6.object({
-  file_path: z6.string().min(1).describe(
-    "Path to the file (relative to cwd, or absolute. In sandbox mode, / maps to the sandbox root)."
+  file_path: z6.preprocess(
+    (value) => parseOptionalString(value),
+    z6.string().min(1).optional().describe(
+      "Path to the file (relative to cwd, or absolute. In sandbox mode, / maps to the sandbox root)."
+    )
+  ),
+  path: z6.preprocess(
+    (value) => parseOptionalString(value),
+    z6.string().min(1).optional().describe(
+      "Alias for file_path. If both file_path and path are provided they must be identical."
+    )
   ),
   offset: z6.number().int().min(1).nullish().describe("The line number to start reading from. Must be 1 or greater."),
-  limit: z6.number().int().min(1).nullish().describe("The maximum number of lines to return."),
-  mode: z6.enum(["slice", "indentation"]).nullish().describe('Optional mode selector: "slice" (default) or "indentation".'),
-  indentation: z6.object({
-    anchor_line: z6.number().int().min(1).nullish(),
-    max_levels: z6.number().int().min(0).nullish(),
-    include_siblings: z6.boolean().nullish(),
-    include_header: z6.boolean().nullish(),
-    max_lines: z6.number().int().min(1).nullish()
-  }).nullish()
+  limit: z6.number().int().min(1).nullish().describe("The maximum number of lines to return.")
+}).strict().superRefine((value, context) => {
+  const filePath = value.file_path?.trim() ?? "";
+  const aliasPath = value.path?.trim() ?? "";
+  if (filePath.length === 0 && aliasPath.length === 0) {
+    context.addIssue({
+      code: z6.ZodIssueCode.custom,
+      message: "read_file requires file_path (or path alias).",
+      path: ["file_path"]
+    });
+  }
+  if (filePath.length > 0 && aliasPath.length > 0 && filePath !== aliasPath) {
+    context.addIssue({
+      code: z6.ZodIssueCode.custom,
+      message: "file_path and path must match when both are provided.",
+      path: ["path"]
+    });
+  }
 });
 var codexListDirInputSchema = z6.object({
   dir_path: z6.string().min(1).describe(
@@ -7870,6 +7943,9 @@ var codexGrepFilesInputSchema = z6.object({
   path: z6.string().nullish().describe("Directory or file path to search. Defaults to cwd."),
   limit: z6.number().int().min(1).nullish().describe("Maximum number of file paths to return (defaults to 100).")
 });
+var codexViewImageInputSchema = z6.object({
+  path: z6.string().min(1).describe("Local filesystem path to an image file")
+});
 var applyPatchInputSchema = z6.object({
   input: z6.string().min(1).describe(CODEX_APPLY_PATCH_INPUT_DESCRIPTION)
 });
@@ -7877,24 +7953,7 @@ var geminiReadFileInputSchema = z6.object({
   file_path: z6.string().min(1),
   offset: z6.number().int().min(0).nullish(),
   limit: z6.number().int().min(1).nullish()
-});
-var geminiReadFilesInputSchema = z6.object({
-  paths: z6.array(z6.string().min(1)).min(1),
-  line_offset: z6.number().int().min(0).nullish(),
-  line_limit: z6.number().int().min(1).nullish(),
-  char_offset: z6.number().int().min(0).nullish(),
-  char_limit: z6.number().int().min(1).nullish(),
-  include_line_numbers: z6.boolean().nullish()
-}).superRefine((value, context) => {
-  const hasLineWindow = value.line_offset !== void 0 || value.line_limit !== void 0;
-  const hasCharWindow = value.char_offset !== void 0 || value.char_limit !== void 0;
-  if (hasLineWindow && hasCharWindow) {
-    context.addIssue({
-      code: z6.ZodIssueCode.custom,
-      message: "Use either line_* or char_* window arguments, not both."
-    });
-  }
-});
+}).strict();
 var geminiWriteFileInputSchema = z6.object({
   file_path: z6.string().min(1),
   content: z6.string()
@@ -7977,7 +8036,8 @@ function createCodexFilesystemToolSet(options = {}) {
     apply_patch: createCodexApplyPatchTool(options),
     read_file: createCodexReadFileTool(options),
     list_dir: createListDirTool(options),
-    grep_files: createGrepFilesTool(options)
+    grep_files: createGrepFilesTool(options),
+    view_image: createViewImageTool(options)
   };
 }
 function createGeminiFilesystemToolSet(options = {}) {
@@ -8026,7 +8086,7 @@ function createCodexApplyPatchTool(options = {}) {
 }
 function createCodexReadFileTool(options = {}) {
   return tool({
-    description: "Reads a local file with 1-indexed line numbers, supporting slice and indentation-aware block modes.",
+    description: "Reads a local UTF-8 text file with 1-indexed line numbers.",
     inputSchema: codexReadFileInputSchema,
     execute: async (input) => readFileCodex(input, options)
   });
@@ -8045,6 +8105,13 @@ function createGrepFilesTool(options = {}) {
     execute: async (input) => grepFilesCodex(input, options)
   });
 }
+function createViewImageTool(options = {}) {
+  return tool({
+    description: "View a local image from the filesystem (only use if given a full filepath by the user, and the image isn't already attached to the thread context within <image ...> tags).",
+    inputSchema: codexViewImageInputSchema,
+    execute: async (input) => viewImageCodex(input, options)
+  });
+}
 function createGeminiReadFileTool(options = {}) {
   return tool({
     description: "Reads and returns the content of a specified file. Supports optional 0-based line offset and line limit.",
@@ -8052,13 +8119,6 @@ function createGeminiReadFileTool(options = {}) {
     execute: async (input) => readFileGemini(input, options)
   });
 }
-function createReadFilesTool(options = {}) {
-  return tool({
-    description: "Reads one or more files with optional line-based or character-based slicing, similar to a controlled head/tail view.",
-    inputSchema: geminiReadFilesInputSchema,
-    execute: async (input) => readFilesGemini(input, options)
-  });
-}
 function createWriteFileTool(options = {}) {
   return tool({
     description: "Writes content to a specified file in the local filesystem.",
@@ -8101,53 +8161,61 @@ function createGlobTool(options = {}) {
     execute: async (input) => globFilesGemini(input, options)
   });
 }
+function resolveCodexReadFilePath(input) {
+  const filePath = parseOptionalString(input.file_path);
+  if (filePath) {
+    return filePath;
+  }
+  const aliasPath = parseOptionalString(input.path);
+  if (aliasPath) {
+    return aliasPath;
+  }
+  throw new Error("read_file requires file_path");
+}
 async function readFileCodex(input, options) {
   const runtime = resolveRuntime(options);
-  const filePath = resolvePathWithPolicy(input.file_path, runtime.cwd, runtime.allowOutsideCwd);
+  const filePath = resolvePathWithPolicy(
+    resolveCodexReadFilePath(input),
+    runtime.cwd,
+    runtime.allowOutsideCwd
+  );
   await runAccessHook2(runtime, {
     cwd: runtime.cwd,
     tool: "read_file",
     action: "read",
     path: filePath
   });
-  const content = await runtime.filesystem.readTextFile(filePath);
+  const fileBytes = await readBinaryFile(runtime.filesystem, filePath);
+  const imageMimeType = detectImageMimeType(fileBytes, filePath);
+  if (imageMimeType) {
+    throw new Error(
+      `read_file only supports text files; "${toDisplayPath2(filePath, runtime.cwd)}" is an image (${imageMimeType}). Use view_image instead.`
+    );
+  }
+  if (isPdfFile(fileBytes, filePath)) {
+    throw new Error(
+      `read_file only supports text files; "${toDisplayPath2(filePath, runtime.cwd)}" is a PDF.`
+    );
+  }
+  if (!isValidUtf8(fileBytes)) {
+    throw new Error(
+      `read_file only supports UTF-8 text files; "${toDisplayPath2(filePath, runtime.cwd)}" appears to be binary.`
+    );
+  }
+  const content = fileBytes.toString("utf8");
   const lines = splitLines(content);
   const offset = input.offset ?? 1;
   const limit = input.limit ?? DEFAULT_READ_FILE_LINE_LIMIT;
-  const mode = input.mode ?? "slice";
   if (offset > lines.length) {
     throw new Error("offset exceeds file length");
   }
-  if (mode === "slice") {
-    const output = [];
-    const lastLine = Math.min(lines.length, offset + limit - 1);
-    for (let lineNumber = offset; lineNumber <= lastLine; lineNumber += 1) {
-      const line = lines[lineNumber - 1] ?? "";
-      output.push(`L${lineNumber}: ${truncateAtCodePointBoundary(line, runtime.maxLineLength)}`);
-    }
-    return output.join("\n");
-  }
-  const indentation = input.indentation ?? {};
-  const anchorLine = indentation.anchor_line ?? offset;
-  if (anchorLine < 1 || anchorLine > lines.length) {
-    throw new Error("anchor_line exceeds file length");
-  }
-  const records = lines.map((line, index) => ({
-    number: index + 1,
-    raw: line,
-    display: truncateAtCodePointBoundary(line, runtime.maxLineLength),
-    indent: measureIndent(line, DEFAULT_TAB_WIDTH)
-  }));
-  const selected = readWithIndentationMode({
-    records,
-    anchorLine,
-    limit,
-    maxLevels: indentation.max_levels ?? 0,
-    includeSiblings: indentation.include_siblings ?? false,
-    includeHeader: indentation.include_header ?? true,
-    maxLines: indentation.max_lines ?? void 0
-  });
-  return selected.map((record) => `L${record.number}: ${record.display}`).join("\n");
+  const output = [];
+  const lastLine = Math.min(lines.length, offset + limit - 1);
+  for (let lineNumber = offset; lineNumber <= lastLine; lineNumber += 1) {
+    const line = lines[lineNumber - 1] ?? "";
+    output.push(`L${lineNumber}: ${truncateAtCodePointBoundary(line, runtime.maxLineLength)}`);
+  }
+  return output.join("\n");
 }
 async function listDirectoryCodex(input, options) {
   const runtime = resolveRuntime(options);
@@ -8235,6 +8303,85 @@ async function grepFilesCodex(input, options) {
   const limit = Math.min(input.limit ?? DEFAULT_GREP_LIMIT, MAX_GREP_LIMIT);
   return matches.slice(0, limit).map((match) => match.filePath).join("\n");
 }
+async function viewImageCodex(input, options) {
+  const runtime = resolveRuntime(options);
+  const imagePath = resolvePathWithPolicy(input.path, runtime.cwd, runtime.allowOutsideCwd);
+  await runAccessHook2(runtime, {
+    cwd: runtime.cwd,
+    tool: "view_image",
+    action: "read",
+    path: imagePath
+  });
+  const stats = await runtime.filesystem.stat(imagePath);
+  if (stats.kind !== "file") {
+    throw new Error(`image path \`${toDisplayPath2(imagePath, runtime.cwd)}\` is not a file`);
+  }
+  const bytes = await readBinaryFile(runtime.filesystem, imagePath);
+  if (bytes.byteLength > MAX_VIEW_IMAGE_BYTES) {
+    return [
+      {
+        type: "input_text",
+        text: `Codex cannot attach image at \`${toDisplayPath2(imagePath, runtime.cwd)}\`: image exceeds ${MAX_VIEW_IMAGE_BYTES} bytes.`
+      }
+    ];
+  }
+  const mimeType = detectImageMimeType(bytes, imagePath);
+  if (!mimeType) {
+    return [
+      {
+        type: "input_text",
+        text: `Codex cannot attach image at \`${toDisplayPath2(imagePath, runtime.cwd)}\`: unsupported image format.`
+      }
+    ];
+  }
+  return [
+    {
+      type: "input_image",
+      image_url: `data:${mimeType};base64,${bytes.toString("base64")}`
+    }
+  ];
+}
+async function readBinaryFile(filesystem, filePath) {
+  if (typeof filesystem.readBinaryFile === "function") {
+    return await filesystem.readBinaryFile(filePath);
+  }
+  const text = await filesystem.readTextFile(filePath);
+  return Buffer4.from(text, "utf8");
+}
+function detectImageMimeType(buffer, filePath) {
+  if (buffer.length >= 8 && buffer[0] === 137 && buffer[1] === 80 && buffer[2] === 78 && buffer[3] === 71 && buffer[4] === 13 && buffer[5] === 10 && buffer[6] === 26 && buffer[7] === 10) {
+    return "image/png";
+  }
+  if (buffer.length >= 3 && buffer[0] === 255 && buffer[1] === 216 && buffer[2] === 255) {
+    return "image/jpeg";
+  }
+  if (buffer.length >= 6) {
+    const signature = buffer.subarray(0, 6).toString("ascii");
+    if (signature === "GIF87a" || signature === "GIF89a") {
+      return "image/gif";
+    }
+  }
+  if (buffer.length >= 12 && buffer.subarray(0, 4).toString("ascii") === "RIFF" && buffer.subarray(8, 12).toString("ascii") === "WEBP") {
+    return "image/webp";
+  }
+  const fromExtension = IMAGE_MIME_BY_EXTENSION[path5.extname(filePath).toLowerCase()];
+  if (fromExtension && SUPPORTED_IMAGE_MIME_TYPES.has(fromExtension)) {
+    return fromExtension;
+  }
+  return void 0;
+}
+function isPdfFile(buffer, filePath) {
+  if (buffer.length >= 5 && buffer.subarray(0, 5).toString("ascii") === "%PDF-") {
+    return true;
+  }
+  return path5.extname(filePath).toLowerCase() === ".pdf";
+}
+function isValidUtf8(buffer) {
+  if (buffer.length === 0) {
+    return true;
+  }
+  return Buffer4.from(buffer.toString("utf8"), "utf8").equals(buffer);
+}
 async function readFileGemini(input, options) {
   const runtime = resolveRuntime(options);
   const filePath = resolvePathWithPolicy(input.file_path, runtime.cwd, runtime.allowOutsideCwd);
@@ -8256,56 +8403,6 @@ async function readFileGemini(input, options) {
     (line, index) => `L${offset + index + 1}: ${truncateAtCodePointBoundary(line ?? "", runtime.maxLineLength)}`
   ).join("\n");
 }
-async function readFilesGemini(input, options) {
-  const runtime = resolveRuntime(options);
-  const useCharWindow = input.char_offset !== void 0 || input.char_limit !== void 0;
-  const lineOffset = Math.max(0, input.line_offset ?? 0);
-  const lineLimit = input.line_limit ?? DEFAULT_READ_FILES_LINE_LIMIT;
-  const charOffset = Math.max(0, input.char_offset ?? 0);
-  const charLimit = input.char_limit ?? DEFAULT_READ_FILES_CHAR_LIMIT;
-  const includeLineNumbers = input.include_line_numbers !== false;
-  const sections = [];
-  for (const rawPath of input.paths) {
-    const filePath = resolvePathWithPolicy(rawPath, runtime.cwd, runtime.allowOutsideCwd);
-    await runAccessHook2(runtime, {
-      cwd: runtime.cwd,
-      tool: "read_files",
-      action: "read",
-      path: filePath
-    });
-    const content = await runtime.filesystem.readTextFile(filePath);
-    const displayPath = normalizeSlashes(toDisplayPath2(filePath, runtime.cwd));
-    sections.push(`==> ${displayPath} <==`);
-    if (useCharWindow) {
-      if (charOffset >= content.length) {
-        sections.push("");
-        continue;
-      }
-      const end2 = Math.min(content.length, charOffset + charLimit);
-      sections.push(content.slice(charOffset, end2));
-      continue;
-    }
-    const lines = splitLines(content);
-    if (lineOffset >= lines.length) {
-      sections.push("");
-      continue;
-    }
-    const end = Math.min(lines.length, lineOffset + lineLimit);
-    const selected = lines.slice(lineOffset, end);
-    if (includeLineNumbers) {
-      for (let index = 0; index < selected.length; index += 1) {
-        const lineNumber = lineOffset + index + 1;
-        const line = selected[index] ?? "";
-        sections.push(
-          `L${lineNumber}: ${truncateAtCodePointBoundary(line, runtime.maxLineLength)}`
-        );
-      }
-      continue;
-    }
-    sections.push(selected.join("\n"));
-  }
-  return sections.join("\n");
-}
 async function writeFileGemini(input, options) {
   const runtime = resolveRuntime(options);
   const filePath = resolvePathWithPolicy(input.file_path, runtime.cwd, runtime.allowOutsideCwd);
@@ -8614,117 +8711,6 @@ function truncateAtCodePointBoundary(value, maxLength) {
   }
   return Array.from(value).slice(0, maxLength).join("");
 }
-function measureIndent(line, tabWidth) {
-  let count = 0;
-  for (const char of line) {
-    if (char === " ") {
-      count += 1;
-      continue;
-    }
-    if (char === "	") {
-      count += tabWidth;
-      continue;
-    }
-    break;
-  }
-  return count;
-}
-function computeEffectiveIndents(records) {
-  const effective = [];
-  let previous = 0;
-  for (const record of records) {
-    if (record.raw.trim().length === 0) {
-      effective.push(previous);
-    } else {
-      previous = record.indent;
-      effective.push(previous);
-    }
-  }
-  return effective;
-}
-function trimBoundaryBlankLines(records) {
-  while (records.length > 0 && records[0]?.raw.trim().length === 0) {
-    records.shift();
-  }
-  while (records.length > 0 && records[records.length - 1]?.raw.trim().length === 0) {
-    records.pop();
-  }
-}
-function isCommentLine(line) {
-  const trimmed = line.trim();
-  return trimmed.startsWith("#") || trimmed.startsWith("//") || trimmed.startsWith("--");
-}
-function readWithIndentationMode(params) {
-  const { records, anchorLine, limit, maxLevels, includeSiblings, includeHeader, maxLines } = params;
-  const anchorIndex = anchorLine - 1;
-  const effectiveIndents = computeEffectiveIndents(records);
-  const anchorIndent = effectiveIndents[anchorIndex] ?? 0;
-  const minIndent = maxLevels === 0 ? 0 : Math.max(anchorIndent - maxLevels * DEFAULT_TAB_WIDTH, 0);
-  const guardLimit = maxLines ?? limit;
-  const finalLimit = Math.min(limit, guardLimit, records.length);
-  if (finalLimit <= 1) {
-    return [records[anchorIndex]].filter((entry) => Boolean(entry));
-  }
-  let upper = anchorIndex - 1;
-  let lower = anchorIndex + 1;
-  let upperMinIndentHits = 0;
-  let lowerMinIndentHits = 0;
-  const output = [records[anchorIndex]].filter(
-    (entry) => Boolean(entry)
-  );
-  while (output.length < finalLimit) {
-    let progressed = 0;
-    if (upper >= 0) {
-      const candidate = records[upper];
-      const candidateIndent = effectiveIndents[upper] ?? 0;
-      if (candidate && candidateIndent >= minIndent) {
-        output.unshift(candidate);
-        progressed += 1;
-        upper -= 1;
-        if (candidateIndent === minIndent && !includeSiblings) {
-          const allowHeaderComment = includeHeader && isCommentLine(candidate.raw);
-          const canTakeLine = allowHeaderComment || upperMinIndentHits === 0;
-          if (canTakeLine) {
-            upperMinIndentHits += 1;
-          } else {
-            output.shift();
-            progressed -= 1;
-            upper = -1;
-          }
-        }
-        if (output.length >= finalLimit) {
-          break;
-        }
-      } else {
-        upper = -1;
-      }
-    }
-    if (lower < records.length) {
-      const candidate = records[lower];
-      const candidateIndent = effectiveIndents[lower] ?? 0;
-      if (candidate && candidateIndent >= minIndent) {
-        output.push(candidate);
-        progressed += 1;
-        lower += 1;
-        if (candidateIndent === minIndent && !includeSiblings) {
-          if (lowerMinIndentHits > 0) {
-            output.pop();
-            progressed -= 1;
-            lower = records.length;
-          }
-          lowerMinIndentHits += 1;
-        }
-      } else {
-        lower = records.length;
-      }
-    }
-    if (progressed === 0) {
-      break;
-    }
-  }
-  trimBoundaryBlankLines(output);
-  return output;
-}
 async function collectDirectoryEntries(filesystem, rootPath, depth, maxLineLength) {
   const queue = [
     { path: rootPath, relativePrefix: "", remainingDepth: depth }
@@ -10042,10 +10028,10 @@ export {
   createListDirectoryTool,
   createModelAgnosticFilesystemToolSet,
   createNodeAgentFilesystem,
-  createReadFilesTool,
   createReplaceTool,
   createRgSearchTool,
   createToolLoopSteeringChannel,
+  createViewImageTool,
   createWriteFileTool,
   customTool,
   encodeChatGptAuthJson,