@ljoukov/llm 2.0.0 → 3.0.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 {
@@ -73,6 +73,35 @@ function createAsyncQueue() {
   return { push, close, fail, iterable: iterator() };
 }
 
+// src/fireworks/pricing.ts
+var FIREWORKS_KIMI_K25_PRICING = {
+  inputRate: 0.6 / 1e6,
+  cachedRate: 0.1 / 1e6,
+  outputRate: 3 / 1e6
+};
+var FIREWORKS_GLM_5_PRICING = {
+  inputRate: 1 / 1e6,
+  cachedRate: 0.2 / 1e6,
+  outputRate: 3.2 / 1e6
+};
+var FIREWORKS_MINIMAX_M21_PRICING = {
+  inputRate: 0.3 / 1e6,
+  cachedRate: 0.15 / 1e6,
+  outputRate: 1.2 / 1e6
+};
+function getFireworksPricing(modelId) {
+  if (modelId.includes("kimi-k2.5") || modelId.includes("kimi-k2p5")) {
+    return FIREWORKS_KIMI_K25_PRICING;
+  }
+  if (modelId.includes("glm-5")) {
+    return FIREWORKS_GLM_5_PRICING;
+  }
+  if (modelId.includes("minimax-m2.1") || modelId.includes("minimax-m2p1")) {
+    return FIREWORKS_MINIMAX_M21_PRICING;
+  }
+  return void 0;
+}
+
 // src/google/pricing.ts
 var GEMINI_3_PRO_PREVIEW_PRICING = {
   threshold: 2e5,
@@ -125,17 +154,34 @@ var OPENAI_GPT_52_PRICING = {
   cachedRate: 0.175 / 1e6,
   outputRate: 14 / 1e6
 };
-var OPENAI_GPT_51_CODEX_MINI_PRICING = {
+var OPENAI_GPT_53_CODEX_PRICING = {
+  inputRate: 1.25 / 1e6,
+  cachedRate: 0.125 / 1e6,
+  outputRate: 10 / 1e6
+};
+var OPENAI_GPT_5_MINI_PRICING = {
   inputRate: 0.25 / 1e6,
   cachedRate: 0.025 / 1e6,
   outputRate: 2 / 1e6
 };
 function getOpenAiPricing(modelId) {
+  if (modelId.includes("gpt-5.3-codex-spark")) {
+    return OPENAI_GPT_5_MINI_PRICING;
+  }
+  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;
   }
+  if (modelId.includes("gpt-5-mini")) {
+    return OPENAI_GPT_5_MINI_PRICING;
+  }
   if (modelId.includes("gpt-5.1-codex-mini")) {
-    return OPENAI_GPT_51_CODEX_MINI_PRICING;
+    return OPENAI_GPT_5_MINI_PRICING;
   }
   return void 0;
 }
@@ -196,6 +242,14 @@ function estimateCallCostUsd({
     const outputCost = outputTokens * outputRate;
     return inputCost + cachedCost + outputCost;
   }
+  const fireworksPricing = getFireworksPricing(modelId);
+  if (fireworksPricing) {
+    const inputCost = nonCachedPrompt * fireworksPricing.inputRate;
+    const cachedCost = cachedTokens * fireworksPricing.cachedRate;
+    const outputTokens = responseTokens + thinkingTokens;
+    const outputCost = outputTokens * fireworksPricing.outputRate;
+    return inputCost + cachedCost + outputCost;
+  }
   const openAiPricing = getOpenAiPricing(modelId);
   if (openAiPricing) {
     const inputCost = nonCachedPrompt * openAiPricing.inputRate;
@@ -208,11 +262,14 @@ function estimateCallCostUsd({
 }
 
 // src/openai/chatgpt-codex.ts
-import os from "os";
+import os2 from "os";
 import { TextDecoder } from "util";
 
 // src/openai/chatgpt-auth.ts
-import { Buffer } from "buffer";
+import { Buffer as Buffer2 } from "buffer";
+import fs2 from "fs";
+import os from "os";
+import path2 from "path";
 import { z } from "zod";
 
 // src/utils/env.ts
@@ -277,34 +334,30 @@ function parseEnvLine(line) {
 }
 
 // src/openai/chatgpt-auth.ts
-var CHATGPT_AUTH_JSON_ENV = "CHATGPT_AUTH_JSON";
-var CHATGPT_AUTH_JSON_B64_ENV = "CHATGPT_AUTH_JSON_B64";
-var CHATGPT_ACCESS_ENV = "CHATGPT_ACCESS";
-var CHATGPT_REFRESH_ENV = "CHATGPT_REFRESH";
-var CHATGPT_EXPIRES_ENV = "CHATGPT_EXPIRES";
-var CHATGPT_ACCOUNT_ID_ENV = "CHATGPT_ACCOUNT_ID";
-var CHATGPT_ID_TOKEN_ENV = "CHATGPT_ID_TOKEN";
-var CHATGPT_ACCESS_TOKEN_ENV = "CHATGPT_ACCESS_TOKEN";
-var CHATGPT_REFRESH_TOKEN_ENV = "CHATGPT_REFRESH_TOKEN";
-var CHATGPT_EXPIRES_AT_ENV = "CHATGPT_EXPIRES_AT";
+var CHATGPT_AUTH_TOKEN_PROVIDER_URL_ENV = "CHATGPT_AUTH_TOKEN_PROVIDER_URL";
+var CHATGPT_AUTH_TOKEN_PROVIDER_STORE_ENV = "CHATGPT_AUTH_TOKEN_PROVIDER_STORE";
+var CHATGPT_AUTH_SERVER_URL_ENV = "CHATGPT_AUTH_SERVER_URL";
+var CHATGPT_AUTH_SERVER_STORE_ENV = "CHATGPT_AUTH_SERVER_STORE";
+var CHATGPT_AUTH_API_KEY_ENV = "CHATGPT_AUTH_API_KEY";
+var CHATGPT_AUTH_TOKEN_PROVIDER_API_KEY_ENV = "CHATGPT_AUTH_TOKEN_PROVIDER_API_KEY";
 var CHATGPT_OAUTH_CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
 var CHATGPT_OAUTH_TOKEN_URL = "https://auth.openai.com/oauth/token";
 var CHATGPT_OAUTH_REDIRECT_URI = "http://localhost:1455/auth/callback";
 var TOKEN_EXPIRY_BUFFER_MS = 3e4;
-var AuthInputSchema = z.object({
-  access: z.string().min(1).optional(),
-  access_token: z.string().min(1).optional(),
-  accessToken: z.string().min(1).optional(),
-  refresh: z.string().min(1).optional(),
-  refresh_token: z.string().min(1).optional(),
-  refreshToken: z.string().min(1).optional(),
-  expires: z.union([z.number(), z.string()]).optional(),
-  expires_at: z.union([z.number(), z.string()]).optional(),
-  expiresAt: z.union([z.number(), z.string()]).optional(),
-  accountId: z.string().min(1).optional(),
-  account_id: z.string().min(1).optional(),
-  id_token: z.string().optional(),
-  idToken: z.string().optional()
+var CodexAuthFileSchema = z.object({
+  OPENAI_API_KEY: z.string().nullable().optional(),
+  last_refresh: z.string().optional(),
+  tokens: z.object({
+    access_token: z.string().min(1).optional(),
+    refresh_token: z.string().min(1).optional(),
+    id_token: z.string().min(1).optional(),
+    account_id: z.string().min(1).optional(),
+    // Allow a bit of flexibility if the file format changes.
+    accessToken: z.string().min(1).optional(),
+    refreshToken: z.string().min(1).optional(),
+    idToken: z.string().min(1).optional(),
+    accountId: z.string().min(1).optional()
+  }).optional()
 }).loose();
 var RefreshResponseSchema = z.object({
   access_token: z.string().min(1),
@@ -319,6 +372,44 @@ var ExchangeResponseSchema = z.object({
 });
 var cachedProfile = null;
 var refreshPromise = null;
+async function fetchChatGptAuthProfileFromTokenProvider(options) {
+  const base = options.baseUrl.replace(/\/+$/u, "");
+  const store = options.store?.trim() ? options.store.trim() : "kv";
+  const url = new URL(`${base}/v1/token`);
+  url.searchParams.set("store", store);
+  const response = await fetch(url.toString(), {
+    method: "GET",
+    headers: {
+      Authorization: `Bearer ${options.apiKey}`,
+      "x-chatgpt-auth": options.apiKey,
+      Accept: "application/json"
+    }
+  });
+  if (!response.ok) {
+    const body = await response.text();
+    throw new Error(`ChatGPT token provider request failed (${response.status}): ${body}`);
+  }
+  const payload = await response.json();
+  if (!payload || typeof payload !== "object") {
+    throw new Error("ChatGPT token provider returned invalid JSON.");
+  }
+  const accessToken = payload.accessToken ?? payload.access_token;
+  const accountId = payload.accountId ?? payload.account_id;
+  const expiresAt = payload.expiresAt ?? payload.expires_at;
+  if (typeof accessToken !== "string" || accessToken.trim().length === 0) {
+    throw new Error("ChatGPT token provider response missing accessToken.");
+  }
+  if (typeof accountId !== "string" || accountId.trim().length === 0) {
+    throw new Error("ChatGPT token provider response missing accountId.");
+  }
+  const expires = normalizeEpochMillis(expiresAt) ?? Date.now() + 5 * 6e4;
+  return {
+    access: accessToken,
+    refresh: "token_provider",
+    expires,
+    accountId
+  };
+}
 function encodeChatGptAuthJson(profile) {
   const payload = {
     access: profile.access,
@@ -330,7 +421,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,
@@ -357,7 +448,7 @@ async function exchangeChatGptOauthCode({
   const payload = ExchangeResponseSchema.parse(await response.json());
   return profileFromTokenResponse(payload);
 }
-async function refreshChatGptOauthToken(refreshToken) {
+async function refreshChatGptOauthToken(refreshToken, fallback) {
   const params = new URLSearchParams();
   params.set("grant_type", "refresh_token");
   params.set("client_id", CHATGPT_OAUTH_CLIENT_ID);
@@ -374,9 +465,35 @@ async function refreshChatGptOauthToken(refreshToken) {
     throw new Error(`ChatGPT OAuth refresh failed (${response.status}): ${body}`);
   }
   const payload = RefreshResponseSchema.parse(await response.json());
-  return profileFromTokenResponse(payload);
+  return profileFromTokenResponse(payload, fallback);
 }
 async function getChatGptAuthProfile() {
+  loadLocalEnv();
+  const tokenProviderUrl = process.env[CHATGPT_AUTH_TOKEN_PROVIDER_URL_ENV] ?? process.env[CHATGPT_AUTH_SERVER_URL_ENV];
+  const tokenProviderKey = process.env[CHATGPT_AUTH_TOKEN_PROVIDER_API_KEY_ENV] ?? process.env[CHATGPT_AUTH_API_KEY_ENV];
+  if (tokenProviderUrl && tokenProviderUrl.trim().length > 0 && tokenProviderKey && tokenProviderKey.trim().length > 0) {
+    if (cachedProfile && !isExpired(cachedProfile)) {
+      return cachedProfile;
+    }
+    if (refreshPromise) {
+      return refreshPromise;
+    }
+    refreshPromise = (async () => {
+      try {
+        const store = process.env[CHATGPT_AUTH_TOKEN_PROVIDER_STORE_ENV] ?? process.env[CHATGPT_AUTH_SERVER_STORE_ENV];
+        const profile = await fetchChatGptAuthProfileFromTokenProvider({
+          baseUrl: tokenProviderUrl,
+          apiKey: tokenProviderKey,
+          store: store ?? void 0
+        });
+        cachedProfile = profile;
+        return profile;
+      } finally {
+        refreshPromise = null;
+      }
+    })();
+    return refreshPromise;
+  }
   if (cachedProfile && !isExpired(cachedProfile)) {
     return cachedProfile;
   }
@@ -385,8 +502,8 @@ async function getChatGptAuthProfile() {
   }
   refreshPromise = (async () => {
     try {
-      const baseProfile = cachedProfile ?? loadAuthProfileFromEnv();
-      const profile = isExpired(baseProfile) ? await refreshChatGptOauthToken(baseProfile.refresh) : baseProfile;
+      const baseProfile = cachedProfile ?? loadAuthProfileFromCodexStore();
+      const profile = isExpired(baseProfile) ? await refreshAndPersistCodexProfile(baseProfile) : baseProfile;
       cachedProfile = profile;
       return profile;
     } finally {
@@ -395,39 +512,111 @@ async function getChatGptAuthProfile() {
   })();
   return refreshPromise;
 }
-function profileFromTokenResponse(payload) {
-  const expires = Date.now() + normalizeNumber(payload.expires_in) * 1e3;
-  const accountId = extractChatGptAccountId(payload.id_token ?? "") ?? extractChatGptAccountId(payload.access_token);
+function resolveCodexHome() {
+  const codexHome = process.env.CODEX_HOME;
+  if (codexHome && codexHome.trim().length > 0) {
+    return codexHome.trim();
+  }
+  return path2.join(os.homedir(), ".codex");
+}
+function resolveCodexAuthJsonPath() {
+  return path2.join(resolveCodexHome(), "auth.json");
+}
+function loadAuthProfileFromCodexStore() {
+  const authPath = resolveCodexAuthJsonPath();
+  let raw;
+  try {
+    raw = fs2.readFileSync(authPath, "utf8");
+  } catch {
+    throw new Error(
+      `ChatGPT auth not configured. Set ${CHATGPT_AUTH_TOKEN_PROVIDER_URL_ENV}+${CHATGPT_AUTH_API_KEY_ENV} or login via Codex to create ${authPath}.`
+    );
+  }
+  let parsed;
+  try {
+    parsed = CodexAuthFileSchema.parse(JSON.parse(raw));
+  } catch (e) {
+    throw new Error(
+      `Failed to parse Codex auth store at ${authPath}. (${e?.message ?? e})`
+    );
+  }
+  const tokens = parsed.tokens;
+  if (!tokens) {
+    throw new Error(
+      `Codex auth store at ${authPath} is missing tokens. Re-login via Codex, or configure ${CHATGPT_AUTH_TOKEN_PROVIDER_URL_ENV}.`
+    );
+  }
+  const access = tokens.access_token ?? tokens.accessToken ?? void 0;
+  const refresh = tokens.refresh_token ?? tokens.refreshToken ?? void 0;
+  const idToken = tokens.id_token ?? tokens.idToken ?? void 0;
+  if (!access || !refresh) {
+    throw new Error(
+      `Codex auth store at ${authPath} is missing access_token/refresh_token. Re-login via Codex, or configure ${CHATGPT_AUTH_TOKEN_PROVIDER_URL_ENV}.`
+    );
+  }
+  const expires = extractJwtExpiry(access) ?? extractJwtExpiry(idToken ?? "") ?? Date.now() + 5 * 6e4;
+  const accountId = tokens.account_id ?? tokens.accountId ?? extractChatGptAccountId(idToken ?? "") ?? extractChatGptAccountId(access);
   if (!accountId) {
-    throw new Error("Failed to extract chatgpt_account_id from access token.");
+    throw new Error(`Codex auth store at ${authPath} is missing chatgpt_account_id/account_id.`);
   }
   return {
-    access: payload.access_token,
-    refresh: payload.refresh_token,
+    access,
+    refresh,
     expires,
     accountId,
-    idToken: payload.id_token
+    idToken: idToken ?? void 0
   };
 }
-function normalizeAuthProfile(data) {
-  const access = data.access ?? data.access_token ?? data.accessToken ?? void 0;
-  const refresh = data.refresh ?? data.refresh_token ?? data.refreshToken ?? void 0;
-  if (!access || !refresh) {
-    throw new Error("ChatGPT credentials must include access and refresh.");
+async function refreshAndPersistCodexProfile(baseProfile) {
+  const refreshed = await refreshChatGptOauthToken(baseProfile.refresh, {
+    accountId: baseProfile.accountId,
+    idToken: baseProfile.idToken
+  });
+  persistCodexTokens(refreshed);
+  return refreshed;
+}
+function persistCodexTokens(profile) {
+  const authPath = resolveCodexAuthJsonPath();
+  const codexHome = path2.dirname(authPath);
+  let doc = {};
+  try {
+    doc = JSON.parse(fs2.readFileSync(authPath, "utf8"));
+  } catch {
+    doc = {};
+  }
+  if (!doc || typeof doc !== "object") {
+    doc = {};
+  }
+  if (!doc.tokens || typeof doc.tokens !== "object") {
+    doc.tokens = {};
   }
-  const expiresRaw = data.expires ?? data.expires_at ?? data.expiresAt;
-  const idToken = data.idToken ?? data.id_token ?? void 0;
-  const expires = normalizeEpochMillis(expiresRaw) ?? extractJwtExpiry(idToken ?? access) ?? Date.now() + 5 * 6e4;
-  const accountId = data.accountId ?? data.account_id ?? extractChatGptAccountId(idToken ?? "") ?? extractChatGptAccountId(access);
+  doc.tokens.access_token = profile.access;
+  doc.tokens.refresh_token = profile.refresh;
+  doc.tokens.account_id = profile.accountId;
+  if (profile.idToken) {
+    doc.tokens.id_token = profile.idToken;
+  }
+  doc.last_refresh = (/* @__PURE__ */ new Date()).toISOString();
+  fs2.mkdirSync(codexHome, { recursive: true, mode: 448 });
+  const tmpPath = `${authPath}.tmp.${process.pid}.${Math.random().toString(16).slice(2)}`;
+  fs2.writeFileSync(tmpPath, `${JSON.stringify(doc, null, 2)}
+`, { mode: 384 });
+  fs2.renameSync(tmpPath, authPath);
+}
+function profileFromTokenResponse(payload, fallback) {
+  const expires = Date.now() + normalizeNumber(payload.expires_in) * 1e3;
+  const fallbackAccountId = fallback?.accountId;
+  const fallbackIdToken = fallback?.idToken;
+  const accountId = extractChatGptAccountId(payload.id_token ?? "") ?? extractChatGptAccountId(payload.access_token) ?? fallbackAccountId;
   if (!accountId) {
-    throw new Error("ChatGPT credentials missing chatgpt_account_id.");
+    throw new Error("Failed to extract chatgpt_account_id from access token.");
   }
   return {
-    access,
-    refresh,
+    access: payload.access_token,
+    refresh: payload.refresh_token,
     expires,
     accountId,
-    idToken: idToken ?? void 0
+    idToken: payload.id_token ?? fallbackIdToken
   };
 }
 function normalizeEpochMillis(value) {
@@ -456,31 +645,6 @@ function isExpired(profile) {
   }
   return Date.now() + TOKEN_EXPIRY_BUFFER_MS >= expires;
 }
-function loadAuthProfileFromEnv() {
-  loadLocalEnv();
-  const rawJson = process.env[CHATGPT_AUTH_JSON_ENV];
-  if (rawJson && rawJson.trim().length > 0) {
-    return normalizeAuthProfile(AuthInputSchema.parse(JSON.parse(rawJson)));
-  }
-  const rawB64 = process.env[CHATGPT_AUTH_JSON_B64_ENV];
-  if (rawB64 && rawB64.trim().length > 0) {
-    const decoded = Buffer.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;
-  const refresh = process.env[CHATGPT_REFRESH_ENV] ?? process.env[CHATGPT_REFRESH_TOKEN_ENV] ?? void 0;
-  const expires = process.env[CHATGPT_EXPIRES_ENV] ?? process.env[CHATGPT_EXPIRES_AT_ENV] ?? void 0;
-  const accountId = process.env[CHATGPT_ACCOUNT_ID_ENV] ?? void 0;
-  const idToken = process.env[CHATGPT_ID_TOKEN_ENV] ?? void 0;
-  const parsed = AuthInputSchema.parse({
-    access,
-    refresh,
-    expires,
-    accountId,
-    idToken
-  });
-  return normalizeAuthProfile(parsed);
-}
 function decodeJwtPayload(token) {
   const segments = token.split(".");
   if (segments.length < 2) {
@@ -488,7 +652,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;
@@ -511,8 +675,12 @@ function extractChatGptAccountId(token) {
   if (!payload || typeof payload !== "object") {
     return void 0;
   }
-  const accountId = payload.chatgpt_account_id;
-  return typeof accountId === "string" && accountId.length > 0 ? accountId : void 0;
+  const direct = payload.chatgpt_account_id;
+  if (typeof direct === "string" && direct.length > 0) {
+    return direct;
+  }
+  const namespaced = payload["https://api.openai.com/auth"]?.chatgpt_account_id;
+  return typeof namespaced === "string" && namespaced.length > 0 ? namespaced : void 0;
 }
 
 // src/openai/chatgpt-codex.ts
@@ -548,7 +716,19 @@ async function streamChatGptCodexResponse(options) {
   return parseEventStream(body);
 }
 async function collectChatGptCodexResponse(options) {
-  const stream = await streamChatGptCodexResponse(options);
+  let stream;
+  try {
+    stream = await streamChatGptCodexResponse(options);
+  } catch (error) {
+    if (shouldRetryWithoutReasoningSummary(options.request, error)) {
+      stream = await streamChatGptCodexResponse({
+        ...options,
+        request: removeReasoningSummary(options.request)
+      });
+    } else {
+      throw error;
+    }
+  }
   const toolCalls = /* @__PURE__ */ new Map();
   const toolCallOrder = [];
   const webSearchCalls = /* @__PURE__ */ new Map();
@@ -557,6 +737,7 @@ async function collectChatGptCodexResponse(options) {
   const reasoningText = "";
   let reasoningSummaryText = "";
   let usage;
+  let responseId;
   let model;
   let status;
   let blocked = false;
@@ -597,7 +778,18 @@ async function collectChatGptCodexResponse(options) {
             if (!toolCalls.has(callId)) {
               toolCallOrder.push(callId);
             }
-            toolCalls.set(callId, { id, callId, name, arguments: args });
+            toolCalls.set(callId, { kind: "function", id, callId, name, arguments: args });
+          }
+        } else if (item.type === "custom_tool_call") {
+          const id = typeof item.id === "string" ? item.id : "";
+          const callId = typeof item.call_id === "string" ? item.call_id : id;
+          const name = typeof item.name === "string" ? item.name : "";
+          const input = typeof item.input === "string" ? item.input : "";
+          if (callId) {
+            if (!toolCalls.has(callId)) {
+              toolCallOrder.push(callId);
+            }
+            toolCalls.set(callId, { kind: "custom", id, callId, name, input });
           }
         } else if (item.type === "web_search_call") {
           const id = typeof item.id === "string" ? item.id : "";
@@ -619,6 +811,7 @@ async function collectChatGptCodexResponse(options) {
       const response = event.response;
       if (response) {
         usage = response.usage;
+        responseId = typeof response.id === "string" ? response.id : responseId;
         model = typeof response.model === "string" ? response.model : void 0;
         status = typeof response.status === "string" ? response.status : void 0;
       }
@@ -628,6 +821,7 @@ async function collectChatGptCodexResponse(options) {
       const response = event.response;
       if (response) {
         usage = response.usage;
+        responseId = typeof response.id === "string" ? response.id : responseId;
         model = typeof response.model === "string" ? response.model : void 0;
         status = typeof response.status === "string" ? response.status : void 0;
       }
@@ -637,6 +831,7 @@ async function collectChatGptCodexResponse(options) {
       const response = event.response;
       if (response) {
         usage = response.usage;
+        responseId = typeof response.id === "string" ? response.id : responseId;
         model = typeof response.model === "string" ? response.model : void 0;
         status = typeof response.status === "string" ? response.status : void 0;
       }
@@ -654,15 +849,38 @@ async function collectChatGptCodexResponse(options) {
     toolCalls: orderedToolCalls,
     webSearchCalls: orderedWebSearchCalls,
     usage,
+    id: responseId,
     model,
     status,
     blocked
   };
 }
+function shouldRetryWithoutReasoningSummary(request, error) {
+  if (!request.reasoning?.summary) {
+    return false;
+  }
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  const message = error.message.toLowerCase();
+  return message.includes("unsupported parameter") && message.includes("reasoning.summary");
+}
+function removeReasoningSummary(request) {
+  const reasoning = request.reasoning;
+  if (!reasoning?.summary) {
+    return request;
+  }
+  return {
+    ...request,
+    reasoning: {
+      effort: reasoning.effort
+    }
+  };
+}
 function buildUserAgent() {
   const node = process.version;
-  const platform = os.platform();
-  const release = os.release();
+  const platform = os2.platform();
+  const release = os2.release();
   return `@ljoukov/llm (node ${node}; ${platform} ${release})`;
 }
 async function* parseEventStream(stream) {
@@ -810,6 +1028,110 @@ function createCallScheduler(options = {}) {
   return { run };
 }
 
+// src/fireworks/client.ts
+import OpenAI from "openai";
+import { Agent, fetch as undiciFetch } from "undici";
+var DEFAULT_FIREWORKS_BASE_URL = "https://api.fireworks.ai/inference/v1";
+var DEFAULT_FIREWORKS_TIMEOUT_MS = 15 * 6e4;
+var cachedClient = null;
+var cachedFetch = null;
+var cachedBaseUrl = null;
+var cachedApiKey = null;
+var cachedTimeoutMs = null;
+function resolveTimeoutMs() {
+  if (cachedTimeoutMs !== null) {
+    return cachedTimeoutMs;
+  }
+  const raw = process.env.FIREWORKS_TIMEOUT_MS;
+  const parsed = raw ? Number(raw) : Number.NaN;
+  cachedTimeoutMs = Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_FIREWORKS_TIMEOUT_MS;
+  return cachedTimeoutMs;
+}
+function resolveBaseUrl() {
+  if (cachedBaseUrl !== null) {
+    return cachedBaseUrl;
+  }
+  loadLocalEnv();
+  const raw = process.env.FIREWORKS_BASE_URL?.trim();
+  cachedBaseUrl = raw && raw.length > 0 ? raw : DEFAULT_FIREWORKS_BASE_URL;
+  return cachedBaseUrl;
+}
+function resolveApiKey() {
+  if (cachedApiKey !== null) {
+    return cachedApiKey;
+  }
+  loadLocalEnv();
+  const raw = process.env.FIREWORKS_TOKEN ?? process.env.FIREWORKS_API_KEY;
+  const token = raw?.trim();
+  if (!token) {
+    throw new Error(
+      "FIREWORKS_TOKEN (or FIREWORKS_API_KEY) must be provided to access Fireworks APIs."
+    );
+  }
+  cachedApiKey = token;
+  return cachedApiKey;
+}
+function getFireworksFetch() {
+  if (cachedFetch) {
+    return cachedFetch;
+  }
+  const timeoutMs = resolveTimeoutMs();
+  const dispatcher = new Agent({
+    bodyTimeout: timeoutMs,
+    headersTimeout: timeoutMs
+  });
+  cachedFetch = ((input, init) => {
+    return undiciFetch(input, {
+      ...init ?? {},
+      dispatcher
+    });
+  });
+  return cachedFetch;
+}
+function getFireworksClient() {
+  if (cachedClient) {
+    return cachedClient;
+  }
+  cachedClient = new OpenAI({
+    apiKey: resolveApiKey(),
+    baseURL: resolveBaseUrl(),
+    timeout: resolveTimeoutMs(),
+    fetch: getFireworksFetch()
+  });
+  return cachedClient;
+}
+
+// src/fireworks/calls.ts
+var scheduler = createCallScheduler({
+  maxParallelRequests: 3,
+  minIntervalBetweenStartMs: 200,
+  startJitterMs: 200
+});
+async function runFireworksCall(fn) {
+  return scheduler.run(async () => fn(getFireworksClient()));
+}
+
+// src/fireworks/models.ts
+var FIREWORKS_MODEL_IDS = ["kimi-k2.5", "glm-5", "minimax-m2.1"];
+var FIREWORKS_DEFAULT_KIMI_MODEL = "kimi-k2.5";
+var FIREWORKS_DEFAULT_GLM_MODEL = "glm-5";
+var FIREWORKS_DEFAULT_MINIMAX_MODEL = "minimax-m2.1";
+var FIREWORKS_CANONICAL_MODEL_IDS = {
+  "kimi-k2.5": "accounts/fireworks/models/kimi-k2p5",
+  "glm-5": "accounts/fireworks/models/glm-5",
+  "minimax-m2.1": "accounts/fireworks/models/minimax-m2p1"
+};
+function isFireworksModelId(value) {
+  return FIREWORKS_MODEL_IDS.includes(value.trim());
+}
+function resolveFireworksModelId(model) {
+  const trimmed = model.trim();
+  if (!isFireworksModelId(trimmed)) {
+    return void 0;
+  }
+  return FIREWORKS_CANONICAL_MODEL_IDS[trimmed];
+}
+
 // src/google/client.ts
 import { GoogleGenAI } from "@google/genai";
 
@@ -878,6 +1200,7 @@ function getGoogleAuthOptions(scopes) {
 // src/google/client.ts
 var GEMINI_MODEL_IDS = [
   "gemini-3-pro-preview",
+  "gemini-3-flash-preview",
   "gemini-2.5-pro",
   "gemini-flash-latest",
   "gemini-flash-lite-latest"
@@ -1117,7 +1440,7 @@ function retryDelayMs(attempt) {
   const jitter = Math.floor(Math.random() * 200);
   return base + jitter;
 }
-var scheduler = createCallScheduler({
+var scheduler2 = createCallScheduler({
   maxParallelRequests: 3,
   minIntervalBetweenStartMs: 200,
   startJitterMs: 200,
@@ -1133,46 +1456,46 @@ var scheduler = createCallScheduler({
   }
 });
 async function runGeminiCall(fn) {
-  return scheduler.run(async () => fn(await getGeminiClient()));
+  return scheduler2.run(async () => fn(await getGeminiClient()));
 }
 
 // src/openai/client.ts
-import OpenAI from "openai";
-import { Agent, fetch as undiciFetch } from "undici";
-var cachedApiKey = null;
-var cachedClient = null;
-var cachedFetch = null;
-var cachedTimeoutMs = null;
+import OpenAI2 from "openai";
+import { Agent as Agent2, fetch as undiciFetch2 } from "undici";
+var cachedApiKey2 = null;
+var cachedClient2 = null;
+var cachedFetch2 = null;
+var cachedTimeoutMs2 = null;
 var DEFAULT_OPENAI_TIMEOUT_MS = 15 * 6e4;
 function resolveOpenAiTimeoutMs() {
-  if (cachedTimeoutMs !== null) {
-    return cachedTimeoutMs;
+  if (cachedTimeoutMs2 !== null) {
+    return cachedTimeoutMs2;
   }
   const raw = process.env.OPENAI_STREAM_TIMEOUT_MS ?? process.env.OPENAI_TIMEOUT_MS;
   const parsed = raw ? Number(raw) : Number.NaN;
-  cachedTimeoutMs = Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_OPENAI_TIMEOUT_MS;
-  return cachedTimeoutMs;
+  cachedTimeoutMs2 = Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_OPENAI_TIMEOUT_MS;
+  return cachedTimeoutMs2;
 }
 function getOpenAiFetch() {
-  if (cachedFetch) {
-    return cachedFetch;
+  if (cachedFetch2) {
+    return cachedFetch2;
   }
   const timeoutMs = resolveOpenAiTimeoutMs();
-  const dispatcher = new Agent({
+  const dispatcher = new Agent2({
     bodyTimeout: timeoutMs,
     headersTimeout: timeoutMs
   });
-  cachedFetch = ((input, init) => {
-    return undiciFetch(input, {
+  cachedFetch2 = ((input, init) => {
+    return undiciFetch2(input, {
       ...init ?? {},
       dispatcher
     });
   });
-  return cachedFetch;
+  return cachedFetch2;
 }
 function getOpenAiApiKey() {
-  if (cachedApiKey !== null) {
-    return cachedApiKey;
+  if (cachedApiKey2 !== null) {
+    return cachedApiKey2;
   }
   loadLocalEnv();
   const raw = process.env.OPENAI_API_KEY;
@@ -1180,32 +1503,32 @@ function getOpenAiApiKey() {
   if (!value) {
     throw new Error("OPENAI_API_KEY must be provided to access OpenAI APIs.");
   }
-  cachedApiKey = value;
-  return cachedApiKey;
+  cachedApiKey2 = value;
+  return cachedApiKey2;
 }
 function getOpenAiClient() {
-  if (cachedClient) {
-    return cachedClient;
+  if (cachedClient2) {
+    return cachedClient2;
   }
   const apiKey = getOpenAiApiKey();
   const timeoutMs = resolveOpenAiTimeoutMs();
-  cachedClient = new OpenAI({
+  cachedClient2 = new OpenAI2({
     apiKey,
     fetch: getOpenAiFetch(),
     timeout: timeoutMs
   });
-  return cachedClient;
+  return cachedClient2;
 }
 
 // src/openai/calls.ts
 var DEFAULT_OPENAI_REASONING_EFFORT = "medium";
-var scheduler2 = createCallScheduler({
+var scheduler3 = createCallScheduler({
   maxParallelRequests: 3,
   minIntervalBetweenStartMs: 200,
   startJitterMs: 200
 });
 async function runOpenAiCall(fn) {
-  return scheduler2.run(async () => fn(getOpenAiClient()));
+  return scheduler3.run(async () => fn(getOpenAiClient()));
 }
 
 // src/llm.ts
@@ -1221,7 +1544,16 @@ var LlmJsonCallError = class extends Error {
   }
 };
 function tool(options) {
-  return options;
+  return {
+    type: "function",
+    ...options
+  };
+}
+function customTool(options) {
+  return {
+    type: "custom",
+    ...options
+  };
 }
 function isPlainRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -1475,9 +1807,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",
@@ -1567,6 +1899,10 @@ function resolveProvider(model) {
   if (model.startsWith("gemini-")) {
     return { provider: "gemini", model };
   }
+  const fireworksModel = resolveFireworksModelId(model);
+  if (fireworksModel) {
+    return { provider: "fireworks", model: fireworksModel };
+  }
   return { provider: "openai", model };
 }
 function isOpenAiCodexModel(modelId) {
@@ -1596,6 +1932,27 @@ function toOpenAiReasoningEffort(effort) {
 function resolveOpenAiVerbosity(modelId) {
   return isOpenAiCodexModel(modelId) ? "medium" : "high";
 }
+function isRetryableChatGptTransportError(error) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  const message = error.message.toLowerCase();
+  return message === "terminated" || message.includes("socket hang up") || message.includes("fetch failed") || message.includes("network");
+}
+async function collectChatGptCodexResponseWithRetry(options, maxAttempts = 2) {
+  let attempt = 1;
+  while (true) {
+    try {
+      return await collectChatGptCodexResponse(options);
+    } catch (error) {
+      if (attempt >= maxAttempts || !isRetryableChatGptTransportError(error)) {
+        throw error;
+      }
+      await new Promise((resolve) => setTimeout(resolve, 250 * attempt));
+      attempt += 1;
+    }
+  }
+}
 function isInlineImageMime(mimeType) {
   if (!mimeType) {
     return false;
@@ -2178,6 +2535,53 @@ function toChatGptInput(contents) {
     input
   };
 }
+function toFireworksMessages(contents, options) {
+  const systemMessages = [];
+  const messages = [];
+  if (options?.responseMimeType === "application/json") {
+    systemMessages.push("Return valid JSON only. Do not include markdown or prose outside JSON.");
+  }
+  if (options?.responseJsonSchema) {
+    systemMessages.push(`Target JSON schema:
+${JSON.stringify(options.responseJsonSchema)}`);
+  }
+  for (const content of contents) {
+    const text = content.parts.map((part) => {
+      if (part.type === "text") {
+        return part.text;
+      }
+      const mimeType = part.mimeType ?? "application/octet-stream";
+      if (isInlineImageMime(mimeType)) {
+        return `[image:${mimeType}]`;
+      }
+      return `[file:${mimeType}]`;
+    }).join("\n").trim();
+    if (content.role === "system" || content.role === "developer") {
+      if (text.length > 0) {
+        systemMessages.push(text);
+      }
+      continue;
+    }
+    if (content.role === "tool" || content.role === "assistant") {
+      messages.push({
+        role: "assistant",
+        content: text.length > 0 ? text : "(empty content)"
+      });
+      continue;
+    }
+    messages.push({
+      role: "user",
+      content: text.length > 0 ? text : "(empty content)"
+    });
+  }
+  if (systemMessages.length > 0) {
+    messages.unshift({
+      role: "system",
+      content: systemMessages.join("\n\n")
+    });
+  }
+  return messages;
+}
 function toGeminiTools(tools) {
   if (!tools || tools.length === 0) {
     return void 0;
@@ -2351,19 +2755,54 @@ function extractChatGptUsageTokens(usage) {
     totalTokens
   };
 }
-var MODERATION_FINISH_REASONS = /* @__PURE__ */ new Set([
-  FinishReason.SAFETY,
-  FinishReason.BLOCKLIST,
-  FinishReason.PROHIBITED_CONTENT,
-  FinishReason.SPII
-]);
-function isModerationFinish(reason) {
-  if (!reason) {
-    return false;
+function extractFireworksUsageTokens(usage) {
+  if (!usage || typeof usage !== "object") {
+    return void 0;
   }
-  return MODERATION_FINISH_REASONS.has(reason);
-}
-function mergeToolOutput(value) {
+  const promptTokens = toMaybeNumber(
+    usage.prompt_tokens ?? usage.input_tokens
+  );
+  const cachedTokens = toMaybeNumber(
+    usage.prompt_tokens_details?.cached_tokens ?? usage.input_tokens_details?.cached_tokens
+  );
+  const outputTokensRaw = toMaybeNumber(
+    usage.completion_tokens ?? usage.output_tokens
+  );
+  const reasoningTokens = toMaybeNumber(
+    usage.completion_tokens_details?.reasoning_tokens ?? usage.output_tokens_details?.reasoning_tokens
+  );
+  const totalTokens = toMaybeNumber(
+    usage.total_tokens ?? usage.totalTokenCount
+  );
+  let responseTokens;
+  if (outputTokensRaw !== void 0) {
+    const adjusted = outputTokensRaw - (reasoningTokens ?? 0);
+    responseTokens = adjusted >= 0 ? adjusted : 0;
+  }
+  if (promptTokens === void 0 && cachedTokens === void 0 && responseTokens === void 0 && reasoningTokens === void 0 && totalTokens === void 0) {
+    return void 0;
+  }
+  return {
+    promptTokens,
+    cachedTokens,
+    responseTokens,
+    thinkingTokens: reasoningTokens,
+    totalTokens
+  };
+}
+var MODERATION_FINISH_REASONS = /* @__PURE__ */ new Set([
+  FinishReason.SAFETY,
+  FinishReason.BLOCKLIST,
+  FinishReason.PROHIBITED_CONTENT,
+  FinishReason.SPII
+]);
+function isModerationFinish(reason) {
+  if (!reason) {
+    return false;
+  }
+  return MODERATION_FINISH_REASONS.has(reason);
+}
+function mergeToolOutput(value) {
   if (typeof value === "string") {
     return value;
   }
@@ -2389,8 +2828,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 path6 = issue.path.length > 0 ? issue.path.map(String).join(".") : "input";
+    messages.push(`${path6}: ${issue.message}`);
   }
   return messages.join("; ");
 }
@@ -2406,7 +2845,7 @@ function buildToolErrorOutput(message, issues) {
   return output;
 }
 async function executeToolCall(params) {
-  const { toolName, tool: tool2, rawInput, parseError } = params;
+  const { callKind, toolName, tool: tool2, rawInput, parseError } = params;
   if (!tool2) {
     const message = `Unknown tool: ${toolName}`;
     return {
@@ -2414,6 +2853,39 @@ async function executeToolCall(params) {
       outputPayload: buildToolErrorOutput(message)
     };
   }
+  if (callKind === "custom") {
+    if (!isCustomTool(tool2)) {
+      const message = `Tool ${toolName} was called as custom_tool_call but is declared as function.`;
+      const outputPayload = buildToolErrorOutput(message);
+      return {
+        result: { toolName, input: rawInput, output: outputPayload, error: message },
+        outputPayload
+      };
+    }
+    const input = typeof rawInput === "string" ? rawInput : String(rawInput ?? "");
+    try {
+      const output = await tool2.execute(input);
+      return {
+        result: { toolName, input, output },
+        outputPayload: output
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      const outputPayload = buildToolErrorOutput(`Tool ${toolName} failed: ${message}`);
+      return {
+        result: { toolName, input, output: outputPayload, error: message },
+        outputPayload
+      };
+    }
+  }
+  if (isCustomTool(tool2)) {
+    const message = `Tool ${toolName} was called as function_call but is declared as custom.`;
+    const outputPayload = buildToolErrorOutput(message);
+    return {
+      result: { toolName, input: rawInput, output: outputPayload, error: message },
+      outputPayload
+    };
+  }
   if (parseError) {
     const message = `Invalid JSON for tool ${toolName}: ${parseError}`;
     return {
@@ -2470,8 +2942,12 @@ function normalizeChatGptToolIds(params) {
     rawItemId = nextItemId ?? rawItemId;
   }
   const callValue = sanitizeChatGptToolId(rawCallId || rawItemId || randomBytes(8).toString("hex"));
-  let itemValue = sanitizeChatGptToolId(rawItemId || `fc-${callValue}`);
-  if (!itemValue.startsWith("fc")) {
+  let itemValue = sanitizeChatGptToolId(rawItemId || callValue);
+  if (params.callKind === "custom") {
+    if (!itemValue.startsWith("ctc")) {
+      itemValue = `ctc_${itemValue}`;
+    }
+  } else if (!itemValue.startsWith("fc")) {
     itemValue = `fc-${itemValue}`;
   }
   return { callId: callValue, itemId: itemValue };
@@ -2536,7 +3012,7 @@ function extractOpenAiResponseParts(response) {
   }
   return { parts, blocked };
 }
-function extractOpenAiFunctionCalls(output) {
+function extractOpenAiToolCalls(output) {
   const calls = [];
   if (!Array.isArray(output)) {
     return calls;
@@ -2545,22 +3021,78 @@ function extractOpenAiFunctionCalls(output) {
     if (!item || typeof item !== "object") {
       continue;
     }
-    if (item.type === "function_call") {
+    const itemType = item.type;
+    if (itemType === "function_call") {
       const name = typeof item.name === "string" ? item.name : "";
       const args = typeof item.arguments === "string" ? item.arguments : "";
       const call_id = typeof item.call_id === "string" ? item.call_id : "";
       const id = typeof item.id === "string" ? item.id : void 0;
       if (name && call_id) {
-        calls.push({ name, arguments: args, call_id, id });
+        calls.push({ kind: "function", name, arguments: args, call_id, id });
+      }
+      continue;
+    }
+    if (itemType === "custom_tool_call") {
+      const name = typeof item.name === "string" ? item.name : "";
+      const input = typeof item.input === "string" ? item.input : "";
+      const call_id = typeof item.call_id === "string" ? item.call_id : "";
+      const id = typeof item.id === "string" ? item.id : void 0;
+      if (name && call_id) {
+        calls.push({ kind: "custom", name, input, call_id, id });
       }
     }
   }
   return calls;
 }
+function extractFireworksMessageText(message) {
+  if (!message || typeof message !== "object") {
+    return "";
+  }
+  const content = message.content;
+  if (typeof content === "string") {
+    return content;
+  }
+  if (!Array.isArray(content)) {
+    return "";
+  }
+  let text = "";
+  for (const part of content) {
+    const textPart = part.text;
+    if (typeof textPart === "string") {
+      text += textPart;
+    }
+  }
+  return text;
+}
+function extractFireworksToolCalls(message) {
+  if (!message || typeof message !== "object") {
+    return [];
+  }
+  const toolCalls = message.tool_calls;
+  if (!Array.isArray(toolCalls)) {
+    return [];
+  }
+  const calls = [];
+  for (const call of toolCalls) {
+    if (!call || typeof call !== "object") {
+      continue;
+    }
+    const id = typeof call.id === "string" ? call.id : "";
+    const fn = call.function;
+    const name = fn && typeof fn === "object" && typeof fn.name === "string" ? fn.name ?? "" : "";
+    const args = fn && typeof fn === "object" && typeof fn.arguments === "string" ? fn.arguments ?? "" : "";
+    if (id && name) {
+      calls.push({ id, name, arguments: args });
+    }
+  }
+  return calls;
+}
 function resolveGeminiThinkingConfig(modelId) {
   switch (modelId) {
     case "gemini-3-pro-preview":
       return { includeThoughts: true };
+    case "gemini-3-flash-preview":
+      return { includeThoughts: true, thinkingBudget: 16384 };
     case "gemini-2.5-pro":
       return { includeThoughts: true, thinkingBudget: 32768 };
     case "gemini-flash-latest":
@@ -2572,9 +3104,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) {
@@ -2736,7 +3268,7 @@ async function runTextCall(params) {
     };
     let sawResponseDelta = false;
     let sawThoughtDelta = false;
-    const result = await collectChatGptCodexResponse({
+    const result = await collectChatGptCodexResponseWithRetry({
       request: requestPayload,
       signal,
       onDelta: (delta) => {
@@ -2767,6 +3299,47 @@ async function runTextCall(params) {
     if (!sawResponseDelta && fallbackText.length > 0) {
       pushDelta("response", fallbackText);
     }
+  } else if (provider === "fireworks") {
+    if (request.tools && request.tools.length > 0) {
+      throw new Error(
+        "Fireworks provider does not support provider-native tools in generateText; use runToolLoop for function tools."
+      );
+    }
+    const fireworksMessages = toFireworksMessages(contents, {
+      responseMimeType: request.responseMimeType,
+      responseJsonSchema: request.responseJsonSchema
+    });
+    await runFireworksCall(async (client) => {
+      const responseFormat = request.responseJsonSchema ? {
+        type: "json_schema",
+        json_schema: {
+          name: "llm-response",
+          schema: request.responseJsonSchema
+        }
+      } : request.responseMimeType === "application/json" ? { type: "json_object" } : void 0;
+      const response = await client.chat.completions.create(
+        {
+          model: modelForProvider,
+          messages: fireworksMessages,
+          ...responseFormat ? { response_format: responseFormat } : {}
+        },
+        { signal }
+      );
+      modelVersion = typeof response.model === "string" ? response.model : request.model;
+      queue.push({ type: "model", modelVersion });
+      const choice = Array.isArray(response.choices) ? response.choices[0] : void 0;
+      if (choice?.finish_reason === "content_filter") {
+        blocked = true;
+        queue.push({ type: "blocked" });
+      }
+      const textOutput = extractFireworksMessageText(
+        choice?.message
+      );
+      if (textOutput.length > 0) {
+        pushDelta("response", textOutput);
+      }
+      latestUsage = extractFireworksUsageTokens(response.usage);
+    });
   } else {
     const geminiContents = contents.map(convertLlmContentToGeminiContent);
     const config = {
@@ -2891,11 +3464,12 @@ 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";
+  const isGeminiVariant = providerInfo.provider === "gemini";
   const baseJsonSchema = zodToJsonSchema(request.schema, {
     name: schemaName,
     target: isOpenAiVariant ? "openAi" : "jsonSchema7"
   });
-  const responseJsonSchema = isOpenAiVariant ? resolveOpenAiSchemaRoot(baseJsonSchema) : addGeminiPropertyOrdering(baseJsonSchema);
+  const responseJsonSchema = isOpenAiVariant ? resolveOpenAiSchemaRoot(baseJsonSchema) : isGeminiVariant ? addGeminiPropertyOrdering(baseJsonSchema) : resolveOpenAiSchemaRoot(baseJsonSchema);
   if (isOpenAiVariant && !isJsonSchemaObject(responseJsonSchema)) {
     throw new Error("OpenAI structured outputs require a JSON object schema at the root.");
   }
@@ -3062,15 +3636,46 @@ var DEFAULT_TOOL_LOOP_MAX_STEPS = 8;
 function resolveToolLoopContents(input) {
   return resolveTextContents(input);
 }
-function buildOpenAiFunctionTools(tools) {
+function isCustomTool(toolDef) {
+  return toolDef.type === "custom";
+}
+function buildOpenAiToolsFromToolSet(tools) {
   const toolEntries = Object.entries(tools);
-  return toolEntries.map(([name, toolDef]) => ({
-    type: "function",
-    name,
-    description: toolDef.description ?? void 0,
-    parameters: buildOpenAiToolSchema(toolDef.inputSchema, name),
-    strict: true
-  }));
+  return toolEntries.map(([name, toolDef]) => {
+    if (isCustomTool(toolDef)) {
+      return {
+        type: "custom",
+        name,
+        description: toolDef.description ?? void 0,
+        ...toolDef.format ? { format: toolDef.format } : {}
+      };
+    }
+    return {
+      type: "function",
+      name,
+      description: toolDef.description ?? void 0,
+      parameters: buildOpenAiToolSchema(toolDef.inputSchema, name),
+      strict: true
+    };
+  });
+}
+function buildFireworksToolsFromToolSet(tools) {
+  const toolEntries = Object.entries(tools);
+  return toolEntries.map(([name, toolDef]) => {
+    if (isCustomTool(toolDef)) {
+      throw new Error(
+        `Fireworks provider does not support custom/freeform tools (${name}). Use JSON function tools instead.`
+      );
+    }
+    return {
+      type: "function",
+      function: {
+        name,
+        description: toolDef.description ?? void 0,
+        parameters: buildOpenAiToolSchema(toolDef.inputSchema, name)
+      }
+    };
+  });
 }
 function buildOpenAiToolSchema(schema, name) {
   const rawSchema = zodToJsonSchema(schema, { name, target: "openAi" });
@@ -3082,11 +3687,18 @@ function buildOpenAiToolSchema(schema, name) {
 }
 function buildGeminiFunctionDeclarations(tools) {
   const toolEntries = Object.entries(tools);
-  const functionDeclarations = toolEntries.map(([name, toolDef]) => ({
-    name,
-    description: toolDef.description ?? "",
-    parametersJsonSchema: buildGeminiToolSchema(toolDef.inputSchema, name)
-  }));
+  const functionDeclarations = toolEntries.map(([name, toolDef]) => {
+    if (isCustomTool(toolDef)) {
+      throw new Error(
+        `Gemini provider does not support custom/freeform tools (${name}). Use JSON function tools instead.`
+      );
+    }
+    return {
+      name,
+      description: toolDef.description ?? "",
+      parametersJsonSchema: buildGeminiToolSchema(toolDef.inputSchema, name)
+    };
+  });
   return [{ functionDeclarations }];
 }
 function buildGeminiToolSchema(schema, name) {
@@ -3147,9 +3759,9 @@ async function runToolLoop(request) {
   let finalText = "";
   let finalThoughts = "";
   if (providerInfo.provider === "openai") {
-    const openAiFunctionTools = buildOpenAiFunctionTools(request.tools);
+    const openAiAgentTools = buildOpenAiToolsFromToolSet(request.tools);
     const openAiNativeTools = toOpenAiTools(request.modelTools);
-    const openAiTools = openAiNativeTools ? [...openAiNativeTools, ...openAiFunctionTools] : [...openAiFunctionTools];
+    const openAiTools = openAiNativeTools ? [...openAiNativeTools, ...openAiAgentTools] : [...openAiAgentTools];
     const reasoningEffort = resolveOpenAiReasoningEffort(
       providerInfo.model,
       request.openAiReasoningEffort
@@ -3241,9 +3853,9 @@ async function runToolLoop(request) {
       if (usageTokens) {
         emitEvent({ type: "usage", usage: usageTokens, costUsd: stepCostUsd, modelVersion });
       }
-      const functionCalls = extractOpenAiFunctionCalls(finalResponse.output);
+      const responseToolCalls = extractOpenAiToolCalls(finalResponse.output);
       const stepToolCalls = [];
-      if (functionCalls.length === 0) {
+      if (responseToolCalls.length === 0) {
         finalText = responseText;
         finalThoughts = reasoningSummary;
         steps.push({
@@ -3257,10 +3869,21 @@ async function runToolLoop(request) {
         });
         return { text: finalText, thoughts: finalThoughts, steps, totalCostUsd };
       }
-      const callInputs = functionCalls.map((call, index) => {
+      const callInputs = responseToolCalls.map((call, index) => {
         const toolIndex = index + 1;
         const toolId = buildToolLogId(turn, toolIndex);
         const toolName = call.name;
+        if (call.kind === "custom") {
+          return {
+            call,
+            toolName,
+            value: call.input,
+            parseError: void 0,
+            toolId,
+            turn,
+            toolIndex
+          };
+        }
         const { value, error: parseError } = parseOpenAiToolArguments(call.arguments);
         return { call, toolName, value, parseError, toolId, turn, toolIndex };
       });
@@ -3275,6 +3898,7 @@ async function runToolLoop(request) {
             },
             async () => {
               const { result, outputPayload } = await executeToolCall({
+                callKind: entry.call.kind,
                 toolName: entry.toolName,
                 tool: request.tools[entry.toolName],
                 rawInput: entry.value,
@@ -3288,11 +3912,19 @@ async function runToolLoop(request) {
       const toolOutputs = [];
       for (const { entry, result, outputPayload } of callResults) {
         stepToolCalls.push({ ...result, callId: entry.call.call_id });
-        toolOutputs.push({
-          type: "function_call_output",
-          call_id: entry.call.call_id,
-          output: mergeToolOutput(outputPayload)
-        });
+        if (entry.call.kind === "custom") {
+          toolOutputs.push({
+            type: "custom_tool_call_output",
+            call_id: entry.call.call_id,
+            output: mergeToolOutput(outputPayload)
+          });
+        } else {
+          toolOutputs.push({
+            type: "function_call_output",
+            call_id: entry.call.call_id,
+            output: mergeToolOutput(outputPayload)
+          });
+        }
       }
       steps.push({
         step: steps.length + 1,
@@ -3309,24 +3941,28 @@ async function runToolLoop(request) {
     throw new Error(`Tool loop exceeded max steps (${maxSteps}) without final response.`);
   }
   if (providerInfo.provider === "chatgpt") {
-    const openAiFunctionTools = buildOpenAiFunctionTools(request.tools);
+    const openAiAgentTools = buildOpenAiToolsFromToolSet(request.tools);
     const openAiNativeTools = toOpenAiTools(request.modelTools);
-    const openAiTools = openAiNativeTools ? [...openAiNativeTools, ...openAiFunctionTools] : [...openAiFunctionTools];
+    const openAiTools = openAiNativeTools ? [...openAiNativeTools, ...openAiAgentTools] : [...openAiAgentTools];
     const reasoningEffort = resolveOpenAiReasoningEffort(
       request.model,
       request.openAiReasoningEffort
     );
     const toolLoopInput = toChatGptInput(contents);
+    const conversationId = `tool-loop-${randomBytes(8).toString("hex")}`;
+    const promptCacheKey = conversationId;
     let input = [...toolLoopInput.input];
     for (let stepIndex = 0; stepIndex < maxSteps; stepIndex += 1) {
       const turn = stepIndex + 1;
-      const response = await collectChatGptCodexResponse({
+      const response = await collectChatGptCodexResponseWithRetry({
+        sessionId: conversationId,
         request: {
           model: providerInfo.model,
           store: false,
           stream: true,
           instructions: toolLoopInput.instructions ?? "You are a helpful assistant.",
           input,
+          prompt_cache_key: promptCacheKey,
           include: ["reasoning.encrypted_content"],
           tools: openAiTools,
           tool_choice: "auto",
@@ -3357,8 +3993,8 @@ async function runToolLoop(request) {
       totalCostUsd += stepCostUsd;
       const responseText = (response.text ?? "").trim();
       const reasoningSummaryText = (response.reasoningSummaryText ?? "").trim();
-      const functionCalls = response.toolCalls ?? [];
-      if (functionCalls.length === 0) {
+      const responseToolCalls = response.toolCalls ?? [];
+      if (responseToolCalls.length === 0) {
         finalText = responseText;
         finalThoughts = reasoningSummaryText;
         steps.push({
@@ -3374,12 +4010,16 @@ async function runToolLoop(request) {
       }
       const toolCalls = [];
       const toolOutputs = [];
-      const callInputs = functionCalls.map((call, index) => {
+      const callInputs = responseToolCalls.map((call, index) => {
         const toolIndex = index + 1;
         const toolId = buildToolLogId(turn, toolIndex);
         const toolName = call.name;
-        const { value, error: parseError } = parseOpenAiToolArguments(call.arguments);
-        const ids = normalizeChatGptToolIds({ callId: call.callId, itemId: call.id });
+        const { value, error: parseError } = call.kind === "custom" ? { value: call.input, error: void 0 } : parseOpenAiToolArguments(call.arguments);
+        const ids = normalizeChatGptToolIds({
+          callKind: call.kind,
+          callId: call.callId,
+          itemId: call.id
+        });
         return { call, toolName, value, parseError, ids, toolId, turn, toolIndex };
       });
       const callResults = await Promise.all(
@@ -3393,6 +4033,7 @@ async function runToolLoop(request) {
             },
             async () => {
               const { result, outputPayload } = await executeToolCall({
+                callKind: entry.call.kind,
                 toolName: entry.toolName,
                 tool: request.tools[entry.toolName],
                 rawInput: entry.value,
@@ -3405,19 +4046,35 @@ async function runToolLoop(request) {
       );
       for (const { entry, result, outputPayload } of callResults) {
         toolCalls.push({ ...result, callId: entry.ids.callId });
-        toolOutputs.push({
-          type: "function_call",
-          id: entry.ids.itemId,
-          call_id: entry.ids.callId,
-          name: entry.toolName,
-          arguments: entry.call.arguments,
-          status: "completed"
-        });
-        toolOutputs.push({
-          type: "function_call_output",
-          call_id: entry.ids.callId,
-          output: mergeToolOutput(outputPayload)
-        });
+        if (entry.call.kind === "custom") {
+          toolOutputs.push({
+            type: "custom_tool_call",
+            id: entry.ids.itemId,
+            call_id: entry.ids.callId,
+            name: entry.toolName,
+            input: entry.call.input,
+            status: "completed"
+          });
+          toolOutputs.push({
+            type: "custom_tool_call_output",
+            call_id: entry.ids.callId,
+            output: mergeToolOutput(outputPayload)
+          });
+        } else {
+          toolOutputs.push({
+            type: "function_call",
+            id: entry.ids.itemId,
+            call_id: entry.ids.callId,
+            name: entry.toolName,
+            arguments: entry.call.arguments,
+            status: "completed"
+          });
+          toolOutputs.push({
+            type: "function_call_output",
+            call_id: entry.ids.callId,
+            output: mergeToolOutput(outputPayload)
+          });
+        }
       }
       steps.push({
         step: steps.length + 1,
@@ -3432,6 +4089,134 @@ async function runToolLoop(request) {
     }
     throw new Error(`Tool loop exceeded max steps (${maxSteps}) without final response.`);
   }
+  if (providerInfo.provider === "fireworks") {
+    if (request.modelTools && request.modelTools.length > 0) {
+      throw new Error(
+        "Fireworks provider does not support provider-native modelTools in runToolLoop."
+      );
+    }
+    const fireworksTools = buildFireworksToolsFromToolSet(request.tools);
+    const messages = toFireworksMessages(contents);
+    for (let stepIndex = 0; stepIndex < maxSteps; stepIndex += 1) {
+      const turn = stepIndex + 1;
+      const response = await runFireworksCall(async (client) => {
+        return await client.chat.completions.create(
+          {
+            model: providerInfo.model,
+            messages,
+            tools: fireworksTools,
+            tool_choice: "auto",
+            parallel_tool_calls: true
+          },
+          { signal: request.signal }
+        );
+      });
+      const modelVersion = typeof response.model === "string" ? response.model : request.model;
+      request.onEvent?.({ type: "model", modelVersion });
+      const choice = Array.isArray(response.choices) ? response.choices[0] : void 0;
+      if (choice?.finish_reason === "content_filter") {
+        request.onEvent?.({ type: "blocked" });
+      }
+      const message = choice?.message;
+      const responseText = extractFireworksMessageText(message).trim();
+      if (responseText.length > 0) {
+        request.onEvent?.({ type: "delta", channel: "response", text: responseText });
+      }
+      const usageTokens = extractFireworksUsageTokens(response.usage);
+      const stepCostUsd = estimateCallCostUsd({
+        modelId: modelVersion,
+        tokens: usageTokens,
+        responseImages: 0
+      });
+      totalCostUsd += stepCostUsd;
+      if (usageTokens) {
+        request.onEvent?.({
+          type: "usage",
+          usage: usageTokens,
+          costUsd: stepCostUsd,
+          modelVersion
+        });
+      }
+      const responseToolCalls = extractFireworksToolCalls(message);
+      if (responseToolCalls.length === 0) {
+        finalText = responseText;
+        finalThoughts = "";
+        steps.push({
+          step: steps.length + 1,
+          modelVersion,
+          text: responseText || void 0,
+          thoughts: void 0,
+          toolCalls: [],
+          usage: usageTokens,
+          costUsd: stepCostUsd
+        });
+        return { text: finalText, thoughts: finalThoughts, steps, totalCostUsd };
+      }
+      const stepToolCalls = [];
+      const callInputs = responseToolCalls.map((call, index) => {
+        const toolIndex = index + 1;
+        const toolId = buildToolLogId(turn, toolIndex);
+        const { value, error: parseError } = parseOpenAiToolArguments(call.arguments);
+        return { call, toolName: call.name, value, parseError, toolId, turn, toolIndex };
+      });
+      const callResults = await Promise.all(
+        callInputs.map(async (entry) => {
+          return await toolCallContextStorage.run(
+            {
+              toolName: entry.toolName,
+              toolId: entry.toolId,
+              turn: entry.turn,
+              toolIndex: entry.toolIndex
+            },
+            async () => {
+              const { result, outputPayload } = await executeToolCall({
+                callKind: "function",
+                toolName: entry.toolName,
+                tool: request.tools[entry.toolName],
+                rawInput: entry.value,
+                parseError: entry.parseError
+              });
+              return { entry, result, outputPayload };
+            }
+          );
+        })
+      );
+      const assistantToolCalls = [];
+      const toolMessages = [];
+      for (const { entry, result, outputPayload } of callResults) {
+        stepToolCalls.push({ ...result, callId: entry.call.id });
+        assistantToolCalls.push({
+          id: entry.call.id,
+          type: "function",
+          function: {
+            name: entry.toolName,
+            arguments: entry.call.arguments
+          }
+        });
+        toolMessages.push({
+          role: "tool",
+          tool_call_id: entry.call.id,
+          content: mergeToolOutput(outputPayload)
+        });
+      }
+      steps.push({
+        step: steps.length + 1,
+        modelVersion,
+        text: responseText || void 0,
+        thoughts: void 0,
+        toolCalls: stepToolCalls,
+        usage: usageTokens,
+        costUsd: stepCostUsd
+      });
+      messages.push({
+        role: "assistant",
+        ...responseText.length > 0 ? { content: responseText } : {},
+        tool_calls: assistantToolCalls
+      });
+      messages.push(...toolMessages);
+    }
+    throw new Error(`Tool loop exceeded max steps (${maxSteps}) without final response.`);
+  }
   const geminiFunctionTools = buildGeminiFunctionDeclarations(request.tools);
   const geminiNativeTools = toGeminiTools(request.modelTools);
   const geminiTools = geminiNativeTools ? geminiNativeTools.concat(geminiFunctionTools) : geminiFunctionTools;
@@ -3581,6 +4366,7 @@ async function runToolLoop(request) {
           },
           async () => {
             const { result, outputPayload } = await executeToolCall({
+              callKind: "function",
               toolName: entry.toolName,
               tool: request.tools[entry.toolName],
               rawInput: entry.rawInput
@@ -3858,11 +4644,1880 @@ function appendMarkdownSourcesSection(value, sources) {
 ## Sources
 ${lines}`;
 }
+
+// src/tools/filesystemTools.ts
+import path5 from "path";
+import { z as z5 } from "zod";
+
+// src/tools/applyPatch.ts
+import path4 from "path";
+import { z as z4 } from "zod";
+
+// src/tools/filesystem.ts
+import { promises as fs3 } from "fs";
+import path3 from "path";
+var InMemoryAgentFilesystem = class {
+  #files = /* @__PURE__ */ new Map();
+  #dirs = /* @__PURE__ */ new Map();
+  #clock = 0;
+  constructor(initialFiles = {}) {
+    const root = path3.resolve("/");
+    this.#dirs.set(root, { mtimeMs: this.#nextMtime() });
+    for (const [filePath, content] of Object.entries(initialFiles)) {
+      const absolutePath = path3.resolve(filePath);
+      this.#ensureDirSync(path3.dirname(absolutePath));
+      this.#files.set(absolutePath, {
+        content,
+        mtimeMs: this.#nextMtime()
+      });
+    }
+  }
+  async readTextFile(filePath) {
+    const absolutePath = path3.resolve(filePath);
+    const file = this.#files.get(absolutePath);
+    if (!file) {
+      throw createNoSuchFileError("open", absolutePath);
+    }
+    return file.content;
+  }
+  async writeTextFile(filePath, content) {
+    const absolutePath = path3.resolve(filePath);
+    const parentPath = path3.dirname(absolutePath);
+    if (!this.#dirs.has(parentPath)) {
+      throw createNoSuchFileError("open", parentPath);
+    }
+    this.#files.set(absolutePath, { content, mtimeMs: this.#nextMtime() });
+  }
+  async deleteFile(filePath) {
+    const absolutePath = path3.resolve(filePath);
+    if (!this.#files.delete(absolutePath)) {
+      throw createNoSuchFileError("unlink", absolutePath);
+    }
+  }
+  async ensureDir(directoryPath) {
+    this.#ensureDirSync(path3.resolve(directoryPath));
+  }
+  async readDir(directoryPath) {
+    const absolutePath = path3.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 (path3.dirname(dirPath) !== absolutePath) {
+        continue;
+      }
+      const name = path3.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 (path3.dirname(filePath) !== absolutePath) {
+        continue;
+      }
+      const name = path3.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 = path3.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 = path3.resolve(directoryPath);
+    const parts = [];
+    let cursor = absolutePath;
+    for (; ; ) {
+      if (this.#dirs.has(cursor)) {
+        break;
+      }
+      parts.push(cursor);
+      const parent = path3.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) => fs3.readFile(filePath, "utf8"),
+    writeTextFile: async (filePath, content) => fs3.writeFile(filePath, content, "utf8"),
+    deleteFile: async (filePath) => fs3.unlink(filePath),
+    ensureDir: async (directoryPath) => {
+      await fs3.mkdir(directoryPath, { recursive: true });
+    },
+    readDir: async (directoryPath) => {
+      const entries = await fs3.readdir(directoryPath, { withFileTypes: true });
+      const result = [];
+      for (const entry of entries) {
+        const entryPath = path3.resolve(directoryPath, entry.name);
+        const stats = await fs3.lstat(entryPath);
+        result.push({
+          name: entry.name,
+          path: entryPath,
+          kind: statsToKind(stats),
+          mtimeMs: stats.mtimeMs
+        });
+      }
+      return result;
+    },
+    stat: async (entryPath) => {
+      const stats = await fs3.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 CODEX_APPLY_PATCH_INPUT_DESCRIPTION = "The entire contents of the apply_patch command";
+var CODEX_APPLY_PATCH_FREEFORM_TOOL_DESCRIPTION = "Use the `apply_patch` tool to edit files. This is a FREEFORM tool, so do not wrap the patch in JSON.";
+var CODEX_APPLY_PATCH_LARK_GRAMMAR = [
+  "start: begin_patch hunk+ end_patch",
+  'begin_patch: "*** Begin Patch" LF',
+  'end_patch: "*** End Patch" LF?',
+  "",
+  "hunk: add_hunk | delete_hunk | update_hunk",
+  'add_hunk: "*** Add File: " filename LF add_line+',
+  'delete_hunk: "*** Delete File: " filename LF',
+  'update_hunk: "*** Update File: " filename LF change_move? change?',
+  "",
+  "filename: /(.+)/",
+  'add_line: "+" /(.*)/ LF -> line',
+  "",
+  'change_move: "*** Move to: " filename LF',
+  "change: (change_context | change_line)+ eof_line?",
+  'change_context: ("@@" | "@@ " /(.+)/) LF',
+  'change_line: ("+" | "-" | " ") /(.*)/ LF',
+  'eof_line: "*** End of File" LF',
+  "",
+  "%import common.LF"
+].join("\n");
+var CODEX_APPLY_PATCH_JSON_TOOL_DESCRIPTION = [
+  "Use the `apply_patch` tool to edit files.",
+  "Your patch language is a stripped\u2011down, file\u2011oriented diff format designed to be easy to parse and safe to apply. You can think of it as a high\u2011level envelope:",
+  "",
+  "*** Begin Patch",
+  "[ one or more file sections ]",
+  "*** End Patch",
+  "",
+  "Within that envelope, you get a sequence of file operations.",
+  "You MUST include a header to specify the action you are taking.",
+  "Each operation starts with one of three headers:",
+  "",
+  "*** Add File: <path> - create a new file. Every following line is a + line (the initial contents).",
+  "*** Delete File: <path> - remove an existing file. Nothing follows.",
+  "*** Update File: <path> - patch an existing file in place (optionally with a rename).",
+  "",
+  "May be immediately followed by *** Move to: <new path> if you want to rename the file.",
+  "Then one or more \u201Chunks\u201D, each introduced by @@ (optionally followed by a hunk header).",
+  "Within a hunk each line starts with:",
+  "",
+  "For instructions on [context_before] and [context_after]:",
+  "- By default, show 3 lines of code immediately above and 3 lines immediately below each change. If a change is within 3 lines of a previous change, do NOT duplicate the first change\u2019s [context_after] lines in the second change\u2019s [context_before] lines.",
+  "- If 3 lines of context is insufficient to uniquely identify the snippet of code within the file, use the @@ operator to indicate the class or function to which the snippet belongs. For instance, we might have:",
+  "@@ class BaseClass",
+  "[3 lines of pre-context]",
+  "- [old_code]",
+  "+ [new_code]",
+  "[3 lines of post-context]",
+  "",
+  "- If a code block is repeated so many times in a class or function such that even a single `@@` statement and 3 lines of context cannot uniquely identify the snippet of code, you can use multiple `@@` statements to jump to the right context. For instance:",
+  "",
+  "@@ class BaseClass",
+  "@@ 	 def method():",
+  "[3 lines of pre-context]",
+  "- [old_code]",
+  "+ [new_code]",
+  "[3 lines of post-context]",
+  "",
+  "The full grammar definition is below:",
+  "Patch := Begin { FileOp } End",
+  'Begin := "*** Begin Patch" NEWLINE',
+  'End := "*** End Patch" NEWLINE',
+  "FileOp := AddFile | DeleteFile | UpdateFile",
+  'AddFile := "*** Add File: " path NEWLINE { "+" line NEWLINE }',
+  'DeleteFile := "*** Delete File: " path NEWLINE',
+  'UpdateFile := "*** Update File: " path NEWLINE [ MoveTo ] { Hunk }',
+  'MoveTo := "*** Move to: " newPath NEWLINE',
+  'Hunk := "@@" [ header ] NEWLINE { HunkLine } [ "*** End of File" NEWLINE ]',
+  'HunkLine := (" " | "-" | "+") text NEWLINE',
+  "",
+  "A full patch can combine several operations:",
+  "",
+  "*** Begin Patch",
+  "*** Add File: hello.txt",
+  "+Hello world",
+  "*** Update File: src/app.py",
+  "*** Move to: src/main.py",
+  "@@ def greet():",
+  '-print("Hi")',
+  '+print("Hello, world!")',
+  "*** Delete File: obsolete.txt",
+  "*** End Patch",
+  "",
+  "It is important to remember:",
+  "",
+  "- You must include a header with your intended action (Add/Delete/Update)",
+  "- You must prefix new lines with `+` even when creating a new file",
+  "- File references can only be relative, NEVER ABSOLUTE."
+].join("\n");
+var applyPatchToolInputSchema = z4.object({
+  input: z4.string().min(1).describe(CODEX_APPLY_PATCH_INPUT_DESCRIPTION)
+});
+function createApplyPatchTool(options = {}) {
+  return tool({
+    description: options.description ?? CODEX_APPLY_PATCH_JSON_TOOL_DESCRIPTION,
+    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 = path4.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(path4.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(path4.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 = path4.isAbsolute(trimmed) ? path4.resolve(trimmed) : path4.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 = path4.relative(cwd, candidatePath);
+  return relative === "" || !relative.startsWith("..") && !path4.isAbsolute(relative);
+}
+function toDisplayPath(absolutePath, cwd) {
+  const relative = path4.relative(cwd, absolutePath);
+  if (relative === "") {
+    return ".";
+  }
+  if (!relative.startsWith("..") && !path4.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_READ_FILES_LINE_LIMIT = 200;
+var DEFAULT_READ_FILES_CHAR_LIMIT = 4e3;
+var DEFAULT_LIST_DIR_LIMIT = 25;
+var DEFAULT_LIST_DIR_DEPTH = 2;
+var DEFAULT_GREP_LIMIT = 100;
+var MAX_GREP_LIMIT = 2e3;
+var 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).describe(CODEX_APPLY_PATCH_INPUT_DESCRIPTION)
+});
+var geminiReadFileInputSchema = z5.object({
+  file_path: z5.string().min(1),
+  offset: z5.number().int().min(0).nullish(),
+  limit: z5.number().int().min(1).nullish()
+});
+var geminiReadFilesInputSchema = z5.object({
+  paths: z5.array(z5.string().min(1)).min(1),
+  line_offset: z5.number().int().min(0).nullish(),
+  line_limit: z5.number().int().min(1).nullish(),
+  char_offset: z5.number().int().min(0).nullish(),
+  char_limit: z5.number().int().min(1).nullish(),
+  include_line_numbers: z5.boolean().nullish()
+}).superRefine((value, context) => {
+  const hasLineWindow = value.line_offset !== void 0 || value.line_limit !== void 0;
+  const hasCharWindow = value.char_offset !== void 0 || value.char_limit !== void 0;
+  if (hasLineWindow && hasCharWindow) {
+    context.addIssue({
+      code: z5.ZodIssueCode.custom,
+      message: "Use either line_* or char_* window arguments, not both."
+    });
+  }
+});
+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).nullish()
+});
+var geminiListDirectoryInputSchema = z5.object({
+  dir_path: z5.string().min(1),
+  ignore: z5.array(z5.string()).nullish(),
+  file_filtering_options: z5.object({
+    respect_git_ignore: z5.boolean().nullish(),
+    respect_gemini_ignore: z5.boolean().nullish()
+  }).nullish()
+});
+var geminiRgSearchInputSchema = z5.object({
+  pattern: z5.string().min(1),
+  path: z5.string().nullish(),
+  glob: z5.string().nullish(),
+  case_sensitive: z5.boolean().nullish(),
+  exclude_pattern: z5.string().nullish(),
+  names_only: z5.boolean().nullish(),
+  max_matches_per_file: z5.number().int().min(1).nullish(),
+  max_results: z5.number().int().min(1).nullish()
+});
+var geminiGrepSearchInputSchema = z5.object({
+  pattern: z5.string().min(1),
+  dir_path: z5.string().nullish(),
+  include: z5.string().nullish(),
+  exclude_pattern: z5.string().nullish(),
+  names_only: z5.boolean().nullish(),
+  max_matches_per_file: z5.number().int().min(1).nullish(),
+  total_max_matches: z5.number().int().min(1).nullish()
+});
+var geminiGlobInputSchema = z5.object({
+  pattern: z5.string().min(1),
+  dir_path: z5.string().nullish(),
+  case_sensitive: z5.boolean().nullish(),
+  respect_git_ignore: z5.boolean().nullish(),
+  respect_gemini_ignore: z5.boolean().nullish()
+});
+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: createGeminiReadFileTool(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 customTool({
+    description: CODEX_APPLY_PATCH_FREEFORM_TOOL_DESCRIPTION,
+    format: {
+      type: "grammar",
+      syntax: "lark",
+      definition: CODEX_APPLY_PATCH_LARK_GRAMMAR
+    },
+    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 createGeminiReadFileTool(options = {}) {
+  return tool({
+    description: "Reads and returns the content of a specified file. Supports optional 0-based line offset and line limit.",
+    inputSchema: geminiReadFileInputSchema,
+    execute: async (input) => readFileGemini(input, options)
+  });
+}
+function createReadFilesTool(options = {}) {
+  return tool({
+    description: "Reads one or more files with optional line-based or character-based slicing, similar to a controlled head/tail view.",
+    inputSchema: geminiReadFilesInputSchema,
+    execute: async (input) => readFilesGemini(input, options)
+  });
+}
+function createWriteFileTool(options = {}) {
+  return tool({
+    description: "Writes content to a specified file in the local filesystem.",
+    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 createRgSearchTool(options = {}) {
+  return tool({
+    description: "Searches for a regex pattern within file contents.",
+    inputSchema: geminiRgSearchInputSchema,
+    execute: async (input) => rgSearchGemini(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 (!path5.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 (!path5.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);
+  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).map(
+    (line, index) => `L${offset + index + 1}: ${truncateAtCodePointBoundary(line ?? "", runtime.maxLineLength)}`
+  ).join("\n");
+}
+async function readFilesGemini(input, options) {
+  const runtime = resolveRuntime(options);
+  const useCharWindow = input.char_offset !== void 0 || input.char_limit !== void 0;
+  const lineOffset = Math.max(0, input.line_offset ?? 0);
+  const lineLimit = input.line_limit ?? DEFAULT_READ_FILES_LINE_LIMIT;
+  const charOffset = Math.max(0, input.char_offset ?? 0);
+  const charLimit = input.char_limit ?? DEFAULT_READ_FILES_CHAR_LIMIT;
+  const includeLineNumbers = input.include_line_numbers !== false;
+  const sections = [];
+  for (const rawPath of input.paths) {
+    const filePath = resolvePathWithPolicy(rawPath, runtime.cwd, runtime.allowOutsideCwd);
+    await runAccessHook2(runtime, {
+      cwd: runtime.cwd,
+      tool: "read_files",
+      action: "read",
+      path: filePath
+    });
+    const content = await runtime.filesystem.readTextFile(filePath);
+    const displayPath = normalizeSlashes(toDisplayPath2(filePath, runtime.cwd));
+    sections.push(`==> ${displayPath} <==`);
+    if (useCharWindow) {
+      if (charOffset >= content.length) {
+        sections.push("");
+        continue;
+      }
+      const end2 = Math.min(content.length, charOffset + charLimit);
+      sections.push(content.slice(charOffset, end2));
+      continue;
+    }
+    const lines = splitLines(content);
+    if (lineOffset >= lines.length) {
+      sections.push("");
+      continue;
+    }
+    const end = Math.min(lines.length, lineOffset + lineLimit);
+    const selected = lines.slice(lineOffset, end);
+    if (includeLineNumbers) {
+      for (let index = 0; index < selected.length; index += 1) {
+        const lineNumber = lineOffset + index + 1;
+        const line = selected[index] ?? "";
+        sections.push(
+          `L${lineNumber}: ${truncateAtCodePointBoundary(line, runtime.maxLineLength)}`
+        );
+      }
+      continue;
+    }
+    sections.push(selected.join("\n"));
+  }
+  return sections.join("\n");
+}
+async function writeFileGemini(input, options) {
+  const runtime = resolveRuntime(options);
+  const filePath = resolvePathWithPolicy(input.file_path, runtime.cwd, runtime.allowOutsideCwd);
+  await runAccessHook2(runtime, {
+    cwd: runtime.cwd,
+    tool: "write_file",
+    action: "write",
+    path: filePath
+  });
+  await runtime.filesystem.ensureDir(path5.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(path5.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 rgSearchGemini(input, options, toolName = "rg_search") {
+  const runtime = resolveRuntime(options);
+  const pattern = input.pattern.trim();
+  if (pattern.length === 0) {
+    throw new Error("pattern must not be empty");
+  }
+  const glob = input.glob?.trim();
+  const searchPath = resolvePathWithPolicy(
+    input.path ?? runtime.cwd,
+    runtime.cwd,
+    runtime.allowOutsideCwd
+  );
+  await runAccessHook2(runtime, {
+    cwd: runtime.cwd,
+    tool: toolName,
+    action: "search",
+    path: searchPath,
+    pattern,
+    include: glob
+  });
+  const searchPathInfo = await runtime.filesystem.stat(searchPath);
+  const filesToScan = await collectSearchFiles({
+    filesystem: runtime.filesystem,
+    searchPath,
+    rootKind: searchPathInfo.kind,
+    maxScannedFiles: runtime.grepMaxScannedFiles
+  });
+  const matcher = glob ? createGlobMatcher(glob) : null;
+  const patternRegex = compileRegex(pattern, input.case_sensitive === true ? "m" : "im");
+  const excludeRegex = input.exclude_pattern ? compileRegex(input.exclude_pattern) : null;
+  const totalMaxMatches = input.max_results ?? 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 grepSearchGemini(input, options) {
+  return rgSearchGemini(
+    {
+      pattern: input.pattern,
+      path: input.dir_path,
+      glob: input.include,
+      exclude_pattern: input.exclude_pattern,
+      names_only: input.names_only,
+      max_matches_per_file: input.max_matches_per_file,
+      max_results: input.total_max_matches
+    },
+    options,
+    "grep_search"
+  );
+}
+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(path5.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(toDisplayPath2(entry.filePath, runtime.cwd))).join("\n");
+}
+function resolveRuntime(options) {
+  return {
+    cwd: path5.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 = path5.isAbsolute(inputPath) ? path5.resolve(inputPath) : path5.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 = path5.relative(cwd, candidatePath);
+  return relative === "" || !relative.startsWith("..") && !path5.isAbsolute(relative);
+}
+function toDisplayPath2(absolutePath, cwd) {
+  const relative = path5.relative(cwd, absolutePath);
+  if (relative === "") {
+    return ".";
+  }
+  if (!relative.startsWith("..") && !path5.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, flags = "m") {
+  try {
+    return new RegExp(pattern, flags);
+  } 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 = path5.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 {
+  CODEX_APPLY_PATCH_FREEFORM_TOOL_DESCRIPTION,
+  CODEX_APPLY_PATCH_JSON_TOOL_DESCRIPTION,
+  CODEX_APPLY_PATCH_LARK_GRAMMAR,
+  FIREWORKS_DEFAULT_GLM_MODEL,
+  FIREWORKS_DEFAULT_KIMI_MODEL,
+  FIREWORKS_DEFAULT_MINIMAX_MODEL,
+  FIREWORKS_MODEL_IDS,
+  InMemoryAgentFilesystem,
   LlmJsonCallError,
   appendMarkdownSourcesSection,
+  applyPatch,
   configureGemini,
   convertGooglePartsToLlmParts,
+  createApplyPatchTool,
+  createCodexApplyPatchTool,
+  createCodexFilesystemToolSet,
+  createCodexReadFileTool,
+  createFilesystemToolSetForModel,
+  createGeminiFilesystemToolSet,
+  createGeminiReadFileTool,
+  createGlobTool,
+  createGrepFilesTool,
+  createGrepSearchTool,
+  createInMemoryAgentFilesystem,
+  createListDirTool,
+  createListDirectoryTool,
+  createModelAgnosticFilesystemToolSet,
+  createNodeAgentFilesystem,
+  createReadFilesTool,
+  createReplaceTool,
+  createRgSearchTool,
+  createWriteFileTool,
+  customTool,
   encodeChatGptAuthJson,
   encodeChatGptAuthJsonB64,
   estimateCallCostUsd,
@@ -3873,11 +6528,15 @@ export {
   generateText,
   getChatGptAuthProfile,
   getCurrentToolCallContext,
+  isFireworksModelId,
   isGeminiModelId,
   loadEnvFromFile,
   loadLocalEnv,
   parseJsonFromLlmText,
   refreshChatGptOauthToken,
+  resolveFilesystemToolProfile,
+  resolveFireworksModelId,
+  runAgentLoop,
   runToolLoop,
   sanitisePartForLogging,
   streamJson,