@ljoukov/llm 2.1.0 → 3.0.0

package/dist/index.js

@@ -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,
@@ -130,12 +159,15 @@ var OPENAI_GPT_53_CODEX_PRICING = {
   cachedRate: 0.125 / 1e6,
   outputRate: 10 / 1e6
 };
-var OPENAI_GPT_51_CODEX_MINI_PRICING = {
+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;
   }
@@ -145,8 +177,11 @@ function getOpenAiPricing(modelId) {
   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;
 }
@@ -207,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;
@@ -219,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 as Buffer2 } from "buffer";
+import fs2 from "fs";
+import os from "os";
+import path2 from "path";
 import { z } from "zod";
 
 // src/utils/env.ts
@@ -288,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),
@@ -330,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,
@@ -368,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);
@@ -385,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;
   }
@@ -396,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 {
@@ -406,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 = {};
   }
-  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);
+  if (!doc.tokens || typeof doc.tokens !== "object") {
+    doc.tokens = {};
+  }
+  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) {
@@ -467,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 = Buffer2.from(rawB64.trim(), "base64url").toString("utf8");
-    return normalizeAuthProfile(AuthInputSchema.parse(JSON.parse(decoded)));
-  }
-  const access = process.env[CHATGPT_ACCESS_ENV] ?? process.env[CHATGPT_ACCESS_TOKEN_ENV] ?? void 0;
-  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) {
@@ -522,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
@@ -559,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();
@@ -568,6 +737,7 @@ async function collectChatGptCodexResponse(options) {
   const reasoningText = "";
   let reasoningSummaryText = "";
   let usage;
+  let responseId;
   let model;
   let status;
   let blocked = false;
@@ -608,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 : "";
@@ -630,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;
       }
@@ -639,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;
       }
@@ -648,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;
       }
@@ -665,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) {
@@ -821,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";
 
@@ -889,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"
@@ -1128,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,
@@ -1144,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;
@@ -1191,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
@@ -1232,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);
@@ -1578,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) {
@@ -1607,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;
@@ -2189,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;
@@ -2362,6 +2755,41 @@ function extractChatGptUsageTokens(usage) {
     totalTokens
   };
 }
