@ljoukov/llm 0.1.0

package/dist/index.js

@@ -0,0 +1,3412 @@
+// src/llm.ts
+import { Buffer as Buffer2 } from "buffer";
+import { AsyncLocalStorage } from "async_hooks";
+import { randomBytes } from "crypto";
+import {
+  FinishReason,
+  FunctionCallingConfigMode
+} from "@google/genai";
+import { zodToJsonSchema } from "@alcyone-labs/zod-to-json-schema";
+import { z as z3 } from "zod";
+
+// src/utils/asyncQueue.ts
+function createAsyncQueue() {
+  let closed = false;
+  let error = null;
+  const values = [];
+  let pending = null;
+  const push = (value) => {
+    if (closed || error) {
+      return;
+    }
+    if (pending) {
+      const { resolve } = pending;
+      pending = null;
+      resolve({ value, done: false });
+      return;
+    }
+    values.push(value);
+  };
+  const close = () => {
+    if (closed || error) {
+      return;
+    }
+    closed = true;
+    if (pending) {
+      const { resolve } = pending;
+      pending = null;
+      resolve({ value: void 0, done: true });
+    }
+  };
+  const fail = (err) => {
+    if (closed || error) {
+      return;
+    }
+    error = err;
+    if (pending) {
+      const { reject } = pending;
+      pending = null;
+      reject(err);
+    }
+  };
+  async function* iterator() {
+    while (true) {
+      if (error) {
+        throw error;
+      }
+      if (values.length > 0) {
+        yield values.shift();
+        continue;
+      }
+      if (closed) {
+        return;
+      }
+      const next = await new Promise((resolve, reject) => {
+        pending = { resolve, reject };
+      });
+      if (next.done) {
+        return;
+      }
+      yield next.value;
+    }
+  }
+  return { push, close, fail, iterable: iterator() };
+}
+
+// src/google/pricing.ts
+var GEMINI_3_PRO_PREVIEW_PRICING = {
+  threshold: 2e5,
+  inputRateLow: 2 / 1e6,
+  inputRateHigh: 4 / 1e6,
+  cachedRateLow: 0.2 / 1e6,
+  cachedRateHigh: 0.4 / 1e6,
+  outputRateLow: 12 / 1e6,
+  outputRateHigh: 18 / 1e6
+};
+var GEMINI_2_5_PRO_PRICING = {
+  threshold: 2e5,
+  inputRateLow: 1.25 / 1e6,
+  inputRateHigh: 2.5 / 1e6,
+  cachedRateLow: 0.125 / 1e6,
+  cachedRateHigh: 0.25 / 1e6,
+  outputRateLow: 10 / 1e6,
+  outputRateHigh: 15 / 1e6
+};
+var GEMINI_IMAGE_PREVIEW_PRICING = {
+  inputRate: 2 / 1e6,
+  cachedRate: 0.2 / 1e6,
+  outputTextRate: 12 / 1e6,
+  outputImageRate: 120 / 1e6,
+  imagePrices: {
+    "1K": 0.134,
+    "2K": 0.134,
+    "4K": 0.24
+  }
+};
+function getGeminiProPricing(modelId) {
+  if (modelId.includes("gemini-2.5-pro")) {
+    return GEMINI_2_5_PRO_PRICING;
+  }
+  if (modelId.includes("gemini-3-pro")) {
+    return GEMINI_3_PRO_PREVIEW_PRICING;
+  }
+  return void 0;
+}
+function getGeminiImagePricing(modelId) {
+  if (modelId.includes("image-preview")) {
+    return GEMINI_IMAGE_PREVIEW_PRICING;
+  }
+  return void 0;
+}
+
+// src/openai/pricing.ts
+var OPENAI_GPT_52_PRICING = {
+  inputRate: 1.75 / 1e6,
+  cachedRate: 0.175 / 1e6,
+  outputRate: 14 / 1e6
+};
+var OPENAI_GPT_51_CODEX_MINI_PRICING = {
+  inputRate: 0.25 / 1e6,
+  cachedRate: 0.025 / 1e6,
+  outputRate: 2 / 1e6
+};
+function getOpenAiPricing(modelId) {
+  if (modelId.includes("gpt-5.2")) {
+    return OPENAI_GPT_52_PRICING;
+  }
+  if (modelId.includes("gpt-5.1-codex-mini")) {
+    return OPENAI_GPT_51_CODEX_MINI_PRICING;
+  }
+  return void 0;
+}
+
+// src/utils/cost.ts
+function resolveUsageNumber(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return Math.max(0, value);
+  }
+  return 0;
+}
+function estimateCallCostUsd({
+  modelId,
+  tokens,
+  responseImages,
+  imageSize
+}) {
+  if (!tokens) {
+    return 0;
+  }
+  const promptTokens = resolveUsageNumber(tokens.promptTokens);
+  const cachedTokens = resolveUsageNumber(tokens.cachedTokens);
+  const responseTokens = resolveUsageNumber(tokens.responseTokens);
+  const responseImageTokens = resolveUsageNumber(tokens.responseImageTokens);
+  const thinkingTokens = resolveUsageNumber(tokens.thinkingTokens);
+  const toolUsePromptTokens = resolveUsageNumber(tokens.toolUsePromptTokens);
+  const promptTokenTotal = promptTokens + toolUsePromptTokens;
+  const nonCachedPrompt = Math.max(0, promptTokenTotal - cachedTokens);
+  const imagePreviewPricing = getGeminiImagePricing(modelId);
+  if (imagePreviewPricing) {
+    const resolvedImageSize = imageSize && imagePreviewPricing.imagePrices[imageSize] ? imageSize : "2K";
+    const imageRate = imagePreviewPricing.imagePrices[resolvedImageSize] ?? 0;
+    const tokensPerImage = imagePreviewPricing.outputImageRate > 0 ? imageRate / imagePreviewPricing.outputImageRate : 0;
+    let responseTextForPricing = Math.max(0, responseTokens - responseImageTokens);
+    let imageTokensForPricing = responseImageTokens;
+    if (imageTokensForPricing <= 0 && responseImages > 0 && tokensPerImage > 0) {
+      const estimatedImageTokens = responseImages * tokensPerImage;
+      imageTokensForPricing = estimatedImageTokens;
+      if (responseTextForPricing >= estimatedImageTokens) {
+        responseTextForPricing -= estimatedImageTokens;
+      }
+    }
+    const textOutputCost = (responseTextForPricing + thinkingTokens) * imagePreviewPricing.outputTextRate;
+    const inputCost = nonCachedPrompt * imagePreviewPricing.inputRate;
+    const cachedCost = cachedTokens * imagePreviewPricing.cachedRate;
+    const imageOutputCost = imageTokensForPricing * imagePreviewPricing.outputImageRate;
+    return inputCost + cachedCost + textOutputCost + imageOutputCost;
+  }
+  const geminiPricing = getGeminiProPricing(modelId);
+  if (geminiPricing) {
+    const useHighTier = promptTokenTotal > geminiPricing.threshold;
+    const inputRate = useHighTier ? geminiPricing.inputRateHigh : geminiPricing.inputRateLow;
+    const cachedRate = useHighTier ? geminiPricing.cachedRateHigh : geminiPricing.cachedRateLow;
+    const outputRate = useHighTier ? geminiPricing.outputRateHigh : geminiPricing.outputRateLow;
+    const inputCost = nonCachedPrompt * inputRate;
+    const cachedCost = cachedTokens * cachedRate;
+    const outputTokens = responseTokens + thinkingTokens;
+    const outputCost = outputTokens * outputRate;
+    return inputCost + cachedCost + outputCost;
+  }
+  const openAiPricing = getOpenAiPricing(modelId);
+  if (openAiPricing) {
+    const inputCost = nonCachedPrompt * openAiPricing.inputRate;
+    const cachedCost = cachedTokens * openAiPricing.cachedRate;
+    const outputTokens = responseTokens + thinkingTokens;
+    const outputCost = outputTokens * openAiPricing.outputRate;
+    return inputCost + cachedCost + outputCost;
+  }
+  return 0;
+}
+
+// src/openai/chatgpt-codex.ts
+import os from "os";
+import { TextDecoder } from "util";
+
+// src/openai/chatgpt-auth.ts
+import { Buffer } from "buffer";
+import { z } from "zod";
+
+// src/utils/env.ts
+import fs from "fs";
+import path from "path";
+var envLoaded = false;
+function loadLocalEnv() {
+  if (envLoaded) {
+    return;
+  }
+  const envPath = path.join(process.cwd(), ".env.local");
+  loadEnvFromFile(envPath, { override: false });
+  envLoaded = true;
+}
+function loadEnvFromFile(filePath, { override = false } = {}) {
+  let content;
+  try {
+    content = fs.readFileSync(filePath, "utf8");
+  } catch (error) {
+    if (error?.code === "ENOENT") {
+      return;
+    }
+    throw error;
+  }
+  for (const line of content.split(/\r?\n/u)) {
+    const entry = parseEnvLine(line);
+    if (!entry) {
+      continue;
+    }
+    const [key, value] = entry;
+    if (override || process.env[key] === void 0) {
+      process.env[key] = value;
+    }
+  }
+}
+function parseEnvLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed || trimmed.startsWith("#")) {
+    return null;
+  }
+  const match = trimmed.match(/^(?:export\s+)?([A-Za-z_][A-Za-z0-9_\-.]*)\s*=\s*(.*)$/u);
+  if (!match) {
+    return null;
+  }
+  const key = match[1];
+  if (!key) {
+    return null;
+  }
+  let value = match[2] ?? "";
+  if (value.startsWith('"') && value.endsWith('"') && value.length >= 2) {
+    value = value.slice(1, -1);
+  } else if (value.startsWith("'") && value.endsWith("'") && value.length >= 2) {
+    value = value.slice(1, -1);
+  } else {
+    const commentIndex = value.indexOf(" #");
+    if (commentIndex >= 0) {
+      value = value.slice(0, commentIndex);
+    }
+    value = value.trim();
+  }
+  return [key, value];
+}
+
+// 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_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()
+}).loose();
+var RefreshResponseSchema = z.object({
+  access_token: z.string().min(1),
+  refresh_token: z.string().min(1),
+  expires_in: z.union([z.number(), z.string()])
+});
+var ExchangeResponseSchema = z.object({
+  access_token: z.string().min(1),
+  refresh_token: z.string().min(1),
+  expires_in: z.union([z.number(), z.string()]),
+  id_token: z.string().optional()
+});
+var cachedProfile = null;
+var refreshPromise = null;
+function encodeChatGptAuthJson(profile) {
+  const payload = {
+    access: profile.access,
+    refresh: profile.refresh,
+    expires: profile.expires,
+    accountId: profile.accountId,
+    ...profile.idToken ? { id_token: profile.idToken } : {}
+  };
+  return JSON.stringify(payload);
+}
+function encodeChatGptAuthJsonB64(profile) {
+  return Buffer.from(encodeChatGptAuthJson(profile)).toString("base64url");
+}
+async function exchangeChatGptOauthCode({
+  code,
+  verifier,
+  redirectUri = CHATGPT_OAUTH_REDIRECT_URI
+}) {
+  const params = new URLSearchParams();
+  params.set("grant_type", "authorization_code");
+  params.set("client_id", CHATGPT_OAUTH_CLIENT_ID);
+  params.set("code", code);
+  params.set("code_verifier", verifier);
+  params.set("redirect_uri", redirectUri);
+  const response = await fetch(CHATGPT_OAUTH_TOKEN_URL, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded"
+    },
+    body: params.toString()
+  });
+  if (!response.ok) {
+    const body = await response.text();
+    throw new Error(`ChatGPT OAuth token exchange failed (${response.status}): ${body}`);
+  }
+  const payload = ExchangeResponseSchema.parse(await response.json());
+  return profileFromTokenResponse(payload);
+}
+async function refreshChatGptOauthToken(refreshToken) {
+  const params = new URLSearchParams();
+  params.set("grant_type", "refresh_token");
+  params.set("client_id", CHATGPT_OAUTH_CLIENT_ID);
+  params.set("refresh_token", refreshToken);
+  const response = await fetch(CHATGPT_OAUTH_TOKEN_URL, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded"
+    },
+    body: params.toString()
+  });
+  if (!response.ok) {
+    const body = await response.text();
+    throw new Error(`ChatGPT OAuth refresh failed (${response.status}): ${body}`);
+  }
+  const payload = RefreshResponseSchema.parse(await response.json());
+  return profileFromTokenResponse(payload);
+}
+async function getChatGptAuthProfile() {
+  if (cachedProfile && !isExpired(cachedProfile)) {
+    return cachedProfile;
+  }
+  if (refreshPromise) {
+    return refreshPromise;
+  }
+  refreshPromise = (async () => {
+    try {
+      const baseProfile = cachedProfile ?? loadAuthProfileFromEnv();
+      const profile = isExpired(baseProfile) ? await refreshChatGptOauthToken(baseProfile.refresh) : baseProfile;
+      cachedProfile = profile;
+      return profile;
+    } finally {
+      refreshPromise = null;
+    }
+  })();
+  return refreshPromise;
+}
+function profileFromTokenResponse(payload) {
+  const expires = Date.now() + normalizeNumber(payload.expires_in) * 1e3;
+  const accountId = extractChatGptAccountId(payload.id_token ?? "") ?? extractChatGptAccountId(payload.access_token);
+  if (!accountId) {
+    throw new Error("Failed to extract chatgpt_account_id from access token.");
+  }
+  return {
+    access: payload.access_token,
+    refresh: payload.refresh_token,
+    expires,
+    accountId,
+    idToken: payload.id_token
+  };
+}
+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.");
+  }
+  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 (!accountId) {
+    throw new Error("ChatGPT credentials missing chatgpt_account_id.");
+  }
+  return {
+    access,
+    refresh,
+    expires,
+    accountId,
+    idToken: idToken ?? void 0
+  };
+}
+function normalizeEpochMillis(value) {
+  const numeric = normalizeNumber(value);
+  if (!Number.isFinite(numeric)) {
+    return void 0;
+  }
+  return numeric < 1e12 ? numeric * 1e3 : numeric;
+}
+function normalizeNumber(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  if (typeof value === "string") {
+    const parsed = Number.parseFloat(value);
+    if (Number.isFinite(parsed)) {
+      return parsed;
+    }
+  }
+  return Number.NaN;
+}
+function isExpired(profile) {
+  const expires = profile.expires;
+  if (!Number.isFinite(expires)) {
+    return true;
+  }
+  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) {
+    return null;
+  }
+  const payloadB64 = segments[1] ?? "";
+  try {
+    const decoded = Buffer.from(payloadB64, "base64url").toString("utf8");
+    return JSON.parse(decoded);
+  } catch {
+    return null;
+  }
+}
+function extractJwtExpiry(token) {
+  const payload = decodeJwtPayload(token);
+  if (!payload || typeof payload !== "object") {
+    return void 0;
+  }
+  const exp = payload.exp;
+  const parsed = normalizeNumber(exp);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    return void 0;
+  }
+  return parsed < 1e12 ? parsed * 1e3 : parsed;
+}
+function extractChatGptAccountId(token) {
+  const payload = decodeJwtPayload(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;
+}
+
+// src/openai/chatgpt-codex.ts
+var CHATGPT_CODEX_ENDPOINT = "https://chatgpt.com/backend-api/codex/responses";
+async function streamChatGptCodexResponse(options) {
+  const { access, accountId } = await getChatGptAuthProfile();
+  const headers = {
+    Authorization: `Bearer ${access}`,
+    "chatgpt-account-id": accountId,
+    "OpenAI-Beta": "responses=experimental",
+    originator: "llm",
+    "User-Agent": buildUserAgent(),
+    Accept: "text/event-stream",
+    "Content-Type": "application/json"
+  };
+  if (options.sessionId) {
+    headers.session_id = options.sessionId;
+  }
+  const response = await fetch(CHATGPT_CODEX_ENDPOINT, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(options.request),
+    signal: options.signal
+  });
+  if (!response.ok) {
+    const body2 = await response.text();
+    throw new Error(`ChatGPT Codex request failed (${response.status}): ${body2}`);
+  }
+  const body = response.body;
+  if (!body) {
+    throw new Error("ChatGPT Codex response body was empty.");
+  }
+  return parseEventStream(body);
+}
+async function collectChatGptCodexResponse(options) {
+  const stream = await streamChatGptCodexResponse(options);
+  const toolCalls = /* @__PURE__ */ new Map();
+  const toolCallOrder = [];
+  const webSearchCalls = /* @__PURE__ */ new Map();
+  const webSearchCallOrder = [];
+  let text = "";
+  const reasoningText = "";
+  let reasoningSummaryText = "";
+  let usage;
+  let model;
+  let status;
+  let blocked = false;
+  for await (const event of stream) {
+    const type = typeof event.type === "string" ? event.type : void 0;
+    if (type === "response.output_text.delta") {
+      const delta = typeof event.delta === "string" ? event.delta : "";
+      if (delta.length > 0) {
+        text += delta;
+        options.onDelta?.({ textDelta: delta });
+      }
+      continue;
+    }
+    if (type === "response.reasoning_summary_text.delta") {
+      const delta = typeof event.delta === "string" ? event.delta : "";
+      if (delta.length > 0) {
+        reasoningSummaryText += delta;
+        options.onDelta?.({ thoughtDelta: delta });
+      }
+      continue;
+    }
+    if (type === "response.reasoning_text.delta") {
+      continue;
+    }
+    if (type === "response.refusal.delta") {
+      blocked = true;
+      continue;
+    }
+    if (type === "response.output_item.added" || type === "response.output_item.done") {
+      const item = event.item;
+      if (item) {
+        if (item.type === "function_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 args = typeof item.arguments === "string" ? item.arguments : "";
+          if (callId) {
+            if (!toolCalls.has(callId)) {
+              toolCallOrder.push(callId);
+            }
+            toolCalls.set(callId, { id, callId, name, arguments: args });
+          }
+        } else if (item.type === "web_search_call") {
+          const id = typeof item.id === "string" ? item.id : "";
+          if (id) {
+            if (!webSearchCalls.has(id)) {
+              webSearchCallOrder.push(id);
+            }
+            webSearchCalls.set(id, {
+              id,
+              status: typeof item.status === "string" ? item.status : void 0,
+              action: item.action && typeof item.action === "object" ? item.action : void 0
+            });
+          }
+        }
+      }
+      continue;
+    }
+    if (type === "response.completed") {
+      const response = event.response;
+      if (response) {
+        usage = response.usage;
+        model = typeof response.model === "string" ? response.model : void 0;
+        status = typeof response.status === "string" ? response.status : void 0;
+      }
+      continue;
+    }
+    if (type === "response.failed") {
+      const response = event.response;
+      if (response) {
+        usage = response.usage;
+        model = typeof response.model === "string" ? response.model : void 0;
+        status = typeof response.status === "string" ? response.status : void 0;
+      }
+      continue;
+    }
+    if (type === "response.in_progress") {
+      const response = event.response;
+      if (response) {
+        usage = response.usage;
+        model = typeof response.model === "string" ? response.model : void 0;
+        status = typeof response.status === "string" ? response.status : void 0;
+      }
+    }
+  }
+  if (!reasoningSummaryText && reasoningText) {
+    reasoningSummaryText = reasoningText;
+  }
+  const orderedToolCalls = toolCallOrder.map((id) => toolCalls.get(id)).filter((call) => call !== void 0);
+  const orderedWebSearchCalls = webSearchCallOrder.map((id) => webSearchCalls.get(id)).filter((call) => call !== void 0);
+  return {
+    text,
+    reasoningText,
+    reasoningSummaryText,
+    toolCalls: orderedToolCalls,
+    webSearchCalls: orderedWebSearchCalls,
+    usage,
+    model,
+    status,
+    blocked
+  };
+}
+function buildUserAgent() {
+  const node = process.version;
+  const platform = os.platform();
+  const release = os.release();
+  return `@ljoukov/llm (node ${node}; ${platform} ${release})`;
+}
+async function* parseEventStream(stream) {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) {
+      break;
+    }
+    buffer += decoder.decode(value, { stream: true });
+    let sepIndex = buffer.indexOf("\n\n");
+    while (sepIndex !== -1) {
+      const raw = buffer.slice(0, sepIndex);
+      buffer = buffer.slice(sepIndex + 2);
+      const event = parseEventBlock(raw);
+      if (event) {
+        yield event;
+      }
+      sepIndex = buffer.indexOf("\n\n");
+    }
+  }
+  if (buffer.trim().length > 0) {
+    const event = parseEventBlock(buffer);
+    if (event) {
+      yield event;
+    }
+  }
+}
+function parseEventBlock(raw) {
+  const lines = raw.split(/\r?\n/u).map((line) => line.trimEnd()).filter(Boolean);
+  const dataLines = lines.filter((line) => line.startsWith("data:")).map((line) => line.slice("data:".length).trimStart());
+  if (dataLines.length === 0) {
+    return null;
+  }
+  const payload = dataLines.join("\n");
+  if (payload === "[DONE]") {
+    return null;
+  }
+  try {
+    return JSON.parse(payload);
+  } catch {
+    return null;
+  }
+}
+
+// src/utils/scheduler.ts
+function sleep(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+function toError(value) {
+  if (value instanceof Error) {
+    return value;
+  }
+  if (typeof value === "string") {
+    return new Error(value);
+  }
+  return new Error("Unknown error");
+}
+function createCallScheduler(options = {}) {
+  const maxParallelRequests = Math.max(1, Math.floor(options.maxParallelRequests ?? 3));
+  const minIntervalBetweenStartMs = Math.max(0, Math.floor(options.minIntervalBetweenStartMs ?? 0));
+  const startJitterMs = Math.max(0, Math.floor(options.startJitterMs ?? 0));
+  const retryPolicy = options.retry;
+  let activeCount = 0;
+  let lastStartTime = 0;
+  let startSpacingChain = Promise.resolve();
+  const queue = [];
+  async function applyStartSpacing() {
+    const previous = startSpacingChain;
+    let release;
+    startSpacingChain = new Promise((resolve) => {
+      release = resolve;
+    });
+    await previous;
+    try {
+      if (lastStartTime > 0 && minIntervalBetweenStartMs > 0) {
+        const earliestNext = lastStartTime + minIntervalBetweenStartMs;
+        const wait = Math.max(0, earliestNext - Date.now());
+        if (wait > 0) {
+          await sleep(wait);
+        }
+      }
+      if (startJitterMs > 0) {
+        await sleep(Math.floor(Math.random() * (startJitterMs + 1)));
+      }
+      lastStartTime = Date.now();
+    } finally {
+      release?.();
+    }
+  }
+  async function attemptWithRetries(fn, attempt) {
+    try {
+      await applyStartSpacing();
+      return await fn();
+    } catch (error) {
+      const err = toError(error);
+      if (!retryPolicy || attempt >= retryPolicy.maxAttempts) {
+        throw err;
+      }
+      let delay = retryPolicy.getDelayMs(attempt, error);
+      if (delay === null) {
+        throw err;
+      }
+      if (!Number.isFinite(delay)) {
+        delay = 0;
+      }
+      const normalizedDelay = Math.max(0, delay);
+      if (normalizedDelay > 0) {
+        await sleep(normalizedDelay);
+      }
+      return attemptWithRetries(fn, attempt + 1);
+    }
+  }
+  function drainQueue() {
+    while (activeCount < maxParallelRequests && queue.length > 0) {
+      const task = queue.shift();
+      if (!task) {
+        continue;
+      }
+      activeCount += 1;
+      void task();
+    }
+  }
+  function run(fn) {
+    return new Promise((resolve, reject) => {
+      const job = async () => {
+        try {
+          const result = await attemptWithRetries(fn, 1);
+          resolve(result);
+        } catch (error) {
+          reject(toError(error));
+        } finally {
+          activeCount -= 1;
+          queueMicrotask(drainQueue);
+        }
+      };
+      queue.push(job);
+      drainQueue();
+    });
+  }
+  return { run };
+}
+
+// src/google/client.ts
+import { GoogleGenAI } from "@google/genai";
+
+// src/google/auth.ts
+import { GoogleAuth } from "google-auth-library";
+import { z as z2 } from "zod";
+var ServiceAccountSchema = z2.object({
+  project_id: z2.string().min(1),
+  client_email: z2.email(),
+  private_key: z2.string().min(1),
+  token_uri: z2.string().optional()
+}).transform(({ project_id, client_email, private_key, token_uri }) => ({
+  projectId: project_id,
+  clientEmail: client_email,
+  privateKey: private_key.replace(/\\n/g, "\n"),
+  tokenUri: token_uri
+}));
+var cachedServiceAccount = null;
+function parseGoogleServiceAccount(input) {
+  let parsed;
+  try {
+    parsed = JSON.parse(input);
+  } catch (error) {
+    throw new Error(`Invalid Google service account JSON: ${error.message}`);
+  }
+  return ServiceAccountSchema.parse(parsed);
+}
+function getGoogleServiceAccount() {
+  if (cachedServiceAccount) {
+    return cachedServiceAccount;
+  }
+  loadLocalEnv();
+  const raw = process.env.GOOGLE_SERVICE_ACCOUNT_JSON;
+  if (!raw || raw.trim().length === 0) {
+    throw new Error("GOOGLE_SERVICE_ACCOUNT_JSON must be provided for Google APIs access.");
+  }
+  cachedServiceAccount = parseGoogleServiceAccount(raw);
+  return cachedServiceAccount;
+}
+function normaliseScopes(scopes) {
+  if (!scopes) {
+    return void 0;
+  }
+  if (typeof scopes === "string") {
+    return [scopes];
+  }
+  if (scopes.length === 0) {
+    return void 0;
+  }
+  return Array.from(new Set(scopes)).sort();
+}
+function getGoogleAuthOptions(scopes) {
+  const serviceAccount = getGoogleServiceAccount();
+  const normalisedScopes = normaliseScopes(scopes);
+  const options = {
+    credentials: {
+      client_email: serviceAccount.clientEmail,
+      private_key: serviceAccount.privateKey
+    },
+    projectId: serviceAccount.projectId,
+    scopes: normalisedScopes
+  };
+  return options;
+}
+
+// src/google/client.ts
+var GEMINI_MODEL_IDS = [
+  "gemini-3-pro-preview",
+  "gemini-2.5-pro",
+  "gemini-flash-latest",
+  "gemini-flash-lite-latest"
+];
+function isGeminiModelId(value) {
+  return GEMINI_MODEL_IDS.includes(value);
+}
+var CLOUD_PLATFORM_SCOPE = "https://www.googleapis.com/auth/cloud-platform";
+var DEFAULT_VERTEX_LOCATION = "global";
+var geminiConfiguration = {};
+var clientPromise;
+function normaliseConfigValue(value) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function configureGemini(options = {}) {
+  const nextProjectId = normaliseConfigValue(options.projectId);
+  const nextLocation = normaliseConfigValue(options.location);
+  geminiConfiguration = {
+    projectId: nextProjectId !== void 0 ? nextProjectId : geminiConfiguration.projectId,
+    location: nextLocation !== void 0 ? nextLocation : geminiConfiguration.location
+  };
+  clientPromise = void 0;
+}
+function resolveProjectId() {
+  const override = geminiConfiguration.projectId;
+  if (override) {
+    return override;
+  }
+  const serviceAccount = getGoogleServiceAccount();
+  return serviceAccount.projectId;
+}
+function resolveLocation() {
+  const override = geminiConfiguration.location;
+  if (override) {
+    return override;
+  }
+  return DEFAULT_VERTEX_LOCATION;
+}
+async function getGeminiClient() {
+  if (!clientPromise) {
+    clientPromise = Promise.resolve().then(() => {
+      const projectId = resolveProjectId();
+      const location = resolveLocation();
+      const googleAuthOptions = getGoogleAuthOptions(CLOUD_PLATFORM_SCOPE);
+      return new GoogleGenAI({
+        vertexai: true,
+        project: projectId,
+        location,
+        googleAuthOptions
+      });
+    });
+  }
+  return clientPromise;
+}
+
+// src/google/calls.ts
+var RETRYABLE_STATUSES = /* @__PURE__ */ new Set([408, 425, 429, 500, 502, 503, 504]);
+var RETRYABLE_ERROR_CODES = /* @__PURE__ */ new Set(["ECONNRESET", "ETIMEDOUT", "EAI_AGAIN"]);
+var RATE_LIMIT_REASONS = /* @__PURE__ */ new Set(["RATE_LIMIT_EXCEEDED", "RESOURCE_EXHAUSTED", "QUOTA_EXCEEDED"]);
+function getStatus(error) {
+  const maybe = error;
+  const candidates = [maybe?.status, maybe?.statusCode, maybe?.response?.status];
+  for (const value of candidates) {
+    if (typeof value === "number") {
+      return value;
+    }
+    if (typeof value === "string") {
+      const parsed = Number(value);
+      if (!Number.isNaN(parsed)) {
+        return parsed;
+      }
+    }
+  }
+  if (typeof maybe?.code === "number") {
+    return maybe.code;
+  }
+  return void 0;
+}
+function getErrorCode(error) {
+  if (!error || typeof error !== "object") {
+    return void 0;
+  }
+  const maybe = error;
+  if (typeof maybe.code === "string") {
+    return maybe.code;
+  }
+  if (maybe.cause && typeof maybe.cause === "object") {
+    const causeCode = maybe.cause.code;
+    if (typeof causeCode === "string") {
+      return causeCode;
+    }
+  }
+  return void 0;
+}
+function getErrorReason(error) {
+  if (!error || typeof error !== "object") {
+    return void 0;
+  }
+  const details = error.errorDetails;
+  if (Array.isArray(details) && details.length > 0) {
+    const reason = details[0].reason;
+    if (typeof reason === "string") {
+      return reason;
+    }
+  }
+  const cause = error.cause;
+  if (cause && typeof cause === "object") {
+    const nestedDetails = cause.errorDetails;
+    if (Array.isArray(nestedDetails) && nestedDetails.length > 0) {
+      const reason = nestedDetails[0].reason;
+      if (typeof reason === "string") {
+        return reason;
+      }
+    }
+  }
+  return void 0;
+}
+function getErrorMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  if (typeof error === "string") {
+    return error;
+  }
+  return "";
+}
+function parseRetryInfo(details) {
+  if (Array.isArray(details)) {
+    for (const entry of details) {
+      const ms = parseRetryInfo(entry);
+      if (ms !== void 0) {
+        return ms;
+      }
+    }
+    return void 0;
+  }
+  if (!details || typeof details !== "object") {
+    return void 0;
+  }
+  const retryDelay = details.retryDelay;
+  if (retryDelay) {
+    const secondsRaw = retryDelay.seconds;
+    const nanosRaw = retryDelay.nanos;
+    const seconds = typeof secondsRaw === "number" ? secondsRaw : typeof secondsRaw === "string" ? Number.parseFloat(secondsRaw) : 0;
+    const nanos = typeof nanosRaw === "number" ? nanosRaw : typeof nanosRaw === "string" ? Number.parseInt(nanosRaw, 10) : 0;
+    if (Number.isFinite(seconds) || Number.isFinite(nanos)) {
+      const totalMs = seconds * 1e3 + nanos / 1e6;
+      if (totalMs > 0) {
+        return totalMs;
+      }
+    }
+  }
+  const nestedDetails = details.details;
+  if (nestedDetails) {
+    const nested = parseRetryInfo(nestedDetails);
+    if (nested !== void 0) {
+      return nested;
+    }
+  }
+  return void 0;
+}
+function parseRetryAfterFromMessage(message) {
+  const trimmed = message.trim();
+  if (!trimmed) {
+    return void 0;
+  }
+  const regex = /retry in\\s+([0-9]+(?:\\.[0-9]+)?)\\s*(s|sec|secs|seconds?)/iu;
+  const match = regex.exec(trimmed);
+  if (match?.[1]) {
+    const value = Number.parseFloat(match[1]);
+    if (Number.isFinite(value) && value > 0) {
+      return value * 1e3;
+    }
+  }
+  return void 0;
+}
+function getRetryAfterMs(error) {
+  if (!error || typeof error !== "object") {
+    return void 0;
+  }
+  const infoFromDetails = parseRetryInfo(error.errorDetails);
+  if (infoFromDetails !== void 0) {
+    return infoFromDetails;
+  }
+  const cause = error.cause;
+  if (cause && typeof cause === "object") {
+    const nested = getRetryAfterMs(cause);
+    if (nested !== void 0) {
+      return nested;
+    }
+  }
+  const message = getErrorMessage(error);
+  if (message) {
+    const fromMessage = parseRetryAfterFromMessage(message.toLowerCase());
+    if (fromMessage !== void 0) {
+      return fromMessage;
+    }
+  }
+  return void 0;
+}
+function shouldRetry(error) {
+  const status = getStatus(error);
+  if (status && RETRYABLE_STATUSES.has(status)) {
+    return true;
+  }
+  const reason = getErrorReason(error);
+  if (reason && RATE_LIMIT_REASONS.has(reason)) {
+    return true;
+  }
+  const code = getErrorCode(error);
+  if (code && RETRYABLE_ERROR_CODES.has(code)) {
+    return true;
+  }
+  const message = getErrorMessage(error).toLowerCase();
+  if (message.includes("rate limit") || message.includes("temporarily unavailable")) {
+    return true;
+  }
+  if (message.includes("fetch failed") || message.includes("socket hang up")) {
+    return true;
+  }
+  if (message.includes("quota") || message.includes("insufficient")) {
+    return false;
+  }
+  if (message.includes("timeout") || message.includes("network")) {
+    return true;
+  }
+  return false;
+}
+function retryDelayMs(attempt) {
+  const baseRetryDelayMs = 500;
+  const maxRetryDelayMs = 4e3;
+  const base = Math.min(maxRetryDelayMs, baseRetryDelayMs * 2 ** (attempt - 1));
+  const jitter = Math.floor(Math.random() * 200);
+  return base + jitter;
+}
+var scheduler = createCallScheduler({
+  maxParallelRequests: 3,
+  minIntervalBetweenStartMs: 200,
+  startJitterMs: 200,
+  retry: {
+    maxAttempts: 3,
+    getDelayMs: (attempt, error) => {
+      if (!shouldRetry(error)) {
+        return null;
+      }
+      const hintedDelay = getRetryAfterMs(error);
+      return hintedDelay ?? retryDelayMs(attempt);
+    }
+  }
+});
+async function runGeminiCall(fn) {
+  return scheduler.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;
+var DEFAULT_OPENAI_TIMEOUT_MS = 15 * 6e4;
+function resolveOpenAiTimeoutMs() {
+  if (cachedTimeoutMs !== null) {
+    return cachedTimeoutMs;
+  }
+  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;
+}
+function getOpenAiFetch() {
+  if (cachedFetch) {
+    return cachedFetch;
+  }
+  const timeoutMs = resolveOpenAiTimeoutMs();
+  const dispatcher = new Agent({
+    bodyTimeout: timeoutMs,
+    headersTimeout: timeoutMs
+  });
+  cachedFetch = ((input, init) => {
+    return undiciFetch(input, {
+      ...init ?? {},
+      dispatcher
+    });
+  });
+  return cachedFetch;
+}
+function getOpenAiApiKey() {
+  if (cachedApiKey !== null) {
+    return cachedApiKey;
+  }
+  loadLocalEnv();
+  const raw = process.env.OPENAI_API_KEY;
+  const value = raw?.trim();
+  if (!value) {
+    throw new Error("OPENAI_API_KEY must be provided to access OpenAI APIs.");
+  }
+  cachedApiKey = value;
+  return cachedApiKey;
+}
+function getOpenAiClient() {
+  if (cachedClient) {
+    return cachedClient;
+  }
+  const apiKey = getOpenAiApiKey();
+  const timeoutMs = resolveOpenAiTimeoutMs();
+  cachedClient = new OpenAI({
+    apiKey,
+    fetch: getOpenAiFetch(),
+    timeout: timeoutMs
+  });
+  return cachedClient;
+}
+
+// src/openai/calls.ts
+var DEFAULT_OPENAI_REASONING_EFFORT = "medium";
+var scheduler2 = createCallScheduler({
+  maxParallelRequests: 3,
+  minIntervalBetweenStartMs: 200,
+  startJitterMs: 200
+});
+async function runOpenAiCall(fn) {
+  return scheduler2.run(async () => fn(getOpenAiClient()));
+}
+
+// src/llm.ts
+var toolCallContextStorage = new AsyncLocalStorage();
+function getCurrentToolCallContext() {
+  return toolCallContextStorage.getStore() ?? null;
+}
+var LlmJsonCallError = class extends Error {
+  constructor(message, attempts) {
+    super(message);
+    this.attempts = attempts;
+    this.name = "LlmJsonCallError";
+  }
+};
+function tool(options) {
+  return options;
+}
+function isPlainRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function applyNullableJsonSchema(schema) {
+  const anyOf = schema.anyOf;
+  if (Array.isArray(anyOf)) {
+    if (!anyOf.some((entry) => isPlainRecord(entry) && entry.type === "null")) {
+      anyOf.push({ type: "null" });
+    }
+    return;
+  }
+  const type = schema.type;
+  if (typeof type === "string") {
+    schema.type = type === "null" ? "null" : [type, "null"];
+    return;
+  }
+  if (Array.isArray(type)) {
+    const normalized = type.filter((entry) => typeof entry === "string");
+    if (!normalized.includes("null")) {
+      schema.type = [...normalized, "null"];
+    } else {
+      schema.type = normalized;
+    }
+    return;
+  }
+  schema.type = ["null"];
+}
+function orderedJsonSchemaKeys(properties, ordering) {
+  const keys = Object.keys(properties);
+  if (!ordering || ordering.length === 0) {
+    return keys;
+  }
+  const ordered = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const key of ordering) {
+    if (Object.hasOwn(properties, key)) {
+      ordered.push(key);
+      seen.add(key);
+    }
+  }
+  for (const key of keys) {
+    if (!seen.has(key)) {
+      ordered.push(key);
+    }
+  }
+  return ordered;
+}
+function addGeminiPropertyOrdering(schema) {
+  if (!isPlainRecord(schema)) {
+    return schema;
+  }
+  if (typeof schema.$ref === "string") {
+    return { $ref: schema.$ref };
+  }
+  const output = {};
+  for (const [key, value] of Object.entries(schema)) {
+    if (key === "properties") {
+      continue;
+    }
+    if (key === "items") {
+      output.items = isPlainRecord(value) ? addGeminiPropertyOrdering(value) : value;
+      continue;
+    }
+    if (key === "anyOf" || key === "oneOf") {
+      output[key] = Array.isArray(value) ? value.map((entry) => addGeminiPropertyOrdering(entry)) : value;
+      continue;
+    }
+    if (key === "$defs" && isPlainRecord(value)) {
+      const defs = {};
+      for (const [defKey, defValue] of Object.entries(value)) {
+        if (isPlainRecord(defValue)) {
+          defs[defKey] = addGeminiPropertyOrdering(defValue);
+        }
+      }
+      output.$defs = defs;
+      continue;
+    }
+    output[key] = value;
+  }
+  const propertiesRaw = schema.properties;
+  if (isPlainRecord(propertiesRaw)) {
+    const properties = {};
+    for (const [key, value] of Object.entries(propertiesRaw)) {
+      properties[key] = isPlainRecord(value) ? addGeminiPropertyOrdering(value) : value;
+    }
+    output.properties = properties;
+    output.propertyOrdering = Object.keys(properties);
+  }
+  if (schema.nullable) {
+    applyNullableJsonSchema(output);
+  }
+  return output;
+}
+function normalizeOpenAiSchema(schema) {
+  if (!isPlainRecord(schema)) {
+    return schema;
+  }
+  if (typeof schema.$ref === "string") {
+    return { $ref: schema.$ref };
+  }
+  const output = {};
+  for (const [key, value] of Object.entries(schema)) {
+    if (key === "properties") {
+      continue;
+    }
+    if (key === "required") {
+      continue;
+    }
+    if (key === "additionalProperties") {
+      continue;
+    }
+    if (key === "propertyOrdering") {
+      continue;
+    }
+    if (key === "items") {
+      if (isPlainRecord(value)) {
+        output.items = normalizeOpenAiSchema(value);
+      }
+      continue;
+    }
+    if (key === "anyOf" || key === "oneOf") {
+      if (Array.isArray(value)) {
+        output.anyOf = value.map((entry) => normalizeOpenAiSchema(entry));
+      }
+      continue;
+    }
+    if (key === "$defs" && isPlainRecord(value)) {
+      const defs = {};
+      for (const [defKey, defValue] of Object.entries(value)) {
+        if (isPlainRecord(defValue)) {
+          defs[defKey] = normalizeOpenAiSchema(defValue);
+        }
+      }
+      output.$defs = defs;
+      continue;
+    }
+    output[key] = value;
+  }
+  const propertiesRaw = schema.properties;
+  if (isPlainRecord(propertiesRaw)) {
+    const ordering = Array.isArray(schema.propertyOrdering) ? schema.propertyOrdering : void 0;
+    const orderedKeys = orderedJsonSchemaKeys(propertiesRaw, ordering);
+    const properties = {};
+    for (const key of orderedKeys) {
+      const value = propertiesRaw[key];
+      if (!isPlainRecord(value)) {
+        properties[key] = value;
+        continue;
+      }
+      properties[key] = normalizeOpenAiSchema(value);
+    }
+    output.properties = properties;
+    output.required = orderedKeys;
+    output.additionalProperties = false;
+  }
+  const schemaType = schema.type;
+  if (output.additionalProperties === void 0 && (schemaType === "object" || Array.isArray(schemaType) && schemaType.includes("object"))) {
+    output.additionalProperties = false;
+    if (!Array.isArray(output.required)) {
+      output.required = [];
+    }
+  }
+  const normalizeExclusiveBound = (options) => {
+    const exclusiveValue = output[options.exclusiveKey];
+    if (exclusiveValue === false) {
+      delete output[options.exclusiveKey];
+      return;
+    }
+    const inclusiveValue = output[options.inclusiveKey];
+    if (exclusiveValue === true) {
+      if (typeof inclusiveValue === "number" && Number.isFinite(inclusiveValue)) {
+        output[options.exclusiveKey] = inclusiveValue;
+        delete output[options.inclusiveKey];
+      } else {
+        delete output[options.exclusiveKey];
+      }
+      return;
+    }
+    if (typeof exclusiveValue === "number" && Number.isFinite(exclusiveValue)) {
+      delete output[options.inclusiveKey];
+    }
+  };
+  normalizeExclusiveBound({
+    exclusiveKey: "exclusiveMinimum",
+    inclusiveKey: "minimum"
+  });
+  normalizeExclusiveBound({
+    exclusiveKey: "exclusiveMaximum",
+    inclusiveKey: "maximum"
+  });
+  return output;
+}
+function resolveOpenAiSchemaRoot(schema) {
+  if (!isPlainRecord(schema)) {
+    return schema;
+  }
+  if (typeof schema.$ref !== "string") {
+    return schema;
+  }
+  const refMatch = /^#\/(definitions|[$]defs)\/(.+)$/u.exec(schema.$ref);
+  if (!refMatch) {
+    return schema;
+  }
+  const section = refMatch[1];
+  const key = refMatch[2];
+  if (!section || !key) {
+    return schema;
+  }
+  const defsSource = section === "definitions" ? schema.definitions : schema.$defs;
+  if (!isPlainRecord(defsSource)) {
+    return schema;
+  }
+  const resolved = defsSource[key];
+  if (!isPlainRecord(resolved)) {
+    return schema;
+  }
+  return { ...resolved };
+}
+function toGeminiJsonSchema(schema, options) {
+  const jsonSchema = zodToJsonSchema(schema, {
+    name: options?.name,
+    target: "jsonSchema7"
+  });
+  return addGeminiPropertyOrdering(resolveOpenAiSchemaRoot(jsonSchema));
+}
+function isJsonSchemaObject(schema) {
+  if (!schema || !isPlainRecord(schema)) {
+    return false;
+  }
+  const type = schema.type;
+  if (type === "object") {
+    return true;
+  }
+  if (Array.isArray(type) && type.includes("object")) {
+    return true;
+  }
+  if (isPlainRecord(schema.properties)) {
+    return true;
+  }
+  return false;
+}
+function sanitisePartForLogging(part) {
+  switch (part.type) {
+    case "text":
+      return {
+        type: "text",
+        thought: part.thought === true ? true : void 0,
+        preview: part.text.slice(0, 200)
+      };
+    case "inlineData": {
+      let omittedBytes;
+      try {
+        omittedBytes = Buffer2.from(part.data, "base64").byteLength;
+      } catch {
+        omittedBytes = Buffer2.byteLength(part.data, "utf8");
+      }
+      return {
+        type: "inlineData",
+        mimeType: part.mimeType,
+        data: `[omitted:${omittedBytes}b]`
+      };
+    }
+    default:
+      return "[unknown part]";
+  }
+}
+function convertGooglePartsToLlmParts(parts) {
+  const result = [];
+  for (const part of parts) {
+    if (part.text !== void 0) {
+      result.push({
+        type: "text",
+        text: part.text,
+        thought: part.thought ? true : void 0
+      });
+      continue;
+    }
+    const inline = part.inlineData;
+    if (inline?.data) {
+      result.push({
+        type: "inlineData",
+        data: inline.data,
+        mimeType: inline.mimeType
+      });
+      continue;
+    }
+    if (part.fileData?.fileUri) {
+      throw new Error("fileData parts are not supported");
+    }
+  }
+  return result;
+}
+function assertLlmRole(value) {
+  switch (value) {
+    case "user":
+    case "model":
+    case "system":
+    case "tool":
+      return value;
+    default:
+      throw new Error(`Unsupported LLM role: ${String(value)}`);
+  }
+}
+function convertGeminiContentToLlmContent(content) {
+  return {
+    role: assertLlmRole(content.role),
+    parts: convertGooglePartsToLlmParts(content.parts ?? [])
+  };
+}
+function toGeminiPart(part) {
+  switch (part.type) {
+    case "text":
+      return {
+        text: part.text,
+        thought: part.thought === true ? true : void 0
+      };
+    case "inlineData":
+      return {
+        inlineData: {
+          data: part.data,
+          mimeType: part.mimeType
+        }
+      };
+    default:
+      throw new Error("Unsupported LLM content part");
+  }
+}
+function convertLlmContentToGeminiContent(content) {
+  return {
+    role: content.role,
+    parts: content.parts.map(toGeminiPart)
+  };
+}
+function resolveProvider(model) {
+  if (model.startsWith("chatgpt-")) {
+    return { provider: "chatgpt", model: model.slice("chatgpt-".length) };
+  }
+  if (model.startsWith("gemini-")) {
+    return { provider: "gemini", model };
+  }
+  return { provider: "openai", model };
+}
+function isOpenAiCodexModel(modelId) {
+  return modelId.includes("codex");
+}
+function resolveOpenAiReasoningEffort(modelId, override) {
+  if (override) {
+    return override;
+  }
+  if (isOpenAiCodexModel(modelId)) {
+    return "medium";
+  }
+  return DEFAULT_OPENAI_REASONING_EFFORT;
+}
+function toOpenAiReasoningEffort(effort) {
+  switch (effort) {
+    case "low":
+      return "low";
+    case "medium":
+      return "medium";
+    case "high":
+      return "high";
+    case "xhigh":
+      return "high";
+  }
+}
+function resolveOpenAiVerbosity(modelId) {
+  return isOpenAiCodexModel(modelId) ? "medium" : "high";
+}
+function isInlineImageMime(mimeType) {
+  if (!mimeType) {
+    return false;
+  }
+  return mimeType.startsWith("image/");
+}
+function mergeConsecutiveTextParts(parts) {
+  if (parts.length === 0) {
+    return [];
+  }
+  const merged = [];
+  for (const part of parts) {
+    if (part.type !== "text") {
+      merged.push({ type: "inlineData", data: part.data, mimeType: part.mimeType });
+      continue;
+    }
+    const isThought = part.thought === true;
+    const last = merged[merged.length - 1];
+    if (last && last.type === "text" && last.thought === true === isThought) {
+      last.text += part.text;
+      last.thought = isThought ? true : void 0;
+    } else {
+      merged.push({
+        type: "text",
+        text: part.text,
+        thought: isThought ? true : void 0
+      });
+    }
+  }
+  return merged;
+}
+function extractTextByChannel(content) {
+  if (!content) {
+    return { text: "", thoughts: "" };
+  }
+  let text = "";
+  let thoughts = "";
+  for (const part of content.parts) {
+    if (part.type !== "text") {
+      continue;
+    }
+    if (part.thought === true) {
+      thoughts += part.text;
+    } else {
+      text += part.text;
+    }
+  }
+  return { text: text.trim(), thoughts: thoughts.trim() };
+}
+function normalizeJsonText(rawText) {
+  let text = rawText.trim();
+  if (text.startsWith("```")) {
+    text = text.replace(/^```[a-zA-Z0-9_-]*\s*\n?/, "");
+    text = text.replace(/```(?:\s*)?$/, "").trim();
+  }
+  const fenced = /^```(?:json)?\s*([\s\S]*?)\s*```$/i.exec(text);
+  if (fenced?.[1]) {
+    return fenced[1].trim();
+  }
+  if (!text.startsWith("{") && !text.startsWith("[")) {
+    const firstBrace = text.indexOf("{");
+    if (firstBrace !== -1) {
+      const lastBrace = text.lastIndexOf("}");
+      if (lastBrace !== -1 && lastBrace > firstBrace) {
+        text = text.slice(firstBrace, lastBrace + 1).trim();
+      }
+    }
+  }
+  return text;
+}
+function escapeNewlinesInStrings(jsonText) {
+  let output = "";
+  let inString = false;
+  let escaped = false;
+  for (let i = 0; i < jsonText.length; i += 1) {
+    const char = jsonText[i] ?? "";
+    if (inString) {
+      if (escaped) {
+        output += char;
+        escaped = false;
+        continue;
+      }
+      if (char === "\\") {
+        output += char;
+        escaped = true;
+        continue;
+      }
+      if (char === '"') {
+        output += char;
+        inString = false;
+        continue;
+      }
+      if (char === "\n") {
+        output += "\\n";
+        continue;
+      }
+      if (char === "\r") {
+        output += "\\r";
+        continue;
+      }
+      output += char;
+      continue;
+    }
+    if (char === '"') {
+      inString = true;
+      output += char;
+      continue;
+    }
+    output += char;
+  }
+  return output;
+}
+function parseJsonFromLlmText(rawText) {
+  const cleanedText = normalizeJsonText(rawText);
+  const repairedText = escapeNewlinesInStrings(cleanedText);
+  return JSON.parse(repairedText);
+}
+function resolveTextContents(input) {
+  if ("contents" in input) {
+    return input.contents;
+  }
+  const contents = [];
+  if (input.systemPrompt) {
+    contents.push({
+      role: "system",
+      parts: [{ type: "text", text: input.systemPrompt }]
+    });
+  }
+  contents.push({
+    role: "user",
+    parts: [{ type: "text", text: input.prompt }]
+  });
+  return contents;
+}
+function toOpenAiInput(contents) {
+  const OPENAI_ROLE_FROM_LLM = {
+    user: "user",
+    model: "assistant",
+    system: "system",
+    tool: "assistant"
+  };
+  return contents.map((content) => {
+    const parts = [];
+    for (const part of content.parts) {
+      if (part.type === "text") {
+        parts.push({ type: "input_text", text: part.text });
+        continue;
+      }
+      const mimeType = part.mimeType ?? "application/octet-stream";
+      const dataUrl = `data:${mimeType};base64,${part.data}`;
+      parts.push({ type: "input_image", image_url: dataUrl, detail: "auto" });
+    }
+    if (parts.length === 1 && parts[0]?.type === "input_text" && typeof parts[0].text === "string") {
+      return {
+        role: OPENAI_ROLE_FROM_LLM[content.role],
+        content: parts[0].text
+      };
+    }
+    return {
+      role: OPENAI_ROLE_FROM_LLM[content.role],
+      content: parts
+    };
+  });
+}
+function toChatGptInput(contents) {
+  const instructionsParts = [];
+  const input = [];
+  for (const content of contents) {
+    if (content.role === "system") {
+      for (const part of content.parts) {
+        if (part.type === "text") {
+          instructionsParts.push(part.text);
+        }
+      }
+      continue;
+    }
+    const isAssistant = content.role === "model";
+    const parts = [];
+    for (const part of content.parts) {
+      if (part.type === "text") {
+        parts.push({
+          type: isAssistant ? "output_text" : "input_text",
+          text: part.text
+        });
+        continue;
+      }
+      const mimeType = part.mimeType ?? "application/octet-stream";
+      const dataUrl = `data:${mimeType};base64,${part.data}`;
+      if (isAssistant) {
+        parts.push({
+          type: "output_text",
+          text: `[image:${mimeType}]`
+        });
+      } else {
+        parts.push({
+          type: "input_image",
+          image_url: dataUrl,
+          detail: "auto"
+        });
+      }
+    }
+    if (parts.length === 0) {
+      parts.push({
+        type: isAssistant ? "output_text" : "input_text",
+        text: "(empty content)"
+      });
+    }
+    if (isAssistant) {
+      input.push({
+        type: "message",
+        role: "assistant",
+        status: "completed",
+        content: parts
+      });
+    } else {
+      input.push({
+        role: "user",
+        content: parts
+      });
+    }
+  }
+  const instructions = instructionsParts.map((part) => part.trim()).filter((part) => part.length > 0).join("\\n\\n");
+  return {
+    instructions: instructions.length > 0 ? instructions : void 0,
+    input
+  };
+}
+function toGeminiTools(tools) {
+  if (!tools || tools.length === 0) {
+    return void 0;
+  }
+  return tools.map((tool2) => {
+    switch (tool2.type) {
+      case "web-search":
+        return { googleSearch: {} };
+      case "code-execution":
+        return { codeExecution: {} };
+      default:
+        throw new Error("Unsupported tool configuration");
+    }
+  });
+}
+function toOpenAiTools(tools) {
+  if (!tools || tools.length === 0) {
+    return void 0;
+  }
+  return tools.map((tool2) => {
+    switch (tool2.type) {
+      case "web-search": {
+        const external_web_access = tool2.mode !== "cached";
+        return { type: "web_search", external_web_access };
+      }
+      case "code-execution": {
+        return { type: "code_interpreter", container: { type: "auto" } };
+      }
+      default:
+        throw new Error("Unsupported tool configuration");
+    }
+  });
+}
+function mergeTokenUpdates(current, next) {
+  if (!next) {
+    return current;
+  }
+  if (!current) {
+    return next;
+  }
+  return {
+    promptTokens: next.promptTokens ?? current.promptTokens,
+    cachedTokens: next.cachedTokens ?? current.cachedTokens,
+    responseTokens: next.responseTokens ?? current.responseTokens,
+    responseImageTokens: next.responseImageTokens ?? current.responseImageTokens,
+    thinkingTokens: next.thinkingTokens ?? current.thinkingTokens,
+    totalTokens: next.totalTokens ?? current.totalTokens,
+    toolUsePromptTokens: next.toolUsePromptTokens ?? current.toolUsePromptTokens
+  };
+}
+function toMaybeNumber(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  if (typeof value === "string") {
+    const parsed = Number.parseFloat(value);
+    if (Number.isFinite(parsed)) {
+      return parsed;
+    }
+  }
+  return void 0;
+}
+function sumModalityTokenCounts(details, modality) {
+  if (!Array.isArray(details)) {
+    return 0;
+  }
+  let total = 0;
+  for (const entry of details) {
+    const entryModality = entry.modality;
+    if (typeof entryModality !== "string") {
+      continue;
+    }
+    if (entryModality.toUpperCase() !== modality.toUpperCase()) {
+      continue;
+    }
+    const tokenCount = toMaybeNumber(entry.tokenCount);
+    if (tokenCount !== void 0 && tokenCount > 0) {
+      total += tokenCount;
+    }
+  }
+  return total;
+}
+function extractGeminiUsageTokens(usage) {
+  if (!usage || typeof usage !== "object") {
+    return void 0;
+  }
+  const promptTokens = toMaybeNumber(usage.promptTokenCount);
+  const cachedTokens = toMaybeNumber(
+    usage.cachedContentTokenCount
+  );
+  const responseTokens = toMaybeNumber(
+    usage.candidatesTokenCount ?? usage.responseTokenCount
+  );
+  const thinkingTokens = toMaybeNumber(
+    usage.thoughtsTokenCount
+  );
+  const totalTokens = toMaybeNumber(usage.totalTokenCount);
+  const toolUsePromptTokens = toMaybeNumber(
+    usage.toolUsePromptTokenCount
+  );
+  const responseDetails = usage.candidatesTokensDetails ?? usage.responseTokensDetails;
+  const responseImageTokens = sumModalityTokenCounts(responseDetails, "IMAGE");
+  if (promptTokens === void 0 && cachedTokens === void 0 && responseTokens === void 0 && responseImageTokens === 0 && thinkingTokens === void 0 && totalTokens === void 0 && toolUsePromptTokens === void 0) {
+    return void 0;
+  }
+  return {
+    promptTokens,
+    cachedTokens,
+    responseTokens,
+    responseImageTokens: responseImageTokens > 0 ? responseImageTokens : void 0,
+    thinkingTokens,
+    totalTokens,
+    toolUsePromptTokens
+  };
+}
+function extractOpenAiUsageTokens(usage) {
+  if (!usage || typeof usage !== "object") {
+    return void 0;
+  }
+  const promptTokens = toMaybeNumber(usage.input_tokens);
+  const cachedTokens = toMaybeNumber(
+    usage.input_tokens_details?.cached_tokens
+  );
+  const outputTokensRaw = toMaybeNumber(usage.output_tokens);
+  const reasoningTokens = toMaybeNumber(
+    usage.output_tokens_details?.reasoning_tokens
+  );
+  const totalTokens = toMaybeNumber(usage.total_tokens);
+  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
+  };
+}
+function extractChatGptUsageTokens(usage) {
+  if (!usage || typeof usage !== "object") {
+    return void 0;
+  }
+  const promptTokens = toMaybeNumber(usage.input_tokens);
+  const cachedTokens = toMaybeNumber(
+    usage.input_tokens_details?.cached_tokens
+  );
+  const outputTokensRaw = toMaybeNumber(usage.output_tokens);
+  const reasoningTokens = toMaybeNumber(
+    usage.output_tokens_details?.reasoning_tokens
+  );
+  const totalTokens = toMaybeNumber(usage.total_tokens);
+  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;
+  }
+  try {
+    return JSON.stringify(value);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return JSON.stringify({ error: "Failed to serialize tool output", detail: message });
+  }
+}
+function parseOpenAiToolArguments(raw) {
+  const trimmed = raw.trim();
+  if (trimmed.length === 0) {
+    return { value: {} };
+  }
+  try {
+    return { value: JSON.parse(trimmed) };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { value: raw, error: message };
+  }
+}
+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}`);
+  }
+  return messages.join("; ");
+}
+function buildToolErrorOutput(message, issues) {
+  const output = { error: message };
+  if (issues && issues.length > 0) {
+    output.issues = issues.map((issue) => ({
+      path: issue.path.map(String),
+      message: issue.message,
+      code: issue.code
+    }));
+  }
+  return output;
+}
+async function executeToolCall(params) {
+  const { toolName, tool: tool2, rawInput, parseError } = params;
+  if (!tool2) {
+    const message = `Unknown tool: ${toolName}`;
+    return {
+      result: { toolName, input: rawInput, output: { error: message }, error: message },
+      outputPayload: buildToolErrorOutput(message)
+    };
+  }
+  if (parseError) {
+    const message = `Invalid JSON for tool ${toolName}: ${parseError}`;
+    return {
+      result: { toolName, input: rawInput, output: { error: message }, error: message },
+      outputPayload: buildToolErrorOutput(message)
+    };
+  }
+  const parsed = tool2.inputSchema.safeParse(rawInput);
+  if (!parsed.success) {
+    const message = `Invalid tool arguments for ${toolName}: ${formatZodIssues(parsed.error.issues)}`;
+    const outputPayload = buildToolErrorOutput(message, parsed.error.issues);
+    return {
+      result: { toolName, input: rawInput, output: outputPayload, error: message },
+      outputPayload
+    };
+  }
+  try {
+    const output = await tool2.execute(parsed.data);
+    return {
+      result: { toolName, input: parsed.data, 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: parsed.data, output: outputPayload, error: message },
+      outputPayload
+    };
+  }
+}
+function buildToolLogId(turn, toolIndex) {
+  return `turn${turn.toString()}/tool${toolIndex.toString()}`;
+}
+function sanitizeChatGptToolId(value) {
+  const cleaned = value.replace(/[^A-Za-z0-9_-]/gu, "");
+  if (cleaned.length === 0) {
+    return randomBytes(8).toString("hex");
+  }
+  return cleaned.slice(0, 64);
+}
+function normalizeChatGptToolIds(params) {
+  let rawCallId = params.callId ?? "";
+  let rawItemId = params.itemId ?? "";
+  if (rawCallId.includes("|")) {
+    const [nextCallId, nextItemId] = rawCallId.split("|");
+    rawCallId = nextCallId ?? rawCallId;
+    if (nextItemId) {
+      rawItemId = nextItemId;
+    }
+  } else if (rawItemId.includes("|")) {
+    const [nextCallId, nextItemId] = rawItemId.split("|");
+    rawCallId = nextCallId ?? rawCallId;
+    rawItemId = nextItemId ?? rawItemId;
+  }
+  const callValue = sanitizeChatGptToolId(rawCallId || rawItemId || randomBytes(8).toString("hex"));
+  let itemValue = sanitizeChatGptToolId(rawItemId || `fc-${callValue}`);
+  if (!itemValue.startsWith("fc")) {
+    itemValue = `fc-${itemValue}`;
+  }
+  return { callId: callValue, itemId: itemValue };
+}
+function extractOpenAiResponseParts(response) {
+  const parts = [];
+  let blocked = false;
+  const output = response.output;
+  if (Array.isArray(output)) {
+    for (const item of output) {
+      if (!item || typeof item !== "object") {
+        continue;
+      }
+      const itemType = item.type;
+      if (itemType === "message") {
+        const content = item.content;
+        if (Array.isArray(content)) {
+          for (const entry of content) {
+            if (!entry || typeof entry !== "object") {
+              continue;
+            }
+            const entryType = entry.type;
+            if (entryType === "output_text") {
+              const text = entry.text;
+              if (typeof text === "string" && text.length > 0) {
+                parts.push({ type: "text", text });
+              }
+            } else if (entryType === "refusal") {
+              blocked = true;
+            }
+          }
+        }
+      } else if (itemType === "reasoning") {
+        const content = item.content;
+        if (Array.isArray(content)) {
+          for (const entry of content) {
+            if (!entry || typeof entry !== "object") {
+              continue;
+            }
+            const entryType = entry.type;
+            if (entryType === "reasoning_summary_text" || entryType === "reasoning_summary") {
+              const entryText = typeof entry.text === "string" ? entry.text : typeof entry.summary === "string" ? entry.summary : void 0;
+              if (typeof entryText === "string" && entryText.length > 0) {
+                parts.push({ type: "text", text: entryText, thought: true });
+              }
+            }
+          }
+        }
+      } else if (itemType === "function_call" || itemType === "tool_call" || itemType === "custom_tool_call") {
+        const serialized = JSON.stringify(item, null, 2);
+        if (serialized.length > 0) {
+          parts.push({ type: "text", text: `[tool-call]\\n${serialized}\\n` });
+        }
+      }
+    }
+  }
+  if (parts.length === 0) {
+    const outputText = response.output_text;
+    if (typeof outputText === "string" && outputText.length > 0) {
+      parts.push({ type: "text", text: outputText });
+    }
+  }
+  return { parts, blocked };
+}
+function extractOpenAiFunctionCalls(output) {
+  const calls = [];
+  if (!Array.isArray(output)) {
+    return calls;
+  }
+  for (const item of output) {
+    if (!item || typeof item !== "object") {
+      continue;
+    }
+    if (item.type === "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 });
+      }
+    }
+  }
+  return calls;
+}
+function resolveGeminiThinkingConfig(modelId) {
+  switch (modelId) {
+    case "gemini-3-pro-preview":
+      return { includeThoughts: true };
+    case "gemini-2.5-pro":
+      return { includeThoughts: true, thinkingBudget: 32768 };
+    case "gemini-flash-latest":
+    case "gemini-flash-lite-latest":
+      return { includeThoughts: true, thinkingBudget: 24576 };
+    default:
+      return { includeThoughts: true };
+  }
+}
+function decodeInlineDataBuffer(base64) {
+  try {
+    return Buffer2.from(base64, "base64");
+  } catch {
+    return Buffer2.from(base64, "base64url");
+  }
+}
+function extractImages(content) {
+  if (!content) {
+    return [];
+  }
+  const images = [];
+  for (const part of content.parts) {
+    if (part.type !== "inlineData") {
+      continue;
+    }
+    const buffer = decodeInlineDataBuffer(part.data);
+    images.push({ mimeType: part.mimeType, data: buffer });
+  }
+  return images;
+}
+async function runTextCall(params) {
+  const { request, queue, abortController } = params;
+  const providerInfo = resolveProvider(request.model);
+  const provider = providerInfo.provider;
+  const modelForProvider = providerInfo.model;
+  const contents = resolveTextContents(request);
+  if (contents.length === 0) {
+    throw new Error("LLM call received an empty prompt.");
+  }
+  let modelVersion = request.model;
+  let blocked = false;
+  let grounding;
+  const responseParts = [];
+  let responseRole;
+  let latestUsage;
+  let responseImages = 0;
+  const pushDelta = (channel, text2) => {
+    if (!text2) {
+      return;
+    }
+    responseParts.push({ type: "text", text: text2, ...channel === "thought" ? { thought: true } : {} });
+    queue.push({ type: "delta", channel, text: text2 });
+  };
+  const pushInline = (data, mimeType) => {
+    if (!data) {
+      return;
+    }
+    responseParts.push({ type: "inlineData", data, mimeType });
+    if (isInlineImageMime(mimeType)) {
+      responseImages += 1;
+    }
+  };
+  const resolveAbortSignal = () => {
+    if (!request.signal) {
+      return abortController.signal;
+    }
+    if (request.signal.aborted) {
+      abortController.abort(request.signal.reason);
+    } else {
+      request.signal.addEventListener(
+        "abort",
+        () => abortController.abort(request.signal?.reason),
+        { once: true }
+      );
+    }
+    return abortController.signal;
+  };
+  const signal = resolveAbortSignal();
+  if (provider === "openai") {
+    const openAiInput = toOpenAiInput(contents);
+    const openAiTools = toOpenAiTools(request.tools);
+    const reasoningEffort = resolveOpenAiReasoningEffort(
+      modelForProvider,
+      request.openAiReasoningEffort
+    );
+    const openAiTextConfig = {
+      format: request.openAiTextFormat ?? { type: "text" },
+      verbosity: resolveOpenAiVerbosity(modelForProvider)
+    };
+    const reasoning = {
+      effort: toOpenAiReasoningEffort(reasoningEffort),
+      summary: "detailed"
+    };
+    await runOpenAiCall(async (client) => {
+      const stream = client.responses.stream(
+        {
+          model: modelForProvider,
+          input: openAiInput,
+          reasoning,
+          text: openAiTextConfig,
+          ...openAiTools ? { tools: openAiTools } : {},
+          include: ["code_interpreter_call.outputs", "reasoning.encrypted_content"]
+        },
+        { signal }
+      );
+      for await (const event of stream) {
+        switch (event.type) {
+          case "response.output_text.delta": {
+            const delta = event.delta ?? "";
+            pushDelta("response", typeof delta === "string" ? delta : "");
+            break;
+          }
+          case "response.reasoning_summary_text.delta": {
+            const delta = event.delta ?? "";
+            pushDelta("thought", typeof delta === "string" ? delta : "");
+            break;
+          }
+          case "response.refusal.delta": {
+            blocked = true;
+            queue.push({ type: "blocked" });
+            break;
+          }
+          default:
+            break;
+        }
+      }
+      const finalResponse = await stream.finalResponse();
+      modelVersion = typeof finalResponse.model === "string" ? finalResponse.model : request.model;
+      queue.push({ type: "model", modelVersion });
+      if (finalResponse.error) {
+        const message = typeof finalResponse.error.message === "string" ? finalResponse.error.message : "OpenAI response failed";
+        throw new Error(message);
+      }
+      if (finalResponse.status && finalResponse.status !== "completed" && finalResponse.status !== "in_progress") {
+        const detail = finalResponse.incomplete_details?.reason;
+        throw new Error(
+          `OpenAI response status ${finalResponse.status}${detail ? ` (${detail})` : ""}`
+        );
+      }
+      latestUsage = extractOpenAiUsageTokens(finalResponse.usage);
+      if (responseParts.length === 0) {
+        const fallback = extractOpenAiResponseParts(finalResponse);
+        blocked = blocked || fallback.blocked;
+        for (const part of fallback.parts) {
+          if (part.type === "text") {
+            pushDelta(part.thought === true ? "thought" : "response", part.text);
+          } else {
+            pushInline(part.data, part.mimeType);
+          }
+        }
+      }
+    });
+  } else if (provider === "chatgpt") {
+    const chatGptInput = toChatGptInput(contents);
+    const reasoningEffort = resolveOpenAiReasoningEffort(
+      request.model,
+      request.openAiReasoningEffort
+    );
+    const openAiTools = toOpenAiTools(request.tools);
+    const requestPayload = {
+      model: modelForProvider,
+      store: false,
+      stream: true,
+      instructions: chatGptInput.instructions ?? "You are a helpful assistant.",
+      input: chatGptInput.input,
+      include: ["reasoning.encrypted_content"],
+      reasoning: { effort: toOpenAiReasoningEffort(reasoningEffort), summary: "detailed" },
+      text: {
+        format: request.openAiTextFormat ?? { type: "text" },
+        verbosity: resolveOpenAiVerbosity(request.model)
+      },
+      ...openAiTools ? { tools: openAiTools } : {}
+    };
+    let sawResponseDelta = false;
+    let sawThoughtDelta = false;
+    const result = await collectChatGptCodexResponse({
+      request: requestPayload,
+      signal,
+      onDelta: (delta) => {
+        if (delta.thoughtDelta) {
+          sawThoughtDelta = true;
+          pushDelta("thought", delta.thoughtDelta);
+        }
+        if (delta.textDelta) {
+          sawResponseDelta = true;
+          pushDelta("response", delta.textDelta);
+        }
+      }
+    });
+    blocked = blocked || result.blocked;
+    if (blocked) {
+      queue.push({ type: "blocked" });
+    }
+    if (result.model) {
+      modelVersion = `chatgpt-${result.model}`;
+      queue.push({ type: "model", modelVersion });
+    }
+    latestUsage = extractChatGptUsageTokens(result.usage);
+    const fallbackText = typeof result.text === "string" ? result.text : "";
+    const fallbackThoughts = typeof result.reasoningSummaryText === "string" && result.reasoningSummaryText.length > 0 ? result.reasoningSummaryText : typeof result.reasoningText === "string" ? result.reasoningText : "";
+    if (!sawThoughtDelta && fallbackThoughts.length > 0) {
+      pushDelta("thought", fallbackThoughts);
+    }
+    if (!sawResponseDelta && fallbackText.length > 0) {
+      pushDelta("response", fallbackText);
+    }
+  } else {
+    const geminiContents = contents.map(convertLlmContentToGeminiContent);
+    const config = {
+      maxOutputTokens: 32e3,
+      thinkingConfig: resolveGeminiThinkingConfig(modelForProvider),
+      ...request.responseMimeType ? { responseMimeType: request.responseMimeType } : {},
+      ...request.responseJsonSchema ? { responseJsonSchema: request.responseJsonSchema } : {},
+      ...request.responseModalities ? { responseModalities: Array.from(request.responseModalities) } : {},
+      ...request.imageAspectRatio || request.imageSize ? {
+        imageConfig: {
+          ...request.imageAspectRatio ? { aspectRatio: request.imageAspectRatio } : {},
+          ...request.imageSize ? { imageSize: request.imageSize } : {}
+        }
+      } : {}
+    };
+    const geminiTools = toGeminiTools(request.tools);
+    if (geminiTools) {
+      config.tools = geminiTools;
+    }
+    await runGeminiCall(async (client) => {
+      const stream = await client.models.generateContentStream({
+        model: modelForProvider,
+        contents: geminiContents,
+        config
+      });
+      let latestGrounding;
+      for await (const chunk of stream) {
+        if (chunk.modelVersion) {
+          modelVersion = chunk.modelVersion;
+          queue.push({ type: "model", modelVersion });
+        }
+        if (chunk.promptFeedback?.blockReason) {
+          blocked = true;
+          queue.push({ type: "blocked" });
+        }
+        latestUsage = mergeTokenUpdates(latestUsage, extractGeminiUsageTokens(chunk.usageMetadata));
+        const candidates = chunk.candidates;
+        if (!candidates || candidates.length === 0) {
+          continue;
+        }
+        const primary = candidates[0];
+        if (primary && isModerationFinish(primary.finishReason)) {
+          blocked = true;
+          queue.push({ type: "blocked" });
+        }
+        for (const candidate of candidates) {
+          const candidateContent = candidate.content;
+          if (!candidateContent) {
+            continue;
+          }
+          if (candidate.groundingMetadata) {
+            latestGrounding = candidate.groundingMetadata;
+          }
+          const content2 = convertGeminiContentToLlmContent(candidateContent);
+          if (!responseRole) {
+            responseRole = content2.role;
+          }
+          for (const part of content2.parts) {
+            if (part.type === "text") {
+              pushDelta(part.thought === true ? "thought" : "response", part.text);
+            } else {
+              pushInline(part.data, part.mimeType);
+            }
+          }
+        }
+      }
+      grounding = latestGrounding;
+    });
+  }
+  const mergedParts = mergeConsecutiveTextParts(responseParts);
+  const content = mergedParts.length > 0 ? { role: responseRole ?? "model", parts: mergedParts } : void 0;
+  const { text, thoughts } = extractTextByChannel(content);
+  const costUsd = estimateCallCostUsd({
+    modelId: modelVersion,
+    tokens: latestUsage,
+    responseImages,
+    imageSize: request.imageSize
+  });
+  if (latestUsage) {
+    queue.push({ type: "usage", usage: latestUsage, costUsd, modelVersion });
+  }
+  return {
+    provider,
+    model: request.model,
+    modelVersion,
+    content,
+    text,
+    thoughts,
+    blocked,
+    usage: latestUsage,
+    costUsd,
+    grounding
+  };
+}
+function streamText(request) {
+  const queue = createAsyncQueue();
+  const abortController = new AbortController();
+  const result = (async () => {
+    try {
+      const output = await runTextCall({ request, queue, abortController });
+      queue.close();
+      return output;
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      queue.fail(err);
+      throw err;
+    }
+  })();
+  return {
+    events: queue.iterable,
+    result,
+    abort: () => abortController.abort()
+  };
+}
+async function generateText(request) {
+  const call = streamText(request);
+  for await (const _event of call.events) {
+  }
+  return await call.result;
+}
+async function generateJson(request) {
+  const maxAttempts = Math.max(1, Math.floor(request.maxAttempts ?? 2));
+  const schemaName = (request.openAiSchemaName ?? "llm-response").trim() || "llm-response";
+  const providerInfo = resolveProvider(request.model);
+  const isOpenAiVariant = providerInfo.provider === "openai" || providerInfo.provider === "chatgpt";
+  const baseJsonSchema = zodToJsonSchema(request.schema, {
+    name: schemaName,
+    target: isOpenAiVariant ? "openAi" : "jsonSchema7"
+  });
+  const responseJsonSchema = isOpenAiVariant ? resolveOpenAiSchemaRoot(baseJsonSchema) : addGeminiPropertyOrdering(baseJsonSchema);
+  if (isOpenAiVariant && !isJsonSchemaObject(responseJsonSchema)) {
+    throw new Error("OpenAI structured outputs require a JSON object schema at the root.");
+  }
+  const openAiTextFormat = providerInfo.provider === "openai" ? {
+    type: "json_schema",
+    name: schemaName,
+    strict: true,
+    schema: normalizeOpenAiSchema(responseJsonSchema)
+  } : void 0;
+  const failures = [];
+  for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+    let rawText = "";
+    try {
+      const contents = resolveTextContents(request);
+      const call = streamText({
+        model: request.model,
+        contents,
+        tools: request.tools,
+        responseMimeType: request.responseMimeType ?? "application/json",
+        responseJsonSchema,
+        openAiReasoningEffort: request.openAiReasoningEffort,
+        ...openAiTextFormat ? { openAiTextFormat } : {},
+        signal: request.signal
+      });
+      for await (const event of call.events) {
+        if (event.type === "delta" && event.channel === "response") {
+          rawText += event.text;
+        }
+      }
+      const result = await call.result;
+      rawText = rawText || result.text;
+      const cleanedText = normalizeJsonText(rawText);
+      const repairedText = escapeNewlinesInStrings(cleanedText);
+      const payload = JSON.parse(repairedText);
+      const normalized = typeof request.normalizeJson === "function" ? request.normalizeJson(payload) : payload;
+      const parsed = request.schema.parse(normalized);
+      return { value: parsed, rawText, result };
+    } catch (error) {
+      const handled = error instanceof Error ? error : new Error(String(error));
+      failures.push({ attempt, rawText, error: handled });
+      if (attempt >= maxAttempts) {
+        throw new LlmJsonCallError(`LLM JSON call failed after ${attempt} attempt(s)`, failures);
+      }
+    }
+  }
+  throw new LlmJsonCallError("LLM JSON call failed", failures);
+}
+var DEFAULT_TOOL_LOOP_MAX_STEPS = 8;
+function resolveToolLoopContents(input) {
+  return resolveTextContents(input);
+}
+function buildOpenAiFunctionTools(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
+  }));
+}
+function buildOpenAiToolSchema(schema, name) {
+  const rawSchema = zodToJsonSchema(schema, { name, target: "openAi" });
+  const normalized = normalizeOpenAiSchema(resolveOpenAiSchemaRoot(rawSchema));
+  if (!isJsonSchemaObject(normalized)) {
+    throw new Error(`OpenAI tool schema for ${name} must be a JSON object at the root.`);
+  }
+  return normalized;
+}
+function buildGeminiFunctionDeclarations(tools) {
+  const toolEntries = Object.entries(tools);
+  const functionDeclarations = toolEntries.map(([name, toolDef]) => ({
+    name,
+    description: toolDef.description ?? "",
+    parametersJsonSchema: buildGeminiToolSchema(toolDef.inputSchema, name)
+  }));
+  return [{ functionDeclarations }];
+}
+function buildGeminiToolSchema(schema, name) {
+  const jsonSchema = toGeminiJsonSchema(schema, { name });
+  if (!isJsonSchemaObject(jsonSchema)) {
+    throw new Error(`Gemini tool schema for ${name} must be a JSON object at the root.`);
+  }
+  return jsonSchema;
+}
+function extractOpenAiReasoningSummary(response) {
+  if (!response || typeof response !== "object") {
+    return "";
+  }
+  const output = response.output;
+  if (!Array.isArray(output)) {
+    return "";
+  }
+  let summary = "";
+  for (const item of output) {
+    if (!item || typeof item !== "object") {
+      continue;
+    }
+    if (item.type !== "reasoning") {
+      continue;
+    }
+    const content = item.content;
+    if (!Array.isArray(content)) {
+      continue;
+    }
+    for (const entry of content) {
+      if (!entry || typeof entry !== "object") {
+        continue;
+      }
+      const entryType = entry.type;
+      if (entryType === "reasoning_summary_text") {
+        const text = entry.text;
+        if (typeof text === "string") {
+          summary += text;
+        }
+      }
+    }
+  }
+  return summary;
+}
+async function runToolLoop(request) {
+  const toolEntries = Object.entries(request.tools);
+  if (toolEntries.length === 0) {
+    throw new Error("Tool loop requires at least one tool definition.");
+  }
+  const contents = resolveToolLoopContents(request);
+  if (contents.length === 0) {
+    throw new Error("Tool loop prompt must not be empty.");
+  }
+  const maxSteps = Math.max(1, Math.floor(request.maxSteps ?? DEFAULT_TOOL_LOOP_MAX_STEPS));
+  const providerInfo = resolveProvider(request.model);
+  const steps = [];
+  let totalCostUsd = 0;
+  let finalText = "";
+  let finalThoughts = "";
+  if (providerInfo.provider === "openai") {
+    const openAiFunctionTools = buildOpenAiFunctionTools(request.tools);
+    const openAiNativeTools = toOpenAiTools(request.modelTools);
+    const openAiTools = openAiNativeTools ? [...openAiNativeTools, ...openAiFunctionTools] : [...openAiFunctionTools];
+    const reasoningEffort = resolveOpenAiReasoningEffort(
+      providerInfo.model,
+      request.openAiReasoningEffort
+    );
+    const textConfig = {
+      format: { type: "text" },
+      verbosity: resolveOpenAiVerbosity(providerInfo.model)
+    };
+    const reasoning = {
+      effort: toOpenAiReasoningEffort(reasoningEffort),
+      summary: "detailed"
+    };
+    let previousResponseId;
+    let input = toOpenAiInput(contents);
+    for (let stepIndex = 0; stepIndex < maxSteps; stepIndex += 1) {
+      const turn = stepIndex + 1;
+      const abortController = new AbortController();
+      if (request.signal) {
+        if (request.signal.aborted) {
+          abortController.abort(request.signal.reason);
+        } else {
+          request.signal.addEventListener(
+            "abort",
+            () => abortController.abort(request.signal?.reason),
+            { once: true }
+          );
+        }
+      }
+      const onEvent = request.onEvent;
+      let modelVersion = request.model;
+      let usageTokens;
+      const emitEvent = (ev) => {
+        onEvent?.(ev);
+      };
+      const finalResponse = await runOpenAiCall(async (client) => {
+        const stream = client.responses.stream(
+          {
+            model: providerInfo.model,
+            input,
+            ...previousResponseId ? { previous_response_id: previousResponseId } : {},
+            ...openAiTools.length > 0 ? { tools: openAiTools } : {},
+            ...openAiTools.length > 0 ? { parallel_tool_calls: true } : {},
+            reasoning,
+            text: textConfig,
+            include: ["reasoning.encrypted_content"]
+          },
+          { signal: abortController.signal }
+        );
+        for await (const event of stream) {
+          switch (event.type) {
+            case "response.output_text.delta":
+              emitEvent({
+                type: "delta",
+                channel: "response",
+                text: typeof event.delta === "string" ? event.delta : ""
+              });
+              break;
+            case "response.reasoning_summary_text.delta":
+              emitEvent({
+                type: "delta",
+                channel: "thought",
+                text: typeof event.delta === "string" ? event.delta : ""
+              });
+              break;
+            case "response.refusal.delta":
+              emitEvent({ type: "blocked" });
+              break;
+            default:
+              break;
+          }
+        }
+        return await stream.finalResponse();
+      });
+      modelVersion = typeof finalResponse.model === "string" ? finalResponse.model : request.model;
+      emitEvent({ type: "model", modelVersion });
+      if (finalResponse.error) {
+        const message = typeof finalResponse.error.message === "string" ? finalResponse.error.message : "OpenAI response failed";
+        throw new Error(message);
+      }
+      usageTokens = extractOpenAiUsageTokens(finalResponse.usage);
+      const responseText = extractOpenAiResponseParts(finalResponse).parts.filter((p) => p.type === "text" && p.thought !== true).map((p) => p.text).join("").trim();
+      const reasoningSummary = extractOpenAiReasoningSummary(finalResponse).trim();
+      const stepCostUsd = estimateCallCostUsd({
+        modelId: modelVersion,
+        tokens: usageTokens,
+        responseImages: 0
+      });
+      totalCostUsd += stepCostUsd;
+      if (usageTokens) {
+        emitEvent({ type: "usage", usage: usageTokens, costUsd: stepCostUsd, modelVersion });
+      }
+      const functionCalls = extractOpenAiFunctionCalls(finalResponse.output);
+      const stepToolCalls = [];
+      if (functionCalls.length === 0) {
+        finalText = responseText;
+        finalThoughts = reasoningSummary;
+        steps.push({
+          step: steps.length + 1,
+          modelVersion,
+          text: responseText || void 0,
+          thoughts: reasoningSummary || void 0,
+          toolCalls: [],
+          usage: usageTokens,
+          costUsd: stepCostUsd
+        });
+        return { text: finalText, thoughts: finalThoughts, steps, totalCostUsd };
+      }
+      const callInputs = functionCalls.map((call, index) => {
+        const toolIndex = index + 1;
+        const toolId = buildToolLogId(turn, toolIndex);
+        const toolName = call.name;
+        const { value, error: parseError } = parseOpenAiToolArguments(call.arguments);
+        return { call, toolName, 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({
+                toolName: entry.toolName,
+                tool: request.tools[entry.toolName],
+                rawInput: entry.value,
+                parseError: entry.parseError
+              });
+              return { entry, result, outputPayload };
+            }
+          );
+        })
+      );
+      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)
+        });
+      }
+      steps.push({
+        step: steps.length + 1,
+        modelVersion,
+        text: responseText || void 0,
+        thoughts: reasoningSummary || void 0,
+        toolCalls: stepToolCalls,
+        usage: usageTokens,
+        costUsd: stepCostUsd
+      });
+      previousResponseId = finalResponse.id;
+      input = toolOutputs;
+    }
+    throw new Error(`Tool loop exceeded max steps (${maxSteps}) without final response.`);
+  }
+  if (providerInfo.provider === "chatgpt") {
+    const openAiFunctionTools = buildOpenAiFunctionTools(request.tools);
+    const openAiNativeTools = toOpenAiTools(request.modelTools);
+    const openAiTools = openAiNativeTools ? [...openAiNativeTools, ...openAiFunctionTools] : [...openAiFunctionTools];
+    const reasoningEffort = resolveOpenAiReasoningEffort(
+      request.model,
+      request.openAiReasoningEffort
+    );
+    const toolLoopInput = toChatGptInput(contents);
+    let input = [...toolLoopInput.input];
+    for (let stepIndex = 0; stepIndex < maxSteps; stepIndex += 1) {
+      const turn = stepIndex + 1;
+      const response = await collectChatGptCodexResponse({
+        request: {
+          model: providerInfo.model,
+          store: false,
+          stream: true,
+          instructions: toolLoopInput.instructions ?? "You are a helpful assistant.",
+          input,
+          include: ["reasoning.encrypted_content"],
+          tools: openAiTools,
+          tool_choice: "auto",
+          parallel_tool_calls: true,
+          reasoning: {
+            effort: toOpenAiReasoningEffort(reasoningEffort),
+            summary: "detailed"
+          },
+          text: { verbosity: resolveOpenAiVerbosity(request.model) }
+        },
+        signal: request.signal,
+        onDelta: (delta) => {
+          if (delta.thoughtDelta) {
+            request.onEvent?.({ type: "delta", channel: "thought", text: delta.thoughtDelta });
+          }
+          if (delta.textDelta) {
+            request.onEvent?.({ type: "delta", channel: "response", text: delta.textDelta });
+          }
+        }
+      });
+      const modelVersion = response.model ? `chatgpt-${response.model}` : request.model;
+      const usageTokens = extractChatGptUsageTokens(response.usage);
+      const stepCostUsd = estimateCallCostUsd({
+        modelId: modelVersion,
+        tokens: usageTokens,
+        responseImages: 0
+      });
+      totalCostUsd += stepCostUsd;
+      const responseText = (response.text ?? "").trim();
+      const reasoningSummaryText = (response.reasoningSummaryText ?? "").trim();
+      const functionCalls = response.toolCalls ?? [];
+      if (functionCalls.length === 0) {
+        finalText = responseText;
+        finalThoughts = reasoningSummaryText;
+        steps.push({
+          step: steps.length + 1,
+          modelVersion,
+          text: responseText || void 0,
+          thoughts: reasoningSummaryText || void 0,
+          toolCalls: [],
+          usage: usageTokens,
+          costUsd: stepCostUsd
+        });
+        return { text: finalText, thoughts: finalThoughts, steps, totalCostUsd };
+      }
+      const toolCalls = [];
+      const toolOutputs = [];
+      const callInputs = functionCalls.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 });
+        return { call, toolName, value, parseError, ids, 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({
+                toolName: entry.toolName,
+                tool: request.tools[entry.toolName],
+                rawInput: entry.value,
+                parseError: entry.parseError
+              });
+              return { entry, result, outputPayload };
+            }
+          );
+        })
+      );
+      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)
+        });
+      }
+      steps.push({
+        step: steps.length + 1,
+        modelVersion,
+        text: responseText || void 0,
+        thoughts: reasoningSummaryText || void 0,
+        toolCalls,
+        usage: usageTokens,
+        costUsd: stepCostUsd
+      });
+      input = input.concat(toolOutputs);
+    }
+    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;
+  const geminiContents = contents.map(convertLlmContentToGeminiContent);
+  for (let stepIndex = 0; stepIndex < maxSteps; stepIndex += 1) {
+    const config = {
+      maxOutputTokens: 32e3,
+      tools: geminiTools,
+      toolConfig: {
+        functionCallingConfig: {
+          mode: FunctionCallingConfigMode.VALIDATED
+        }
+      },
+      thinkingConfig: resolveGeminiThinkingConfig(request.model)
+    };
+    const onEvent = request.onEvent;
+    const response = await runGeminiCall(async (client) => {
+      const stream = await client.models.generateContentStream({
+        model: request.model,
+        contents: geminiContents,
+        config
+      });
+      let responseText = "";
+      let thoughtsText = "";
+      const modelParts = [];
+      const functionCalls = [];
+      const seenFunctionCallIds = /* @__PURE__ */ new Set();
+      const seenFunctionCallKeys = /* @__PURE__ */ new Set();
+      let latestUsageMetadata;
+      let resolvedModelVersion;
+      for await (const chunk of stream) {
+        if (chunk.modelVersion) {
+          resolvedModelVersion = chunk.modelVersion;
+          onEvent?.({ type: "model", modelVersion: chunk.modelVersion });
+        }
+        if (chunk.usageMetadata) {
+          latestUsageMetadata = chunk.usageMetadata;
+        }
+        const candidates = chunk.candidates;
+        if (!candidates || candidates.length === 0) {
+          continue;
+        }
+        const primary = candidates[0];
+        const parts = primary?.content?.parts;
+        if (!parts || parts.length === 0) {
+          continue;
+        }
+        for (const part of parts) {
+          modelParts.push(part);
+          const call = part.functionCall;
+          if (call) {
+            const id = typeof call.id === "string" ? call.id : "";
+            const shouldAdd = (() => {
+              if (id.length > 0) {
+                if (seenFunctionCallIds.has(id)) {
+                  return false;
+                }
+                seenFunctionCallIds.add(id);
+                return true;
+              }
+              const key = JSON.stringify({ name: call.name ?? "", args: call.args ?? null });
+              if (seenFunctionCallKeys.has(key)) {
+                return false;
+              }
+              seenFunctionCallKeys.add(key);
+              return true;
+            })();
+            if (shouldAdd) {
+              functionCalls.push(call);
+            }
+          }
+          if (typeof part.text === "string" && part.text.length > 0) {
+            if (part.thought) {
+              thoughtsText += part.text;
+              onEvent?.({ type: "delta", channel: "thought", text: part.text });
+            } else {
+              responseText += part.text;
+              onEvent?.({ type: "delta", channel: "response", text: part.text });
+            }
+          }
+        }
+      }
+      return {
+        responseText,
+        thoughtsText,
+        functionCalls,
+        modelParts,
+        usageMetadata: latestUsageMetadata,
+        modelVersion: resolvedModelVersion ?? request.model
+      };
+    });
+    const usageTokens = extractGeminiUsageTokens(response.usageMetadata);
+    const modelVersion = response.modelVersion ?? request.model;
+    const stepCostUsd = estimateCallCostUsd({
+      modelId: modelVersion,
+      tokens: usageTokens,
+      responseImages: 0
+    });
+    totalCostUsd += stepCostUsd;
+    if (response.functionCalls.length === 0) {
+      finalText = response.responseText.trim();
+      finalThoughts = response.thoughtsText.trim();
+      steps.push({
+        step: steps.length + 1,
+        modelVersion,
+        text: finalText || void 0,
+        thoughts: finalThoughts || void 0,
+        toolCalls: [],
+        usage: usageTokens,
+        costUsd: stepCostUsd
+      });
+      return { text: finalText, thoughts: finalThoughts, steps, totalCostUsd };
+    }
+    const toolCalls = [];
+    const modelPartsForHistory = response.modelParts.filter(
+      (part) => !(typeof part.text === "string" && part.thought === true)
+    );
+    if (modelPartsForHistory.length > 0) {
+      geminiContents.push({ role: "model", parts: modelPartsForHistory });
+    } else {
+      const parts = [];
+      if (response.responseText) {
+        parts.push({ text: response.responseText });
+      }
+      for (const call of response.functionCalls) {
+        parts.push({ functionCall: call });
+      }
+      geminiContents.push({ role: "model", parts });
+    }
+    const responseParts = [];
+    const callInputs = response.functionCalls.map((call, index) => {
+      const turn = stepIndex + 1;
+      const toolIndex = index + 1;
+      const toolId = buildToolLogId(turn, toolIndex);
+      const toolName = call.name ?? "unknown";
+      const rawInput = call.args ?? {};
+      return { call, toolName, rawInput, 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({
+              toolName: entry.toolName,
+              tool: request.tools[entry.toolName],
+              rawInput: entry.rawInput
+            });
+            return { entry, result, outputPayload };
+          }
+        );
+      })
+    );
+    for (const { entry, result, outputPayload } of callResults) {
+      toolCalls.push({ ...result, callId: entry.call.id });
+      const responsePayload = isPlainRecord(outputPayload) ? outputPayload : { output: outputPayload };
+      responseParts.push({
+        functionResponse: {
+          name: entry.toolName,
+          response: responsePayload,
+          ...entry.call.id ? { id: entry.call.id } : {}
+        }
+      });
+    }
+    steps.push({
+      step: steps.length + 1,
+      modelVersion,
+      text: response.responseText.trim() || void 0,
+      thoughts: response.thoughtsText.trim() || void 0,
+      toolCalls,
+      usage: usageTokens,
+      costUsd: stepCostUsd
+    });
+    geminiContents.push({ role: "user", parts: responseParts });
+  }
+  throw new Error(`Tool loop exceeded max steps (${maxSteps}) without final response.`);
+}
+var IMAGE_GRADE_SCHEMA = z3.enum(["pass", "fail"]);
+async function gradeGeneratedImage(params) {
+  const parts = [
+    {
+      type: "text",
+      text: [
+        params.gradingPrompt,
+        "",
+        "Image prompt to grade:",
+        params.imagePrompt,
+        "",
+        'Respond with the JSON string "pass" or "fail".'
+      ].join("\\n")
+    },
+    {
+      type: "inlineData",
+      data: params.image.data.toString("base64"),
+      mimeType: params.image.mimeType ?? "image/png"
+    }
+  ];
+  const { value } = await generateJson({
+    model: params.model,
+    contents: [{ role: "user", parts }],
+    schema: IMAGE_GRADE_SCHEMA
+  });
+  return value;
+}
+async function generateImages(request) {
+  const maxAttempts = Math.max(1, Math.floor(request.maxAttempts ?? 4));
+  const promptList = Array.from(request.imagePrompts);
+  if (promptList.length === 0) {
+    return [];
+  }
+  const numImages = promptList.length;
+  const promptEntries = promptList.map((rawPrompt, arrayIndex) => {
+    const trimmedPrompt = rawPrompt.trim();
+    if (!trimmedPrompt) {
+      throw new Error(`imagePrompts[${arrayIndex}] must be a non-empty string`);
+    }
+    return { index: arrayIndex + 1, prompt: trimmedPrompt };
+  });
+  const gradingPrompt = request.imageGradingPrompt.trim();
+  if (!gradingPrompt) {
+    throw new Error("imageGradingPrompt must be a non-empty string");
+  }
+  const addText = (parts, text) => {
+    const lastPart = parts[parts.length - 1];
+    if (lastPart !== void 0 && lastPart.type === "text") {
+      lastPart.text = `${lastPart.text}\\n${text}`;
+    } else {
+      parts.push({ type: "text", text });
+    }
+  };
+  const buildInitialPromptParts = () => {
+    const parts = [];
+    addText(
+      parts,
+      [
+        `Please make all ${numImages} requested images:`,
+        "",
+        "Follow the style:",
+        request.stylePrompt
+      ].join("\\n")
+    );
+    if (request.styleImages && request.styleImages.length > 0) {
+      addText(
+        parts,
+        "\\nFollow the visual style, composition and the characters from these images:"
+      );
+      for (const styleImage of request.styleImages) {
+        parts.push({
+          type: "inlineData",
+          data: styleImage.data.toString("base64"),
+          mimeType: styleImage.mimeType
+        });
+      }
+    }
+    const lines = ["", "Image descriptions:"];
+    for (const entry of promptEntries) {
+      lines.push(`\\nImage ${entry.index}: ${entry.prompt}`);
+    }
+    lines.push("");
+    lines.push(`Please make all ${numImages} images.`);
+    addText(parts, lines.join("\\n"));
+    return parts;
+  };
+  const buildContinuationPromptParts = (pending) => {
+    const pendingIds = pending.map((entry) => entry.index).join(", ");
+    const lines = [
+      `Please continue generating the remaining images: ${pendingIds}.`,
+      "",
+      "Image descriptions:"
+    ];
+    for (const entry of pending) {
+      lines.push(`\\nImage ${entry.index}: ${entry.prompt}`);
+    }
+    lines.push(`\\nPlease make all ${pending.length} remaining images.`);
+    return [{ type: "text", text: lines.join("\\n") }];
+  };
+  const contents = [{ role: "user", parts: buildInitialPromptParts() }];
+  const orderedEntries = [...promptEntries];
+  const resolvedImages = /* @__PURE__ */ new Map();
+  const removeResolvedEntries = (resolved) => {
+    if (resolved.size === 0) {
+      return;
+    }
+    for (let i = promptEntries.length - 1; i >= 0; i -= 1) {
+      const entry = promptEntries[i];
+      if (!entry) {
+        continue;
+      }
+      if (resolved.has(entry.index)) {
+        promptEntries.splice(i, 1);
+      }
+    }
+  };
+  for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+    const result = await generateText({
+      model: request.model,
+      contents,
+      responseModalities: ["IMAGE", "TEXT"],
+      imageAspectRatio: request.imageAspectRatio,
+      imageSize: request.imageSize ?? "2K"
+    });
+    if (result.blocked || !result.content) {
+      continue;
+    }
+    const images = extractImages(result.content);
+    if (images.length > 0 && promptEntries.length > 0) {
+      const assignedCount = Math.min(images.length, promptEntries.length);
+      const pendingAssignments = promptEntries.slice(0, assignedCount);
+      const assignedImages = images.slice(0, assignedCount);
+      const gradeResults = await Promise.all(
+        pendingAssignments.map(
+          (entry, index) => gradeGeneratedImage({
+            gradingPrompt,
+            imagePrompt: entry.prompt,
+            image: (() => {
+              const image = assignedImages[index];
+              if (!image) {
+                throw new Error("Image generation returned fewer images than expected.");
+              }
+              return image;
+            })(),
+            model: "gpt-5.2"
+          })
+        )
+      );
+      const passedEntries = /* @__PURE__ */ new Set();
+      for (let i = 0; i < gradeResults.length; i += 1) {
+        const grade = gradeResults[i];
+        const entry = pendingAssignments[i];
+        const image = assignedImages[i];
+        if (!grade || !entry || !image) {
+          continue;
+        }
+        if (grade === "pass") {
+          resolvedImages.set(entry.index, image);
+          passedEntries.add(entry.index);
+        }
+      }
+      removeResolvedEntries(passedEntries);
+    }
+    if (promptEntries.length === 0) {
+      break;
+    }
+    contents.push(result.content);
+    contents.push({ role: "user", parts: buildContinuationPromptParts(promptEntries) });
+  }
+  const orderedImages = [];
+  for (const entry of orderedEntries) {
+    const image = resolvedImages.get(entry.index);
+    if (image) {
+      orderedImages.push(image);
+    }
+  }
+  return orderedImages.slice(0, numImages);
+}
+async function generateImageInBatches(request) {
+  const {
+    batchSize,
+    overlapSize,
+    imagePrompts,
+    styleImages: baseStyleImagesInput,
+    ...rest
+  } = request;
+  if (batchSize <= 0) {
+    throw new Error("batchSize must be greater than 0");
+  }
+  if (imagePrompts.length === 0) {
+    return [];
+  }
+  const baseStyleImages = baseStyleImagesInput ? [...baseStyleImagesInput] : [];
+  const generatedImages = [];
+  const totalPrompts = imagePrompts.length;
+  for (let startIndex = 0; startIndex < totalPrompts; startIndex += batchSize) {
+    const endIndex = Math.min(startIndex + batchSize, totalPrompts);
+    const batchPrompts = imagePrompts.slice(startIndex, endIndex);
+    let styleImagesForBatch = baseStyleImages;
+    if (overlapSize > 0 && generatedImages.length > 0) {
+      const overlapImages = generatedImages.slice(
+        Math.max(0, generatedImages.length - overlapSize)
+      );
+      if (overlapImages.length > 0) {
+        styleImagesForBatch = [...baseStyleImages, ...overlapImages];
+      }
+    }
+    const batchImages = await generateImages({
+      ...rest,
+      imagePrompts: batchPrompts,
+      styleImages: styleImagesForBatch
+    });
+    generatedImages.push(...batchImages);
+  }
+  return generatedImages;
+}
+function stripCodexCitationMarkers(value) {
+  const citationBlockPattern = /\uE200cite\uE202[^\uE201]*\uE201/gu;
+  const leftoverMarkersPattern = /[\uE200\uE201\uE202]/gu;
+  const withoutBlocks = value.replace(citationBlockPattern, "");
+  const withoutMarkers = withoutBlocks.replace(leftoverMarkersPattern, "");
+  const stripped = withoutMarkers !== value;
+  return { text: withoutMarkers, stripped };
+}
+function hasMarkdownSourcesSection(value) {
+  return /^##\s+Sources\s*$/gmu.test(value);
+}
+function appendMarkdownSourcesSection(value, sources) {
+  const trimmed = value.trimEnd();
+  if (sources.length === 0) {
+    return trimmed;
+  }
+  if (hasMarkdownSourcesSection(trimmed)) {
+    return trimmed;
+  }
+  const lines = sources.map((url) => `- <${url}>`).join("\n");
+  return `${trimmed}
+
+## Sources
+${lines}`;
+}
+export {
+  LlmJsonCallError,
+  appendMarkdownSourcesSection,
+  configureGemini,
+  convertGooglePartsToLlmParts,
+  encodeChatGptAuthJson,
+  encodeChatGptAuthJsonB64,
+  estimateCallCostUsd,
+  exchangeChatGptOauthCode,
+  generateImageInBatches,
+  generateImages,
+  generateJson,
+  generateText,
+  getChatGptAuthProfile,
+  getCurrentToolCallContext,
+  isGeminiModelId,
+  loadEnvFromFile,
+  loadLocalEnv,
+  parseJsonFromLlmText,
+  refreshChatGptOauthToken,
+  runToolLoop,
+  sanitisePartForLogging,
+  streamText,
+  stripCodexCitationMarkers,
+  toGeminiJsonSchema,
+  tool
+};
+//# sourceMappingURL=index.js.map