@ljoukov/llm 2.0.0 → 2.1.0

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/llm.ts
-import { Buffer as Buffer2 } from "buffer";
+import { Buffer as Buffer3 } from "buffer";
 import { AsyncLocalStorage } from "async_hooks";
 import { randomBytes } from "crypto";
 import {
@@ -125,12 +125,23 @@ var OPENAI_GPT_52_PRICING = {
   cachedRate: 0.175 / 1e6,
   outputRate: 14 / 1e6
 };
+var OPENAI_GPT_53_CODEX_PRICING = {
+  inputRate: 1.25 / 1e6,
+  cachedRate: 0.125 / 1e6,
+  outputRate: 10 / 1e6
+};
 var OPENAI_GPT_51_CODEX_MINI_PRICING = {
   inputRate: 0.25 / 1e6,
   cachedRate: 0.025 / 1e6,
   outputRate: 2 / 1e6
 };
 function getOpenAiPricing(modelId) {
+  if (modelId.includes("gpt-5.3-codex")) {
+    return OPENAI_GPT_53_CODEX_PRICING;
+  }
+  if (modelId.includes("gpt-5-codex")) {
+    return OPENAI_GPT_53_CODEX_PRICING;
+  }
   if (modelId.includes("gpt-5.2")) {
     return OPENAI_GPT_52_PRICING;
   }
@@ -212,7 +223,7 @@ import os from "os";
 import { TextDecoder } from "util";
 
 // src/openai/chatgpt-auth.ts
-import { Buffer } from "buffer";
+import { Buffer as Buffer2 } from "buffer";
 import { z } from "zod";
 
 // src/utils/env.ts
@@ -330,7 +341,7 @@ function encodeChatGptAuthJson(profile) {
   return JSON.stringify(payload);
 }
 function encodeChatGptAuthJsonB64(profile) {
-  return Buffer.from(encodeChatGptAuthJson(profile)).toString("base64url");
+  return Buffer2.from(encodeChatGptAuthJson(profile)).toString("base64url");
 }
 async function exchangeChatGptOauthCode({
   code,
@@ -464,7 +475,7 @@ function loadAuthProfileFromEnv() {
   }
   const rawB64 = process.env[CHATGPT_AUTH_JSON_B64_ENV];
   if (rawB64 && rawB64.trim().length > 0) {
-    const decoded = Buffer.from(rawB64.trim(), "base64url").toString("utf8");
+    const decoded = Buffer2.from(rawB64.trim(), "base64url").toString("utf8");
     return normalizeAuthProfile(AuthInputSchema.parse(JSON.parse(decoded)));
   }
   const access = process.env[CHATGPT_ACCESS_ENV] ?? process.env[CHATGPT_ACCESS_TOKEN_ENV] ?? void 0;
@@ -488,7 +499,7 @@ function decodeJwtPayload(token) {
   }
   const payloadB64 = segments[1] ?? "";
   try {
-    const decoded = Buffer.from(payloadB64, "base64url").toString("utf8");
+    const decoded = Buffer2.from(payloadB64, "base64url").toString("utf8");
     return JSON.parse(decoded);
   } catch {
     return null;
@@ -1475,9 +1486,9 @@ function sanitisePartForLogging(part) {
     case "inlineData": {
       let omittedBytes;
       try {
-        omittedBytes = Buffer2.from(part.data, "base64").byteLength;
+        omittedBytes = Buffer3.from(part.data, "base64").byteLength;
       } catch {
-        omittedBytes = Buffer2.byteLength(part.data, "utf8");
+        omittedBytes = Buffer3.byteLength(part.data, "utf8");
       }
       return {
         type: "inlineData",
@@ -2389,8 +2400,8 @@ function parseOpenAiToolArguments(raw) {
 function formatZodIssues(issues) {
   const messages = [];
   for (const issue of issues) {
-    const path2 = issue.path.length > 0 ? issue.path.map(String).join(".") : "input";
-    messages.push(`${path2}: ${issue.message}`);
+    const path5 = issue.path.length > 0 ? issue.path.map(String).join(".") : "input";
+    messages.push(`${path5}: ${issue.message}`);
   }
   return messages.join("; ");
 }
@@ -2572,9 +2583,9 @@ function resolveGeminiThinkingConfig(modelId) {
 }
 function decodeInlineDataBuffer(base64) {
   try {
-    return Buffer2.from(base64, "base64");
+    return Buffer3.from(base64, "base64");
   } catch {
-    return Buffer2.from(base64, "base64url");
+    return Buffer3.from(base64, "base64url");
   }
 }
 function extractImages(content) {
@@ -3858,11 +3869,1667 @@ function appendMarkdownSourcesSection(value, sources) {
 ## Sources
 ${lines}`;
 }
+
+// src/tools/filesystemTools.ts
+import path4 from "path";
+import { z as z5 } from "zod";
+
+// src/tools/applyPatch.ts
+import path3 from "path";
+import { z as z4 } from "zod";
+
+// src/tools/filesystem.ts
+import { promises as fs2 } from "fs";
+import path2 from "path";
+var InMemoryAgentFilesystem = class {
+  #files = /* @__PURE__ */ new Map();
+  #dirs = /* @__PURE__ */ new Map();
+  #clock = 0;
+  constructor(initialFiles = {}) {
+    const root = path2.resolve("/");
+    this.#dirs.set(root, { mtimeMs: this.#nextMtime() });
+    for (const [filePath, content] of Object.entries(initialFiles)) {
+      const absolutePath = path2.resolve(filePath);
+      this.#ensureDirSync(path2.dirname(absolutePath));
+      this.#files.set(absolutePath, {
+        content,
+        mtimeMs: this.#nextMtime()
+      });
+    }
+  }
+  async readTextFile(filePath) {
+    const absolutePath = path2.resolve(filePath);
+    const file = this.#files.get(absolutePath);
+    if (!file) {
+      throw createNoSuchFileError("open", absolutePath);
+    }
+    return file.content;
+  }
+  async writeTextFile(filePath, content) {
+    const absolutePath = path2.resolve(filePath);
+    const parentPath = path2.dirname(absolutePath);
+    if (!this.#dirs.has(parentPath)) {
+      throw createNoSuchFileError("open", parentPath);
+    }
+    this.#files.set(absolutePath, { content, mtimeMs: this.#nextMtime() });
+  }
+  async deleteFile(filePath) {
+    const absolutePath = path2.resolve(filePath);
+    if (!this.#files.delete(absolutePath)) {
+      throw createNoSuchFileError("unlink", absolutePath);
+    }
+  }
+  async ensureDir(directoryPath) {
+    this.#ensureDirSync(path2.resolve(directoryPath));
+  }
+  async readDir(directoryPath) {
+    const absolutePath = path2.resolve(directoryPath);
+    const directory = this.#dirs.get(absolutePath);
+    if (!directory) {
+      throw createNoSuchFileError("scandir", absolutePath);
+    }
+    const entries = [];
+    const seenNames = /* @__PURE__ */ new Set();
+    for (const [dirPath, dirRecord] of this.#dirs.entries()) {
+      if (dirPath === absolutePath) {
+        continue;
+      }
+      if (path2.dirname(dirPath) !== absolutePath) {
+        continue;
+      }
+      const name = path2.basename(dirPath);
+      if (seenNames.has(name)) {
+        continue;
+      }
+      seenNames.add(name);
+      entries.push({
+        name,
+        path: dirPath,
+        kind: "directory",
+        mtimeMs: dirRecord.mtimeMs
+      });
+    }
+    for (const [filePath, fileRecord] of this.#files.entries()) {
+      if (path2.dirname(filePath) !== absolutePath) {
+        continue;
+      }
+      const name = path2.basename(filePath);
+      if (seenNames.has(name)) {
+        continue;
+      }
+      seenNames.add(name);
+      entries.push({
+        name,
+        path: filePath,
+        kind: "file",
+        mtimeMs: fileRecord.mtimeMs
+      });
+    }
+    entries.sort((left, right) => left.name.localeCompare(right.name));
+    return entries;
+  }
+  async stat(entryPath) {
+    const absolutePath = path2.resolve(entryPath);
+    const file = this.#files.get(absolutePath);
+    if (file) {
+      return { kind: "file", mtimeMs: file.mtimeMs };
+    }
+    const directory = this.#dirs.get(absolutePath);
+    if (directory) {
+      return { kind: "directory", mtimeMs: directory.mtimeMs };
+    }
+    throw createNoSuchFileError("stat", absolutePath);
+  }
+  snapshot() {
+    const entries = [...this.#files.entries()].sort(([left], [right]) => left.localeCompare(right));
+    return Object.fromEntries(entries.map(([filePath, record]) => [filePath, record.content]));
+  }
+  #ensureDirSync(directoryPath) {
+    const absolutePath = path2.resolve(directoryPath);
+    const parts = [];
+    let cursor = absolutePath;
+    for (; ; ) {
+      if (this.#dirs.has(cursor)) {
+        break;
+      }
+      parts.push(cursor);
+      const parent = path2.dirname(cursor);
+      if (parent === cursor) {
+        break;
+      }
+      cursor = parent;
+    }
+    for (let index = parts.length - 1; index >= 0; index -= 1) {
+      const nextDir = parts[index];
+      if (nextDir === void 0) {
+        continue;
+      }
+      if (!this.#dirs.has(nextDir)) {
+        this.#dirs.set(nextDir, { mtimeMs: this.#nextMtime() });
+      }
+    }
+  }
+  #nextMtime() {
+    this.#clock += 1;
+    return this.#clock;
+  }
+};
+function createNodeAgentFilesystem() {
+  return {
+    readTextFile: async (filePath) => fs2.readFile(filePath, "utf8"),
+    writeTextFile: async (filePath, content) => fs2.writeFile(filePath, content, "utf8"),
+    deleteFile: async (filePath) => fs2.unlink(filePath),
+    ensureDir: async (directoryPath) => {
+      await fs2.mkdir(directoryPath, { recursive: true });
+    },
+    readDir: async (directoryPath) => {
+      const entries = await fs2.readdir(directoryPath, { withFileTypes: true });
+      const result = [];
+      for (const entry of entries) {
+        const entryPath = path2.resolve(directoryPath, entry.name);
+        const stats = await fs2.lstat(entryPath);
+        result.push({
+          name: entry.name,
+          path: entryPath,
+          kind: statsToKind(stats),
+          mtimeMs: stats.mtimeMs
+        });
+      }
+      return result;
+    },
+    stat: async (entryPath) => {
+      const stats = await fs2.lstat(entryPath);
+      return {
+        kind: statsToKind(stats),
+        mtimeMs: stats.mtimeMs
+      };
+    }
+  };
+}
+function createInMemoryAgentFilesystem(initialFiles = {}) {
+  return new InMemoryAgentFilesystem(initialFiles);
+}
+function statsToKind(stats) {
+  if (stats.isSymbolicLink()) {
+    return "symlink";
+  }
+  if (stats.isDirectory()) {
+    return "directory";
+  }
+  if (stats.isFile()) {
+    return "file";
+  }
+  return "other";
+}
+function createNoSuchFileError(syscall, filePath) {
+  const error = new Error(
+    `ENOENT: no such file or directory, ${syscall} '${filePath}'`
+  );
+  error.code = "ENOENT";
+  error.syscall = syscall;
+  error.path = filePath;
+  return error;
+}
+
+// src/tools/applyPatch.ts
+var BEGIN_PATCH_LINE = "*** Begin Patch";
+var END_PATCH_LINE = "*** End Patch";
+var ADD_FILE_PREFIX = "*** Add File: ";
+var DELETE_FILE_PREFIX = "*** Delete File: ";
+var UPDATE_FILE_PREFIX = "*** Update File: ";
+var MOVE_TO_PREFIX = "*** Move to: ";
+var END_OF_FILE_LINE = "*** End of File";
+var DEFAULT_MAX_PATCH_BYTES = 1024 * 1024;
+var applyPatchToolInputSchema = z4.object({
+  input: z4.string().min(1).describe("The entire apply_patch payload, including Begin/End markers.")
+});
+function createApplyPatchTool(options = {}) {
+  return tool({
+    description: options.description ?? "Apply edits using a Codex-style apply_patch payload with Begin/End markers.",
+    inputSchema: applyPatchToolInputSchema,
+    execute: async ({ input }) => applyPatch({
+      patch: input,
+      cwd: options.cwd,
+      fs: options.fs,
+      allowOutsideCwd: options.allowOutsideCwd,
+      checkAccess: options.checkAccess,
+      maxPatchBytes: options.maxPatchBytes
+    })
+  });
+}
+async function applyPatch(request) {
+  const cwd = path3.resolve(request.cwd ?? process.cwd());
+  const adapter = request.fs ?? createNodeAgentFilesystem();
+  const allowOutsideCwd = request.allowOutsideCwd === true;
+  const patchBytes = Buffer.byteLength(request.patch, "utf8");
+  const maxPatchBytes = request.maxPatchBytes ?? DEFAULT_MAX_PATCH_BYTES;
+  if (patchBytes > maxPatchBytes) {
+    throw new Error(
+      `apply_patch failed: patch too large (${patchBytes} bytes > ${maxPatchBytes} bytes)`
+    );
+  }
+  const parsed = parsePatchDocument(normalizePatchText(request.patch));
+  const added = [];
+  const modified = [];
+  const deleted = [];
+  for (const operation of parsed.operations) {
+    if (operation.type === "add") {
+      const absolutePath2 = resolvePatchPath(operation.path, cwd, allowOutsideCwd);
+      await runAccessHook(request.checkAccess, {
+        cwd,
+        kind: "add",
+        path: absolutePath2
+      });
+      await adapter.ensureDir(path3.dirname(absolutePath2));
+      await adapter.writeTextFile(absolutePath2, operation.content);
+      added.push(toDisplayPath(absolutePath2, cwd));
+      continue;
+    }
+    if (operation.type === "delete") {
+      const absolutePath2 = resolvePatchPath(operation.path, cwd, allowOutsideCwd);
+      await runAccessHook(request.checkAccess, {
+        cwd,
+        kind: "delete",
+        path: absolutePath2
+      });
+      await adapter.readTextFile(absolutePath2);
+      await adapter.deleteFile(absolutePath2);
+      deleted.push(toDisplayPath(absolutePath2, cwd));
+      continue;
+    }
+    const absolutePath = resolvePatchPath(operation.path, cwd, allowOutsideCwd);
+    await runAccessHook(request.checkAccess, {
+      cwd,
+      kind: "update",
+      path: absolutePath
+    });
+    const current = await adapter.readTextFile(absolutePath);
+    const next = deriveUpdatedContent(current, operation.chunks, toDisplayPath(absolutePath, cwd));
+    if (operation.movePath) {
+      const destinationPath = resolvePatchPath(operation.movePath, cwd, allowOutsideCwd);
+      await runAccessHook(request.checkAccess, {
+        cwd,
+        kind: "move",
+        path: destinationPath,
+        fromPath: absolutePath,
+        toPath: destinationPath
+      });
+      await adapter.ensureDir(path3.dirname(destinationPath));
+      await adapter.writeTextFile(destinationPath, next);
+      await adapter.deleteFile(absolutePath);
+      modified.push(toDisplayPath(destinationPath, cwd));
+      continue;
+    }
+    await adapter.writeTextFile(absolutePath, next);
+    modified.push(toDisplayPath(absolutePath, cwd));
+  }
+  return {
+    success: true,
+    summary: formatSummary(added, modified, deleted),
+    added,
+    modified,
+    deleted
+  };
+}
+async function runAccessHook(hook, context) {
+  if (!hook) {
+    return;
+  }
+  await hook(context);
+}
+function normalizePatchText(raw) {
+  return raw.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+function resolvePatchPath(rawPath, cwd, allowOutsideCwd) {
+  const trimmed = rawPath.trim();
+  if (trimmed.length === 0) {
+    throw new Error("apply_patch failed: empty file path");
+  }
+  const absolutePath = path3.isAbsolute(trimmed) ? path3.resolve(trimmed) : path3.resolve(cwd, trimmed);
+  if (!allowOutsideCwd && !isPathInsideCwd(absolutePath, cwd)) {
+    throw new Error(`apply_patch failed: path "${trimmed}" resolves outside cwd "${cwd}"`);
+  }
+  return absolutePath;
+}
+function isPathInsideCwd(candidatePath, cwd) {
+  const relative = path3.relative(cwd, candidatePath);
+  return relative === "" || !relative.startsWith("..") && !path3.isAbsolute(relative);
+}
+function toDisplayPath(absolutePath, cwd) {
+  const relative = path3.relative(cwd, absolutePath);
+  if (relative === "") {
+    return ".";
+  }
+  if (!relative.startsWith("..") && !path3.isAbsolute(relative)) {
+    return relative;
+  }
+  return absolutePath;
+}
+function parsePatchDocument(patch) {
+  const lines = patch.split("\n");
+  if (lines.at(-1) === "") {
+    lines.pop();
+  }
+  if (lines.length < 2) {
+    throw new Error("apply_patch failed: patch must contain Begin/End markers");
+  }
+  if (lines[0] !== BEGIN_PATCH_LINE) {
+    throw new Error(`apply_patch failed: missing "${BEGIN_PATCH_LINE}" header`);
+  }
+  if (lines[lines.length - 1] !== END_PATCH_LINE) {
+    throw new Error(`apply_patch failed: missing "${END_PATCH_LINE}" footer`);
+  }
+  const body = lines.slice(1, -1);
+  if (body.length === 0) {
+    throw new Error("apply_patch failed: patch body is empty");
+  }
+  const operations = [];
+  let index = 0;
+  while (index < body.length) {
+    const line = body[index];
+    if (!line) {
+      throw new Error("apply_patch failed: unexpected empty line between file sections");
+    }
+    if (line.startsWith(ADD_FILE_PREFIX)) {
+      const filePath = extractPatchPath(line, ADD_FILE_PREFIX);
+      index += 1;
+      const contentLines = [];
+      while (index < body.length) {
+        const contentLine = body[index];
+        if (contentLine === void 0 || isPatchSectionHeader(contentLine)) {
+          break;
+        }
+        if (!contentLine.startsWith("+")) {
+          throw new Error(`apply_patch failed: invalid add-file line "${contentLine}"`);
+        }
+        contentLines.push(contentLine.slice(1));
+        index += 1;
+      }
+      if (contentLines.length === 0) {
+        throw new Error(`apply_patch failed: add-file section for "${filePath}" is empty`);
+      }
+      operations.push({
+        type: "add",
+        path: filePath,
+        content: `${contentLines.join("\n")}
+`
+      });
+      continue;
+    }
+    if (line.startsWith(DELETE_FILE_PREFIX)) {
+      operations.push({
+        type: "delete",
+        path: extractPatchPath(line, DELETE_FILE_PREFIX)
+      });
+      index += 1;
+      continue;
+    }
+    if (line.startsWith(UPDATE_FILE_PREFIX)) {
+      const filePath = extractPatchPath(line, UPDATE_FILE_PREFIX);
+      index += 1;
+      let movePath;
+      const moveHeader = body[index];
+      if (moveHeader?.startsWith(MOVE_TO_PREFIX)) {
+        movePath = extractPatchPath(moveHeader, MOVE_TO_PREFIX);
+        index += 1;
+      }
+      const chunks = [];
+      while (index < body.length) {
+        const hunkHeader = body[index];
+        if (hunkHeader === void 0 || isPatchSectionHeader(hunkHeader)) {
+          break;
+        }
+        if (!(hunkHeader === "@@" || hunkHeader.startsWith("@@ "))) {
+          throw new Error(
+            `apply_patch failed: expected hunk marker in "${filePath}", got "${hunkHeader}"`
+          );
+        }
+        const contextSelector = hunkHeader.length > 2 ? hunkHeader.slice(3) : void 0;
+        index += 1;
+        const oldLines = [];
+        const newLines = [];
+        let sawBodyLine = false;
+        let sawChangeLine = false;
+        let isEndOfFile = false;
+        while (index < body.length) {
+          const chunkLine = body[index];
+          if (chunkLine === void 0) {
+            break;
+          }
+          if (chunkLine === "@@" || chunkLine.startsWith("@@ ") || isPatchSectionHeader(chunkLine)) {
+            break;
+          }
+          if (chunkLine === END_OF_FILE_LINE) {
+            isEndOfFile = true;
+            index += 1;
+            break;
+          }
+          if (chunkLine.length === 0) {
+            throw new Error(`apply_patch failed: invalid empty hunk line in "${filePath}"`);
+          }
+          const prefix = chunkLine[0];
+          const content = chunkLine.slice(1);
+          if (prefix === " ") {
+            oldLines.push(content);
+            newLines.push(content);
+          } else if (prefix === "-") {
+            oldLines.push(content);
+            sawChangeLine = true;
+          } else if (prefix === "+") {
+            newLines.push(content);
+            sawChangeLine = true;
+          } else {
+            throw new Error(
+              `apply_patch failed: unsupported hunk prefix "${prefix}" in "${chunkLine}"`
+            );
+          }
+          sawBodyLine = true;
+          index += 1;
+        }
+        if (!sawBodyLine) {
+          throw new Error(`apply_patch failed: empty hunk body in "${filePath}"`);
+        }
+        if (!sawChangeLine) {
+          throw new Error(
+            `apply_patch failed: hunk in "${filePath}" must include '+' or '-' lines`
+          );
+        }
+        chunks.push({
+          contextSelector,
+          oldLines,
+          newLines,
+          isEndOfFile
+        });
+      }
+      if (chunks.length === 0) {
+        throw new Error(`apply_patch failed: update section for "${filePath}" has no hunks`);
+      }
+      operations.push({
+        type: "update",
+        path: filePath,
+        movePath,
+        chunks
+      });
+      continue;
+    }
+    throw new Error(`apply_patch failed: unrecognized section header "${line}"`);
+  }
+  return { operations };
+}
+function extractPatchPath(line, prefix) {
+  const value = line.slice(prefix.length).trim();
+  if (value.length === 0) {
+    throw new Error(`apply_patch failed: missing file path in "${line}"`);
+  }
+  return value;
+}
+function isPatchSectionHeader(line) {
+  return line.startsWith(ADD_FILE_PREFIX) || line.startsWith(DELETE_FILE_PREFIX) || line.startsWith(UPDATE_FILE_PREFIX);
+}
+function deriveUpdatedContent(originalContent, chunks, displayPath) {
+  const originalLines = splitFileContentIntoLines(originalContent);
+  const replacements = [];
+  let lineIndex = 0;
+  for (const chunk of chunks) {
+    if (chunk.contextSelector !== void 0) {
+      const contextIndex = seekSequence(originalLines, [chunk.contextSelector], lineIndex, false);
+      if (contextIndex === null) {
+        throw new Error(
+          `apply_patch failed: unable to locate context "${chunk.contextSelector}" in ${displayPath}`
+        );
+      }
+      lineIndex = contextIndex + 1;
+    }
+    if (chunk.oldLines.length === 0) {
+      replacements.push({
+        startIndex: originalLines.length,
+        oldLength: 0,
+        newLines: [...chunk.newLines]
+      });
+      continue;
+    }
+    let oldLines = [...chunk.oldLines];
+    let newLines = [...chunk.newLines];
+    let startIndex = seekSequence(originalLines, oldLines, lineIndex, chunk.isEndOfFile);
+    if (startIndex === null && oldLines.at(-1) === "") {
+      oldLines = oldLines.slice(0, -1);
+      if (newLines.at(-1) === "") {
+        newLines = newLines.slice(0, -1);
+      }
+      startIndex = seekSequence(originalLines, oldLines, lineIndex, chunk.isEndOfFile);
+    }
+    if (startIndex === null) {
+      throw new Error(
+        `apply_patch failed: failed to match hunk in ${displayPath}:
+${chunk.oldLines.join("\n")}`
+      );
+    }
+    replacements.push({
+      startIndex,
+      oldLength: oldLines.length,
+      newLines
+    });
+    lineIndex = startIndex + oldLines.length;
+  }
+  replacements.sort((left, right) => left.startIndex - right.startIndex);
+  const nextLines = applyReplacements(originalLines, replacements);
+  if (nextLines.length > 0 && nextLines[nextLines.length - 1] !== "") {
+    nextLines.push("");
+  }
+  return nextLines.join("\n");
+}
+function splitFileContentIntoLines(content) {
+  const lines = content.split("\n");
+  if (lines.at(-1) === "") {
+    lines.pop();
+  }
+  return lines;
+}
+function seekSequence(sourceLines, targetLines, startIndex, isEndOfFile) {
+  if (targetLines.length === 0) {
+    return Math.min(Math.max(startIndex, 0), sourceLines.length);
+  }
+  const from = Math.max(startIndex, 0);
+  const maxStart = sourceLines.length - targetLines.length;
+  if (maxStart < from) {
+    return null;
+  }
+  const matchesAt = (candidateIndex) => {
+    for (let offset = 0; offset < targetLines.length; offset += 1) {
+      if (sourceLines[candidateIndex + offset] !== targetLines[offset]) {
+        return false;
+      }
+    }
+    return true;
+  };
+  if (isEndOfFile) {
+    return matchesAt(maxStart) ? maxStart : null;
+  }
+  for (let candidate = from; candidate <= maxStart; candidate += 1) {
+    if (matchesAt(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function applyReplacements(lines, replacements) {
+  const result = [...lines];
+  for (let index = replacements.length - 1; index >= 0; index -= 1) {
+    const replacement = replacements[index];
+    if (replacement === void 0) {
+      continue;
+    }
+    result.splice(replacement.startIndex, replacement.oldLength, ...replacement.newLines);
+  }
+  return result;
+}
+function formatSummary(added, modified, deleted) {
+  const lines = ["Success. Updated the following files:"];
+  for (const filePath of added) {
+    lines.push(`A ${filePath}`);
+  }
+  for (const filePath of modified) {
+    lines.push(`M ${filePath}`);
+  }
+  for (const filePath of deleted) {
+    lines.push(`D ${filePath}`);
+  }
+  return `${lines.join("\n")}
+`;
+}
+
+// src/tools/filesystemTools.ts
+var DEFAULT_READ_FILE_LINE_LIMIT = 2e3;
+var DEFAULT_LIST_DIR_LIMIT = 25;
+var DEFAULT_LIST_DIR_DEPTH = 2;
+var DEFAULT_GREP_LIMIT = 100;
+var MAX_GREP_LIMIT = 2e3;
+var DEFAULT_MAX_LINE_LENGTH = 500;
+var DEFAULT_GREP_MAX_SCANNED_FILES = 2e4;
+var DEFAULT_TAB_WIDTH = 4;
+var codexReadFileInputSchema = z5.object({
+  file_path: z5.string().min(1).describe("Absolute path to the file"),
+  offset: z5.number().int().min(1).optional().describe("The line number to start reading from. Must be 1 or greater."),
+  limit: z5.number().int().min(1).optional().describe("The maximum number of lines to return."),
+  mode: z5.enum(["slice", "indentation"]).optional().describe('Optional mode selector: "slice" (default) or "indentation".'),
+  indentation: z5.object({
+    anchor_line: z5.number().int().min(1).optional(),
+    max_levels: z5.number().int().min(0).optional(),
+    include_siblings: z5.boolean().optional(),
+    include_header: z5.boolean().optional(),
+    max_lines: z5.number().int().min(1).optional()
+  }).optional()
+});
+var codexListDirInputSchema = z5.object({
+  dir_path: z5.string().min(1).describe("Absolute path to the directory to list."),
+  offset: z5.number().int().min(1).optional().describe("The entry number to start listing from. Must be 1 or greater."),
+  limit: z5.number().int().min(1).optional().describe("The maximum number of entries to return."),
+  depth: z5.number().int().min(1).optional().describe("The maximum directory depth to traverse. Must be 1 or greater.")
+});
+var codexGrepFilesInputSchema = z5.object({
+  pattern: z5.string().min(1).describe("Regular expression pattern to search for."),
+  include: z5.string().optional().describe('Optional glob limiting searched files (for example "*.rs").'),
+  path: z5.string().optional().describe("Directory or file path to search. Defaults to cwd."),
+  limit: z5.number().int().min(1).optional().describe("Maximum number of file paths to return (defaults to 100).")
+});
+var applyPatchInputSchema = z5.object({
+  input: z5.string().min(1)
+});
+var geminiReadFileInputSchema = z5.object({
+  file_path: z5.string().min(1),
+  offset: z5.number().int().min(0).optional(),
+  limit: z5.number().int().min(1).optional()
+});
+var geminiWriteFileInputSchema = z5.object({
+  file_path: z5.string().min(1),
+  content: z5.string()
+});
+var geminiReplaceInputSchema = z5.object({
+  file_path: z5.string().min(1),
+  instruction: z5.string().min(1),
+  old_string: z5.string(),
+  new_string: z5.string(),
+  expected_replacements: z5.number().int().min(1).optional()
+});
+var geminiListDirectoryInputSchema = z5.object({
+  dir_path: z5.string().min(1),
+  ignore: z5.array(z5.string()).optional(),
+  file_filtering_options: z5.object({
+    respect_git_ignore: z5.boolean().optional(),
+    respect_gemini_ignore: z5.boolean().optional()
+  }).optional()
+});
+var geminiGrepSearchInputSchema = z5.object({
+  pattern: z5.string().min(1),
+  dir_path: z5.string().optional(),
+  include: z5.string().optional(),
+  exclude_pattern: z5.string().optional(),
+  names_only: z5.boolean().optional(),
+  max_matches_per_file: z5.number().int().min(1).optional(),
+  total_max_matches: z5.number().int().min(1).optional()
+});
+var geminiGlobInputSchema = z5.object({
+  pattern: z5.string().min(1),
+  dir_path: z5.string().optional(),
+  case_sensitive: z5.boolean().optional(),
+  respect_git_ignore: z5.boolean().optional(),
+  respect_gemini_ignore: z5.boolean().optional()
+});
+function resolveFilesystemToolProfile(model, profile = "auto") {
+  if (profile !== "auto") {
+    return profile;
+  }
+  if (isCodexModel(model)) {
+    return "codex";
+  }
+  if (isGeminiModel(model)) {
+    return "gemini";
+  }
+  return "model-agnostic";
+}
+function createFilesystemToolSetForModel(model, profileOrOptions = "auto", maybeOptions) {
+  if (typeof profileOrOptions === "string") {
+    const resolvedProfile2 = resolveFilesystemToolProfile(model, profileOrOptions);
+    if (resolvedProfile2 === "codex") {
+      return createCodexFilesystemToolSet(maybeOptions);
+    }
+    if (resolvedProfile2 === "gemini") {
+      return createGeminiFilesystemToolSet(maybeOptions);
+    }
+    return createModelAgnosticFilesystemToolSet(maybeOptions);
+  }
+  const resolvedProfile = resolveFilesystemToolProfile(model, "auto");
+  if (resolvedProfile === "codex") {
+    return createCodexFilesystemToolSet(profileOrOptions);
+  }
+  if (resolvedProfile === "gemini") {
+    return createGeminiFilesystemToolSet(profileOrOptions);
+  }
+  return createModelAgnosticFilesystemToolSet(profileOrOptions);
+}
+function createCodexFilesystemToolSet(options = {}) {
+  return {
+    apply_patch: createCodexApplyPatchTool(options),
+    read_file: createCodexReadFileTool(options),
+    list_dir: createListDirTool(options),
+    grep_files: createGrepFilesTool(options)
+  };
+}
+function createGeminiFilesystemToolSet(options = {}) {
+  return {
+    read_file: createReadFileTool(options),
+    write_file: createWriteFileTool(options),
+    replace: createReplaceTool(options),
+    list_directory: createListDirectoryTool(options),
+    grep_search: createGrepSearchTool(options),
+    glob: createGlobTool(options)
+  };
+}
+function createModelAgnosticFilesystemToolSet(options = {}) {
+  return createGeminiFilesystemToolSet(options);
+}
+function createCodexApplyPatchTool(options = {}) {
+  return tool({
+    description: "Use the `apply_patch` tool to edit files. This is a FREEFORM tool, so do not wrap the patch in JSON.",
+    inputSchema: applyPatchInputSchema,
+    execute: async ({ input }) => {
+      const runtime = resolveRuntime(options);
+      const result = await applyPatch({
+        patch: input,
+        cwd: runtime.cwd,
+        fs: runtime.filesystem,
+        allowOutsideCwd: runtime.allowOutsideCwd,
+        checkAccess: runtime.checkAccess ? async (context) => {
+          await runtime.checkAccess?.({
+            cwd: runtime.cwd,
+            tool: "apply_patch",
+            action: mapApplyPatchAction(context.kind),
+            path: context.path,
+            fromPath: context.fromPath,
+            toPath: context.toPath
+          });
+        } : void 0,
+        maxPatchBytes: options.applyPatch?.maxPatchBytes
+      });
+      return result.summary;
+    }
+  });
+}
+function createCodexReadFileTool(options = {}) {
+  return tool({
+    description: "Reads a local file with 1-indexed line numbers, supporting slice and indentation-aware block modes.",
+    inputSchema: codexReadFileInputSchema,
+    execute: async (input) => readFileCodex(input, options)
+  });
+}
+function createListDirTool(options = {}) {
+  return tool({
+    description: "Lists entries in a local directory with 1-indexed entry numbers and simple type labels.",
+    inputSchema: codexListDirInputSchema,
+    execute: async (input) => listDirectoryCodex(input, options)
+  });
+}
+function createGrepFilesTool(options = {}) {
+  return tool({
+    description: "Finds files whose contents match the pattern and lists them by modification time.",
+    inputSchema: codexGrepFilesInputSchema,
+    execute: async (input) => grepFilesCodex(input, options)
+  });
+}
+function createReadFileTool(options = {}) {
+  return tool({
+    description: "Reads and returns content of a specified file.",
+    inputSchema: geminiReadFileInputSchema,
+    execute: async (input) => readFileGemini(input, options)
+  });
+}
+function createWriteFileTool(options = {}) {
+  return tool({
+    description: "Writes content to a specified file in the local filesystem.",
+    inputSchema: geminiWriteFileInputSchema,
+    execute: async (input) => writeFileGemini(input, options)
+  });
+}
+function createReplaceTool(options = {}) {
+  return tool({
+    description: "Replaces exact literal text within a file.",
+    inputSchema: geminiReplaceInputSchema,
+    execute: async (input) => replaceFileContentGemini(input, options)
+  });
+}
+function createListDirectoryTool(options = {}) {
+  return tool({
+    description: "Lists files and subdirectories directly within a specified directory path.",
+    inputSchema: geminiListDirectoryInputSchema,
+    execute: async (input) => listDirectoryGemini(input, options)
+  });
+}
+function createGrepSearchTool(options = {}) {
+  return tool({
+    description: "Searches for a regex pattern within file contents.",
+    inputSchema: geminiGrepSearchInputSchema,
+    execute: async (input) => grepSearchGemini(input, options)
+  });
+}
+function createGlobTool(options = {}) {
+  return tool({
+    description: "Finds files matching glob patterns, sorted by modification time (newest first).",
+    inputSchema: geminiGlobInputSchema,
+    execute: async (input) => globFilesGemini(input, options)
+  });
+}
+async function readFileCodex(input, options) {
+  const runtime = resolveRuntime(options);
+  if (!path4.isAbsolute(input.file_path)) {
+    throw new Error("file_path must be an absolute path");
+  }
+  const filePath = resolvePathWithPolicy(input.file_path, 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 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
+  });
+  return selected.map((record) => `L${record.number}: ${record.display}`).join("\n");
+}
+async function listDirectoryCodex(input, options) {
+  const runtime = resolveRuntime(options);
+  if (!path4.isAbsolute(input.dir_path)) {
+    throw new Error("dir_path must be an absolute path");
+  }
+  const dirPath = resolvePathWithPolicy(input.dir_path, runtime.cwd, runtime.allowOutsideCwd);
+  await runAccessHook2(runtime, {
+    cwd: runtime.cwd,
+    tool: "list_dir",
+    action: "list",
+    path: dirPath
+  });
+  const stats = await runtime.filesystem.stat(dirPath);
+  if (stats.kind !== "directory") {
+    throw new Error(`failed to read directory: "${dirPath}" is not a directory`);
+  }
+  const offset = input.offset ?? 1;
+  const limit = input.limit ?? DEFAULT_LIST_DIR_LIMIT;
+  const depth = input.depth ?? DEFAULT_LIST_DIR_DEPTH;
+  const entries = await collectDirectoryEntries(
+    runtime.filesystem,
+    dirPath,
+    depth,
+    runtime.maxLineLength
+  );
+  if (offset > entries.length) {
+    throw new Error("offset exceeds directory entry count");
+  }
+  const startIndex = offset - 1;
+  const remaining = entries.length - startIndex;
+  const cappedLimit = Math.min(limit, remaining);
+  const selected = entries.slice(startIndex, startIndex + cappedLimit);
+  const output = [`Absolute path: ${dirPath}`];
+  for (const entry of selected) {
+    output.push(formatListEntry(entry));
+  }
+  if (startIndex + cappedLimit < entries.length) {
+    output.push(`More than ${cappedLimit} entries found`);
+  }
+  return output.join("\n");
+}
+async function grepFilesCodex(input, options) {
+  const runtime = resolveRuntime(options);
+  const pattern = input.pattern.trim();
+  if (pattern.length === 0) {
+    throw new Error("pattern must not be empty");
+  }
+  const regex = compileRegex(pattern);
+  const searchPath = resolvePathWithPolicy(
+    input.path ?? runtime.cwd,
+    runtime.cwd,
+    runtime.allowOutsideCwd
+  );
+  await runAccessHook2(runtime, {
+    cwd: runtime.cwd,
+    tool: "grep_files",
+    action: "search",
+    path: searchPath,
+    pattern,
+    include: input.include?.trim()
+  });
+  const searchPathInfo = await runtime.filesystem.stat(searchPath);
+  const filesToScan = await collectSearchFiles({
+    filesystem: runtime.filesystem,
+    searchPath,
+    rootKind: searchPathInfo.kind,
+    maxScannedFiles: runtime.grepMaxScannedFiles
+  });
+  const includeMatcher = input.include ? createGlobMatcher(input.include) : null;
+  const matches = [];
+  for (const filePath of filesToScan) {
+    const relativePath = toDisplayPath2(filePath, runtime.cwd);
+    if (includeMatcher && !includeMatcher(relativePath)) {
+      continue;
+    }
+    const fileContent = await runtime.filesystem.readTextFile(filePath);
+    if (!regex.test(fileContent)) {
+      continue;
+    }
+    const stats = await runtime.filesystem.stat(filePath);
+    matches.push({ filePath: normalizeSlashes(relativePath), mtimeMs: stats.mtimeMs });
+  }
+  if (matches.length === 0) {
+    return "No matches found.";
+  }
+  matches.sort((left, right) => right.mtimeMs - left.mtimeMs);
+  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 readFileGemini(input, options) {
+  const runtime = resolveRuntime(options);
+  const filePath = resolvePathWithPolicy(input.file_path, runtime.cwd, runtime.allowOutsideCwd);
+  await runAccessHook2(runtime, {
+    cwd: runtime.cwd,
+    tool: "read_file",
+    action: "read",
+    path: filePath
+  });
+  const content = await runtime.filesystem.readTextFile(filePath);
+  if (input.offset === void 0 && input.limit === void 0) {
+    return content;
+  }
+  const lines = splitLines(content);
+  const offset = Math.max(0, input.offset ?? 0);
+  const limit = input.limit ?? DEFAULT_READ_FILE_LINE_LIMIT;
+  if (offset >= lines.length) {
+    return "";
+  }
+  const end = Math.min(lines.length, offset + limit);
+  return lines.slice(offset, end).join("\n");
+}
+async function writeFileGemini(input, options) {
+  const runtime = resolveRuntime(options);
+  const filePath = resolvePathWithPolicy(input.file_path, runtime.cwd, runtime.allowOutsideCwd);
+  await runAccessHook2(runtime, {
+    cwd: runtime.cwd,
+    tool: "write_file",
+    action: "write",
+    path: filePath
+  });
+  await runtime.filesystem.ensureDir(path4.dirname(filePath));
+  await runtime.filesystem.writeTextFile(filePath, input.content);
+  return `Successfully wrote file: ${toDisplayPath2(filePath, runtime.cwd)}`;
+}
+async function replaceFileContentGemini(input, options) {
+  const runtime = resolveRuntime(options);
+  const filePath = resolvePathWithPolicy(input.file_path, runtime.cwd, runtime.allowOutsideCwd);
+  await runAccessHook2(runtime, {
+    cwd: runtime.cwd,
+    tool: "replace",
+    action: "write",
+    path: filePath
+  });
+  const expectedReplacements = input.expected_replacements ?? 1;
+  const oldValue = input.old_string;
+  const newValue = input.new_string;
+  let originalContent = "";
+  try {
+    originalContent = await runtime.filesystem.readTextFile(filePath);
+  } catch (error) {
+    if (isNoEntError(error) && oldValue.length === 0) {
+      await runtime.filesystem.ensureDir(path4.dirname(filePath));
+      await runtime.filesystem.writeTextFile(filePath, newValue);
+      return `Successfully wrote new file: ${toDisplayPath2(filePath, runtime.cwd)}`;
+    }
+    throw error;
+  }
+  if (oldValue === newValue) {
+    throw new Error("No changes to apply. old_string and new_string are identical.");
+  }
+  const occurrences = countOccurrences(originalContent, oldValue);
+  if (occurrences === 0) {
+    throw new Error("Failed to edit, could not find old_string in file.");
+  }
+  if (occurrences !== expectedReplacements) {
+    throw new Error(
+      `Failed to edit, expected ${expectedReplacements} occurrence(s) but found ${occurrences}.`
+    );
+  }
+  const updatedContent = safeReplaceAll(originalContent, oldValue, newValue);
+  await runtime.filesystem.writeTextFile(filePath, updatedContent);
+  return `Successfully replaced ${occurrences} occurrence(s) in ${toDisplayPath2(filePath, runtime.cwd)}.`;
+}
+async function listDirectoryGemini(input, options) {
+  const runtime = resolveRuntime(options);
+  const dirPath = resolvePathWithPolicy(input.dir_path, runtime.cwd, runtime.allowOutsideCwd);
+  await runAccessHook2(runtime, {
+    cwd: runtime.cwd,
+    tool: "list_directory",
+    action: "list",
+    path: dirPath
+  });
+  const stats = await runtime.filesystem.stat(dirPath);
+  if (stats.kind !== "directory") {
+    throw new Error(`Path is not a directory: ${dirPath}`);
+  }
+  const entries = await runtime.filesystem.readDir(dirPath);
+  const ignoreMatchers = (input.ignore ?? []).map((pattern) => createGlobMatcher(pattern));
+  const filtered = entries.filter((entry) => {
+    if (ignoreMatchers.length === 0) {
+      return true;
+    }
+    return !ignoreMatchers.some((matches) => matches(entry.name));
+  }).sort((left, right) => left.name.localeCompare(right.name));
+  if (filtered.length === 0) {
+    return `Directory ${toDisplayPath2(dirPath, runtime.cwd)} is empty.`;
+  }
+  return filtered.map((entry) => {
+    const label = entry.kind === "directory" ? `${entry.name}/` : entry.name;
+    return label;
+  }).join("\n");
+}
+async function grepSearchGemini(input, options) {
+  const runtime = resolveRuntime(options);
+  const pattern = input.pattern.trim();
+  if (pattern.length === 0) {
+    throw new Error("pattern must not be empty");
+  }
+  const include = input.include?.trim();
+  const searchPath = resolvePathWithPolicy(
+    input.dir_path ?? runtime.cwd,
+    runtime.cwd,
+    runtime.allowOutsideCwd
+  );
+  await runAccessHook2(runtime, {
+    cwd: runtime.cwd,
+    tool: "grep_search",
+    action: "search",
+    path: searchPath,
+    pattern,
+    include
+  });
+  const searchPathInfo = await runtime.filesystem.stat(searchPath);
+  const filesToScan = await collectSearchFiles({
+    filesystem: runtime.filesystem,
+    searchPath,
+    rootKind: searchPathInfo.kind,
+    maxScannedFiles: runtime.grepMaxScannedFiles
+  });
+  const matcher = include ? createGlobMatcher(include) : null;
+  const patternRegex = compileRegex(pattern);
+  const excludeRegex = input.exclude_pattern ? compileRegex(input.exclude_pattern) : null;
+  const totalMaxMatches = input.total_max_matches ?? DEFAULT_GREP_LIMIT;
+  const perFileMaxMatches = input.max_matches_per_file ?? Number.POSITIVE_INFINITY;
+  const matches = [];
+  const fileMatches = /* @__PURE__ */ new Set();
+  for (const filePath of filesToScan) {
+    const relativePath = normalizeSlashes(toDisplayPath2(filePath, runtime.cwd));
+    if (matcher && !matcher(relativePath)) {
+      continue;
+    }
+    const content = await runtime.filesystem.readTextFile(filePath);
+    const lines = splitLines(content);
+    let fileMatchCount = 0;
+    for (let index = 0; index < lines.length; index += 1) {
+      const line = lines[index] ?? "";
+      if (!patternRegex.test(line)) {
+        continue;
+      }
+      if (excludeRegex?.test(line)) {
+        continue;
+      }
+      if (fileMatches.has(relativePath) === false) {
+        fileMatches.add(relativePath);
+      }
+      if (input.names_only) {
+        continue;
+      }
+      matches.push({
+        filePath: relativePath,
+        mtimeMs: 0,
+        lineNumber: index + 1,
+        line
+      });
+      fileMatchCount += 1;
+      if (fileMatchCount >= perFileMaxMatches || matches.length >= totalMaxMatches) {
+        break;
+      }
+    }
+    if (input.names_only && fileMatches.size >= totalMaxMatches) {
+      break;
+    }
+    if (!input.names_only && matches.length >= totalMaxMatches) {
+      break;
+    }
+  }
+  if (input.names_only) {
+    if (fileMatches.size === 0) {
+      return "No matches found.";
+    }
+    return [...fileMatches].slice(0, totalMaxMatches).join("\n");
+  }
+  if (matches.length === 0) {
+    return "No matches found.";
+  }
+  return matches.slice(0, totalMaxMatches).map((match) => `${match.filePath}:${match.lineNumber}:${match.line ?? ""}`).join("\n");
+}
+async function globFilesGemini(input, options) {
+  const runtime = resolveRuntime(options);
+  const dirPath = resolvePathWithPolicy(
+    input.dir_path ?? runtime.cwd,
+    runtime.cwd,
+    runtime.allowOutsideCwd
+  );
+  await runAccessHook2(runtime, {
+    cwd: runtime.cwd,
+    tool: "glob",
+    action: "search",
+    path: dirPath,
+    pattern: input.pattern
+  });
+  const dirStats = await runtime.filesystem.stat(dirPath);
+  if (dirStats.kind !== "directory") {
+    throw new Error(`Path is not a directory: ${dirPath}`);
+  }
+  const matcher = createGlobMatcher(input.pattern, input.case_sensitive === true);
+  const files = await collectSearchFiles({
+    filesystem: runtime.filesystem,
+    searchPath: dirPath,
+    rootKind: "directory",
+    maxScannedFiles: runtime.grepMaxScannedFiles
+  });
+  const matched = [];
+  for (const filePath of files) {
+    const relativePath = normalizeSlashes(path4.relative(dirPath, filePath));
+    if (!matcher(relativePath)) {
+      continue;
+    }
+    const fileStats = await runtime.filesystem.stat(filePath);
+    matched.push({
+      filePath,
+      mtimeMs: fileStats.mtimeMs
+    });
+  }
+  if (matched.length === 0) {
+    return "No files found.";
+  }
+  matched.sort((left, right) => right.mtimeMs - left.mtimeMs);
+  return matched.map((entry) => normalizeSlashes(path4.resolve(entry.filePath))).join("\n");
+}
+function resolveRuntime(options) {
+  return {
+    cwd: path4.resolve(options.cwd ?? process.cwd()),
+    filesystem: options.fs ?? createNodeAgentFilesystem(),
+    allowOutsideCwd: options.allowOutsideCwd === true,
+    checkAccess: options.checkAccess,
+    maxLineLength: options.maxLineLength ?? DEFAULT_MAX_LINE_LENGTH,
+    grepMaxScannedFiles: options.grepMaxScannedFiles ?? DEFAULT_GREP_MAX_SCANNED_FILES
+  };
+}
+async function runAccessHook2(runtime, context) {
+  if (!runtime.checkAccess) {
+    return;
+  }
+  await runtime.checkAccess(context);
+}
+function isCodexModel(model) {
+  const normalized = model.startsWith("chatgpt-") ? model.slice("chatgpt-".length) : model;
+  return normalized.includes("codex");
+}
+function isGeminiModel(model) {
+  return model.startsWith("gemini-");
+}
+function mapApplyPatchAction(action) {
+  if (action === "add" || action === "update") {
+    return "write";
+  }
+  if (action === "delete") {
+    return "delete";
+  }
+  return "move";
+}
+function resolvePathWithPolicy(inputPath, cwd, allowOutsideCwd) {
+  const absolutePath = path4.isAbsolute(inputPath) ? path4.resolve(inputPath) : path4.resolve(cwd, inputPath);
+  if (!allowOutsideCwd && !isPathInsideCwd2(absolutePath, cwd)) {
+    throw new Error(`path "${inputPath}" resolves outside cwd "${cwd}"`);
+  }
+  return absolutePath;
+}
+function isPathInsideCwd2(candidatePath, cwd) {
+  const relative = path4.relative(cwd, candidatePath);
+  return relative === "" || !relative.startsWith("..") && !path4.isAbsolute(relative);
+}
+function toDisplayPath2(absolutePath, cwd) {
+  const relative = path4.relative(cwd, absolutePath);
+  if (relative === "") {
+    return ".";
+  }
+  if (!relative.startsWith("..") && !path4.isAbsolute(relative)) {
+    return relative;
+  }
+  return absolutePath;
+}
+function splitLines(content) {
+  const normalized = content.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  const lines = normalized.split("\n");
+  if (lines.length > 0 && lines[lines.length - 1] === "") {
+    lines.pop();
+  }
+  return lines;
+}
+function truncateAtCodePointBoundary(value, maxLength) {
+  if (value.length <= maxLength) {
+    return value;
+  }
+  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 }
+  ];
+  const records = [];
+  while (queue.length > 0) {
+    const next = queue.shift();
+    if (!next) {
+      break;
+    }
+    const entries = await filesystem.readDir(next.path);
+    const nextEntries = [...entries].map((entry) => {
+      const relativePath = next.relativePrefix ? `${next.relativePrefix}/${entry.name}` : entry.name;
+      return {
+        entry,
+        relativePath,
+        depth: next.relativePrefix.length === 0 ? 0 : next.relativePrefix.split("/").length,
+        sortName: normalizeSlashes(relativePath)
+      };
+    }).sort((left, right) => left.sortName.localeCompare(right.sortName));
+    for (const item of nextEntries) {
+      if (item.entry.kind === "directory" && next.remainingDepth > 1) {
+        queue.push({
+          path: item.entry.path,
+          relativePrefix: item.relativePath,
+          remainingDepth: next.remainingDepth - 1
+        });
+      }
+      records.push({
+        name: item.sortName,
+        displayName: truncateAtCodePointBoundary(item.entry.name, maxLineLength),
+        depth: item.depth,
+        kind: item.entry.kind
+      });
+    }
+  }
+  records.sort((left, right) => left.name.localeCompare(right.name));
+  return records;
+}
+function formatListEntry(entry) {
+  const indent = " ".repeat(entry.depth * 2);
+  let name = entry.displayName;
+  if (entry.kind === "directory") {
+    name += "/";
+  } else if (entry.kind === "symlink") {
+    name += "@";
+  } else if (entry.kind === "other") {
+    name += "?";
+  }
+  return `${indent}${name}`;
+}
+async function collectSearchFiles(params) {
+  const { filesystem, searchPath, rootKind, maxScannedFiles } = params;
+  if (rootKind === "file") {
+    return [searchPath];
+  }
+  const queue = [searchPath];
+  const files = [];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (!current) {
+      break;
+    }
+    const entries = await filesystem.readDir(current);
+    for (const entry of entries) {
+      if (entry.kind === "directory") {
+        queue.push(entry.path);
+        continue;
+      }
+      if (entry.kind !== "file") {
+        continue;
+      }
+      files.push(entry.path);
+      if (files.length >= maxScannedFiles) {
+        return files;
+      }
+    }
+  }
+  return files;
+}
+function compileRegex(pattern) {
+  try {
+    return new RegExp(pattern, "m");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`invalid regex pattern: ${message}`);
+  }
+}
+function createGlobMatcher(pattern, caseSensitive = false) {
+  const expanded = expandBracePatterns(normalizeSlashes(pattern.trim()));
+  const flags = caseSensitive ? "" : "i";
+  const compiled = expanded.map((entry) => ({
+    regex: globToRegex(entry, flags),
+    applyToBasename: !entry.includes("/")
+  }));
+  return (candidatePath) => {
+    const normalizedPath = normalizeSlashes(candidatePath);
+    const basename = path4.posix.basename(normalizedPath);
+    return compiled.some(
+      (entry) => entry.regex.test(entry.applyToBasename ? basename : normalizedPath)
+    );
+  };
+}
+function globToRegex(globPattern, flags) {
+  let source = "^";
+  for (let index = 0; index < globPattern.length; index += 1) {
+    const char = globPattern[index];
+    const nextChar = globPattern[index + 1];
+    if (char === void 0) {
+      continue;
+    }
+    if (char === "*" && nextChar === "*") {
+      source += ".*";
+      index += 1;
+      continue;
+    }
+    if (char === "*") {
+      source += "[^/]*";
+      continue;
+    }
+    if (char === "?") {
+      source += "[^/]";
+      continue;
+    }
+    source += escapeRegexCharacter(char);
+  }
+  source += "$";
+  return new RegExp(source, flags);
+}
+function expandBracePatterns(pattern) {
+  const start = pattern.indexOf("{");
+  if (start === -1) {
+    return [pattern];
+  }
+  let depth = 0;
+  let end = -1;
+  for (let index = start; index < pattern.length; index += 1) {
+    const char = pattern[index];
+    if (char === "{") {
+      depth += 1;
+      continue;
+    }
+    if (char === "}") {
+      depth -= 1;
+      if (depth === 0) {
+        end = index;
+        break;
+      }
+    }
+  }
+  if (end === -1) {
+    return [pattern];
+  }
+  const prefix = pattern.slice(0, start);
+  const suffix = pattern.slice(end + 1);
+  const body = pattern.slice(start + 1, end);
+  const variants = splitTopLevel(body, ",");
+  const expanded = [];
+  for (const variant of variants) {
+    expanded.push(...expandBracePatterns(`${prefix}${variant}${suffix}`));
+  }
+  return expanded;
+}
+function splitTopLevel(value, separator) {
+  const parts = [];
+  let depth = 0;
+  let current = "";
+  for (const char of value) {
+    if (char === "{") {
+      depth += 1;
+      current += char;
+      continue;
+    }
+    if (char === "}") {
+      depth = Math.max(0, depth - 1);
+      current += char;
+      continue;
+    }
+    if (char === separator && depth === 0) {
+      parts.push(current);
+      current = "";
+      continue;
+    }
+    current += char;
+  }
+  parts.push(current);
+  return parts;
+}
+function escapeRegexCharacter(char) {
+  return /[.*+?^${}()|[\]\\]/u.test(char) ? `\\${char}` : char;
+}
+function normalizeSlashes(value) {
+  return value.replaceAll("\\", "/");
+}
+function countOccurrences(text, search) {
+  if (search.length === 0) {
+    return 0;
+  }
+  return text.split(search).length - 1;
+}
+function safeReplaceAll(text, search, replacement) {
+  if (search.length === 0) {
+    return text;
+  }
+  return text.split(search).join(replacement);
+}
+function isNoEntError(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+
+// src/agent.ts
+async function runAgentLoop(request) {
+  const { tools: customTools, filesystemTool, filesystem_tool, ...toolLoopRequest } = request;
+  const filesystemSelection = filesystemTool ?? filesystem_tool;
+  const filesystemTools = resolveFilesystemTools(request.model, filesystemSelection);
+  const mergedTools = mergeToolSets(filesystemTools, customTools ?? {});
+  if (Object.keys(mergedTools).length === 0) {
+    throw new Error(
+      "runAgentLoop requires at least one tool. Provide `tools` or enable `filesystemTool`."
+    );
+  }
+  return runToolLoop({
+    ...toolLoopRequest,
+    tools: mergedTools
+  });
+}
+function resolveFilesystemTools(model, selection) {
+  if (selection === void 0 || selection === false) {
+    return {};
+  }
+  if (selection === true) {
+    return createFilesystemToolSetForModel(model, "auto");
+  }
+  if (typeof selection === "string") {
+    return createFilesystemToolSetForModel(model, selection);
+  }
+  if (selection.enabled === false) {
+    return {};
+  }
+  if (selection.options && selection.profile !== void 0) {
+    return createFilesystemToolSetForModel(model, selection.profile, selection.options);
+  }
+  if (selection.options) {
+    return createFilesystemToolSetForModel(model, selection.options);
+  }
+  return createFilesystemToolSetForModel(model, selection.profile ?? "auto");
+}
+function mergeToolSets(base, extra) {
+  const merged = { ...base };
+  for (const [toolName, toolSpec] of Object.entries(extra)) {
+    if (Object.hasOwn(merged, toolName)) {
+      throw new Error(
+        `Duplicate tool name "${toolName}" in runAgentLoop. Rename the custom tool or disable that filesystem tool.`
+      );
+    }
+    merged[toolName] = toolSpec;
+  }
+  return merged;
+}
 export {
+  InMemoryAgentFilesystem,
   LlmJsonCallError,
   appendMarkdownSourcesSection,
+  applyPatch,
   configureGemini,
   convertGooglePartsToLlmParts,
+  createApplyPatchTool,
+  createCodexApplyPatchTool,
+  createCodexFilesystemToolSet,
+  createCodexReadFileTool,
+  createFilesystemToolSetForModel,
+  createGeminiFilesystemToolSet,
+  createGlobTool,
+  createGrepFilesTool,
+  createGrepSearchTool,
+  createInMemoryAgentFilesystem,
+  createListDirTool,
+  createListDirectoryTool,
+  createModelAgnosticFilesystemToolSet,
+  createNodeAgentFilesystem,
+  createReadFileTool,
+  createReplaceTool,
+  createWriteFileTool,
   encodeChatGptAuthJson,
   encodeChatGptAuthJsonB64,
   estimateCallCostUsd,
@@ -3878,6 +5545,8 @@ export {
   loadLocalEnv,
   parseJsonFromLlmText,
   refreshChatGptOauthToken,
+  resolveFilesystemToolProfile,
+  runAgentLoop,
   runToolLoop,
   sanitisePartForLogging,
   streamJson,