@ggui-ai/ui-gen 0.28.0 → 0.29.0

package/dist/chunk-O2YC6XDC.js

@@ -0,0 +1,1933 @@
+import { createAnthropicClient } from './chunk-QLXXPGTV.js';
+import { CLAUDE_CODE_LOGIN_CREDENTIAL, PROVIDER_KEY_ENV_NAMES, loadClaudeAgentSdk, MCP_SERVER_NAME, claudeCodeLoginQueryOptions, loginChildEnv } from './chunk-JDH5EGNZ.js';
+import { splitCacheInclusiveUsage, splitOpenAiUsage } from './chunk-OVLH5ICV.js';
+import { toolArgsToJsonObject } from './chunk-7QE3AHLE.js';
+import { newLlmTraceId, emitLlmTraceEvent, summarizeTools } from './chunk-5AGTY555.js';
+import { anthropicRejectsForcedToolChoice, normalizeAnthropicModelId, isRecord, anthropicRejectsSamplingParams } from '@ggui-ai/protocol';
+import * as z from 'zod';
+
+// src/adapters/provider-router.ts
+function getBedrockModelId(model) {
+  const BEDROCK_MAP = {
+    "anthropic/claude-haiku-4-5": "us.anthropic.claude-haiku-4-5-20251001-v1:0",
+    "anthropic/claude-haiku-5-5": "us.anthropic.claude-haiku-5-5",
+    // listed ACTIVE in us-east-1 (ggui#1743)
+    "anthropic/claude-sonnet-4-6": "us.anthropic.claude-sonnet-4-6",
+    "anthropic/claude-opus-4-6": "us.anthropic.claude-opus-4-6-v1:0",
+    // Claude 5-family (ggui#706, strings verified 2026-09-02 against
+    // platform.claude.com; Bedrock base form `anthropic.<id>`, upcast to
+    // the cross-region profile). Explicit so the ids are pinned by test,
+    // not merely reachable through the generic fallback below.
+    "anthropic/claude-fable-5-1": "us.anthropic.claude-fable-5-1",
+    "anthropic/claude-opus-5": "us.anthropic.claude-opus-5",
+    "anthropic/claude-sonnet-5": "us.anthropic.claude-sonnet-5",
+    // Legacy (still available; registry state `legacy`, not deprecated).
+    "anthropic/claude-fable-5": "us.anthropic.claude-fable-5"
+  };
+  const normalized = model.replace(/^anthropic\./, "anthropic/");
+  if (BEDROCK_MAP[normalized]) return BEDROCK_MAP[normalized];
+  if (normalized.startsWith("us.anthropic.") || normalized.startsWith("arn:")) {
+    return normalized;
+  }
+  const stripped = normalized.replace(/^anthropic\//, "");
+  return `us.anthropic.${stripped}`;
+}
+var SIBLING_ENV_KEYS = [
+  "ANTHROPIC_API_KEY",
+  "ANTHROPIC_BASE_URL",
+  "CLAUDE_CODE_USE_BEDROCK",
+  "OPENAI_API_KEY",
+  "GEMINI_API_KEY",
+  "GOOGLE_API_KEY",
+  "OPENROUTER_API_KEY"
+];
+function clearSiblings(keep) {
+  const out = {};
+  for (const k of SIBLING_ENV_KEYS) {
+    if (!keep.has(k)) out[k] = void 0;
+  }
+  return out;
+}
+function resolveRoute(input) {
+  const { route, apiKey, env } = input;
+  if (apiKey === CLAUDE_CODE_LOGIN_CREDENTIAL && route.provider !== "anthropic") {
+    throw new Error(
+      `${route.provider}:${route.model} cannot use the claude-code-login credential \u2014 the machine's Claude Code login authenticates the Claude Code binary only; pick an anthropic route or supply a ${route.provider} API key.`
+    );
+  }
+  switch (route.provider) {
+    case "openai": {
+      if (!apiKey) {
+        throw new Error(
+          `openai:${route.model} requires an API key. Set 'apiKey' on the RoutingInput (BYOK) or supply your key via your dispatch layer.`
+        );
+      }
+      return {
+        model: route.model,
+        env: {
+          OPENAI_API_KEY: apiKey,
+          ...clearSiblings(/* @__PURE__ */ new Set(["OPENAI_API_KEY"]))
+        }
+      };
+    }
+    case "google": {
+      if (!apiKey) {
+        throw new Error(
+          `google:${route.model} requires an API key. Set 'apiKey' on the RoutingInput (BYOK) or supply your key via your dispatch layer.`
+        );
+      }
+      return {
+        model: route.model,
+        env: {
+          // `harness/llm-router.ts`'s GoogleAgent reads `GEMINI_API_KEY
+          // || GOOGLE_API_KEY`. Set both so either slot wins;
+          // unsetting one would leave a stale value behind.
+          GEMINI_API_KEY: apiKey,
+          GOOGLE_API_KEY: apiKey,
+          ...clearSiblings(/* @__PURE__ */ new Set(["GEMINI_API_KEY", "GOOGLE_API_KEY"]))
+        }
+      };
+    }
+    case "openrouter": {
+      if (!apiKey) {
+        throw new Error(
+          `openrouter:${route.model} requires an API key. Set 'apiKey' on the RoutingInput (BYOK) or supply your key via your dispatch layer.`
+        );
+      }
+      return {
+        model: route.model,
+        env: {
+          OPENROUTER_API_KEY: apiKey,
+          ...clearSiblings(/* @__PURE__ */ new Set(["OPENROUTER_API_KEY"]))
+        }
+      };
+    }
+    case "bedrock": {
+      return {
+        model: route.model,
+        env: {
+          CLAUDE_CODE_USE_BEDROCK: "1",
+          ...clearSiblings(/* @__PURE__ */ new Set(["CLAUDE_CODE_USE_BEDROCK"]))
+        }
+      };
+    }
+    case "anthropic": {
+      if (apiKey === CLAUDE_CODE_LOGIN_CREDENTIAL) {
+        const cleared = {};
+        for (const k of PROVIDER_KEY_ENV_NAMES) cleared[k] = void 0;
+        return {
+          model: route.model,
+          env: { ...cleared, ...clearSiblings(/* @__PURE__ */ new Set()) },
+          auth: "claude-code-login"
+        };
+      }
+      if (apiKey) {
+        return {
+          model: route.model,
+          env: {
+            ANTHROPIC_API_KEY: apiKey,
+            ...clearSiblings(/* @__PURE__ */ new Set(["ANTHROPIC_API_KEY"]))
+          }
+        };
+      }
+      const explicitBedrock = env.CLAUDE_CODE_USE_BEDROCK === "1";
+      const noApiKey = !env.ANTHROPIC_API_KEY;
+      if (explicitBedrock || noApiKey) {
+        return {
+          model: getBedrockModelId(route.model),
+          env: {
+            CLAUDE_CODE_USE_BEDROCK: "1",
+            ...clearSiblings(/* @__PURE__ */ new Set(["CLAUDE_CODE_USE_BEDROCK"]))
+          }
+        };
+      }
+      return {
+        model: route.model,
+        env: clearSiblings(/* @__PURE__ */ new Set(["ANTHROPIC_API_KEY"]))
+      };
+    }
+  }
+}
+function applyRouteToEnv(baseEnv, route) {
+  const result = { ...baseEnv };
+  for (const [key, value] of Object.entries(route.env)) {
+    if (value === void 0) {
+      delete result[key];
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+var MCP_TOOL_PREFIX = `mcp__${MCP_SERVER_NAME}__`;
+function stripMcpToolPrefix(name) {
+  return name.startsWith(MCP_TOOL_PREFIX) ? name.slice(MCP_TOOL_PREFIX.length) : name;
+}
+var LOGIN_API_KEY_SOURCE = "none";
+var ClaudeCodeLoginAuthError = class extends Error {
+  apiKeySource;
+  constructor(apiKeySource) {
+    super(
+      `claude-code-login: the Claude Code binary authenticated from apiKeySource=${apiKeySource}, not from its login \u2014 a provider key reached the spawned process; the run was stopped before it spent a turn`
+    );
+    this.name = "ClaudeCodeLoginAuthError";
+    this.apiKeySource = apiKeySource;
+  }
+};
+var ClaudeCodeLoginResultError = class extends Error {
+  subtype;
+  errors;
+  status;
+  constructor(subtype, errors, status) {
+    super(
+      `claude-code-login: query() ended with ${subtype}` + (status !== void 0 ? ` (api status ${status})` : "") + `: ${errors.length > 0 ? errors.join("; ") : "no detail from the binary"}`
+    );
+    this.name = "ClaudeCodeLoginResultError";
+    this.subtype = subtype;
+    this.errors = errors;
+    this.status = status;
+  }
+};
+function createDenyingIntercept(intercepted) {
+  return async (toolName, input) => {
+    intercepted.push({ name: toolName, input });
+    return {
+      behavior: "deny",
+      message: "ggui executes tools in its harness; the binary only proposes them."
+    };
+  };
+}
+async function* imageUserMessage(text, image) {
+  const message = {
+    role: "user",
+    content: [
+      {
+        type: "image",
+        source: { type: "base64", media_type: image.mediaType, data: image.base64 }
+      },
+      { type: "text", text }
+    ]
+  };
+  yield { type: "user", message, parent_tool_use_id: null };
+}
+function buildLoginQueryOptions(params) {
+  return {
+    model: params.model,
+    systemPrompt: params.systemPrompt,
+    maxTurns: 1,
+    thinking: { type: "disabled" },
+    env: loginChildEnv(params.env ?? process.env),
+    ...claudeCodeLoginQueryOptions(),
+    ...params.tools !== void 0 ? {
+      mcpServers: { [MCP_SERVER_NAME]: params.tools.server },
+      canUseTool: params.tools.canUseTool
+    } : {}
+  };
+}
+var JSON_SCHEMA_TYPES = [
+  "object",
+  "array",
+  "string",
+  "number",
+  "boolean",
+  "null",
+  "integer"
+];
+function isJsonSchemaType(value) {
+  return typeof value === "string" && JSON_SCHEMA_TYPES.includes(value);
+}
+function isJsonObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function schemaAt(value, path) {
+  if (typeof value === "boolean") return value;
+  if (!isJsonObject(value)) {
+    throw new Error(
+      `claude-code-login: ${path} must be a JSON-Schema object or boolean, got ${JSON.stringify(value)}`
+    );
+  }
+  return toZodJsonSchema(value, path);
+}
+function toZodJsonSchema(parameters, path = "parameters") {
+  const out = {};
+  for (const [key, value] of Object.entries(parameters)) {
+    if (value === void 0) continue;
+    switch (key) {
+      case "type": {
+        if (!isJsonSchemaType(value)) {
+          throw new Error(
+            `claude-code-login: ${path}.type must be one of ${JSON_SCHEMA_TYPES.join("|")}, got ${JSON.stringify(value)}`
+          );
+        }
+        out.type = value;
+        break;
+      }
+      case "properties":
+      case "patternProperties":
+      case "$defs": {
+        if (!isJsonObject(value))
+          throw new Error(`claude-code-login: ${path}.${key} must be an object`);
+        const record = {};
+        for (const [name, sub] of Object.entries(value)) {
+          if (sub === void 0) continue;
+          record[name] = schemaAt(sub, `${path}.${key}.${name}`);
+        }
+        if (key === "$defs") {
+          const defs = {};
+          for (const [name, sub] of Object.entries(record)) {
+            if (typeof sub === "boolean")
+              throw new Error(`claude-code-login: ${path}.$defs.${name} must be an object`);
+            defs[name] = sub;
+          }
+          out.$defs = defs;
+        } else {
+          out[key] = record;
+        }
+        break;
+      }
+      case "items": {
+        out.items = Array.isArray(value) ? value.map((sub, i) => schemaAt(sub, `${path}.items[${i}]`)) : schemaAt(value, `${path}.items`);
+        break;
+      }
+      case "additionalProperties":
+      case "not": {
+        out[key] = schemaAt(value, `${path}.${key}`);
+        break;
+      }
+      case "anyOf":
+      case "oneOf":
+      case "allOf": {
+        if (!Array.isArray(value))
+          throw new Error(`claude-code-login: ${path}.${key} must be an array`);
+        out[key] = value.map((sub, i) => {
+          const s = schemaAt(sub, `${path}.${key}[${i}]`);
+          if (typeof s === "boolean")
+            throw new Error(`claude-code-login: ${path}.${key}[${i}] must be an object`);
+          return s;
+        });
+        break;
+      }
+      case "required": {
+        if (!Array.isArray(value) || !value.every((v) => typeof v === "string")) {
+          throw new Error(`claude-code-login: ${path}.required must be an array of strings`);
+        }
+        out.required = value;
+        break;
+      }
+      case "enum": {
+        if (!Array.isArray(value) || !value.every(
+          (v) => v === null || typeof v === "string" || typeof v === "number" || typeof v === "boolean"
+        )) {
+          throw new Error(`claude-code-login: ${path}.enum must be an array of primitives`);
+        }
+        out.enum = value;
+        break;
+      }
+      default:
+        out[key] = value;
+    }
+  }
+  return out;
+}
+function createLoginToolServer(sdk, tools) {
+  const sdkTools = tools.map((def) => {
+    const schema = z.fromJSONSchema(toZodJsonSchema(def.parameters, `${def.name}.parameters`));
+    if (!(schema instanceof z.ZodObject)) {
+      throw new Error(
+        `claude-code-login: tool ${def.name}'s parameters must be a JSON-Schema object`
+      );
+    }
+    return sdk.tool(def.name, def.description, schema.shape, async () => {
+      throw new Error(
+        `claude-code-login: the binary tried to execute ${def.name} \u2014 ggui's tools are proposed to the harness and never run in the binary (the intercept denies every call)`
+      );
+    });
+  });
+  return sdk.createSdkMcpServer({ name: MCP_SERVER_NAME, version: "1.0.0", tools: sdkTools });
+}
+var LOGIN_REQUIRED_TOOL_INSTRUCTION = "Respond only with tool calls: do not write any text before, between or after them. Text outside a tool call is not read.";
+function describeCalls(calls) {
+  return JSON.stringify(calls.map((c) => ({ name: stripMcpToolPrefix(c.name), input: c.input })));
+}
+async function collectLoginTurn(stream, opts) {
+  let init;
+  const toolCalls = [];
+  let text = "";
+  let thinkingBlocks = 0;
+  let result;
+  try {
+    for await (const msg of stream) {
+      if (msg.type === "system" && msg.subtype === "init") {
+        const measured = msg;
+        init = measured;
+        opts.log(
+          `[claude-code-login] apiKeySource=${measured.apiKeySource} claude_code_version=${measured.claude_code_version} model=${measured.model}`
+        );
+        if (measured.apiKeySource !== LOGIN_API_KEY_SOURCE) {
+          throw new ClaudeCodeLoginAuthError(measured.apiKeySource);
+        }
+      } else if (msg.type === "assistant") {
+        for (const block of msg.message.content) {
+          if (block.type === "tool_use") {
+            toolCalls.push({
+              id: block.id,
+              name: stripMcpToolPrefix(block.name),
+              input: isRecord(block.input) ? toolArgsToJsonObject(block.input) : {}
+            });
+          } else if (block.type === "text") {
+            text += block.text;
+          } else if (block.type === "thinking" || block.type === "redacted_thinking") {
+            thinkingBlocks += 1;
+          }
+        }
+      } else if (msg.type === "result") {
+        result = msg;
+      }
+    }
+  } catch (e) {
+    if (result === void 0) throw e;
+    opts.log(
+      `[claude-code-login] query() threw after its result message \u2014 the result decides (${e instanceof Error ? e.message : String(e)})`
+    );
+  }
+  if (result === void 0) {
+    throw new Error("claude-code-login: query() ended without a result message");
+  }
+  const usage = result.usage;
+  const thinkingTokens = usage.output_tokens_details?.thinking_tokens ?? 0;
+  opts.log(
+    `[claude-code-login] usage kind=${opts.kind} input=${usage.input_tokens} output=${usage.output_tokens} cacheRead=${usage.cache_read_input_tokens} cacheCreated=${usage.cache_creation_input_tokens} thinking=${thinkingTokens} thinkingBlocks=${thinkingBlocks} textChars=${text.length} toolCalls=${toolCalls.length} stop=${result.stop_reason ?? "none"} choice=${opts.choice}`
+  );
+  const streamSaw = describeCalls(toolCalls);
+  const interceptSaw = describeCalls(opts.intercepted);
+  if (streamSaw !== interceptSaw) {
+    opts.warn(
+      `[claude-code-login] intercept/stream disagreement \u2014 the stream's blocks win. intercepted=${interceptSaw} stream=${streamSaw}`
+    );
+  }
+  if (result.subtype === "success") {
+    if (result.is_error) {
+      throw new ClaudeCodeLoginResultError(
+        "success",
+        [result.result],
+        result.api_error_status ?? void 0
+      );
+    }
+  } else if (result.subtype !== "error_max_turns") {
+    const failed = result;
+    throw new ClaudeCodeLoginResultError(failed.subtype, failed.errors, void 0);
+  }
+  return { init, toolCalls, text, result };
+}
+
+// src/harness/llm-router.ts
+function servedModelOf(name) {
+  return typeof name === "string" && name.length > 0 ? { servedModel: name } : {};
+}
+function anthropicFinishReason(stopReason) {
+  if (stopReason === null || stopReason === void 0) return void 0;
+  if (stopReason === "end_turn" || stopReason === "stop_sequence") return "stop";
+  if (stopReason === "max_tokens") return "length";
+  if (stopReason === "refusal") return "content-filter";
+  return "other";
+}
+function googleFinishReason(finishReason) {
+  if (finishReason === null || finishReason === void 0) return void 0;
+  if (finishReason === "STOP") return "stop";
+  if (finishReason === "MAX_TOKENS") return "length";
+  if (["SAFETY", "RECITATION", "BLOCKLIST", "PROHIBITED_CONTENT", "SPII", "IMAGE_SAFETY"].includes(finishReason)) return "content-filter";
+  return "other";
+}
+function visionFinish(finishReason) {
+  return finishReason !== void 0 ? { finishReason } : {};
+}
+function addStrictSchemaConstraints(schema) {
+  const result = { ...schema };
+  if (result.type === "object" && result.properties) {
+    result.additionalProperties = false;
+    const propKeys = Object.keys(result.properties);
+    if (!result.required || result.required.length < propKeys.length) {
+      result.required = propKeys;
+    }
+    const props = { ...result.properties };
+    for (const [key, value] of Object.entries(props)) {
+      if (typeof value === "object" && value !== null) {
+        props[key] = addStrictSchemaConstraints(value);
+      }
+    }
+    result.properties = props;
+  }
+  if (result.type === "array" && result.items && typeof result.items === "object") {
+    result.items = addStrictSchemaConstraints(result.items);
+  }
+  return result;
+}
+function errorSummary(e) {
+  if (!(e instanceof Error)) return String(e);
+  const status = "status" in e ? ` (${e.status})` : "";
+  const code = "code" in e ? ` [${e.code}]` : "";
+  let body = "";
+  if ("error" in e && typeof e.error === "object") {
+    const errObj = e.error;
+    if (errObj?.message) body = ` body="${errObj.message.slice(0, 200)}"`;
+  }
+  return `${e.constructor.name}${status}${code}: ${e.message.slice(0, 120)}${body}`;
+}
+function isRateLimited(e) {
+  if (!(e instanceof Error) || !("status" in e)) return false;
+  return e.status === 429;
+}
+function extractStatus(e) {
+  if (!(e instanceof Error) || !("status" in e)) return void 0;
+  const status = e.status;
+  return typeof status === "number" ? status : void 0;
+}
+function extractRetryAfterSec(e) {
+  if (!(e instanceof Error) || !("headers" in e)) return void 0;
+  const headers = e.headers;
+  if (headers === null || typeof headers !== "object" || !("get" in headers) || typeof headers.get !== "function") {
+    return void 0;
+  }
+  const raw = headers.get("retry-after");
+  if (raw === null) return void 0;
+  const parsed = Number(raw);
+  return Number.isFinite(parsed) && parsed >= 0 ? Math.floor(parsed) : void 0;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var MAX_RETRY_ATTEMPTS = 2;
+var RETRY_AFTER_CAP_SEC = 15;
+var DEFAULT_BACKOFF_BASE_MS = 1e3;
+var DEFAULT_BACKOFF_MAX_MS = 8e3;
+var MAX_TOTAL_RETRY_DELAY_MS = 2e4;
+var LLMAgent = class {
+  client = null;
+  // ── Session state for server-side chaining ──────────────
+  // Google: previous_interaction_id, OpenAI: previous_response_id
+  // Enables turn 2+ to skip re-sending system prompt + history.
+  // Call resetSession() between independent generation runs.
+  lastSessionId;
+  /**
+   * Explicit per-call routing override — see `AgentConfig.routeOverride`.
+   * Absent when constructed via the bare `new XAgent()` form (every
+   * existing call site), so `createClient()`/`resolveModel()` fall
+   * back to `process.env` exactly as before.
+   */
+  routeOverride;
+  /** See `AgentConfig.onRetry` (#489). Absent is a no-op. */
+  onRetry;
+  constructor(routeOverride, onRetry) {
+    this.routeOverride = routeOverride;
+    this.onRetry = onRetry;
+  }
+  async getClient() {
+    if (!this.client) {
+      this.client = await this.createClient();
+    }
+    return this.client;
+  }
+  /**
+   * Pre-warm cache for repeated callTools() calls with the same system prompt + tools.
+   * Override in providers that support server-side context caching (e.g., Google).
+   * No-op by default (Anthropic/OpenAI handle caching automatically per-request).
+   */
+  async warmCache(_model, _systemPrompt, _tools, _toolChoice) {
+  }
+  /** Cleanup any cached resources. Call after generation completes. No-op by default. */
+  async cleanup() {
+  }
+  /** Reset session state between independent generation runs. */
+  resetSession() {
+    this.lastSessionId = void 0;
+  }
+  /**
+   * Send tool execution results back to the provider to close the API contract.
+   * Call this after executing tools from callTools() and before the next callTools().
+   *
+   * For providers with server-side state (Google, OpenAI), this sends the
+   * function results so the next callTools() can chain properly.
+   * For stateless providers (Anthropic), this is a no-op.
+   *
+   * Override in providers that need it.
+   */
+  async sendToolResult(_results) {
+  }
+  /**
+   * Execute an API call, retrying once or twice on HTTP 429
+   * (rate-limited) before giving up (#489).
+   *
+   * Policy: on a 429, honor the provider's `Retry-After` header when
+   * present (capped at `RETRY_AFTER_CAP_SEC` — a provider asking for a
+   * longer wait is treated as "don't retry", not "wait longer": making
+   * the caller sit through 15+ more seconds on a single failed call is
+   * a bad experience regardless of what's driving the request);
+   * otherwise fall back to exponential backoff with jitter, capped at
+   * `DEFAULT_BACKOFF_MAX_MS` per attempt. Stops after
+   * `MAX_RETRY_ATTEMPTS` retries OR once the cumulative delay would
+   * exceed `MAX_TOTAL_RETRY_DELAY_MS`, whichever comes first. Any
+   * non-429 error, or a 429 with no attempts left, is logged and
+   * re-thrown immediately — unchanged from the pre-#489 behavior.
+   *
+   * **Budget scope (final-review correction):** `MAX_TOTAL_RETRY_DELAY_MS`
+   * bounds a single `apiCall()` invocation, not a whole generation. A
+   * generation issues many sequential `apiCall()` calls (coding turns,
+   * tool-result round-trips, eval rounds); under sustained throttling
+   * each one can independently add up to `MAX_TOTAL_RETRY_DELAY_MS`, so
+   * a generation with k rate-limited calls can add up to roughly `k *
+   * MAX_TOTAL_RETRY_DELAY_MS` to how long it holds its caller's
+   * resources (e.g. the caller's concurrency slot) — not a flat 20s
+   * ceiling. No shared per-generation budget is threaded here by
+   * design (accepted ruling, not an oversight): the caller's own
+   * queue/admission backstop is what bounds how long other
+   * queued work waits, independent of any one generation's retry
+   * total.
+   */
+  async apiCall(fn) {
+    const start = Date.now();
+    let totalDelayMs = 0;
+    for (let attempt = 0; ; attempt++) {
+      try {
+        return await fn();
+      } catch (e) {
+        const ms = Date.now() - start;
+        if (attempt >= MAX_RETRY_ATTEMPTS || !isRateLimited(e)) {
+          console.error(`[${this.provider}] API error after ${ms}ms: ${errorSummary(e)}`);
+          throw e;
+        }
+        const retryAfterSec = extractRetryAfterSec(e);
+        if (retryAfterSec !== void 0 && retryAfterSec > RETRY_AFTER_CAP_SEC) {
+          console.error(
+            `[${this.provider}] API error after ${ms}ms (retry-after ${retryAfterSec}s exceeds ${RETRY_AFTER_CAP_SEC}s cap, not retrying): ${errorSummary(e)}`
+          );
+          throw e;
+        }
+        const delayMs = retryAfterSec !== void 0 ? retryAfterSec * 1e3 : Math.min(DEFAULT_BACKOFF_BASE_MS * 2 ** attempt, DEFAULT_BACKOFF_MAX_MS) + Math.floor(Math.random() * 250);
+        if (totalDelayMs + delayMs > MAX_TOTAL_RETRY_DELAY_MS) {
+          console.error(
+            `[${this.provider}] API error after ${ms}ms (retry budget exhausted, not retrying): ${errorSummary(e)}`
+          );
+          throw e;
+        }
+        totalDelayMs += delayMs;
+        const info = {
+          provider: this.provider,
+          attempt: attempt + 1,
+          maxAttempts: MAX_RETRY_ATTEMPTS,
+          status: extractStatus(e),
+          retryAfterSec,
+          delayMs,
+          message: errorSummary(e)
+        };
+        console.warn(
+          `[${this.provider}] rate-limited (attempt ${info.attempt}/${info.maxAttempts}), retrying in ${delayMs}ms`
+        );
+        try {
+          this.onRetry?.(info);
+        } catch (observerError) {
+          console.warn(
+            `[${this.provider}] onRetry observer threw (ignored, retry proceeds): ${errorSummary(observerError)}`
+          );
+        }
+        await sleep(delayMs);
+      }
+    }
+  }
+};
+function resolveAnthropicSampling(model, temperature) {
+  if (temperature === void 0) {
+    return { request: {}, applied: { temperature: "provider-default" } };
+  }
+  if (anthropicRejectsSamplingParams(model)) {
+    return {
+      request: {},
+      applied: {
+        temperature: "provider-default",
+        strippedReason: `${normalizeAnthropicModelId(model)} rejects non-default sampling params (HTTP 400 on Opus 4.7+/5-family); caller's temperature=${temperature} was not sent`
+      }
+    };
+  }
+  return { request: { temperature }, applied: { temperature } };
+}
+var AnthropicAgent = class extends LLMAgent {
+  provider = "anthropic";
+  resolveModel(model) {
+    const useBedrock = this.routeOverride?.useBedrock ?? process.env.CLAUDE_CODE_USE_BEDROCK === "1";
+    if (useBedrock) {
+      return getBedrockModelId(model);
+    }
+    return model.startsWith("anthropic/") ? model.slice("anthropic/".length) : model;
+  }
+  async createClient() {
+    const useBedrock = this.routeOverride?.useBedrock ?? process.env.CLAUDE_CODE_USE_BEDROCK === "1";
+    if (useBedrock) {
+      const { AnthropicBedrock } = await import('@anthropic-ai/bedrock-sdk');
+      return new AnthropicBedrock({
+        awsRegion: process.env.AWS_REGION ?? process.env.AWS_DEFAULT_REGION ?? "us-east-1"
+      });
+    }
+    return createAnthropicClient(this.routeOverride?.apiKey ?? process.env.ANTHROPIC_API_KEY);
+  }
+  async callText(model, systemPrompt, userPrompt, maxTokens, temperature) {
+    const client = await this.getClient();
+    const traceId = newLlmTraceId();
+    const startedAt = Date.now();
+    const resolvedModel = this.resolveModel(model);
+    const system = [
+      {
+        type: "text",
+        text: systemPrompt,
+        cache_control: { type: "ephemeral" }
+      }
+    ];
+    const sampling = resolveAnthropicSampling(resolvedModel, temperature);
+    if (sampling.applied.strippedReason !== void 0) {
+      console.warn(`[anthropic] callText: ${sampling.applied.strippedReason}`);
+    }
+    try {
+      const response = await this.apiCall(
+        () => client.messages.create({
+          model: resolvedModel,
+          max_tokens: maxTokens ?? 4096,
+          system,
+          messages: [{ role: "user", content: userPrompt }],
+          ...sampling.request
+        })
+      );
+      const usage = response.usage;
+      const cacheCreated = usage.cache_creation_input_tokens ?? 0;
+      const cacheRead = usage.cache_read_input_tokens ?? 0;
+      if (cacheCreated || cacheRead) {
+        console.log(`[anthropic] callText cache: created=${cacheCreated} read=${cacheRead} input=${usage.input_tokens} output=${usage.output_tokens}`);
+      }
+      const text = response.content.filter((block) => block.type === "text").map((block) => block.text).join("");
+      const endedAt = Date.now();
+      emitLlmTraceEvent({
+        id: traceId,
+        at: startedAt,
+        endedAt,
+        durationMs: endedAt - startedAt,
+        provider: "anthropic",
+        model: resolvedModel,
+        kind: "callText",
+        systemPrompt,
+        userPrompt,
+        result: {
+          inputTokens: response.usage.input_tokens,
+          outputTokens: response.usage.output_tokens,
+          cacheCreated,
+          cacheRead,
+          text
+        }
+      });
+      return {
+        text,
+        inputTokens: response.usage.input_tokens,
+        outputTokens: response.usage.output_tokens,
+        sampling: sampling.applied
+      };
+    } catch (e) {
+      const endedAt = Date.now();
+      emitLlmTraceEvent({
+        id: traceId,
+        at: startedAt,
+        endedAt,
+        durationMs: endedAt - startedAt,
+        provider: "anthropic",
+        model: resolvedModel,
+        kind: "callText",
+        systemPrompt,
+        userPrompt,
+        error: { message: e instanceof Error ? e.message : String(e) }
+      });
+      throw e;
+    }
+  }
+  async callVision(model, systemPrompt, userPrompt, image, maxTokens) {
+    const client = await this.getClient();
+    const traceId = newLlmTraceId();
+    const startedAt = Date.now();
+    const resolvedModel = this.resolveModel(model);
+    const imageBlock = {
+      type: "image",
+      source: {
+        type: "base64",
+        media_type: image.mediaType,
+        data: image.base64
+      }
+    };
+    try {
+      const response = await this.apiCall(
+        () => client.messages.create({
+          model: resolvedModel,
+          max_tokens: maxTokens ?? 1500,
+          system: systemPrompt,
+          messages: [
+            {
+              role: "user",
+              content: [imageBlock, { type: "text", text: userPrompt }]
+            }
+          ]
+        })
+      );
+      const text = response.content.filter((block) => block.type === "text").map((block) => block.text).join("");
+      const endedAt = Date.now();
+      emitLlmTraceEvent({
+        id: traceId,
+        at: startedAt,
+        endedAt,
+        durationMs: endedAt - startedAt,
+        provider: "anthropic",
+        model: resolvedModel,
+        kind: "callVision",
+        systemPrompt,
+        userPrompt,
+        result: {
+          inputTokens: response.usage.input_tokens,
+          outputTokens: response.usage.output_tokens,
+          text
+        }
+      });
+      return {
+        text,
+        inputTokens: response.usage.input_tokens,
+        outputTokens: response.usage.output_tokens,
+        ...visionFinish(anthropicFinishReason(response.stop_reason)),
+        ...servedModelOf(response.model)
+      };
+    } catch (e) {
+      const endedAt = Date.now();
+      emitLlmTraceEvent({
+        id: traceId,
+        at: startedAt,
+        endedAt,
+        durationMs: endedAt - startedAt,
+        provider: "anthropic",
+        model: resolvedModel,
+        kind: "callVision",
+        systemPrompt,
+        userPrompt,
+        error: { message: e instanceof Error ? e.message : String(e) }
+      });
+      throw e;
+    }
+  }
+  async callTools(model, systemPrompt, userPrompt, tools, toolChoice = "required", _scopedTools) {
+    const client = await this.getClient();
+    const traceId = newLlmTraceId();
+    const startedAt = Date.now();
+    const resolvedModel = this.resolveModel(model);
+    const system = [
+      {
+        type: "text",
+        text: systemPrompt,
+        cache_control: { type: "ephemeral" }
+      }
+    ];
+    const cachedTools = tools.map((t, i) => ({
+      name: t.name,
+      description: t.description,
+      input_schema: t.parameters,
+      // Mark last tool to cache the entire tool list
+      ...i === tools.length - 1 ? { cache_control: { type: "ephemeral" } } : {}
+    }));
+    try {
+      const appliedToolChoice = toolChoice === "required" && anthropicRejectsForcedToolChoice(resolvedModel) ? "auto" : toolChoice;
+      if (appliedToolChoice !== toolChoice) {
+        console.warn(
+          `[anthropic] callTools: ${normalizeAnthropicModelId(resolvedModel)} would reject a forced tool_choice (the API answers 400); caller's 'required' downgraded to 'auto' before sending`
+        );
+      }
+      const response = await this.apiCall(
+        () => client.messages.stream({
+          model: resolvedModel,
+          max_tokens: 32768,
+          system,
+          messages: [{ role: "user", content: userPrompt }],
+          tools: cachedTools,
+          tool_choice: { type: appliedToolChoice === "required" ? "any" : "auto" }
+        }).finalMessage()
+      );
+      const usage = response.usage;
+      const cacheCreated = usage.cache_creation_input_tokens ?? 0;
+      const cacheRead = usage.cache_read_input_tokens ?? 0;
+      if (cacheCreated || cacheRead) {
+        console.log(`[anthropic] callTools cache: created=${cacheCreated} read=${cacheRead} input=${usage.input_tokens} output=${usage.output_tokens}`);
+      }
+      const toolUses = response.content.filter(
+        (block) => block.type === "tool_use"
+      );
+      const toolCalls = toolUses.map((tu) => ({
+        id: tu.id,
+        name: tu.name,
+        input: tu.input ?? {}
+      }));
+      const endedAt = Date.now();
+      emitLlmTraceEvent({
+        id: traceId,
+        at: startedAt,
+        endedAt,
+        durationMs: endedAt - startedAt,
+        provider: "anthropic",
+        model: resolvedModel,
+        kind: "callTools",
+        systemPrompt,
+        userPrompt,
+        tools: summarizeTools(tools),
+        result: {
+          inputTokens: response.usage.input_tokens,
+          outputTokens: response.usage.output_tokens,
+          cacheCreated,
+          cacheRead,
+          toolCalls: toolCalls.map((c) => ({ name: c.name, input: c.input }))
+        }
+      });
+      return {
+        toolCalls,
+        inputTokens: response.usage.input_tokens,
+        outputTokens: response.usage.output_tokens,
+        cacheReadTokens: cacheRead,
+        cacheCreationTokens: cacheCreated,
+        appliedToolChoice
+      };
+    } catch (e) {
+      const endedAt = Date.now();
+      emitLlmTraceEvent({
+        id: traceId,
+        at: startedAt,
+        endedAt,
+        durationMs: endedAt - startedAt,
+        provider: "anthropic",
+        model: resolvedModel,
+        kind: "callTools",
+        systemPrompt,
+        userPrompt,
+        tools: summarizeTools(tools),
+        error: { message: e instanceof Error ? e.message : String(e) }
+      });
+      throw e;
+    }
+  }
+  async callWithTools(model, systemPrompt, userPrompt, tools, maxTurns) {
+    const client = await this.getClient();
+    const resolvedModel = this.resolveModel(model);
+    const traceId = newLlmTraceId();
+    const startedAt = Date.now();
+    const anthropicTools = tools.map((t) => ({
+      name: t.name,
+      description: t.description,
+      input_schema: t.parameters
+    }));
+    const messages = [
+      { role: "user", content: userPrompt }
+    ];
+    let totalIn = 0;
+    let totalOut = 0;
+    let allText = "";
+    try {
+      for (let turn = 0; turn < maxTurns; turn++) {
+        const response = await this.apiCall(
+          () => client.messages.stream({
+            model: resolvedModel,
+            max_tokens: 32768,
+            system: systemPrompt,
+            messages,
+            tools: anthropicTools
+          }).finalMessage()
+        );
+        totalIn += response.usage.input_tokens;
+        totalOut += response.usage.output_tokens;
+        for (const block of response.content) {
+          if (block.type === "text") allText += block.text;
+        }
+        const toolUses = response.content.filter(
+          (b) => b.type === "tool_use"
+        );
+        if (toolUses.length === 0) break;
+        messages.push({ role: "assistant", content: response.content });
+        const toolResults = [];
+        for (const tu of toolUses) {
+          const tool = tools.find((t) => t.name === tu.name);
+          if (!tool) {
+            toolResults.push({
+              type: "tool_result",
+              tool_use_id: tu.id,
+              content: `Tool '${tu.name}' not found`
+            });
+            continue;
+          }
+          const result = await tool.handler(
+            tu.input ?? {}
+          );
+          toolResults.push({
+            type: "tool_result",
+            tool_use_id: tu.id,
+            content: result.content[0]?.text ?? ""
+          });
+        }
+        messages.push({ role: "user", content: toolResults });
+      }
+      const endedAt = Date.now();
+      emitLlmTraceEvent({
+        id: traceId,
+        at: startedAt,
+        endedAt,
+        durationMs: endedAt - startedAt,
+        provider: "anthropic",
+        model: resolvedModel,
+        kind: "callWithTools",
+        systemPrompt,
+        userPrompt,
+        tools: tools.map((t) => ({ name: t.name, description: t.description })),
+        result: {
+          inputTokens: totalIn,
+          outputTokens: totalOut,
+          text: allText,
+          turnsUsed: messages.length
+        }
+      });
+      return {
+        text: allText,
+        inputTokens: totalIn,
+        outputTokens: totalOut,
+        turnsUsed: messages.length
+      };
+    } catch (e) {
+      const endedAt = Date.now();
+      emitLlmTraceEvent({
+        id: traceId,
+        at: startedAt,
+        endedAt,
+        durationMs: endedAt - startedAt,
+        provider: "anthropic",
+        model: resolvedModel,
+        kind: "callWithTools",
+        systemPrompt,
+        userPrompt,
+        tools: tools.map((t) => ({ name: t.name, description: t.description })),
+        error: { message: e instanceof Error ? e.message : String(e) }
+      });
+      throw e;
+    }
+  }
+};
+var ClaudeCodeLoginAgent = class extends LLMAgent {
+  provider = "anthropic";
+  resolveModel(model) {
+    return model.startsWith("anthropic/") ? model.slice("anthropic/".length) : model;
+  }
+  async createClient() {
+    const { query, tool, createSdkMcpServer } = await loadClaudeAgentSdk();
+    return { query, tool, createSdkMcpServer };
+  }
+  async callText(model, systemPrompt, userPrompt, _maxTokens, _temperature) {
+    const sdk = await this.getClient();
+    const traceId = newLlmTraceId();
+    const startedAt = Date.now();
+    const resolvedModel = this.resolveModel(model);
+    try {
+      const turn = await this.apiCall(
+        () => collectLoginTurn(
+          sdk.query({
+            prompt: userPrompt,
+            options: buildLoginQueryOptions({ model: resolvedModel, systemPrompt })
+          }),
+          { intercepted: [], kind: "callText", choice: "none", log: console.log, warn: console.warn }
+        )
+      );
+      const usage = turn.result.usage;
+      const endedAt = Date.now();
+      emitLlmTraceEvent({
+        id: traceId,
+        at: startedAt,
+        endedAt,
+        durationMs: endedAt - startedAt,
+        provider: "claude-code-login",
+        model: resolvedModel,
+        kind: "callText",
+        systemPrompt,
+        userPrompt,
+        result: {
+          inputTokens: usage.input_tokens,
+          outputTokens: usage.output_tokens,
+          cacheCreated: usage.cache_creation_input_tokens,
+          cacheRead: usage.cache_read_input_tokens,
+          text: turn.text
+        }
+      });
+      return { text: turn.text, inputTokens: usage.input_tokens, outputTokens: usage.output_tokens };
+    } catch (e) {
+      const endedAt = Date.now();
+      emitLlmTraceEvent({
+        id: traceId,
+        at: startedAt,
+        endedAt,
+        durationMs: endedAt - startedAt,
+        provider: "claude-code-login",
+        model: resolvedModel,
+        kind: "callText",
+        systemPrompt,
+        userPrompt,
+        error: { message: e instanceof Error ? e.message : String(e) }
+      });
+      throw e;
+    }
+  }
+  async callVision(model, systemPrompt, userPrompt, image, _maxTokens) {
+    const sdk = await this.getClient();
+    const traceId = newLlmTraceId();
+    const startedAt = Date.now();
+    const resolvedModel = this.resolveModel(model);
+    try {
+      const turn = await this.apiCall(
+        () => collectLoginTurn(
+          sdk.query({
+            prompt: imageUserMessage(userPrompt, image),
+            options: buildLoginQueryOptions({ model: resolvedModel, systemPrompt })
+          }),
+          { intercepted: [], kind: "callVision", choice: "none", log: console.log, warn: console.warn }
+        )
+      );
+      const usage = turn.result.usage;
+      const endedAt = Date.now();
+      emitLlmTraceEvent({
+        id: traceId,
+        at: startedAt,
+        endedAt,
+        durationMs: endedAt - startedAt,
+        provider: "claude-code-login",
+        model: resolvedModel,
+        kind: "callVision",
+        systemPrompt,
+        userPrompt,
+        result: { inputTokens: usage.input_tokens, outputTokens: usage.output_tokens, text: turn.text }
+      });
+      return { text: turn.text, inputTokens: usage.input_tokens, outputTokens: usage.output_tokens };
+    } catch (e) {
+      const endedAt = Date.now();
+      emitLlmTraceEvent({
+        id: traceId,
+        at: startedAt,
+        endedAt,
+        durationMs: endedAt - startedAt,
+        provider: "claude-code-login",
+        model: resolvedModel,
+        kind: "callVision",
+        systemPrompt,
+        userPrompt,
+        error: { message: e instanceof Error ? e.message : String(e) }
+      });
+      throw e;
+    }
+  }
+  async callTools(model, systemPrompt, userPrompt, tools, toolChoice = "required", _scopedTools) {
+    const sdk = await this.getClient();
+    const traceId = newLlmTraceId();
+    const startedAt = Date.now();
+    const resolvedModel = this.resolveModel(model);
+    const sentUserPrompt = toolChoice === "required" ? `${userPrompt}
+
+${LOGIN_REQUIRED_TOOL_INSTRUCTION}` : userPrompt;
+    try {
+      const turn = await this.apiCall(() => {
+        const intercepted = [];
+        const server = createLoginToolServer(sdk, tools);
+        return collectLoginTurn(
+          sdk.query({
+            prompt: sentUserPrompt,
+            options: buildLoginQueryOptions({
+              model: resolvedModel,
+              systemPrompt,
+              tools: { server, canUseTool: createDenyingIntercept(intercepted) }
+            })
+          }),
+          { intercepted, kind: "callTools", choice: toolChoice === "required" ? "required:instructed" : "auto", log: console.log, warn: console.warn }
+        );
+      });
+      const usage = turn.result.usage;
+      const cacheCreated = usage.cache_creation_input_tokens;
+      const cacheRead = usage.cache_read_input_tokens;
+      if (cacheCreated || cacheRead) {
+        console.log(
+          `[claude-code-login] callTools cache: created=${cacheCreated} read=${cacheRead} input=${usage.input_tokens} output=${usage.output_tokens}`
+        );
+      }
+      const toolCalls = turn.toolCalls.map((c) => ({ id: c.id, name: c.name, input: c.input }));
+      const endedAt = Date.now();
+      emitLlmTraceEvent({
+        id: traceId,
+        at: startedAt,
+        endedAt,
+        durationMs: endedAt - startedAt,
+        provider: "claude-code-login",
+        model: resolvedModel,
+        kind: "callTools",
+        systemPrompt,
+        userPrompt: sentUserPrompt,
+        tools: summarizeTools(tools),
+        result: {
+          inputTokens: usage.input_tokens,
+          outputTokens: usage.output_tokens,
+          cacheCreated,
+          cacheRead,
+          toolCalls: toolCalls.map((c) => ({ name: c.name, input: c.input }))
+        }
+      });
+      return {
+        toolCalls,
+        inputTokens: usage.input_tokens,
+        outputTokens: usage.output_tokens,
+        cacheReadTokens: cacheRead,
+        cacheCreationTokens: cacheCreated,
+        appliedToolChoice: "auto"
+      };
+    } catch (e) {
+      const endedAt = Date.now();
+      emitLlmTraceEvent({
+        id: traceId,
+        at: startedAt,
+        endedAt,
+        durationMs: endedAt - startedAt,
+        provider: "claude-code-login",
+        model: resolvedModel,
+        kind: "callTools",
+        systemPrompt,
+        userPrompt: sentUserPrompt,
+        tools: summarizeTools(tools),
+        error: { message: e instanceof Error ? e.message : String(e) }
+      });
+      throw e;
+    }
+  }
+  async callWithTools() {
+    throw new Error(
+      "claude-code-login: callWithTools (an in-client agentic loop) is not part of the login client \u2014 ggui's harness runs the loop through callTools"
+    );
+  }
+};
+var OpenAIAgent = class extends LLMAgent {
+  provider = "openai";
+  resolveModel(model) {
+    return model.startsWith("openai/") ? model.slice("openai/".length) : model;
+  }
+  async createClient() {
+    const { default: OpenAISDK } = await import('openai');
+    return new OpenAISDK({ apiKey: this.routeOverride?.apiKey ?? process.env.OPENAI_API_KEY });
+  }
+  async callText(model, systemPrompt, userPrompt, maxTokens, temperature) {
+    const client = await this.getClient();
+    const response = await this.apiCall(
+      () => client.responses.create({
+        model: this.resolveModel(model),
+        instructions: systemPrompt,
+        input: [{ role: "user", content: userPrompt }],
+        ...maxTokens && { max_output_tokens: maxTokens },
+        ...temperature !== void 0 && { temperature }
+      })
+    );
+    let text = "";
+    for (const item of response.output) {
+      if (item.type === "message") {
+        for (const part of item.content) {
+          if (part.type === "output_text") text += part.text;
+        }
+      }
+    }
+    const textUsage = splitOpenAiUsage(
+      response.usage?.input_tokens ?? 0,
+      response.usage?.output_tokens ?? 0,
+      response.usage?.input_tokens_details?.cached_tokens ?? 0,
+      0
+    );
+    return {
+      text,
+      inputTokens: textUsage.tokens.input,
+      outputTokens: textUsage.tokens.output,
+      sampling: { temperature: temperature ?? "provider-default" }
+    };
+  }
+  async callTools(model, systemPrompt, userPrompt, tools, toolChoice = "required", _scopedTools) {
+    const client = await this.getClient();
+    const openaiTools = tools.map((t) => ({
+      type: "function",
+      name: t.name,
+      description: t.description,
+      parameters: addStrictSchemaConstraints(t.parameters),
+      strict: true
+    }));
+    const pending = this.pendingToolResults;
+    this.pendingToolResults = [];
+    const input = pending.length > 0 ? [...pending, { role: "user", content: userPrompt }] : [{ role: "user", content: userPrompt }];
+    const response = await this.apiCall(
+      () => client.responses.create({
+        model: this.resolveModel(model),
+        instructions: systemPrompt,
+        input,
+        tools: openaiTools,
+        tool_choice: toolChoice,
+        store: true,
+        // Enable response storage + server-side chaining
+        ...this.lastSessionId && { previous_response_id: this.lastSessionId }
+      })
+    );
+    this.lastSessionId = response.id;
+    const usage = response.usage;
+    if (usage) {
+      const cached = usage.input_tokens_details;
+      if (cached?.cached_tokens) {
+        console.log(`[openai] session ${this.lastSessionId ? "chained" : "new"}: ${cached.cached_tokens} cached of ${usage.input_tokens} input`);
+      }
+    }
+    const functionCalls = response.output.filter(
+      (o) => o.type === "function_call"
+    );
+    const toolsUsage = splitOpenAiUsage(
+      response.usage?.input_tokens ?? 0,
+      response.usage?.output_tokens ?? 0,
+      response.usage?.input_tokens_details?.cached_tokens ?? 0,
+      response.usage?.input_tokens_details?.cache_write_tokens ?? 0
+    );
+    return {
+      toolCalls: functionCalls.map((fc) => ({
+        id: fc.call_id,
+        name: fc.name,
+        input: JSON.parse(fc.arguments ?? "{}")
+      })),
+      inputTokens: toolsUsage.tokens.input,
+      outputTokens: toolsUsage.tokens.output,
+      cacheReadTokens: toolsUsage.cacheReadTokens,
+      cacheCreationTokens: toolsUsage.cacheCreationTokens
+    };
+  }
+  // Pending tool results — stored by sendToolResult, consumed by next callTools
+  pendingToolResults = [];
+  async sendToolResult(results) {
+    this.pendingToolResults = results.map((r) => ({
+      type: "function_call_output",
+      call_id: r.callId ?? "",
+      output: r.result
+    }));
+  }
+  async callWithTools(model, systemPrompt, userPrompt, tools, maxTurns) {
+    const client = await this.getClient();
+    const resolvedModel = this.resolveModel(model);
+    const openaiTools = tools.map((t) => ({
+      type: "function",
+      name: t.name,
+      description: t.description,
+      parameters: t.parameters,
+      strict: false
+    }));
+    let input = [
+      { role: "user", content: userPrompt }
+    ];
+    let totalIn = 0;
+    let totalOut = 0;
+    let totalCacheRead = 0;
+    let totalCacheWrite = 0;
+    let allText = "";
+    for (let turn = 0; turn < maxTurns; turn++) {
+      const response = await this.apiCall(
+        () => client.responses.create({
+          model: resolvedModel,
+          instructions: systemPrompt,
+          input,
+          tools: openaiTools
+        })
+      );
+      const turnUsage = splitOpenAiUsage(
+        response.usage?.input_tokens ?? 0,
+        response.usage?.output_tokens ?? 0,
+        response.usage?.input_tokens_details?.cached_tokens ?? 0,
+        response.usage?.input_tokens_details?.cache_write_tokens ?? 0
+      );
+      totalIn += turnUsage.tokens.input;
+      totalOut += turnUsage.tokens.output;
+      totalCacheRead += turnUsage.cacheReadTokens;
+      totalCacheWrite += turnUsage.cacheCreationTokens;
+      const functionCalls = response.output.filter(
+        (o) => o.type === "function_call"
+      );
+      for (const item of response.output) {
+        if (item.type === "message") {
+          for (const part of item.content) {
+            if (part.type === "output_text") allText += part.text;
+          }
+        }
+      }
+      if (functionCalls.length === 0) break;
+      input = [
+        ...response.output
+      ];
+      for (const fc of functionCalls) {
+        const tool = tools.find((t) => t.name === fc.name);
+        const result = tool ? await tool.handler(
+          JSON.parse(fc.arguments ?? "{}")
+        ) : { content: [{ text: `Tool '${fc.name}' not found` }] };
+        input.push({
+          type: "function_call_output",
+          call_id: fc.call_id,
+          output: result.content[0]?.text ?? ""
+        });
+      }
+    }
+    return {
+      text: allText,
+      inputTokens: totalIn,
+      outputTokens: totalOut,
+      cacheReadTokens: totalCacheRead,
+      cacheCreationTokens: totalCacheWrite,
+      turnsUsed: input.length
+    };
+  }
+};
+function interactionText(interaction) {
+  let text = "";
+  for (const step of interaction.steps ?? []) {
+    if (step.type === "model_output") {
+      for (const content of step.content ?? []) {
+        if (content.type === "text") {
+          text += content.text;
+        }
+      }
+    }
+  }
+  return text;
+}
+function functionCallSteps(interaction) {
+  return (interaction.steps ?? []).filter(
+    (s) => s.type === "function_call"
+  );
+}
+function toUserInputStep(text) {
+  return { type: "user_input", content: [{ type: "text", text }] };
+}
+function googleInteractionUsage(usage) {
+  const split = splitCacheInclusiveUsage(usage?.total_input_tokens ?? 0, usage?.total_output_tokens ?? 0, usage?.total_cached_tokens ?? 0);
+  return { inputTokens: split.tokens.input, outputTokens: split.tokens.output, cacheReadTokens: split.cacheReadTokens };
+}
+var GoogleAgent = class extends LLMAgent {
+  provider = "google";
+  resolveModel(model) {
+    return model.startsWith("gemini/") ? model.slice("gemini/".length) : model;
+  }
+  async createClient() {
+    const { GoogleGenAI: GoogleGenAISDK } = await import('@google/genai');
+    return new GoogleGenAISDK({
+      apiKey: this.routeOverride?.apiKey ?? (process.env.GEMINI_API_KEY || process.env.GOOGLE_API_KEY),
+      httpOptions: { timeout: 3e5 }
+      // 5 min — Pro models can be slow
+    });
+  }
+  async callText(model, systemPrompt, userPrompt, maxTokens, temperature) {
+    const client = await this.getClient();
+    const generationConfig = {
+      ...maxTokens ? { max_output_tokens: maxTokens } : {},
+      ...temperature !== void 0 ? { temperature } : {}
+    };
+    const interaction = await this.apiCall(
+      () => client.interactions.create({
+        model: this.resolveModel(model),
+        system_instruction: systemPrompt,
+        input: userPrompt,
+        generation_config: Object.keys(generationConfig).length > 0 ? generationConfig : void 0
+      })
+    );
+    return {
+      text: interactionText(interaction),
+      // ggui#1186 (third site): `total_input_tokens` INCLUDES the cached part of the prompt — report the non-cached input.
+      inputTokens: googleInteractionUsage(interaction.usage).inputTokens,
+      outputTokens: googleInteractionUsage(interaction.usage).outputTokens,
+      sampling: { temperature: temperature ?? "provider-default" }
+    };
+  }
+  async callVision(model, systemPrompt, userPrompt, image, maxTokens) {
+    const client = await this.getClient();
+    const traceId = newLlmTraceId();
+    const startedAt = Date.now();
+    const resolvedModel = this.resolveModel(model);
+    try {
+      const response = await this.apiCall(
+        () => client.models.generateContent({
+          model: resolvedModel,
+          contents: [
+            {
+              role: "user",
+              parts: [
+                { inlineData: { mimeType: image.mediaType, data: image.base64 } },
+                { text: userPrompt }
+              ]
+            }
+          ],
+          config: {
+            systemInstruction: systemPrompt,
+            ...maxTokens ? { maxOutputTokens: maxTokens } : {}
+          }
+        })
+      );
+      const text = response.candidates?.[0]?.content?.parts?.map((p) => p.text || "").join("") || "";
+      const usage = response.usageMetadata;
+      const result = {
+        text,
+        // ggui#1186 (third site): `promptTokenCount` includes `cachedContentTokenCount` — report the non-cached input.
+        inputTokens: splitCacheInclusiveUsage(usage?.promptTokenCount ?? 0, usage?.candidatesTokenCount ?? 0, usage?.cachedContentTokenCount ?? 0).tokens.input,
+        outputTokens: usage?.candidatesTokenCount ?? 0,
+        ...visionFinish(googleFinishReason(response.candidates?.[0]?.finishReason)),
+        ...servedModelOf(response.modelVersion)
+      };
+      const endedAt = Date.now();
+      emitLlmTraceEvent({
+        id: traceId,
+        at: startedAt,
+        endedAt,
+        durationMs: endedAt - startedAt,
+        provider: "google",
+        model: resolvedModel,
+        kind: "callVision",
+        systemPrompt,
+        userPrompt,
+        result: {
+          inputTokens: result.inputTokens,
+          outputTokens: result.outputTokens,
+          text
+        }
+      });
+      return result;
+    } catch (e) {
+      const endedAt = Date.now();
+      emitLlmTraceEvent({
+        id: traceId,
+        at: startedAt,
+        endedAt,
+        durationMs: endedAt - startedAt,
+        provider: "google",
+        model: resolvedModel,
+        kind: "callVision",
+        systemPrompt,
+        userPrompt,
+        error: { message: e instanceof Error ? e.message : String(e) }
+      });
+      throw e;
+    }
+  }
+  async callTools(model, systemPrompt, userPrompt, tools, _toolChoice = "required", scopedTools) {
+    const client = await this.getClient();
+    const interactionTools = tools.map((t) => ({
+      type: "function",
+      name: t.name,
+      description: t.description,
+      parameters: t.parameters
+    }));
+    const scopedInteractionTools = scopedTools?.map((t) => ({
+      type: "function",
+      name: t.name,
+      description: t.description,
+      parameters: t.parameters
+    }));
+    const resolvedModel = this.resolveModel(model);
+    const pending = this.pendingToolResults;
+    this.pendingToolResults = [];
+    const input = pending.length > 0 ? [...pending, toUserInputStep(userPrompt)] : userPrompt;
+    const createInteraction = () => this.lastSessionId ? client.interactions.create({
+      model: resolvedModel,
+      previous_interaction_id: this.lastSessionId,
+      input,
+      tools: interactionTools,
+      generation_config: { max_output_tokens: 16384 }
+    }) : client.interactions.create({
+      model: resolvedModel,
+      system_instruction: systemPrompt,
+      tools: interactionTools,
+      input: userPrompt,
+      generation_config: { max_output_tokens: 16384 }
+    });
+    let interaction;
+    const MAX_MALFORMED_RETRIES = 3;
+    let succeeded = false;
+    for (let attempt = 0; attempt < MAX_MALFORMED_RETRIES; attempt++) {
+      try {
+        if (attempt === 0) {
+          interaction = await this.apiCall(createInteraction);
+        } else {
+          const jsonHint = "\n\nIMPORTANT: Your previous response had invalid JSON. Produce valid JSON in your tool call arguments.";
+          const retryPrompt = userPrompt + jsonHint;
+          interaction = await this.apiCall(
+            () => this.lastSessionId ? client.interactions.create({
+              model: resolvedModel,
+              previous_interaction_id: this.lastSessionId,
+              input: pending.length > 0 ? [...pending, toUserInputStep(retryPrompt)] : retryPrompt,
+              tools: interactionTools,
+              generation_config: { max_output_tokens: 16384 }
+            }) : client.interactions.create({
+              model: resolvedModel,
+              system_instruction: systemPrompt,
+              tools: interactionTools,
+              input: retryPrompt,
+              generation_config: { max_output_tokens: 16384 }
+            })
+          );
+        }
+        succeeded = true;
+        break;
+      } catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        if (msg.includes("malformed_tool_call") && attempt < MAX_MALFORMED_RETRIES - 1) {
+          console.warn(`[google] malformed_tool_call (attempt ${attempt + 1}/${MAX_MALFORMED_RETRIES}) \u2014 retrying`);
+          continue;
+        }
+        if (msg.includes("malformed_tool_call") && scopedInteractionTools) {
+          console.warn("[google] malformed_tool_call exhausted \u2014 retrying with scoped tool schema");
+          const scopedHint = "\n\nYour previous response exceeded the tool-call payload budget. Produce a SINGLE small change (\u226420 lines) using the narrowed tool schema.";
+          const scopedPrompt = userPrompt + scopedHint;
+          try {
+            interaction = await this.apiCall(
+              () => this.lastSessionId ? client.interactions.create({
+                model: resolvedModel,
+                previous_interaction_id: this.lastSessionId,
+                input: pending.length > 0 ? [...pending, toUserInputStep(scopedPrompt)] : scopedPrompt,
+                tools: scopedInteractionTools,
+                generation_config: { max_output_tokens: 16384 }
+              }) : client.interactions.create({
+                model: resolvedModel,
+                system_instruction: systemPrompt,
+                tools: scopedInteractionTools,
+                input: scopedPrompt,
+                generation_config: { max_output_tokens: 16384 }
+              })
+            );
+            succeeded = true;
+            break;
+          } catch (e2) {
+            const msg2 = e2 instanceof Error ? e2.message : String(e2);
+            console.error(`[google] scoped retry FAILED: ${msg2.slice(0, 300)}`);
+            throw e2;
+          }
+        }
+        console.error(`[google] callTools FAILED: ${msg.slice(0, 300)}`);
+        throw e;
+      }
+    }
+    if (!succeeded) throw new Error("[google] callTools: exhausted retries without success");
+    this.lastSessionId = interaction.id;
+    const toolCalls = functionCallSteps(interaction).map((fc) => ({
+      id: fc.id,
+      name: fc.name,
+      input: toolArgsToJsonObject(fc.arguments)
+    }));
+    return {
+      toolCalls,
+      // ggui#1186 (third site): the coding loop reads this per-turn usage — the non-cached prompt as input, the cached subset reported.
+      ...googleInteractionUsage(interaction.usage)
+    };
+  }
+  // Pending tool results — stored by sendToolResult, consumed by next callTools
+  pendingToolResults = [];
+  async sendToolResult(results) {
+    this.pendingToolResults = results.map((r) => ({
+      type: "function_result",
+      call_id: r.callId ?? "",
+      name: r.name,
+      result: r.result,
+      is_error: r.isError
+    }));
+  }
+  async callWithTools(model, systemPrompt, userPrompt, tools, maxTurns) {
+    const client = await this.getClient();
+    const interactionTools = tools.map((t) => ({
+      type: "function",
+      name: t.name,
+      description: t.description,
+      parameters: t.parameters
+    }));
+    let totalIn = 0;
+    let totalOut = 0;
+    let totalCacheRead = 0;
+    let allText = "";
+    let turnsUsed = 0;
+    let interaction = await this.apiCall(
+      () => client.interactions.create({
+        model: this.resolveModel(model),
+        system_instruction: systemPrompt,
+        tools: interactionTools,
+        input: userPrompt
+      })
+    );
+    for (let turn = 0; turn < maxTurns; turn++) {
+      turnsUsed = turn + 1;
+      if (interaction.usage) {
+        const turnUsage = googleInteractionUsage(interaction.usage);
+        totalIn += turnUsage.inputTokens;
+        totalOut += turnUsage.outputTokens;
+        totalCacheRead += turnUsage.cacheReadTokens;
+      }
+      allText += interactionText(interaction);
+      const fnCalls = functionCallSteps(interaction);
+      if (fnCalls.length === 0) break;
+      const results = [];
+      for (const fc of fnCalls) {
+        const tool = tools.find((t) => t.name === fc.name);
+        if (!tool) {
+          results.push({
+            type: "function_result",
+            call_id: fc.id,
+            name: fc.name,
+            result: JSON.stringify({ error: `Tool '${fc.name}' not found` }),
+            is_error: true
+          });
+          continue;
+        }
+        const result = await tool.handler(toolArgsToJsonObject(fc.arguments));
+        results.push({
+          type: "function_result",
+          call_id: fc.id,
+          name: fc.name,
+          result: result.content.map((c) => c.text).join("\n")
+        });
+      }
+      interaction = await this.apiCall(
+        () => client.interactions.create({
+          model: this.resolveModel(model),
+          previous_interaction_id: interaction.id,
+          input: results
+        })
+      );
+    }
+    return {
+      text: allText,
+      inputTokens: totalIn,
+      outputTokens: totalOut,
+      cacheReadTokens: totalCacheRead,
+      turnsUsed
+    };
+  }
+};
+var OpenRouterAgent = class extends LLMAgent {
+  provider = "openrouter";
+  // Client-side session history — system prompt sent once, subsequent
+  // callTools() calls append to the conversation without re-sending it.
+  sessionMessages = [];
+  resolveModel(model) {
+    return model.startsWith("openrouter/") ? model.slice("openrouter/".length) : model;
+  }
+  resetSession() {
+    super.resetSession();
+    this.sessionMessages = [];
+  }
+  async createClient() {
+    const { OpenRouterClient } = await import('./client-JBPCXU7W.js');
+    return new OpenRouterClient({
+      apiKey: this.routeOverride?.apiKey ?? process.env.OPENROUTER_API_KEY
+    });
+  }
+  async callText(model, systemPrompt, userPrompt, maxTokens, temperature) {
+    const client = await this.getClient();
+    const resolved = this.resolveModel(model);
+    const response = await this.apiCall(
+      () => client.chatCompletion({
+        model: resolved,
+        messages: [
+          { role: "system", content: systemPrompt },
+          { role: "user", content: userPrompt }
+        ],
+        max_tokens: maxTokens ?? 4096,
+        ...temperature !== void 0 && { temperature }
+      })
+    );
+    const text = response.choices[0]?.message.content ?? "";
+    return {
+      text,
+      inputTokens: response.usage.prompt_tokens,
+      outputTokens: response.usage.completion_tokens,
+      sampling: { temperature: temperature ?? "provider-default" }
+    };
+  }
+  async callTools(model, systemPrompt, userPrompt, tools, toolChoice, _scopedTools) {
+    const client = await this.getClient();
+    const resolved = this.resolveModel(model);
+    const orTools = tools.map((t) => ({
+      type: "function",
+      function: { name: t.name, description: t.description, parameters: t.parameters }
+    }));
+    if (this.sessionMessages.length === 0) {
+      this.sessionMessages.push({ role: "system", content: systemPrompt });
+    }
+    this.sessionMessages.push({ role: "user", content: userPrompt });
+    const requested = toolChoice ?? "auto";
+    const appliedToolChoice = requested === "required" && anthropicRejectsForcedToolChoice(resolved) ? "auto" : requested;
+    if (appliedToolChoice !== requested) {
+      console.warn(
+        `[openrouter] callTools: ${resolved} would reject a forced tool_choice (the API answers 400); caller's 'required' downgraded to 'auto' before sending`
+      );
+    }
+    const response = await this.apiCall(
+      () => client.chatCompletion({
+        model: resolved,
+        messages: this.sessionMessages,
+        tools: orTools,
+        tool_choice: appliedToolChoice
+      })
+    );
+    const choice = response.choices[0];
+    if (choice?.message) {
+      this.sessionMessages.push({
+        role: "assistant",
+        content: choice.message.content,
+        tool_calls: choice.message.tool_calls
+      });
+    }
+    const toolCalls = (choice?.message.tool_calls ?? []).map((tc) => ({
+      id: tc.id,
+      name: tc.function.name,
+      input: JSON.parse(tc.function.arguments || "{}")
+    }));
+    return {
+      toolCalls,
+      inputTokens: response.usage.prompt_tokens,
+      outputTokens: response.usage.completion_tokens,
+      appliedToolChoice
+    };
+  }
+  async sendToolResult(results) {
+    for (const r of results) {
+      this.sessionMessages.push({
+        role: "tool",
+        tool_call_id: r.callId,
+        content: r.result
+      });
+    }
+  }
+  async callWithTools(model, systemPrompt, userPrompt, tools, maxTurns) {
+    const client = await this.getClient();
+    const resolved = this.resolveModel(model);
+    const orTools = tools.map((t) => ({
+      type: "function",
+      function: { name: t.name, description: t.description, parameters: t.parameters }
+    }));
+    const messages = [
+      { role: "system", content: systemPrompt },
+      { role: "user", content: userPrompt }
+    ];
+    let totalInput = 0;
+    let totalOutput = 0;
+    let turnsUsed = 0;
+    let finalText = "";
+    for (let turn = 0; turn < maxTurns; turn++) {
+      turnsUsed = turn + 1;
+      const response = await this.apiCall(
+        () => client.chatCompletion({
+          model: resolved,
+          messages,
+          tools: orTools,
+          tool_choice: "auto"
+        })
+      );
+      totalInput += response.usage.prompt_tokens;
+      totalOutput += response.usage.completion_tokens;
+      const choice = response.choices[0];
+      if (!choice) break;
+      if (choice.message.content) {
+        finalText = choice.message.content;
+      }
+      const toolCalls = choice.message.tool_calls;
+      if (!toolCalls || toolCalls.length === 0) break;
+      messages.push({
+        role: "assistant",
+        content: choice.message.content,
+        tool_calls: toolCalls
+      });
+      for (const tc of toolCalls) {
+        const toolDef = tools.find((t) => t.name === tc.function.name);
+        let resultText;
+        if (!toolDef) {
+          resultText = JSON.stringify({ error: `Tool '${tc.function.name}' not found` });
+        } else {
+          const args = JSON.parse(tc.function.arguments || "{}");
+          const result = await toolDef.handler(args);
+          resultText = result.content.map((c) => c.text).join("\n");
+        }
+        messages.push({ role: "tool", tool_call_id: tc.id, content: resultText });
+      }
+    }
+    return { text: finalText, inputTokens: totalInput, outputTokens: totalOutput, turnsUsed };
+  }
+};
+function createAgent(providerOrConfig) {
+  const provider = typeof providerOrConfig === "string" ? providerOrConfig : providerOrConfig.provider;
+  const routeOverride = typeof providerOrConfig === "string" ? void 0 : providerOrConfig.routeOverride;
+  const onRetry = typeof providerOrConfig === "string" ? void 0 : providerOrConfig.onRetry;
+  if (routeOverride?.claudeCodeLogin === true) {
+    if (provider !== "anthropic") {
+      throw new Error(
+        `${provider}: the claude-code-login credential authenticates the Claude Code binary only \u2014 pick an anthropic route or supply a ${provider} API key`
+      );
+    }
+    return new ClaudeCodeLoginAgent(routeOverride, onRetry);
+  }
+  switch (provider) {
+    case "anthropic":
+      return new AnthropicAgent(routeOverride, onRetry);
+    case "openai":
+      return new OpenAIAgent(routeOverride, onRetry);
+    case "google":
+      return new GoogleAgent(routeOverride, onRetry);
+    case "openrouter":
+      return new OpenRouterAgent(routeOverride, onRetry);
+  }
+}
+function createVisionAgent(config) {
+  if (config.routeOverride?.claudeCodeLogin === true) {
+    if (config.provider !== "anthropic") {
+      throw new Error(
+        `${config.provider}: the claude-code-login credential authenticates the Claude Code binary only \u2014 pick an anthropic route or supply a ${config.provider} API key`
+      );
+    }
+    return new ClaudeCodeLoginAgent(config.routeOverride, config.onRetry);
+  }
+  switch (config.provider) {
+    case "anthropic":
+      return new AnthropicAgent(config.routeOverride, config.onRetry);
+    case "google":
+      return new GoogleAgent(config.routeOverride, config.onRetry);
+    default: {
+      const unreachable = config.provider;
+      throw new Error(`createVisionAgent: provider '${String(unreachable)}' has no vision path (anthropic, google)`);
+    }
+  }
+}
+async function callLLM(config, systemPrompt, userPrompt, maxTokens) {
+  const start = Date.now();
+  const agent = createAgent(config);
+  const result = await agent.callText(
+    config.model,
+    systemPrompt,
+    userPrompt,
+    maxTokens,
+    config.temperature
+  );
+  console.log(
+    `[llm-router] ${config.provider}/${config.model} | ${Date.now() - start}ms | in=${result.inputTokens} out=${result.outputTokens}`
+  );
+  return result;
+}
+async function preloadProviderSdks() {
+  const start = Date.now();
+  const attempts = [
+    ["@anthropic-ai/claude-agent-sdk", () => import('@anthropic-ai/claude-agent-sdk')],
+    ["openai", () => import('openai')],
+    ["@google/genai", () => import('@google/genai')],
+    ["@anthropic-ai/bedrock-sdk", () => import('@anthropic-ai/bedrock-sdk')]
+  ];
+  const settled = await Promise.allSettled(attempts.map(([, load]) => load()));
+  const loaded = [];
+  const missing = [];
+  settled.forEach((r, i) => {
+    const specifier = attempts[i]?.[0] ?? "";
+    if (r.status === "fulfilled") loaded.push(specifier);
+    else missing.push({ specifier, reason: r.reason instanceof Error ? r.reason.message : String(r.reason) });
+  });
+  return { ms: Date.now() - start, loaded, missing };
+}
+
+export { applyRouteToEnv, callLLM, createAgent, createVisionAgent, preloadProviderSdks, resolveRoute };
+//# sourceMappingURL=chunk-O2YC6XDC.js.map
+//# sourceMappingURL=chunk-O2YC6XDC.js.map