+function extractFireworksUsageTokens(usage) {
+  if (!usage || typeof usage !== "object") {
+    return void 0;
+  }
+  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,
@@ -2400,8 +2828,8 @@ function parseOpenAiToolArguments(raw) {
 function formatZodIssues(issues) {
   const messages = [];
   for (const issue of issues) {
-    const path5 = issue.path.length > 0 ? issue.path.map(String).join(".") : "input";
-    messages.push(`${path5}: ${issue.message}`);
+    const path6 = issue.path.length > 0 ? issue.path.map(String).join(".") : "input";
+    messages.push(`${path6}: ${issue.message}`);
   }
   return messages.join("; ");
 }
@@ -2417,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 {
@@ -2425,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 {
@@ -2481,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 };
@@ -2547,7 +3012,7 @@ function extractOpenAiResponseParts(response) {
   }
   return { parts, blocked };
 }
-function extractOpenAiFunctionCalls(output) {
+function extractOpenAiToolCalls(output) {
   const calls = [];
   if (!Array.isArray(output)) {
     return calls;
@@ -2556,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":
@@ -2747,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) => {
@@ -2778,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 = {
@@ -2902,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.");
   }
@@ -3073,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" });
@@ -3093,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) {
@@ -3158,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
@@ -3252,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({
@@ -3268,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 };
       });
@@ -3286,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,
@@ -3299,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,
@@ -3320,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",
@@ -3368,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({
@@ -3385,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(
@@ -3404,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,
@@ -3416,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,
@@ -3443,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;
@@ -3592,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
@@ -3871,26 +4646,26 @@ ${lines}`;
 }
 
 // src/tools/filesystemTools.ts
-import path4 from "path";
+import path5 from "path";
 import { z as z5 } from "zod";
 
 // src/tools/applyPatch.ts
-import path3 from "path";
+import path4 from "path";
 import { z as z4 } from "zod";
 
 // src/tools/filesystem.ts
-import { promises as fs2 } from "fs";
-import path2 from "path";
+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 = path2.resolve("/");
+    const root = path3.resolve("/");
     this.#dirs.set(root, { mtimeMs: this.#nextMtime() });
     for (const [filePath, content] of Object.entries(initialFiles)) {
-      const absolutePath = path2.resolve(filePath);
-      this.#ensureDirSync(path2.dirname(absolutePath));
+      const absolutePath = path3.resolve(filePath);
+      this.#ensureDirSync(path3.dirname(absolutePath));
       this.#files.set(absolutePath, {
         content,
         mtimeMs: this.#nextMtime()
@@ -3898,7 +4673,7 @@ var InMemoryAgentFilesystem = class {
     }
   }
   async readTextFile(filePath) {
-    const absolutePath = path2.resolve(filePath);
+    const absolutePath = path3.resolve(filePath);
     const file = this.#files.get(absolutePath);
     if (!file) {
       throw createNoSuchFileError("open", absolutePath);
@@ -3906,24 +4681,24 @@ var InMemoryAgentFilesystem = class {
     return file.content;
   }
   async writeTextFile(filePath, content) {
-    const absolutePath = path2.resolve(filePath);
-    const parentPath = path2.dirname(absolutePath);
+    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 = path2.resolve(filePath);
+    const absolutePath = path3.resolve(filePath);
     if (!this.#files.delete(absolutePath)) {
       throw createNoSuchFileError("unlink", absolutePath);
     }
   }
   async ensureDir(directoryPath) {
-    this.#ensureDirSync(path2.resolve(directoryPath));
+    this.#ensureDirSync(path3.resolve(directoryPath));
   }
   async readDir(directoryPath) {
-    const absolutePath = path2.resolve(directoryPath);
+    const absolutePath = path3.resolve(directoryPath);
     const directory = this.#dirs.get(absolutePath);
     if (!directory) {
       throw createNoSuchFileError("scandir", absolutePath);
@@ -3934,10 +4709,10 @@ var InMemoryAgentFilesystem = class {
       if (dirPath === absolutePath) {
         continue;
       }
-      if (path2.dirname(dirPath) !== absolutePath) {
+      if (path3.dirname(dirPath) !== absolutePath) {
         continue;
       }
-      const name = path2.basename(dirPath);
+      const name = path3.basename(dirPath);
       if (seenNames.has(name)) {
         continue;
       }
@@ -3950,10 +4725,10 @@ var InMemoryAgentFilesystem = class {
       });
     }
     for (const [filePath, fileRecord] of this.#files.entries()) {
-      if (path2.dirname(filePath) !== absolutePath) {
+      if (path3.dirname(filePath) !== absolutePath) {
         continue;
       }
-      const name = path2.basename(filePath);
+      const name = path3.basename(filePath);
       if (seenNames.has(name)) {
         continue;
       }
@@ -3969,7 +4744,7 @@ var InMemoryAgentFilesystem = class {
     return entries;
   }
   async stat(entryPath) {
-    const absolutePath = path2.resolve(entryPath);
+    const absolutePath = path3.resolve(entryPath);
     const file = this.#files.get(absolutePath);
     if (file) {
       return { kind: "file", mtimeMs: file.mtimeMs };
@@ -3985,7 +4760,7 @@ var InMemoryAgentFilesystem = class {
     return Object.fromEntries(entries.map(([filePath, record]) => [filePath, record.content]));
   }
   #ensureDirSync(directoryPath) {
-    const absolutePath = path2.resolve(directoryPath);
+    const absolutePath = path3.resolve(directoryPath);
     const parts = [];
     let cursor = absolutePath;
     for (; ; ) {
@@ -3993,7 +4768,7 @@ var InMemoryAgentFilesystem = class {
         break;
       }
       parts.push(cursor);
-      const parent = path2.dirname(cursor);
+      const parent = path3.dirname(cursor);
       if (parent === cursor) {
         break;
       }
@@ -4016,18 +4791,18 @@ var InMemoryAgentFilesystem = class {
 };
 function createNodeAgentFilesystem() {
   return {
-    readTextFile: async (filePath) => fs2.readFile(filePath, "utf8"),
-    writeTextFile: async (filePath, content) => fs2.writeFile(filePath, content, "utf8"),
-    deleteFile: async (filePath) => fs2.unlink(filePath),
+    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 fs2.mkdir(directoryPath, { recursive: true });
+      await fs3.mkdir(directoryPath, { recursive: true });
     },
     readDir: async (directoryPath) => {
-      const entries = await fs2.readdir(directoryPath, { withFileTypes: true });
+      const entries = await fs3.readdir(directoryPath, { withFileTypes: true });
       const result = [];
       for (const entry of entries) {
-        const entryPath = path2.resolve(directoryPath, entry.name);
-        const stats = await fs2.lstat(entryPath);
+        const entryPath = path3.resolve(directoryPath, entry.name);
+        const stats = await fs3.lstat(entryPath);
         result.push({
           name: entry.name,
           path: entryPath,
@@ -4038,7 +4813,7 @@ function createNodeAgentFilesystem() {
       return result;
     },
     stat: async (entryPath) => {
-      const stats = await fs2.lstat(entryPath);
+      const stats = await fs3.lstat(entryPath);
       return {
         kind: statsToKind(stats),
         mtimeMs: stats.mtimeMs
@@ -4080,12 +4855,104 @@ 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("The entire apply_patch payload, including Begin/End markers.")
+  input: z4.string().min(1).describe(CODEX_APPLY_PATCH_INPUT_DESCRIPTION)
 });
 function createApplyPatchTool(options = {}) {
   return tool({
-    description: options.description ?? "Apply edits using a Codex-style apply_patch payload with Begin/End markers.",
+    description: options.description ?? CODEX_APPLY_PATCH_JSON_TOOL_DESCRIPTION,
     inputSchema: applyPatchToolInputSchema,
     execute: async ({ input }) => applyPatch({
       patch: input,
@@ -4098,7 +4965,7 @@ function createApplyPatchTool(options = {}) {
   });
 }
 async function applyPatch(request) {
-  const cwd = path3.resolve(request.cwd ?? process.cwd());
+  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");
@@ -4120,7 +4987,7 @@ async function applyPatch(request) {
         kind: "add",
         path: absolutePath2
       });
-      await adapter.ensureDir(path3.dirname(absolutePath2));
+      await adapter.ensureDir(path4.dirname(absolutePath2));
       await adapter.writeTextFile(absolutePath2, operation.content);
       added.push(toDisplayPath(absolutePath2, cwd));
       continue;
@@ -4154,7 +5021,7 @@ async function applyPatch(request) {
         fromPath: absolutePath,
         toPath: destinationPath
       });
-      await adapter.ensureDir(path3.dirname(destinationPath));
+      await adapter.ensureDir(path4.dirname(destinationPath));
       await adapter.writeTextFile(destinationPath, next);
       await adapter.deleteFile(absolutePath);
       modified.push(toDisplayPath(destinationPath, cwd));
@@ -4185,22 +5052,22 @@ function resolvePatchPath(rawPath, cwd, allowOutsideCwd) {
   if (trimmed.length === 0) {
     throw new Error("apply_patch failed: empty file path");
   }
-  const absolutePath = path3.isAbsolute(trimmed) ? path3.resolve(trimmed) : path3.resolve(cwd, trimmed);
+  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 = path3.relative(cwd, candidatePath);
-  return relative === "" || !relative.startsWith("..") && !path3.isAbsolute(relative);
+  const relative = path4.relative(cwd, candidatePath);
+  return relative === "" || !relative.startsWith("..") && !path4.isAbsolute(relative);
 }
 function toDisplayPath(absolutePath, cwd) {
-  const relative = path3.relative(cwd, absolutePath);
+  const relative = path4.relative(cwd, absolutePath);
   if (relative === "") {
     return ".";
   }
-  if (!relative.startsWith("..") && !path3.isAbsolute(relative)) {
+  if (!relative.startsWith("..") && !path4.isAbsolute(relative)) {
     return relative;
   }
   return absolutePath;
@@ -4480,6 +5347,8 @@ function formatSummary(added, modified, deleted) {
 
 // src/tools/filesystemTools.ts
 var DEFAULT_READ_FILE_LINE_LIMIT = 2e3;
+var DEFAULT_READ_FILES_LINE_LIMIT = 200;
+var DEFAULT_READ_FILES_CHAR_LIMIT = 4e3;
 var DEFAULT_LIST_DIR_LIMIT = 25;
 var DEFAULT_LIST_DIR_DEPTH = 2;
 var DEFAULT_GREP_LIMIT = 100;
@@ -4513,12 +5382,29 @@ var codexGrepFilesInputSchema = z5.object({
   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)
+  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).optional(),
-  limit: z5.number().int().min(1).optional()
+  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),
@@ -4529,31 +5415,41 @@ var geminiReplaceInputSchema = z5.object({
   instruction: z5.string().min(1),
   old_string: z5.string(),
   new_string: z5.string(),
-  expected_replacements: z5.number().int().min(1).optional()
+  expected_replacements: z5.number().int().min(1).nullish()
 });
 var geminiListDirectoryInputSchema = z5.object({
   dir_path: z5.string().min(1),
-  ignore: z5.array(z5.string()).optional(),
+  ignore: z5.array(z5.string()).nullish(),
   file_filtering_options: z5.object({
-    respect_git_ignore: z5.boolean().optional(),
-    respect_gemini_ignore: z5.boolean().optional()
-  }).optional()
+    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().optional(),
-  include: z5.string().optional(),
-  exclude_pattern: z5.string().optional(),
-  names_only: z5.boolean().optional(),
-  max_matches_per_file: z5.number().int().min(1).optional(),
-  total_max_matches: z5.number().int().min(1).optional()
+  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().optional(),
-  case_sensitive: z5.boolean().optional(),
-  respect_git_ignore: z5.boolean().optional(),
-  respect_gemini_ignore: z5.boolean().optional()
+  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") {
@@ -4597,7 +5493,7 @@ function createCodexFilesystemToolSet(options = {}) {
 }
 function createGeminiFilesystemToolSet(options = {}) {
   return {
-    read_file: createReadFileTool(options),
+    read_file: createGeminiReadFileTool(options),
     write_file: createWriteFileTool(options),
     replace: createReplaceTool(options),
     list_directory: createListDirectoryTool(options),
@@ -4609,10 +5505,14 @@ function createModelAgnosticFilesystemToolSet(options = {}) {
   return createGeminiFilesystemToolSet(options);
 }
 function createCodexApplyPatchTool(options = {}) {
-  return tool({
-    description: "Use the `apply_patch` tool to edit files. This is a FREEFORM tool, so do not wrap the patch in JSON.",
-    inputSchema: applyPatchInputSchema,
-    execute: async ({ input }) => {
+  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,
@@ -4656,13 +5556,20 @@ function createGrepFilesTool(options = {}) {
     execute: async (input) => grepFilesCodex(input, options)
   });
 }
-function createReadFileTool(options = {}) {
+function createGeminiReadFileTool(options = {}) {
   return tool({
-    description: "Reads and returns content of a specified file.",
+    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.",
@@ -4691,6 +5598,13 @@ function createGrepSearchTool(options = {}) {
     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).",
@@ -4700,7 +5614,7 @@ function createGlobTool(options = {}) {
 }
 async function readFileCodex(input, options) {
   const runtime = resolveRuntime(options);
-  if (!path4.isAbsolute(input.file_path)) {
+  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);
@@ -4751,7 +5665,7 @@ async function readFileCodex(input, options) {
 }
 async function listDirectoryCodex(input, options) {
   const runtime = resolveRuntime(options);
-  if (!path4.isAbsolute(input.dir_path)) {
+  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);
@@ -4848,9 +5762,6 @@ async function readFileGemini(input, options) {
     path: filePath
   });
   const content = await runtime.filesystem.readTextFile(filePath);
-  if (input.offset === void 0 && input.limit === void 0) {
-    return content;
-  }
   const lines = splitLines(content);
   const offset = Math.max(0, input.offset ?? 0);
   const limit = input.limit ?? DEFAULT_READ_FILE_LINE_LIMIT;
@@ -4858,7 +5769,59 @@ async function readFileGemini(input, options) {
     return "";
   }
   const end = Math.min(lines.length, offset + limit);
-  return lines.slice(offset, end).join("\n");
+  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);
@@ -4869,7 +5832,7 @@ async function writeFileGemini(input, options) {
     action: "write",
     path: filePath
   });
-  await runtime.filesystem.ensureDir(path4.dirname(filePath));
+  await runtime.filesystem.ensureDir(path5.dirname(filePath));
   await runtime.filesystem.writeTextFile(filePath, input.content);
   return `Successfully wrote file: ${toDisplayPath2(filePath, runtime.cwd)}`;
 }
@@ -4890,7 +5853,7 @@ async function replaceFileContentGemini(input, options) {
     originalContent = await runtime.filesystem.readTextFile(filePath);
   } catch (error) {
     if (isNoEntError(error) && oldValue.length === 0) {
-      await runtime.filesystem.ensureDir(path4.dirname(filePath));
+      await runtime.filesystem.ensureDir(path5.dirname(filePath));
       await runtime.filesystem.writeTextFile(filePath, newValue);
       return `Successfully wrote new file: ${toDisplayPath2(filePath, runtime.cwd)}`;
     }
@@ -4941,25 +5904,25 @@ async function listDirectoryGemini(input, options) {
     return label;
   }).join("\n");
 }
-async function grepSearchGemini(input, options) {
+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 include = input.include?.trim();
+  const glob = input.glob?.trim();
   const searchPath = resolvePathWithPolicy(
-    input.dir_path ?? runtime.cwd,
+    input.path ?? runtime.cwd,
     runtime.cwd,
     runtime.allowOutsideCwd
   );
   await runAccessHook2(runtime, {
     cwd: runtime.cwd,
-    tool: "grep_search",
+    tool: toolName,
     action: "search",
     path: searchPath,
     pattern,
-    include
+    include: glob
   });
   const searchPathInfo = await runtime.filesystem.stat(searchPath);
   const filesToScan = await collectSearchFiles({
@@ -4968,10 +5931,10 @@ async function grepSearchGemini(input, options) {
     rootKind: searchPathInfo.kind,
     maxScannedFiles: runtime.grepMaxScannedFiles
   });
-  const matcher = include ? createGlobMatcher(include) : null;
-  const patternRegex = compileRegex(pattern);
+  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.total_max_matches ?? DEFAULT_GREP_LIMIT;
+  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();
@@ -5026,6 +5989,21 @@ async function grepSearchGemini(input, options) {
   }
   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(
@@ -5053,7 +6031,7 @@ async function globFilesGemini(input, options) {
   });
   const matched = [];
   for (const filePath of files) {
-    const relativePath = normalizeSlashes(path4.relative(dirPath, filePath));
+    const relativePath = normalizeSlashes(path5.relative(dirPath, filePath));
     if (!matcher(relativePath)) {
       continue;
     }
@@ -5067,11 +6045,11 @@ async function globFilesGemini(input, options) {
     return "No files found.";
   }
   matched.sort((left, right) => right.mtimeMs - left.mtimeMs);
-  return matched.map((entry) => normalizeSlashes(path4.resolve(entry.filePath))).join("\n");
+  return matched.map((entry) => normalizeSlashes(toDisplayPath2(entry.filePath, runtime.cwd))).join("\n");
 }
 function resolveRuntime(options) {
   return {
-    cwd: path4.resolve(options.cwd ?? process.cwd()),
+    cwd: path5.resolve(options.cwd ?? process.cwd()),
     filesystem: options.fs ?? createNodeAgentFilesystem(),
     allowOutsideCwd: options.allowOutsideCwd === true,
     checkAccess: options.checkAccess,
@@ -5102,22 +6080,22 @@ function mapApplyPatchAction(action) {
   return "move";
 }
 function resolvePathWithPolicy(inputPath, cwd, allowOutsideCwd) {
-  const absolutePath = path4.isAbsolute(inputPath) ? path4.resolve(inputPath) : path4.resolve(cwd, inputPath);
+  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 = path4.relative(cwd, candidatePath);
-  return relative === "" || !relative.startsWith("..") && !path4.isAbsolute(relative);
+  const relative = path5.relative(cwd, candidatePath);
+  return relative === "" || !relative.startsWith("..") && !path5.isAbsolute(relative);
 }
 function toDisplayPath2(absolutePath, cwd) {
-  const relative = path4.relative(cwd, absolutePath);
+  const relative = path5.relative(cwd, absolutePath);
   if (relative === "") {
     return ".";
   }
-  if (!relative.startsWith("..") && !path4.isAbsolute(relative)) {
+  if (!relative.startsWith("..") && !path5.isAbsolute(relative)) {
     return relative;
   }
   return absolutePath;
@@ -5327,9 +6305,9 @@ async function collectSearchFiles(params) {
   }
   return files;
 }
-function compileRegex(pattern) {
+function compileRegex(pattern, flags = "m") {
   try {
-    return new RegExp(pattern, "m");
+    return new RegExp(pattern, flags);
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     throw new Error(`invalid regex pattern: ${message}`);
@@ -5344,7 +6322,7 @@ function createGlobMatcher(pattern, caseSensitive = false) {
   }));
   return (candidatePath) => {
     const normalizedPath = normalizeSlashes(candidatePath);
-    const basename = path4.posix.basename(normalizedPath);
+    const basename = path5.posix.basename(normalizedPath);
     return compiled.some(
       (entry) => entry.regex.test(entry.applyToBasename ? basename : normalizedPath)
     );
@@ -5507,6 +6485,13 @@ function mergeToolSets(base, extra) {
   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,
@@ -5519,6 +6504,7 @@ export {
   createCodexReadFileTool,
   createFilesystemToolSetForModel,
   createGeminiFilesystemToolSet,
+  createGeminiReadFileTool,
   createGlobTool,
   createGrepFilesTool,
   createGrepSearchTool,
@@ -5527,9 +6513,11 @@ export {
   createListDirectoryTool,
   createModelAgnosticFilesystemToolSet,
   createNodeAgentFilesystem,
-  createReadFileTool,
+  createReadFilesTool,
   createReplaceTool,
+  createRgSearchTool,
   createWriteFileTool,
+  customTool,
   encodeChatGptAuthJson,
   encodeChatGptAuthJsonB64,
   estimateCallCostUsd,
@@ -5540,12 +6528,14 @@ export {
   generateText,
   getChatGptAuthProfile,
   getCurrentToolCallContext,
+  isFireworksModelId,
   isGeminiModelId,
   loadEnvFromFile,
   loadLocalEnv,
   parseJsonFromLlmText,
   refreshChatGptOauthToken,
   resolveFilesystemToolProfile,
+  resolveFireworksModelId,
   runAgentLoop,
   runToolLoop,
   sanitisePartForLogging,