@ljoukov/llm 0.1.3 → 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",
@@ -1518,10 +1529,13 @@ function convertGooglePartsToLlmParts(parts) {
 function assertLlmRole(value) {
   switch (value) {
     case "user":
-    case "model":
+    case "assistant":
     case "system":
+    case "developer":
     case "tool":
       return value;
+    case "model":
+      return "assistant";
     default:
       throw new Error(`Unsupported LLM role: ${String(value)}`);
   }
@@ -1551,8 +1565,9 @@ function toGeminiPart(part) {
   }
 }
 function convertLlmContentToGeminiContent(content) {
+  const role = content.role === "assistant" ? "model" : "user";
   return {
-    role: content.role,
+    role,
     parts: content.parts.map(toGeminiPart)
   };
 }
@@ -1723,28 +1738,350 @@ function parseJsonFromLlmText(rawText) {
   const repairedText = escapeNewlinesInStrings(cleanedText);
   return JSON.parse(repairedText);
 }
-function resolveTextContents(input) {
-  if ("contents" in input) {
-    return input.contents;
+function parsePartialJsonFromLlmText(rawText) {
+  const jsonStart = extractJsonStartText(rawText);
+  if (!jsonStart) {
+    return null;
+  }
+  try {
+    return parsePartialJson(jsonStart);
+  } catch {
+    return null;
+  }
+}
+function extractJsonStartText(rawText) {
+  let text = rawText.trimStart();
+  if (text.startsWith("```")) {
+    text = text.replace(/^```[a-zA-Z0-9_-]*\s*\n?/, "");
+  }
+  const objIndex = text.indexOf("{");
+  const arrIndex = text.indexOf("[");
+  let start = -1;
+  if (objIndex !== -1 && arrIndex !== -1) {
+    start = Math.min(objIndex, arrIndex);
+  } else {
+    start = objIndex !== -1 ? objIndex : arrIndex;
+  }
+  if (start === -1) {
+    return null;
+  }
+  return text.slice(start);
+}
+function parsePartialJson(text) {
+  let i = 0;
+  const len = text.length;
+  const isWhitespace = (char) => char === " " || char === "\n" || char === "\r" || char === "	";
+  const skipWhitespace = () => {
+    while (i < len && isWhitespace(text[i] ?? "")) {
+      i += 1;
+    }
+  };
+  const parseString = () => {
+    if (text[i] !== '"') {
+      return null;
+    }
+    i += 1;
+    let value = "";
+    while (i < len) {
+      const ch = text[i] ?? "";
+      if (ch === '"') {
+        i += 1;
+        return { value, complete: true };
+      }
+      if (ch === "\\") {
+        if (i + 1 >= len) {
+          return { value, complete: false };
+        }
+        const esc = text[i + 1] ?? "";
+        switch (esc) {
+          case '"':
+          case "\\":
+          case "/":
+            value += esc;
+            i += 2;
+            continue;
+          case "b":
+            value += "\b";
+            i += 2;
+            continue;
+          case "f":
+            value += "\f";
+            i += 2;
+            continue;
+          case "n":
+            value += "\n";
+            i += 2;
+            continue;
+          case "r":
+            value += "\r";
+            i += 2;
+            continue;
+          case "t":
+            value += "	";
+            i += 2;
+            continue;
+          case "u": {
+            if (i + 5 >= len) {
+              return { value, complete: false };
+            }
+            const hex = text.slice(i + 2, i + 6);
+            if (!/^[0-9a-fA-F]{4}$/u.test(hex)) {
+              value += "u";
+              i += 2;
+              continue;
+            }
+            value += String.fromCharCode(Number.parseInt(hex, 16));
+            i += 6;
+            continue;
+          }
+          default:
+            value += esc;
+            i += 2;
+            continue;
+        }
+      }
+      value += ch;
+      i += 1;
+    }
+    return { value, complete: false };
+  };
+  const parseNumber = () => {
+    const start = i;
+    while (i < len) {
+      const ch = text[i] ?? "";
+      if (isWhitespace(ch) || ch === "," || ch === "}" || ch === "]") {
+        break;
+      }
+      i += 1;
+    }
+    const raw = text.slice(start, i);
+    if (!/^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?$/u.test(raw)) {
+      i = start;
+      return null;
+    }
+    return { value: Number(raw), complete: true };
+  };
+  const parseLiteral = () => {
+    if (text.startsWith("true", i)) {
+      i += 4;
+      return { value: true, complete: true };
+    }
+    if (text.startsWith("false", i)) {
+      i += 5;
+      return { value: false, complete: true };
+    }
+    if (text.startsWith("null", i)) {
+      i += 4;
+      return { value: null, complete: true };
+    }
+    return null;
+  };
+  skipWhitespace();
+  const first = text[i];
+  if (first !== "{" && first !== "[") {
+    return null;
+  }
+  const root = first === "{" ? {} : [];
+  const stack = first === "{" ? [{ type: "object", value: root, state: "keyOrEnd" }] : [{ type: "array", value: root, state: "valueOrEnd" }];
+  i += 1;
+  while (stack.length > 0) {
+    skipWhitespace();
+    if (i >= len) {
+      break;
+    }
+    const ctx = stack[stack.length - 1];
+    if (!ctx) {
+      break;
+    }
+    const ch = text[i] ?? "";
+    if (ctx.type === "object") {
+      if (ctx.state === "keyOrEnd") {
+        if (ch === "}") {
+          i += 1;
+          stack.pop();
+          continue;
+        }
+        if (ch === ",") {
+          i += 1;
+          continue;
+        }
+        if (ch !== '"') {
+          break;
+        }
+        const key = parseString();
+        if (!key) {
+          break;
+        }
+        if (!key.complete) {
+          break;
+        }
+        ctx.key = key.value;
+        ctx.state = "colon";
+        continue;
+      }
+      if (ctx.state === "colon") {
+        if (ch === ":") {
+          i += 1;
+          ctx.state = "value";
+          continue;
+        }
+        break;
+      }
+      if (ctx.state === "value") {
+        if (ch === "}") {
+          i += 1;
+          ctx.key = void 0;
+          stack.pop();
+          continue;
+        }
+        if (ch === ",") {
+          i += 1;
+          ctx.key = void 0;
+          ctx.state = "keyOrEnd";
+          continue;
+        }
+        const key = ctx.key;
+        if (!key) {
+          break;
+        }
+        if (ch === "{" || ch === "[") {
+          const container = ch === "{" ? {} : [];
+          ctx.value[key] = container;
+          ctx.key = void 0;
+          ctx.state = "commaOrEnd";
+          stack.push(
+            ch === "{" ? { type: "object", value: container, state: "keyOrEnd" } : { type: "array", value: container, state: "valueOrEnd" }
+          );
+          i += 1;
+          continue;
+        }
+        let primitive = null;
+        if (ch === '"') {
+          primitive = parseString();
+        } else if (ch === "-" || ch >= "0" && ch <= "9") {
+          primitive = parseNumber();
+        } else {
+          primitive = parseLiteral();
+        }
+        if (!primitive) {
+          break;
+        }
+        ctx.value[key] = primitive.value;
+        ctx.key = void 0;
+        ctx.state = "commaOrEnd";
+        if (!primitive.complete) {
+          break;
+        }
+        continue;
+      }
+      if (ctx.state === "commaOrEnd") {
+        if (ch === ",") {
+          i += 1;
+          ctx.state = "keyOrEnd";
+          continue;
+        }
+        if (ch === "}") {
+          i += 1;
+          stack.pop();
+          continue;
+        }
+        break;
+      }
+    } else {
+      if (ctx.state === "valueOrEnd") {
+        if (ch === "]") {
+          i += 1;
+          stack.pop();
+          continue;
+        }
+        if (ch === ",") {
+          i += 1;
+          continue;
+        }
+        if (ch === "{" || ch === "[") {
+          const container = ch === "{" ? {} : [];
+          ctx.value.push(container);
+          ctx.state = "commaOrEnd";
+          stack.push(
+            ch === "{" ? { type: "object", value: container, state: "keyOrEnd" } : { type: "array", value: container, state: "valueOrEnd" }
+          );
+          i += 1;
+          continue;
+        }
+        let primitive = null;
+        if (ch === '"') {
+          primitive = parseString();
+        } else if (ch === "-" || ch >= "0" && ch <= "9") {
+          primitive = parseNumber();
+        } else {
+          primitive = parseLiteral();
+        }
+        if (!primitive) {
+          break;
+        }
+        ctx.value.push(primitive.value);
+        ctx.state = "commaOrEnd";
+        if (!primitive.complete) {
+          break;
+        }
+        continue;
+      }
+      if (ctx.state === "commaOrEnd") {
+        if (ch === ",") {
+          i += 1;
+          ctx.state = "valueOrEnd";
+          continue;
+        }
+        if (ch === "]") {
+          i += 1;
+          stack.pop();
+          continue;
+        }
+        break;
+      }
+    }
   }
+  return root;
+}
+function resolveTextContents(input) {
   const contents = [];
-  if (input.systemPrompt) {
+  if (input.instructions) {
+    const instructions = input.instructions.trim();
+    if (instructions.length > 0) {
+      contents.push({
+        role: "system",
+        parts: [{ type: "text", text: instructions }]
+      });
+    }
+  }
+  if (typeof input.input === "string") {
     contents.push({
-      role: "system",
-      parts: [{ type: "text", text: input.systemPrompt }]
+      role: "user",
+      parts: [{ type: "text", text: input.input }]
+    });
+    return contents;
+  }
+  for (const message of input.input) {
+    const parts = typeof message.content === "string" ? [{ type: "text", text: message.content }] : message.content;
+    contents.push({
+      role: message.role,
+      parts: parts.map(
+        (part) => part.type === "text" ? {
+          type: "text",
+          text: part.text,
+          thought: "thought" in part && part.thought === true ? true : void 0
+        } : { type: "inlineData", data: part.data, mimeType: part.mimeType }
+      )
     });
   }
-  contents.push({
-    role: "user",
-    parts: [{ type: "text", text: input.prompt }]
-  });
   return contents;
 }
 function toOpenAiInput(contents) {
   const OPENAI_ROLE_FROM_LLM = {
     user: "user",
-    model: "assistant",
+    assistant: "assistant",
     system: "system",
+    developer: "developer",
     tool: "assistant"
   };
   return contents.map((content) => {
@@ -1783,7 +2120,7 @@ function toChatGptInput(contents) {
   const instructionsParts = [];
   const input = [];
   for (const content of contents) {
-    if (content.role === "system") {
+    if (content.role === "system" || content.role === "developer") {
       for (const part of content.parts) {
         if (part.type === "text") {
           instructionsParts.push(part.text);
@@ -1791,7 +2128,7 @@ function toChatGptInput(contents) {
       }
       continue;
     }
-    const isAssistant = content.role === "model";
+    const isAssistant = content.role === "assistant" || content.role === "tool";
     const parts = [];
     for (const part of content.parts) {
       if (part.type === "text") {
@@ -2063,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("; ");
 }
@@ -2246,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) {
@@ -2511,7 +2848,7 @@ async function runTextCall(params) {
     });
   }
   const mergedParts = mergeConsecutiveTextParts(responseParts);
-  const content = mergedParts.length > 0 ? { role: responseRole ?? "model", parts: mergedParts } : void 0;
+  const content = mergedParts.length > 0 ? { role: responseRole ?? "assistant", parts: mergedParts } : void 0;
   const { text, thoughts } = extractTextByChannel(content);
   const costUsd = estimateCallCostUsd({
     modelId: modelVersion,
@@ -2561,8 +2898,7 @@ async function generateText(request) {
   }
   return await call.result;
 }
-async function generateJson(request) {
-  const maxAttempts = Math.max(1, Math.floor(request.maxAttempts ?? 2));
+function buildJsonSchemaConfig(request) {
   const schemaName = (request.openAiSchemaName ?? "llm-response").trim() || "llm-response";
   const providerInfo = resolveProvider(request.model);
   const isOpenAiVariant = providerInfo.provider === "openai" || providerInfo.provider === "chatgpt";
@@ -2574,31 +2910,143 @@ async function generateJson(request) {
   if (isOpenAiVariant && !isJsonSchemaObject(responseJsonSchema)) {
     throw new Error("OpenAI structured outputs require a JSON object schema at the root.");
   }
-  const openAiTextFormat = providerInfo.provider === "openai" ? {
+  const openAiTextFormat = isOpenAiVariant ? {
     type: "json_schema",
     name: schemaName,
     strict: true,
     schema: normalizeOpenAiSchema(responseJsonSchema)
   } : void 0;
+  return { providerInfo, responseJsonSchema, openAiTextFormat };
+}
+function streamJson(request) {
+  const queue = createAsyncQueue();
+  const abortController = new AbortController();
+  const resolveAbortSignal = () => {
+    if (!request.signal) {
+      return abortController.signal;
+    }
+    if (request.signal.aborted) {
+      abortController.abort(request.signal.reason);
+    } else {
+      request.signal.addEventListener(
+        "abort",
+        () => abortController.abort(request.signal?.reason),
+        {
+          once: true
+        }
+      );
+    }
+    return abortController.signal;
+  };
+  const result = (async () => {
+    const signal = resolveAbortSignal();
+    const maxAttempts = Math.max(1, Math.floor(request.maxAttempts ?? 2));
+    const { providerInfo, responseJsonSchema, openAiTextFormat } = buildJsonSchemaConfig(request);
+    const streamMode = request.streamMode ?? "partial";
+    const failures = [];
+    let openAiTextFormatForAttempt = openAiTextFormat;
+    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+      let rawText = "";
+      let lastPartial = "";
+      try {
+        const call = streamText({
+          model: request.model,
+          input: request.input,
+          instructions: request.instructions,
+          tools: request.tools,
+          responseMimeType: request.responseMimeType ?? "application/json",
+          responseJsonSchema,
+          openAiReasoningEffort: request.openAiReasoningEffort,
+          ...openAiTextFormatForAttempt ? { openAiTextFormat: openAiTextFormatForAttempt } : {},
+          signal
+        });
+        try {
+          for await (const event of call.events) {
+            queue.push(event);
+            if (event.type === "delta" && event.channel === "response") {
+              rawText += event.text;
+              if (streamMode === "partial") {
+                const partial = parsePartialJsonFromLlmText(rawText);
+                if (partial !== null) {
+                  const serialized = JSON.stringify(partial);
+                  if (serialized !== lastPartial) {
+                    lastPartial = serialized;
+                    queue.push({
+                      type: "json",
+                      stage: "partial",
+                      value: partial
+                    });
+                  }
+                }
+              }
+            }
+          }
+        } catch (streamError) {
+          await call.result.catch(() => void 0);
+          throw streamError;
+        }
+        const result2 = await call.result;
+        rawText = rawText || result2.text;
+        const cleanedText = normalizeJsonText(rawText);
+        const repairedText = escapeNewlinesInStrings(cleanedText);
+        const payload = JSON.parse(repairedText);
+        const normalized = typeof request.normalizeJson === "function" ? request.normalizeJson(payload) : payload;
+        const parsed = request.schema.parse(normalized);
+        queue.push({ type: "json", stage: "final", value: parsed });
+        queue.close();
+        return { value: parsed, rawText, result: result2 };
+      } catch (error) {
+        const handled = error instanceof Error ? error : new Error(String(error));
+        failures.push({ attempt, rawText, error: handled });
+        if (providerInfo.provider === "chatgpt" && openAiTextFormatForAttempt) {
+          openAiTextFormatForAttempt = void 0;
+        }
+        if (attempt >= maxAttempts) {
+          throw new LlmJsonCallError(`LLM JSON call failed after ${attempt} attempt(s)`, failures);
+        }
+      }
+    }
+    throw new LlmJsonCallError("LLM JSON call failed", failures);
+  })().catch((error) => {
+    const err = error instanceof Error ? error : new Error(String(error));
+    queue.fail(err);
+    throw err;
+  });
+  return {
+    events: queue.iterable,
+    result,
+    abort: () => abortController.abort()
+  };
+}
+async function generateJson(request) {
+  const maxAttempts = Math.max(1, Math.floor(request.maxAttempts ?? 2));
+  const { providerInfo, responseJsonSchema, openAiTextFormat } = buildJsonSchemaConfig(request);
+  let openAiTextFormatForAttempt = openAiTextFormat;
   const failures = [];
   for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
     let rawText = "";
     try {
-      const contents = resolveTextContents(request);
       const call = streamText({
         model: request.model,
-        contents,
+        input: request.input,
+        instructions: request.instructions,
         tools: request.tools,
         responseMimeType: request.responseMimeType ?? "application/json",
         responseJsonSchema,
         openAiReasoningEffort: request.openAiReasoningEffort,
-        ...openAiTextFormat ? { openAiTextFormat } : {},
+        ...openAiTextFormatForAttempt ? { openAiTextFormat: openAiTextFormatForAttempt } : {},
         signal: request.signal
       });
-      for await (const event of call.events) {
-        if (event.type === "delta" && event.channel === "response") {
-          rawText += event.text;
+      try {
+        for await (const event of call.events) {
+          request.onEvent?.(event);
+          if (event.type === "delta" && event.channel === "response") {
+            rawText += event.text;
+          }
         }
+      } catch (streamError) {
+        await call.result.catch(() => void 0);
+        throw streamError;
       }
       const result = await call.result;
       rawText = rawText || result.text;
@@ -2611,6 +3059,9 @@ async function generateJson(request) {
     } catch (error) {
       const handled = error instanceof Error ? error : new Error(String(error));
       failures.push({ attempt, rawText, error: handled });
+      if (providerInfo.provider === "chatgpt" && openAiTextFormatForAttempt) {
+        openAiTextFormatForAttempt = void 0;
+      }
       if (attempt >= maxAttempts) {
         throw new LlmJsonCallError(`LLM JSON call failed after ${attempt} attempt(s)`, failures);
       }
@@ -3196,7 +3647,7 @@ async function gradeGeneratedImage(params) {
   ];
   const { value } = await generateJson({
     model: params.model,
-    contents: [{ role: "user", parts }],
+    input: [{ role: "user", content: parts }],
     schema: IMAGE_GRADE_SCHEMA
   });
   return value;
@@ -3273,7 +3724,7 @@ async function generateImages(request) {
     lines.push(`\\nPlease make all ${pending.length} remaining images.`);
     return [{ type: "text", text: lines.join("\\n") }];
   };
-  const contents = [{ role: "user", parts: buildInitialPromptParts() }];
+  const inputMessages = [{ role: "user", content: buildInitialPromptParts() }];
   const orderedEntries = [...promptEntries];
   const resolvedImages = /* @__PURE__ */ new Map();
   const removeResolvedEntries = (resolved) => {
@@ -3293,7 +3744,7 @@ async function generateImages(request) {
   for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
     const result = await generateText({
       model: request.model,
-      contents,
+      input: inputMessages,
       responseModalities: ["IMAGE", "TEXT"],
       imageAspectRatio: request.imageAspectRatio,
       imageSize: request.imageSize ?? "2K"
@@ -3340,8 +3791,11 @@ async function generateImages(request) {
     if (promptEntries.length === 0) {
       break;
     }
-    contents.push(result.content);
-    contents.push({ role: "user", parts: buildContinuationPromptParts(promptEntries) });
+    inputMessages.push({
+      role: "assistant",
+      content: result.content.parts
+    });
+    inputMessages.push({ role: "user", content: buildContinuationPromptParts(promptEntries) });
   }
   const orderedImages = [];
   for (const entry of orderedEntries) {
@@ -3415,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,
@@ -3435,8 +5545,11 @@ export {
   loadLocalEnv,
   parseJsonFromLlmText,
   refreshChatGptOauthToken,
+  resolveFilesystemToolProfile,
+  runAgentLoop,
   runToolLoop,
   sanitisePartForLogging,
+  streamJson,
   streamText,
   stripCodexCitationMarkers,
   toGeminiJsonSchema,