@omnicross/core 0.1.0 → 0.1.1

package/dist/provider-proxy/ProviderProxy.js

@@ -0,0 +1,4618 @@
+// src/provider-proxy/ProviderProxy.ts
+import http2 from "http";
+
+// src/serializeError.ts
+function serializeError(err) {
+  if (err == null) return "Unknown error (null)";
+  if (err instanceof Error) {
+    let msg = err.message || err.name || "Error";
+    if (err.cause) {
+      msg += ` [cause: ${serializeError(err.cause)}]`;
+    }
+    const anyErr = err;
+    if (anyErr.status != null) msg += ` (status: ${anyErr.status})`;
+    else if (anyErr.code != null) msg += ` (code: ${anyErr.code})`;
+    return msg;
+  }
+  if (typeof err === "string") return err || "Empty error string";
+  if (typeof err !== "object") return String(err);
+  const obj = err;
+  if (typeof obj.message === "string" && obj.message) {
+    let msg = obj.message;
+    if (obj.status != null) msg += ` (status: ${obj.status})`;
+    else if (obj.code != null) msg += ` (code: ${obj.code})`;
+    if (typeof obj.type === "string") msg += ` [type: ${obj.type}]`;
+    return msg;
+  }
+  if (typeof obj.error === "string" && obj.error) {
+    return obj.error;
+  }
+  if (obj.error && typeof obj.error === "object") {
+    const inner = obj.error;
+    if (typeof inner.message === "string" && inner.message) {
+      let msg = inner.message;
+      if (typeof inner.type === "string") msg += ` [type: ${inner.type}]`;
+      return msg;
+    }
+  }
+  try {
+    const json = JSON.stringify(err, getCircularReplacer(), 2);
+    if (json && json.length > 1e3) {
+      return json.slice(0, 1e3) + "... (truncated)";
+    }
+    return json || "Unserializable error";
+  } catch {
+    return `Unserializable error: ${Object.prototype.toString.call(err)}`;
+  }
+}
+function getCircularReplacer() {
+  const seen = /* @__PURE__ */ new WeakSet();
+  return (_key, value) => {
+    if (typeof value === "object" && value !== null) {
+      if (seen.has(value)) return "[Circular]";
+      seen.add(value);
+    }
+    return value;
+  };
+}
+
+// src/provider-proxy/providerProxyRouteMap.ts
+import { randomBytes } from "crypto";
+var DEFAULT_ROUTE_IDLE_MS = 10 * 60 * 1e3;
+var TOKEN_BYTES = 32;
+var ProviderProxyRouteMap = class {
+  constructor(defaultIdleMs = DEFAULT_ROUTE_IDLE_MS) {
+    this.defaultIdleMs = defaultIdleMs;
+  }
+  defaultIdleMs;
+  routes = /* @__PURE__ */ new Map();
+  /**
+   * Register a route for one run and return its crypto-random token. The
+   * caller (next batch) injects the token as the forwarded auth-header sentinel
+   * (`ANTHROPIC_AUTH_TOKEN` / `OPENAI_API_KEY`). Optionally override the idle
+   * timeout (tests use a short one).
+   */
+  addRoute(context, idleMs) {
+    const token = randomBytes(TOKEN_BYTES).toString("hex");
+    const entry = {
+      context,
+      idleTimer: null,
+      idleMs: idleMs ?? this.defaultIdleMs
+    };
+    this.routes.set(token, entry);
+    this.armIdleTimer(token, entry);
+    return token;
+  }
+  /**
+   * Look up a route by its token, touching the idle timer so an active run's
+   * context survives. Returns `undefined` on a miss / reaped entry — the caller
+   * rejects (no fallback).
+   */
+  lookup(token) {
+    if (!token) return void 0;
+    const entry = this.routes.get(token);
+    if (!entry) return void 0;
+    this.armIdleTimer(token, entry);
+    return entry.context;
+  }
+  /** Remove a route at run end. Returns true if an entry existed. */
+  removeRoute(token) {
+    const entry = this.routes.get(token);
+    if (!entry) return false;
+    this.clearIdleTimer(entry);
+    this.routes.delete(token);
+    return true;
+  }
+  /** Current live-route count (tests / diagnostics). */
+  size() {
+    return this.routes.size;
+  }
+  /** Whether a token currently resolves (does NOT touch the idle timer). */
+  has(token) {
+    return this.routes.has(token);
+  }
+  /** Tear down every route (proxy stop / app teardown). */
+  clear() {
+    for (const entry of this.routes.values()) {
+      this.clearIdleTimer(entry);
+    }
+    this.routes.clear();
+  }
+  // ---------------------------------------------------------------------------
+  // Idle reaping (modeled on AcpSessionManager.armIdleTimer / clearIdleTimer)
+  // ---------------------------------------------------------------------------
+  armIdleTimer(token, entry) {
+    this.clearIdleTimer(entry);
+    entry.idleTimer = setTimeout(() => {
+      this.routes.delete(token);
+    }, entry.idleMs);
+    entry.idleTimer.unref?.();
+  }
+  clearIdleTimer(entry) {
+    if (entry.idleTimer) {
+      clearTimeout(entry.idleTimer);
+      entry.idleTimer = null;
+    }
+  }
+};
+
+// src/completion/DirectApiHandler.ts
+import { getOpenAIReasoningEffort as getOpenAIReasoningEffort2 } from "@omnicross/contracts/thinking-config";
+
+// src/openrouter.ts
+function isOpenRouterProvider(provider) {
+  const baseUrl = (provider.api_base_url || "").toLowerCase();
+  return baseUrl.includes("openrouter.ai");
+}
+var OPENROUTER_APP_HEADERS = {
+  "HTTP-Referer": "https://omnicross.dev",
+  "X-Title": "omnicross"
+};
+
+// src/outbound-api/OutboundApiServer.ts
+import http from "http";
+import { networkInterfaces } from "os";
+
+// src/outbound-api/outboundApiRouter.ts
+import { Readable } from "stream";
+
+// src/outbound-api/outboundApiKeyAuth.ts
+import { createHash, randomBytes as randomBytes2 } from "crypto";
+
+// src/outbound-api/roleDetection.ts
+import { normalizeModelId } from "@omnicross/contracts/canonical-models";
+
+// src/outbound-api/subscriptionSupport.ts
+var SUBSCRIPTION_PROVIDER_IDS = [
+  "claude",
+  "codex",
+  "gemini",
+  "opencodego"
+];
+var SUBSCRIPTION_ID_SET = new Set(SUBSCRIPTION_PROVIDER_IDS);
+
+// src/transformer/anthropicBetaInject.ts
+import { isExtendedContextCapable } from "@omnicross/contracts/extended-context";
+var EXTENDED_CONTEXT_BETA = "context-1m-2025-08-07";
+var ANTHROPIC_BETA_HEADER = "anthropic-beta";
+function injectExtendedContextBeta(headers, model, useExtendedContext) {
+  if (!useExtendedContext) return;
+  if (!isExtendedContextCapable(model)) return;
+  let existingValue = "";
+  for (const key of Object.keys(headers)) {
+    if (key.toLowerCase() === ANTHROPIC_BETA_HEADER) {
+      const v = headers[key];
+      if (typeof v === "string") existingValue = v;
+      if (key !== ANTHROPIC_BETA_HEADER) delete headers[key];
+    }
+  }
+  const parts = existingValue.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+  if (!parts.includes(EXTENDED_CONTEXT_BETA)) {
+    parts.push(EXTENDED_CONTEXT_BETA);
+  }
+  headers[ANTHROPIC_BETA_HEADER] = parts.join(",");
+}
+
+// src/transformer/TransformerChainExecutor.ts
+var defaultLogger = {
+  debug: (msg, ...args) => console.debug(`[ChainExecutor] ${msg}`, ...args),
+  info: (msg, ...args) => console.info(`[ChainExecutor] ${msg}`, ...args),
+  warn: (msg, ...args) => console.warn(`[ChainExecutor] ${msg}`, ...args),
+  error: (msg, ...args) => console.error(`[ChainExecutor] ${msg}`, ...args)
+};
+var TransformerChainExecutor = class {
+  logger;
+  constructor(logger) {
+    this.logger = logger ?? defaultLogger;
+  }
+  /**
+   * Execute the request transformation chain
+   *
+   * @param request - Original request body
+   * @param provider - LLM provider configuration
+   * @param chain - Resolved transformer chain
+   * @param options - Execution options
+   * @returns Transformed request result
+   */
+  async executeRequestChain(request, provider, chain, options = {}) {
+    const { endpointTransformer, headers, extendedContext } = options;
+    const context = {
+      logger: this.logger,
+      providerName: provider.name
+    };
+    let requestBody = request;
+    let config = {};
+    let bypass = false;
+    bypass = this.shouldBypassTransformers(
+      chain,
+      endpointTransformer,
+      requestBody
+    );
+    if (bypass) {
+      if (headers) {
+        const cleanHeaders = this.cleanHeaders(headers);
+        config.headers = cleanHeaders;
+      }
+      this.logger.debug("Bypass mode enabled - skipping transformations");
+    }
+    if (!bypass && endpointTransformer?.transformRequestOut) {
+      this.logger.debug("Executing transformRequestOut");
+      try {
+        const transformOut = await endpointTransformer.transformRequestOut(requestBody, context);
+        if (transformOut && typeof transformOut === "object") {
+          if ("body" in transformOut) {
+            requestBody = transformOut.body;
+            config = transformOut.config ?? {};
+          } else {
+            requestBody = transformOut;
+          }
+        }
+      } catch (error) {
+        this.logger.error(`transformRequestOut error: ${this.getErrorMessage(error)}`);
+        throw error;
+      }
+    }
+    if (!bypass && chain.providerTransformers.length > 0) {
+      this.logger.debug(`Executing ${chain.providerTransformers.length} provider transformers`);
+      for (const transformer of chain.providerTransformers) {
+        if (transformer.transformRequestIn) {
+          try {
+            const transformIn = await transformer.transformRequestIn(
+              requestBody,
+              provider,
+              context
+            );
+            if (transformIn && typeof transformIn === "object") {
+              if ("body" in transformIn) {
+                requestBody = transformIn.body;
+                config = { ...config, ...transformIn.config };
+              } else {
+                requestBody = transformIn;
+              }
+            }
+          } catch (error) {
+            this.logger.error(
+              `Provider transformer ${transformer.name} error: ${this.getErrorMessage(error)}`
+            );
+            throw error;
+          }
+        }
+      }
+    }
+    if (!bypass && chain.modelTransformers.length > 0) {
+      this.logger.debug(`Executing ${chain.modelTransformers.length} model transformers`);
+      for (const transformer of chain.modelTransformers) {
+        if (transformer.transformRequestIn) {
+          try {
+            const result = await transformer.transformRequestIn(
+              requestBody,
+              provider,
+              context
+            );
+            requestBody = result;
+          } catch (error) {
+            this.logger.error(
+              `Model transformer ${transformer.name} error: ${this.getErrorMessage(error)}`
+            );
+            throw error;
+          }
+        }
+      }
+    }
+    if (extendedContext?.enabled) {
+      if (!config.headers || typeof config.headers !== "object") {
+        config.headers = {};
+      }
+      injectExtendedContextBeta(
+        config.headers,
+        extendedContext.model,
+        true
+      );
+    }
+    return { requestBody, config, bypass };
+  }
+  /**
+   * Execute the response transformation chain
+   *
+   * @param request - Original request (for context)
+   * @param response - Response from provider
+   * @param provider - LLM provider configuration
+   * @param chain - Resolved transformer chain
+   * @param options - Execution options
+   * @returns Transformed response
+   */
+  async executeResponseChain(request, response, provider, chain, options = {}) {
+    const { endpointTransformer } = options;
+    const context = {
+      logger: this.logger,
+      providerName: provider.name
+    };
+    let finalResponse = response;
+    const bypass = this.shouldBypassTransformers(chain, endpointTransformer, request);
+    if (bypass) {
+      this.logger.debug("Bypass mode - skipping response transformations");
+      return finalResponse;
+    }
+    if (chain.modelTransformers.length > 0) {
+      const reversedModelTransformers = [...chain.modelTransformers].reverse();
+      this.logger.debug(
+        `Executing ${reversedModelTransformers.length} model response transformers (reversed)`
+      );
+      for (const transformer of reversedModelTransformers) {
+        if (transformer.transformResponseOut) {
+          try {
+            finalResponse = await transformer.transformResponseOut(finalResponse, context);
+          } catch (error) {
+            this.logger.error(
+              `Model transformer ${transformer.name} response error: ${this.getErrorMessage(error)}`
+            );
+            throw error;
+          }
+        }
+      }
+    }
+    if (chain.providerTransformers.length > 0) {
+      const reversedProviderTransformers = [...chain.providerTransformers].reverse();
+      this.logger.debug(
+        `Executing ${reversedProviderTransformers.length} provider response transformers (reversed)`
+      );
+      for (const transformer of reversedProviderTransformers) {
+        if (transformer.transformResponseOut) {
+          try {
+            finalResponse = await transformer.transformResponseOut(finalResponse, context);
+          } catch (error) {
+            this.logger.error(
+              `Provider transformer ${transformer.name} response error: ${this.getErrorMessage(error)}`
+            );
+            throw error;
+          }
+        }
+      }
+    }
+    if (endpointTransformer?.transformResponseIn) {
+      this.logger.debug("Executing transformResponseIn");
+      try {
+        finalResponse = await endpointTransformer.transformResponseIn(finalResponse, context);
+      } catch (error) {
+        this.logger.error(`transformResponseIn error: ${this.getErrorMessage(error)}`);
+        throw error;
+      }
+    }
+    return finalResponse;
+  }
+  /**
+   * Execute authentication handler if available
+   *
+   * @param request - Request body
+   * @param provider - LLM provider
+   * @param endpointTransformer - Endpoint transformer with auth handler
+   * @param context - Transformer context
+   * @returns Auth result with potentially modified request and config
+   */
+  async executeAuth(request, provider, endpointTransformer, context) {
+    let requestBody = request;
+    let config = {};
+    if (endpointTransformer?.auth) {
+      this.logger.debug("Executing auth handler");
+      try {
+        const auth = await endpointTransformer.auth(requestBody, provider, context);
+        if (auth && typeof auth === "object") {
+          if ("body" in auth) {
+            requestBody = auth.body;
+            const authConfig = auth.config;
+            if (authConfig) {
+              const headers = { ...config.headers ?? {}, ...authConfig.headers ?? {} };
+              delete headers["host"];
+              config = { ...config, ...authConfig, headers };
+            }
+          } else {
+            requestBody = auth;
+          }
+        }
+      } catch (error) {
+        this.logger.error(`Auth handler error: ${this.getErrorMessage(error)}`);
+        throw error;
+      }
+    }
+    return { requestBody, config };
+  }
+  /**
+   * Check if transformers should be bypassed (optimization)
+   *
+   * Bypass is enabled when:
+   * - Provider has only one transformer that matches the endpoint transformer
+   * - Model has no specific transformers or only the same endpoint transformer
+   */
+  shouldBypassTransformers(chain, endpointTransformer, _request) {
+    if (!endpointTransformer?.name) {
+      return false;
+    }
+    const providerHasOnlyEndpoint = chain.providerTransformers.length === 1 && chain.providerTransformers[0]?.name === endpointTransformer.name;
+    const modelHasNoTransformers = chain.modelTransformers.length === 0;
+    const modelHasOnlyEndpoint = chain.modelTransformers.length === 1 && chain.modelTransformers[0]?.name === endpointTransformer.name;
+    return providerHasOnlyEndpoint && (modelHasNoTransformers || modelHasOnlyEndpoint);
+  }
+  /**
+   * Clean headers for pass-through
+   */
+  cleanHeaders(headers) {
+    const result = {};
+    if (headers instanceof Headers) {
+      headers.forEach((value, key) => {
+        if (key.toLowerCase() !== "content-length") {
+          result[key] = value;
+        }
+      });
+    } else {
+      for (const [key, value] of Object.entries(headers)) {
+        if (key.toLowerCase() !== "content-length") {
+          result[key] = value;
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * Get error message from unknown error
+   */
+  getErrorMessage(error) {
+    if (error instanceof Error) {
+      return error.message;
+    }
+    return String(error);
+  }
+};
+
+// src/transformer/transformers/AnthropicToolHandling.ts
+function isServerSideTool(tool) {
+  const type = String(tool.type || "");
+  return type.startsWith("web_search_") || type.startsWith("code_execution_") || type.startsWith("text_editor_") || type.startsWith("memory_") || type.startsWith("web_fetch_") || type.startsWith("search_tool_");
+}
+function convertAnthropicToolsToOpenAI(tools) {
+  return tools.filter((tool) => !isServerSideTool(tool)).map((tool) => ({
+    type: "function",
+    function: {
+      name: String(tool.name),
+      description: String(tool.description || ""),
+      parameters: tool.input_schema
+    }
+  }));
+}
+
+// src/transformer/transformers/AnthropicTypes.ts
+function getThinkLevel(budgetTokens) {
+  if (!budgetTokens || budgetTokens <= 0) return "none";
+  if (budgetTokens < 4096) return "low";
+  if (budgetTokens < 16384) return "medium";
+  return "high";
+}
+function formatBase64(data, mediaType) {
+  if (data.startsWith("data:")) return data;
+  return `data:${mediaType || "image/png"};base64,${data}`;
+}
+
+// src/transformer/transformers/AnthropicRequestBuilder.ts
+function buildAnthropicRequestBody(request) {
+  let systemContent;
+  const anthropicMessages = [];
+  for (let i = 0; i < request.messages.length; i++) {
+    const msg = request.messages[i];
+    if (msg.role === "system") {
+      if (typeof msg.content === "string") {
+        systemContent = msg.content;
+      } else if (Array.isArray(msg.content)) {
+        systemContent = msg.content.filter((c) => c.type === "text").map((c) => ({
+          type: "text",
+          text: c.text,
+          ...c.cache_control ? { cache_control: c.cache_control } : {}
+        }));
+      }
+      continue;
+    }
+    if (msg.role === "assistant") {
+      const content = [];
+      if (msg.thinking?.content) {
+        const block = {
+          type: "thinking",
+          thinking: msg.thinking.content
+        };
+        if (msg.thinking.signature) {
+          block.signature = msg.thinking.signature;
+        }
+        content.push(block);
+      }
+      if (msg.content) {
+        const text = typeof msg.content === "string" ? msg.content : msg.content.filter((c) => c.type === "text").map((c) => c.text).join("\n");
+        if (text) {
+          content.push({ type: "text", text });
+        }
+      }
+      if (msg.tool_calls?.length) {
+        for (const tc of msg.tool_calls) {
+          let input;
+          try {
+            input = typeof tc.function.arguments === "string" ? JSON.parse(tc.function.arguments) : tc.function.arguments;
+          } catch {
+            input = { text: tc.function.arguments || "" };
+          }
+          content.push({
+            type: "tool_use",
+            id: tc.id,
+            name: tc.function.name,
+            input
+          });
+        }
+      }
+      anthropicMessages.push({
+        role: "assistant",
+        content: content.length > 0 ? content : ""
+      });
+      continue;
+    }
+    if (msg.role === "tool") {
+      const toolResults = [];
+      let j = i;
+      while (j < request.messages.length && request.messages[j].role === "tool") {
+        const t = request.messages[j];
+        toolResults.push({
+          type: "tool_result",
+          tool_use_id: t.tool_call_id || "",
+          content: typeof t.content === "string" ? t.content : JSON.stringify(t.content),
+          ...t.cache_control ? { cache_control: t.cache_control } : {}
+        });
+        j++;
+      }
+      anthropicMessages.push({ role: "user", content: toolResults });
+      i = j - 1;
+      continue;
+    }
+    if (typeof msg.content === "string") {
+      anthropicMessages.push({ role: "user", content: msg.content });
+    } else if (Array.isArray(msg.content)) {
+      const content = msg.content.map((part) => {
+        if (part.type === "image_url") {
+          const url = part.image_url.url;
+          if (url.startsWith("data:")) {
+            const match = url.match(/^data:([^;]+);base64,(.+)$/);
+            if (match) {
+              return {
+                type: "image",
+                source: { type: "base64", media_type: match[1], data: match[2] }
+              };
+            }
+          }
+          return {
+            type: "image",
+            source: { type: "url", url }
+          };
+        }
+        return { type: "text", text: part.text };
+      });
+      anthropicMessages.push({ role: "user", content });
+    }
+  }
+  const body = {
+    model: request.model,
+    messages: anthropicMessages,
+    max_tokens: request.max_tokens || 4096,
+    stream: request.stream ?? false
+  };
+  if (request.temperature !== void 0) {
+    body.temperature = request.temperature;
+  }
+  if (systemContent !== void 0) {
+    body.system = systemContent;
+  }
+  if (request.tools?.length) {
+    body.tools = request.tools.map((tool) => ({
+      name: tool.function.name,
+      description: tool.function.description || "",
+      input_schema: tool.function.parameters
+    }));
+  }
+  const serverSideTools = request._serverSideTools;
+  if (serverSideTools?.length) {
+    body.tools = [...body.tools || [], ...serverSideTools];
+  }
+  if (request.tool_choice) {
+    if (typeof request.tool_choice === "string") {
+      if (request.tool_choice === "required") {
+        body.tool_choice = { type: "any" };
+      } else if (request.tool_choice !== "none") {
+        body.tool_choice = { type: request.tool_choice };
+      }
+    } else if (typeof request.tool_choice === "object" && "function" in request.tool_choice) {
+      body.tool_choice = { type: "tool", name: request.tool_choice.function.name };
+    }
+  }
+  if (request.reasoning?.enabled) {
+    const budgetMap = { low: 2048, medium: 8192, high: 32768 };
+    const budget = request.reasoning.max_tokens || budgetMap[request.reasoning.effort || "medium"] || 8192;
+    body.thinking = { type: "enabled", budget_tokens: budget };
+    body.temperature = 1;
+  }
+  return body;
+}
+
+// src/transformer/transformers/AnthropicResponseConversion.ts
+function convertAnthropicResponseToOpenAI(anthropicResponse) {
+  const content = anthropicResponse.content || [];
+  const textParts = content.filter((c) => c.type === "text").map((c) => c.text);
+  const toolUses = content.filter((c) => c.type === "tool_use" || c.type === "server_tool_use");
+  const thinkingBlock = content.find((c) => c.type === "thinking");
+  const searchResults = content.filter((c) => c.type === "web_search_tool_result");
+  for (const sr of searchResults) {
+    const searches = sr.content;
+    if (searches?.length) {
+      const formatted = searches.map((s) => `[${s.title}](${s.url}): ${s.page_content || s.snippet || ""}`).join("\n");
+      textParts.push(`
+
+**Search Results:**
+${formatted}`);
+    }
+  }
+  const message = {
+    role: "assistant",
+    content: textParts.join("") || null
+  };
+  if (toolUses.length > 0) {
+    message.tool_calls = toolUses.map((tc) => ({
+      id: tc.id,
+      type: "function",
+      function: {
+        name: tc.name,
+        arguments: JSON.stringify(tc.input || {})
+      }
+    }));
+  }
+  if (thinkingBlock) {
+    message.thinking = {
+      content: thinkingBlock.thinking,
+      signature: thinkingBlock.signature
+    };
+  }
+  const stopReasonMapping = {
+    end_turn: "stop",
+    max_tokens: "length",
+    tool_use: "tool_calls",
+    stop_sequence: "stop"
+  };
+  const usage = anthropicResponse.usage;
+  return {
+    id: anthropicResponse.id || `chatcmpl-${Date.now()}`,
+    object: "chat.completion",
+    created: Math.floor(Date.now() / 1e3),
+    model: anthropicResponse.model || "unknown",
+    choices: [{
+      index: 0,
+      message,
+      finish_reason: stopReasonMapping[anthropicResponse.stop_reason] || "stop"
+    }],
+    usage: usage ? {
+      prompt_tokens: usage.input_tokens || 0,
+      completion_tokens: usage.output_tokens || 0,
+      total_tokens: (usage.input_tokens || 0) + (usage.output_tokens || 0)
+    } : void 0
+  };
+}
+function convertOpenAIResponseToAnthropic2(openaiResponse) {
+  const choice = openaiResponse.choices?.[0];
+  if (!choice) {
+    throw new Error("No choices found in OpenAI response");
+  }
+  const message = choice.message;
+  const content = [];
+  if (message.content) {
+    content.push({
+      type: "text",
+      text: message.content
+    });
+  }
+  const toolCalls = message.tool_calls;
+  if (toolCalls?.length) {
+    for (const toolCall of toolCalls) {
+      const func = toolCall.function;
+      let parsedInput = {};
+      try {
+        const args = func.arguments;
+        parsedInput = typeof args === "string" ? JSON.parse(args) : args;
+      } catch {
+        parsedInput = { text: func.arguments || "" };
+      }
+      content.push({
+        type: "tool_use",
+        id: toolCall.id,
+        name: func.name,
+        input: parsedInput
+      });
+    }
+  }
+  const thinking = message.thinking;
+  if (thinking?.content) {
+    content.push({
+      type: "thinking",
+      thinking: thinking.content,
+      signature: thinking.signature
+    });
+  }
+  const finishReason = choice.finish_reason;
+  const stopReasonMapping = {
+    stop: "end_turn",
+    length: "max_tokens",
+    tool_calls: "tool_use",
+    content_filter: "stop_sequence"
+  };
+  const usage = openaiResponse.usage;
+  const usageDetails = usage?.prompt_tokens_details;
+  return {
+    id: openaiResponse.id,
+    type: "message",
+    role: "assistant",
+    model: openaiResponse.model,
+    content,
+    stop_reason: stopReasonMapping[finishReason] || "end_turn",
+    stop_sequence: null,
+    usage: {
+      input_tokens: (usage?.prompt_tokens || 0) - (usageDetails?.cached_tokens || 0),
+      output_tokens: usage?.completion_tokens || 0,
+      cache_read_input_tokens: usageDetails?.cached_tokens || 0
+    }
+  };
+}
+
+// src/transformer/transformers/AnthropicConversion.ts
+function transformAnthropicRequestToUnified(request) {
+  const anthropicRequest = request;
+  const messages = [];
+  if (anthropicRequest.system) {
+    if (typeof anthropicRequest.system === "string") {
+      messages.push({
+        role: "system",
+        content: anthropicRequest.system
+      });
+    } else if (Array.isArray(anthropicRequest.system)) {
+      const textParts = anthropicRequest.system.filter((item) => item.type === "text" && item.text).map((item) => ({
+        type: "text",
+        text: item.text,
+        cache_control: item.cache_control
+      }));
+      if (textParts.length > 0) {
+        messages.push({
+          role: "system",
+          content: textParts
+        });
+      }
+    }
+  }
+  const requestMessages = JSON.parse(JSON.stringify(anthropicRequest.messages || []));
+  for (const msg of requestMessages) {
+    if (msg.role !== "user" && msg.role !== "assistant") continue;
+    if (typeof msg.content === "string") {
+      messages.push({
+        role: msg.role,
+        content: msg.content
+      });
+      continue;
+    }
+    if (Array.isArray(msg.content)) {
+      if (msg.role === "user") {
+        const toolParts = msg.content.filter(
+          (c) => c.type === "tool_result" && c.tool_use_id
+        );
+        for (const tool of toolParts) {
+          messages.push({
+            role: "tool",
+            content: typeof tool.content === "string" ? tool.content : JSON.stringify(tool.content),
+            tool_call_id: tool.tool_use_id,
+            cache_control: tool.cache_control
+          });
+        }
+        const textAndMediaParts = msg.content.filter(
+          (c) => c.type === "text" && c.text || c.type === "image" && c.source
+        );
+        if (textAndMediaParts.length > 0) {
+          messages.push({
+            role: "user",
+            content: textAndMediaParts.map((part) => {
+              if (part.type === "image") {
+                const imagePart = part;
+                return {
+                  type: "image_url",
+                  image_url: {
+                    url: imagePart.source.type === "base64" ? formatBase64(imagePart.source.data || "", imagePart.source.media_type) : imagePart.source.url || ""
+                  },
+                  media_type: imagePart.source.media_type
+                };
+              }
+              return {
+                type: "text",
+                text: part.text
+              };
+            })
+          });
+        }
+      } else if (msg.role === "assistant") {
+        const assistantMessage = {
+          role: "assistant",
+          content: ""
+        };
+        const textParts = msg.content.filter(
+          (c) => c.type === "text" && c.text
+        );
+        if (textParts.length > 0) {
+          assistantMessage.content = textParts.map((t) => t.text).join("\n");
+        }
+        const toolCallParts = msg.content.filter(
+          (c) => c.type === "tool_use" && c.id
+        );
+        if (toolCallParts.length > 0) {
+          assistantMessage.tool_calls = toolCallParts.map((tool) => ({
+            id: tool.id,
+            type: "function",
+            function: {
+              name: tool.name,
+              arguments: JSON.stringify(tool.input || {})
+            }
+          }));
+        }
+        const thinkingPart = msg.content.find(
+          (c) => c.type === "thinking"
+        );
+        if (thinkingPart?.thinking) {
+          assistantMessage.thinking = {
+            content: thinkingPart.thinking,
+            signature: thinkingPart.signature
+          };
+        }
+        messages.push(assistantMessage);
+      }
+    }
+  }
+  const rawTools = anthropicRequest.tools || [];
+  const serverSideTools = rawTools.filter((t) => isServerSideTool(t));
+  const functionTools = rawTools.length > 0 ? convertAnthropicToolsToOpenAI(rawTools) : void 0;
+  const result = {
+    messages,
+    model: anthropicRequest.model,
+    max_tokens: anthropicRequest.max_tokens,
+    temperature: anthropicRequest.temperature,
+    stream: anthropicRequest.stream,
+    tools: functionTools?.length ? functionTools : void 0
+  };
+  if (serverSideTools.length > 0) {
+    result._serverSideTools = serverSideTools;
+  }
+  if (anthropicRequest.thinking) {
+    result.reasoning = {
+      effort: getThinkLevel(anthropicRequest.thinking.budget_tokens),
+      enabled: anthropicRequest.thinking.type === "enabled"
+    };
+  }
+  if (anthropicRequest.tool_choice) {
+    if (anthropicRequest.tool_choice.type === "tool" && anthropicRequest.tool_choice.name) {
+      result.tool_choice = {
+        type: "function",
+        function: { name: anthropicRequest.tool_choice.name }
+      };
+    } else {
+      result.tool_choice = anthropicRequest.tool_choice.type;
+    }
+  }
+  return result;
+}
+
+// src/transformer/transformers/AnthropicAnthropicToOpenAIStream.ts
+function convertAnthropicStreamToOpenAI2(anthropicStream, logger) {
+  const decoder = new TextDecoder();
+  const encoder = new TextEncoder();
+  const activeToolCalls = /* @__PURE__ */ new Map();
+  let toolCallCounter = 0;
+  let model = "unknown";
+  let messageId = `chatcmpl-${Date.now()}`;
+  return new ReadableStream({
+    start: async (controller) => {
+      const reader = anthropicStream.getReader();
+      let buffer = "";
+      let isClosed = false;
+      const safeEnqueue = (data) => {
+        if (!isClosed) {
+          try {
+            controller.enqueue(encoder.encode(data));
+          } catch {
+            isClosed = true;
+          }
+        }
+      };
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          buffer += decoder.decode(value, { stream: true });
+          const lines = buffer.split("\n");
+          buffer = lines.pop() || "";
+          for (const line of lines) {
+            if (isClosed) break;
+            if (!line.startsWith("data:")) continue;
+            const data = line.slice(5).trim();
+            if (!data || data === "[DONE]") continue;
+            try {
+              const event = JSON.parse(data);
+              if (event.type === "message_start" && event.message) {
+                model = event.message.model || model;
+                messageId = event.message.id || messageId;
+              }
+              if (event.type === "content_block_delta" && event.delta) {
+                const chunk = {
+                  id: messageId,
+                  object: "chat.completion.chunk",
+                  created: Math.floor(Date.now() / 1e3),
+                  model,
+                  choices: [{ index: 0, delta: {}, finish_reason: null }]
+                };
+                const delta = chunk.choices[0].delta;
+                if (event.delta.type === "text_delta") {
+                  delta.content = event.delta.text;
+                } else if (event.delta.type === "input_json_delta") {
+                  const toolInfo = activeToolCalls.get(event.index);
+                  if (toolInfo) {
+                    delta.tool_calls = [{
+                      index: toolInfo.index,
+                      function: { arguments: event.delta.partial_json }
+                    }];
+                  }
+                } else if (event.delta.type === "thinking_delta") {
+                  delta.thinking = { content: event.delta.thinking };
+                } else if (event.delta.type === "signature_delta") {
+                  delta.thinking = { signature: event.delta.signature };
+                } else {
+                  continue;
+                }
+                safeEnqueue(`data: ${JSON.stringify(chunk)}
+
+`);
+              }
+              if (event.type === "content_block_start" && event.content_block) {
+                if (event.content_block.type === "tool_use" || event.content_block.type === "server_tool_use") {
+                  const tcIndex = toolCallCounter++;
+                  activeToolCalls.set(event.index, {
+                    id: event.content_block.id,
+                    name: event.content_block.name,
+                    index: tcIndex
+                  });
+                  const chunk = {
+                    id: messageId,
+                    object: "chat.completion.chunk",
+                    created: Math.floor(Date.now() / 1e3),
+                    model,
+                    choices: [{
+                      index: 0,
+                      delta: {
+                        tool_calls: [{
+                          index: tcIndex,
+                          id: event.content_block.id,
+                          type: "function",
+                          function: { name: event.content_block.name, arguments: "" }
+                        }]
+                      },
+                      finish_reason: null
+                    }]
+                  };
+                  safeEnqueue(`data: ${JSON.stringify(chunk)}
+
+`);
+                } else if (event.content_block.type === "web_search_tool_result") {
+                  const searches = event.content_block.content;
+                  if (searches?.length) {
+                    const formatted = searches.map((s) => `[${s.title}](${s.url}): ${s.page_content || s.snippet || ""}`).join("\n");
+                    const chunk = {
+                      id: messageId,
+                      object: "chat.completion.chunk",
+                      created: Math.floor(Date.now() / 1e3),
+                      model,
+                      choices: [{
+                        index: 0,
+                        delta: { content: `
+
+**Search Results:**
+${formatted}` },
+                        finish_reason: null
+                      }]
+                    };
+                    safeEnqueue(`data: ${JSON.stringify(chunk)}
+
+`);
+                  }
+                }
+              }
+              if (event.type === "message_delta" && event.delta) {
+                const stopReasonMapping = {
+                  end_turn: "stop",
+                  max_tokens: "length",
+                  tool_use: "tool_calls",
+                  stop_sequence: "stop"
+                };
+                const chunk = {
+                  id: messageId,
+                  object: "chat.completion.chunk",
+                  created: Math.floor(Date.now() / 1e3),
+                  model,
+                  choices: [{
+                    index: 0,
+                    delta: {},
+                    finish_reason: stopReasonMapping[event.delta.stop_reason] || "stop"
+                  }]
+                };
+                if (event.usage) {
+                  chunk.usage = {
+                    prompt_tokens: event.usage.input_tokens || 0,
+                    completion_tokens: event.usage.output_tokens || 0,
+                    total_tokens: (event.usage.input_tokens || 0) + (event.usage.output_tokens || 0)
+                  };
+                }
+                safeEnqueue(`data: ${JSON.stringify(chunk)}
+
+`);
+              }
+            } catch (e) {
+              logger?.error("Error parsing Anthropic stream event:", e);
+            }
+          }
+        }
+      } catch (e) {
+        if (!isClosed) {
+          controller.error(e);
+        }
+      } finally {
+        safeEnqueue("data: [DONE]\n\n");
+        if (!isClosed) {
+          try {
+            controller.close();
+          } catch {
+          }
+        }
+        reader.releaseLock();
+      }
+    }
+  });
+}
+
+// src/transformer/transformers/AnthropicOpenAIToAnthropicStream.ts
+function convertOpenAIStreamToAnthropic2(openaiStream, _context, logger) {
+  const decoder = new TextDecoder();
+  const encoder = new TextEncoder();
+  let hasStarted = false;
+  let hasTextContentStarted = false;
+  let isThinkingStarted = false;
+  let contentIndex = 0;
+  let currentContentBlockIndex = -1;
+  const toolCallIndexToContentBlockIndex = /* @__PURE__ */ new Map();
+  return new ReadableStream({
+    start: async (controller) => {
+      const reader = openaiStream.getReader();
+      let buffer = "";
+      const messageId = `msg_${Date.now()}`;
+      let model = "unknown";
+      let isClosed = false;
+      let stopReasonDelta = null;
+      const safeEnqueue = (data) => {
+        if (!isClosed) {
+          try {
+            controller.enqueue(encoder.encode(data));
+          } catch (_e) {
+            isClosed = true;
+          }
+        }
+      };
+      const assignContentBlockIndex = () => {
+        return contentIndex++;
+      };
+      const safeClose = () => {
+        if (isClosed) return;
+        if (currentContentBlockIndex >= 0) {
+          safeEnqueue(`event: content_block_stop
+data: ${JSON.stringify({
+            type: "content_block_stop",
+            index: currentContentBlockIndex
+          })}
+
+`);
+        }
+        if (stopReasonDelta) {
+          safeEnqueue(`event: message_delta
+data: ${JSON.stringify(stopReasonDelta)}
+
+`);
+        } else {
+          safeEnqueue(`event: message_delta
+data: ${JSON.stringify({
+            type: "message_delta",
+            delta: { stop_reason: "end_turn", stop_sequence: null },
+            usage: { input_tokens: 0, output_tokens: 0 }
+          })}
+
+`);
+        }
+        safeEnqueue(`event: message_stop
+data: ${JSON.stringify({ type: "message_stop" })}
+
+`);
+        try {
+          controller.close();
+        } catch (_e) {
+        }
+        isClosed = true;
+      };
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          buffer += decoder.decode(value, { stream: true });
+          const lines = buffer.split("\n");
+          buffer = lines.pop() || "";
+          for (const line of lines) {
+            if (isClosed) break;
+            if (!line.startsWith("data:")) continue;
+            const data = line.slice(5).trim();
+            if (data === "[DONE]") continue;
+            try {
+              const chunk = JSON.parse(data);
+              if (chunk.error) {
+                safeEnqueue(`event: error
+data: ${JSON.stringify({
+                  type: "error",
+                  message: { type: "api_error", message: JSON.stringify(chunk.error) }
+                })}
+
+`);
+                continue;
+              }
+              model = chunk.model || model;
+              if (!hasStarted) {
+                hasStarted = true;
+                safeEnqueue(`event: message_start
+data: ${JSON.stringify({
+                  type: "message_start",
+                  message: {
+                    id: messageId,
+                    type: "message",
+                    role: "assistant",
+                    content: [],
+                    model,
+                    stop_reason: null,
+                    stop_sequence: null,
+                    usage: { input_tokens: 0, output_tokens: 0 }
+                  }
+                })}
+
+`);
+              }
+              const choice = chunk.choices?.[0];
+              if (!choice) continue;
+              if (chunk.usage) {
+                stopReasonDelta = {
+                  type: "message_delta",
+                  delta: { stop_reason: "end_turn", stop_sequence: null },
+                  usage: {
+                    input_tokens: (chunk.usage.prompt_tokens || 0) - (chunk.usage.prompt_tokens_details?.cached_tokens || 0),
+                    output_tokens: chunk.usage.completion_tokens || 0,
+                    cache_read_input_tokens: chunk.usage.prompt_tokens_details?.cached_tokens || 0
+                  }
+                };
+              }
+              if (choice.delta?.thinking) {
+                if (!isThinkingStarted) {
+                  const thinkingBlockIndex = assignContentBlockIndex();
+                  safeEnqueue(`event: content_block_start
+data: ${JSON.stringify({
+                    type: "content_block_start",
+                    index: thinkingBlockIndex,
+                    content_block: { type: "thinking", thinking: "" }
+                  })}
+
+`);
+                  currentContentBlockIndex = thinkingBlockIndex;
+                  isThinkingStarted = true;
+                }
+                if (choice.delta.thinking.signature) {
+                  safeEnqueue(`event: content_block_delta
+data: ${JSON.stringify({
+                    type: "content_block_delta",
+                    index: currentContentBlockIndex,
+                    delta: { type: "signature_delta", signature: choice.delta.thinking.signature }
+                  })}
+
+`);
+                  safeEnqueue(`event: content_block_stop
+data: ${JSON.stringify({
+                    type: "content_block_stop",
+                    index: currentContentBlockIndex
+                  })}
+
+`);
+                  currentContentBlockIndex = -1;
+                } else if (choice.delta.thinking.content) {
+                  safeEnqueue(`event: content_block_delta
+data: ${JSON.stringify({
+                    type: "content_block_delta",
+                    index: currentContentBlockIndex,
+                    delta: { type: "thinking_delta", thinking: choice.delta.thinking.content }
+                  })}
+
+`);
+                }
+              }
+              if (choice.delta?.content) {
+                if (!hasTextContentStarted) {
+                  if (currentContentBlockIndex >= 0 && isThinkingStarted) {
+                    safeEnqueue(`event: content_block_stop
+data: ${JSON.stringify({
+                      type: "content_block_stop",
+                      index: currentContentBlockIndex
+                    })}
+
+`);
+                  }
+                  hasTextContentStarted = true;
+                  const textBlockIndex = assignContentBlockIndex();
+                  safeEnqueue(`event: content_block_start
+data: ${JSON.stringify({
+                    type: "content_block_start",
+                    index: textBlockIndex,
+                    content_block: { type: "text", text: "" }
+                  })}
+
+`);
+                  currentContentBlockIndex = textBlockIndex;
+                }
+                safeEnqueue(`event: content_block_delta
+data: ${JSON.stringify({
+                  type: "content_block_delta",
+                  index: currentContentBlockIndex,
+                  delta: { type: "text_delta", text: choice.delta.content }
+                })}
+
+`);
+              }
+              if (choice.delta?.tool_calls) {
+                for (const toolCall of choice.delta.tool_calls) {
+                  const toolCallIndex = toolCall.index ?? 0;
+                  if (!toolCallIndexToContentBlockIndex.has(toolCallIndex)) {
+                    if (currentContentBlockIndex >= 0) {
+                      safeEnqueue(`event: content_block_stop
+data: ${JSON.stringify({
+                        type: "content_block_stop",
+                        index: currentContentBlockIndex
+                      })}
+
+`);
+                      hasTextContentStarted = false;
+                    }
+                    const newBlockIndex = assignContentBlockIndex();
+                    toolCallIndexToContentBlockIndex.set(toolCallIndex, newBlockIndex);
+                    safeEnqueue(`event: content_block_start
+data: ${JSON.stringify({
+                      type: "content_block_start",
+                      index: newBlockIndex,
+                      content_block: {
+                        type: "tool_use",
+                        id: toolCall.id || `call_${Date.now()}_${toolCallIndex}`,
+                        name: toolCall.function?.name || `tool_${toolCallIndex}`,
+                        input: {}
+                      }
+                    })}
+
+`);
+                    currentContentBlockIndex = newBlockIndex;
+                  }
+                  if (toolCall.function?.arguments) {
+                    const blockIndex = toolCallIndexToContentBlockIndex.get(toolCallIndex);
+                    if (blockIndex !== void 0) {
+                      safeEnqueue(`event: content_block_delta
+data: ${JSON.stringify({
+                        type: "content_block_delta",
+                        index: blockIndex,
+                        delta: { type: "input_json_delta", partial_json: toolCall.function.arguments }
+                      })}
+
+`);
+                    }
+                  }
+                }
+              }
+              if (choice.finish_reason) {
+                const stopReasonMapping = {
+                  stop: "end_turn",
+                  length: "max_tokens",
+                  tool_calls: "tool_use",
+                  content_filter: "stop_sequence"
+                };
+                stopReasonDelta = {
+                  type: "message_delta",
+                  delta: {
+                    stop_reason: stopReasonMapping[choice.finish_reason] || "end_turn",
+                    stop_sequence: null
+                  },
+                  usage: {
+                    input_tokens: (chunk.usage?.prompt_tokens || 0) - (chunk.usage?.prompt_tokens_details?.cached_tokens || 0),
+                    output_tokens: chunk.usage?.completion_tokens || 0,
+                    cache_read_input_tokens: chunk.usage?.prompt_tokens_details?.cached_tokens || 0
+                  }
+                };
+              }
+            } catch (e) {
+              logger?.error("Error parsing stream chunk:", e);
+            }
+          }
+        }
+      } catch (e) {
+        if (!isClosed) {
+          controller.error(e);
+        }
+      } finally {
+        safeClose();
+        reader.releaseLock();
+      }
+    }
+  });
+}
+
+// src/transformer/transformers/AnthropicTransformer.ts
+var AnthropicTransformer = class {
+  static TransformerName = "anthropic";
+  name = "anthropic";
+  logger;
+  endPoint = "/v1/messages";
+  useBearer;
+  constructor(options) {
+    this.useBearer = options?.UseBearer ?? false;
+  }
+  /**
+   * Handle authentication - Anthropic uses x-api-key header
+   */
+  async auth(request, provider, _context) {
+    const headers = {};
+    if (this.useBearer) {
+      headers["authorization"] = `Bearer ${provider.apiKey}`;
+      headers["x-api-key"] = void 0;
+    } else {
+      headers["x-api-key"] = provider.apiKey;
+      headers["authorization"] = void 0;
+    }
+    return {
+      body: request,
+      config: { headers }
+    };
+  }
+  /**
+   * Transform Anthropic request to unified format.
+   */
+  async transformRequestOut(request, _context) {
+    return transformAnthropicRequestToUnified(request);
+  }
+  /**
+   * Transform OpenAI/unified response back to Anthropic format
+   * (auto-detects stream vs JSON via Content-Type).
+   */
+  async transformResponseIn(response, context) {
+    const contentType = response.headers.get("Content-Type") ?? "";
+    if (contentType.includes("text/event-stream")) {
+      if (!response.body) {
+        throw new Error("Stream response body is null");
+      }
+      const convertedStream = convertOpenAIStreamToAnthropic2(response.body, context, this.logger);
+      return new Response(convertedStream, {
+        headers: {
+          "Content-Type": "text/event-stream",
+          "Cache-Control": "no-cache",
+          Connection: "keep-alive"
+        }
+      });
+    } else {
+      const data = await response.json();
+      const anthropicResponse = convertOpenAIResponseToAnthropic2(data);
+      return new Response(JSON.stringify(anthropicResponse), {
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+  }
+  /**
+   * Transform unified request to Anthropic Messages API format.
+   * This is the reverse of transformRequestOut — converts OpenAI/unified format
+   * to Anthropic's expected request body structure.
+   */
+  async transformRequestIn(request, _provider, _context) {
+    return buildAnthropicRequestBody(request);
+  }
+  /**
+   * Transform Anthropic response to OpenAI/unified format
+   * (auto-detects stream vs JSON via Content-Type).
+   */
+  async transformResponseOut(response, _context) {
+    const contentType = response.headers.get("Content-Type") ?? "";
+    if (contentType.includes("text/event-stream")) {
+      if (!response.body) {
+        throw new Error("Stream response body is null");
+      }
+      const convertedStream = convertAnthropicStreamToOpenAI2(response.body, this.logger);
+      return new Response(convertedStream, {
+        headers: {
+          "Content-Type": "text/event-stream",
+          "Cache-Control": "no-cache",
+          Connection: "keep-alive"
+        }
+      });
+    } else {
+      const data = await response.json();
+      const openaiResponse = convertAnthropicResponseToOpenAI(data);
+      return new Response(JSON.stringify(openaiResponse), {
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+  }
+};
+
+// src/transformer/transformers/utils/gemini.response-in.ts
+var FINISH_REASON_TO_GEMINI = {
+  stop: "STOP",
+  length: "MAX_TOKENS",
+  tool_calls: "STOP",
+  content_filter: "SAFETY",
+  // Already-lowercased Gemini reasons (pass-through from another transformer)
+  max_tokens: "MAX_TOKENS",
+  safety: "SAFETY"
+};
+function toGeminiFinishReason(openaiReason) {
+  if (!openaiReason) return null;
+  return FINISH_REASON_TO_GEMINI[openaiReason] || openaiReason.toUpperCase();
+}
+function convertOpenAIResponseToGemini(openaiData) {
+  const choice = openaiData.choices?.[0];
+  const message = choice?.message ?? {};
+  const usage = openaiData.usage;
+  const usagePromptDetails = usage?.prompt_tokens_details;
+  const usageOutputDetails = usage?.output_tokens_details;
+  const parts = [];
+  const thinking = message.thinking;
+  if (thinking?.content) {
+    parts.push({ text: thinking.content, thought: true });
+  }
+  if (thinking?.signature) {
+    parts.push({ thoughtSignature: thinking.signature });
+  }
+  if (message.content) {
+    parts.push({ text: message.content });
+  }
+  const toolCalls = message.tool_calls;
+  if (toolCalls?.length) {
+    for (const tc of toolCalls) {
+      const func = tc.function;
+      let args = {};
+      try {
+        const raw = func.arguments;
+        args = typeof raw === "string" ? JSON.parse(raw) : raw;
+      } catch {
+        args = {};
+      }
+      parts.push({
+        functionCall: {
+          id: tc.id,
+          name: func.name,
+          args
+        }
+      });
+    }
+  }
+  if (parts.length === 0) {
+    parts.push({ text: "" });
+  }
+  return {
+    responseId: openaiData.id || "",
+    modelVersion: openaiData.model || "",
+    candidates: [{
+      content: { parts },
+      finishReason: toGeminiFinishReason(choice?.finish_reason)
+    }],
+    usageMetadata: usage ? {
+      promptTokenCount: usage.prompt_tokens || 0,
+      candidatesTokenCount: usage.completion_tokens || 0,
+      totalTokenCount: usage.total_tokens || 0,
+      cachedContentTokenCount: usagePromptDetails?.cached_tokens || 0,
+      thoughtsTokenCount: usageOutputDetails?.reasoning_tokens || 0
+    } : void 0
+  };
+}
+function convertOpenAIStreamToGemini(openaiStream, logger) {
+  const decoder = new TextDecoder();
+  const encoder = new TextEncoder();
+  const pendingToolCalls = /* @__PURE__ */ new Map();
+  let model = "";
+  let responseId = "";
+  return new ReadableStream({
+    start: async (controller) => {
+      const reader = openaiStream.getReader();
+      let buffer = "";
+      let isClosed = false;
+      const emit2 = (data) => {
+        if (isClosed) return;
+        try {
+          controller.enqueue(encoder.encode(`data: ${JSON.stringify(data)}
+
+`));
+        } catch {
+          isClosed = true;
+        }
+      };
+      const flushToolCalls = () => {
+        if (pendingToolCalls.size === 0) return;
+        const parts = [];
+        for (const tc of pendingToolCalls.values()) {
+          let args = {};
+          try {
+            args = JSON.parse(tc.args || "{}");
+          } catch {
+          }
+          parts.push({
+            functionCall: { id: tc.id, name: tc.name, args }
+          });
+        }
+        pendingToolCalls.clear();
+        emit2({
+          responseId,
+          modelVersion: model,
+          candidates: [{ content: { parts }, finishReason: null }]
+        });
+      };
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          buffer += decoder.decode(value, { stream: true });
+          const lines = buffer.split("\n");
+          buffer = lines.pop() || "";
+          for (const line of lines) {
+            if (isClosed) break;
+            if (!line.startsWith("data:")) continue;
+            const data = line.slice(5).trim();
+            if (!data || data === "[DONE]") continue;
+            try {
+              const chunk = JSON.parse(data);
+              if (!responseId && chunk.id) responseId = chunk.id;
+              if (!model && chunk.model) model = chunk.model;
+              const choice = chunk.choices?.[0];
+              if (!choice) continue;
+              const delta = choice.delta ?? {};
+              if (delta.thinking) {
+                const parts = [];
+                if (delta.thinking.content) {
+                  parts.push({ text: delta.thinking.content, thought: true });
+                }
+                if (delta.thinking.signature) {
+                  parts.push({ thoughtSignature: delta.thinking.signature });
+                }
+                if (parts.length > 0) {
+                  emit2({
+                    responseId,
+                    modelVersion: model,
+                    candidates: [{ content: { parts }, finishReason: null }]
+                  });
+                }
+              }
+              if (delta.content) {
+                emit2({
+                  responseId,
+                  modelVersion: model,
+                  candidates: [{
+                    content: { parts: [{ text: delta.content }] },
+                    finishReason: null
+                  }]
+                });
+              }
+              if (delta.tool_calls) {
+                for (const tc of delta.tool_calls) {
+                  const idx = tc.index ?? 0;
+                  const existing = pendingToolCalls.get(idx);
+                  const func = tc.function;
+                  if (existing) {
+                    if (func?.arguments) {
+                      existing.args += func.arguments;
+                    }
+                  } else {
+                    pendingToolCalls.set(idx, {
+                      id: tc.id || `tool_${Date.now()}_${idx}`,
+                      name: func?.name || "",
+                      args: func?.arguments || ""
+                    });
+                  }
+                }
+              }
+              if (choice.finish_reason) {
+                flushToolCalls();
+                const geminiUsage = chunk.usage ? {
+                  promptTokenCount: chunk.usage.prompt_tokens || 0,
+                  candidatesTokenCount: chunk.usage.completion_tokens || 0,
+                  totalTokenCount: chunk.usage.total_tokens || 0,
+                  cachedContentTokenCount: chunk.usage.prompt_tokens_details?.cached_tokens || 0,
+                  thoughtsTokenCount: chunk.usage.output_tokens_details?.reasoning_tokens || 0
+                } : void 0;
+                emit2({
+                  responseId,
+                  modelVersion: model,
+                  candidates: [{
+                    content: { parts: [{ text: "" }] },
+                    finishReason: toGeminiFinishReason(choice.finish_reason) || "STOP"
+                  }],
+                  usageMetadata: geminiUsage
+                });
+              }
+            } catch (e) {
+              logger?.error(`Error parsing OpenAI stream chunk for Gemini conversion: ${e}`);
+            }
+          }
+        }
+        flushToolCalls();
+      } catch (e) {
+        if (!isClosed) controller.error(e);
+      } finally {
+        if (!isClosed) {
+          try {
+            controller.close();
+          } catch {
+          }
+        }
+        reader.releaseLock();
+      }
+    }
+  });
+}
+async function transformResponseIn(response, logger) {
+  const contentType = response.headers.get("Content-Type") ?? "";
+  if (contentType.includes("text/event-stream")) {
+    if (!response.body) {
+      throw new Error("Stream response body is null");
+    }
+    const geminiStream = convertOpenAIStreamToGemini(response.body, logger);
+    return new Response(geminiStream, {
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive"
+      }
+    });
+  }
+  const data = await response.json();
+  const geminiResponse = convertOpenAIResponseToGemini(data);
+  return new Response(JSON.stringify(geminiResponse), {
+    status: response.status,
+    statusText: response.statusText,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+
+// src/transformer/transformers/utils/gemini.stream.ts
+async function transformResponseOut(response, providerName, logger) {
+  const contentType = response.headers.get("Content-Type") ?? "";
+  if (contentType.includes("application/json")) {
+    return handleJsonResponse(response, providerName, logger);
+  } else if (contentType.includes("stream") || contentType.includes("text/event-stream")) {
+    return handleStreamResponse(response, providerName, logger);
+  }
+  return response;
+}
+async function handleJsonResponse(response, providerName, logger) {
+  const jsonResponse = await response.json();
+  logger?.debug(`${providerName} JSON response received`);
+  const parts = jsonResponse.candidates?.[0]?.content?.parts || [];
+  let thinkingContent = "";
+  let thinkingSignature = "";
+  const nonThinkingParts = [];
+  for (const part of parts) {
+    if (part.text && part.thought === true) {
+      thinkingContent += part.text;
+    } else {
+      nonThinkingParts.push(part);
+    }
+  }
+  thinkingSignature = parts.find((part) => part.thoughtSignature)?.thoughtSignature ?? "";
+  const toolCalls = nonThinkingParts.filter((part) => part.functionCall).map((part) => ({
+    id: part.functionCall?.id || `tool_${Math.random().toString(36).substring(2, 15)}`,
+    type: "function",
+    function: {
+      name: part.functionCall?.name ?? "",
+      arguments: JSON.stringify(part.functionCall?.args || {})
+    }
+  }));
+  const textContent = nonThinkingParts.filter((part) => part.text).map((part) => part.text).join("\n");
+  const openAIResponse = {
+    id: jsonResponse.responseId ?? "",
+    choices: [
+      {
+        finish_reason: (jsonResponse.candidates?.[0]?.finishReason ?? "").toLowerCase() || null,
+        index: 0,
+        message: {
+          content: textContent,
+          role: "assistant",
+          tool_calls: toolCalls.length > 0 ? toolCalls : void 0,
+          ...thinkingSignature && {
+            thinking: {
+              content: thinkingContent || "(no content)",
+              signature: thinkingSignature
+            }
+          }
+        }
+      }
+    ],
+    created: Math.floor(Date.now() / 1e3),
+    model: jsonResponse.modelVersion ?? "",
+    object: "chat.completion",
+    usage: {
+      completion_tokens: jsonResponse.usageMetadata?.candidatesTokenCount || 0,
+      prompt_tokens: jsonResponse.usageMetadata?.promptTokenCount || 0,
+      prompt_tokens_details: {
+        cached_tokens: jsonResponse.usageMetadata?.cachedContentTokenCount || 0
+      },
+      total_tokens: jsonResponse.usageMetadata?.totalTokenCount || 0,
+      output_tokens_details: {
+        reasoning_tokens: jsonResponse.usageMetadata?.thoughtsTokenCount || 0
+      }
+    }
+  };
+  return new Response(JSON.stringify(openAIResponse), {
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers
+  });
+}
+function handleStreamResponse(response, providerName, logger) {
+  if (!response.body) {
+    return response;
+  }
+  const decoder = new TextDecoder();
+  const encoder = new TextEncoder();
+  let signatureSent = false;
+  let contentSent = false;
+  let hasThinkingContent = false;
+  let pendingContent = "";
+  let contentIndex = 0;
+  let toolCallIndex = -1;
+  const stream = new ReadableStream({
+    async start(controller) {
+      const reader = response.body.getReader();
+      let buffer = "";
+      const processLine = async (line) => {
+        if (!line.startsWith("data: ")) return;
+        const chunkStr = line.slice(6).trim();
+        if (!chunkStr) return;
+        logger?.debug(`${providerName} chunk: ${chunkStr.substring(0, 100)}...`);
+        try {
+          const chunk = JSON.parse(chunkStr);
+          if (!chunk.candidates?.[0]) {
+            logger?.debug("Invalid chunk structure");
+            return;
+          }
+          const candidate = chunk.candidates[0];
+          const parts = candidate.content?.parts || [];
+          parts.filter((part) => part.text && part.thought === true).forEach((part) => {
+            hasThinkingContent = true;
+            const thinkingChunk = createChunk({
+              responseId: chunk.responseId,
+              modelVersion: chunk.modelVersion,
+              contentIndex,
+              delta: {
+                role: "assistant",
+                content: null,
+                thinking: { content: part.text }
+              }
+            });
+            controller.enqueue(encoder.encode(`data: ${JSON.stringify(thinkingChunk)}
+
+`));
+          });
+          const signature = parts.find((part) => part.thoughtSignature)?.thoughtSignature;
+          if (signature && !signatureSent) {
+            if (!hasThinkingContent) {
+              const thinkingChunk = createChunk({
+                responseId: chunk.responseId,
+                modelVersion: chunk.modelVersion,
+                contentIndex,
+                delta: {
+                  role: "assistant",
+                  content: null,
+                  thinking: { content: "" }
+                }
+              });
+              controller.enqueue(encoder.encode(`data: ${JSON.stringify(thinkingChunk)}
+
+`));
+            }
+            const signatureChunk = createChunk({
+              responseId: chunk.responseId,
+              modelVersion: chunk.modelVersion,
+              contentIndex,
+              delta: {
+                role: "assistant",
+                content: null,
+                thinking: { signature }
+              }
+            });
+            controller.enqueue(encoder.encode(`data: ${JSON.stringify(signatureChunk)}
+
+`));
+            signatureSent = true;
+            contentIndex++;
+            if (pendingContent) {
+              const pendingChunk = createChunk({
+                responseId: chunk.responseId,
+                modelVersion: chunk.modelVersion,
+                contentIndex,
+                delta: { role: "assistant", content: pendingContent }
+              });
+              controller.enqueue(encoder.encode(`data: ${JSON.stringify(pendingChunk)}
+
+`));
+              pendingContent = "";
+              contentSent = true;
+            }
+          }
+          const toolCalls = parts.filter((part) => part.functionCall).map((part) => ({
+            id: part.functionCall?.id || `ccr_tool_${Math.random().toString(36).substring(2, 15)}`,
+            type: "function",
+            function: {
+              name: part.functionCall?.name ?? "",
+              arguments: JSON.stringify(part.functionCall?.args || {})
+            }
+          }));
+          const textContent = parts.filter((part) => part.text && part.thought !== true).map((part) => part.text).join("\n");
+          if (!textContent && signatureSent && !contentSent) {
+            contentSent = true;
+          }
+          if (hasThinkingContent && textContent && !signatureSent) {
+            if (chunk.modelVersion?.includes("3")) {
+              pendingContent += textContent;
+              return;
+            } else {
+              const signatureChunk = createChunk({
+                responseId: chunk.responseId,
+                modelVersion: chunk.modelVersion,
+                contentIndex,
+                delta: {
+                  role: "assistant",
+                  content: null,
+                  thinking: { signature: `ccr_${Date.now()}` }
+                }
+              });
+              controller.enqueue(encoder.encode(`data: ${JSON.stringify(signatureChunk)}
+
+`));
+              signatureSent = true;
+            }
+          }
+          if (textContent) {
+            if (!pendingContent) contentIndex++;
+            const contentChunk = createChunk({
+              responseId: chunk.responseId,
+              modelVersion: chunk.modelVersion,
+              contentIndex,
+              delta: { role: "assistant", content: textContent },
+              finishReason: candidate.finishReason,
+              usageMetadata: chunk.usageMetadata,
+              groundingMetadata: candidate.groundingMetadata
+            });
+            controller.enqueue(encoder.encode(`data: ${JSON.stringify(contentChunk)}
+
+`));
+            contentSent = true;
+          }
+          if (toolCalls.length > 0) {
+            for (const tool of toolCalls) {
+              contentIndex++;
+              toolCallIndex++;
+              const toolChunk = createChunk({
+                responseId: chunk.responseId,
+                modelVersion: chunk.modelVersion,
+                contentIndex,
+                delta: {
+                  role: "assistant",
+                  tool_calls: [{ ...tool, index: toolCallIndex }]
+                },
+                finishReason: candidate.finishReason,
+                usageMetadata: chunk.usageMetadata,
+                groundingMetadata: candidate.groundingMetadata
+              });
+              controller.enqueue(encoder.encode(`data: ${JSON.stringify(toolChunk)}
+
+`));
+            }
+            contentSent = true;
+          }
+        } catch (_error) {
+          logger?.error(`Error parsing ${providerName} stream chunk: ${chunkStr}`);
+        }
+      };
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) {
+            if (buffer) await processLine(buffer);
+            break;
+          }
+          buffer += decoder.decode(value, { stream: true });
+          const lines = buffer.split("\n");
+          buffer = lines.pop() || "";
+          for (const line of lines) {
+            await processLine(line);
+          }
+        }
+      } catch (error) {
+        controller.error(error);
+      } finally {
+        controller.close();
+      }
+    }
+  });
+  return new Response(stream, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers
+  });
+}
+function createChunk(options) {
+  const {
+    responseId,
+    modelVersion,
+    contentIndex,
+    delta,
+    finishReason,
+    usageMetadata,
+    groundingMetadata
+  } = options;
+  const chunk = {
+    choices: [
+      {
+        delta,
+        finish_reason: finishReason?.toLowerCase() || null,
+        index: contentIndex,
+        logprobs: null
+      }
+    ],
+    created: Math.floor(Date.now() / 1e3),
+    id: responseId || "",
+    model: modelVersion || "",
+    object: "chat.completion.chunk",
+    system_fingerprint: "fp_a49d71b8a1"
+  };
+  if (usageMetadata) {
+    chunk.usage = {
+      completion_tokens: usageMetadata.candidatesTokenCount || 0,
+      prompt_tokens: usageMetadata.promptTokenCount || 0,
+      prompt_tokens_details: {
+        cached_tokens: usageMetadata.cachedContentTokenCount || 0
+      },
+      total_tokens: usageMetadata.totalTokenCount || 0,
+      output_tokens_details: {
+        reasoning_tokens: usageMetadata.thoughtsTokenCount || 0
+      }
+    };
+  }
+  if (groundingMetadata?.groundingChunks?.length) {
+    const annotations = groundingMetadata.groundingChunks.map((groundingChunk, index) => {
+      const support = groundingMetadata.groundingSupports?.find(
+        (s) => s.groundingChunkIndices?.includes(index)
+      );
+      return {
+        type: "url_citation",
+        url_citation: {
+          url: groundingChunk.web?.uri || "",
+          title: groundingChunk.web?.title || "",
+          content: support?.segment?.text || "",
+          start_index: support?.segment?.startIndex || 0,
+          end_index: support?.segment?.endIndex || 0
+        }
+      };
+    });
+    chunk.choices[0].delta.annotations = annotations;
+  }
+  return chunk;
+}
+
+// src/transformer/transformers/utils/gemini.schema.ts
+var GeminiType = {
+  TYPE_UNSPECIFIED: "TYPE_UNSPECIFIED",
+  STRING: "STRING",
+  NUMBER: "NUMBER",
+  INTEGER: "INTEGER",
+  BOOLEAN: "BOOLEAN",
+  ARRAY: "ARRAY",
+  OBJECT: "OBJECT",
+  NULL: "NULL"
+};
+function flattenTypeArrayToAnyOf(typeList, resultingSchema) {
+  if (typeList.includes("null")) {
+    resultingSchema.nullable = true;
+  }
+  const listWithoutNull = typeList.filter((type) => type !== "null");
+  if (listWithoutNull.length === 1) {
+    const upperCaseType = listWithoutNull[0].toUpperCase();
+    resultingSchema.type = Object.values(GeminiType).includes(upperCaseType) ? upperCaseType : GeminiType.TYPE_UNSPECIFIED;
+  } else {
+    resultingSchema.anyOf = listWithoutNull.map((typeName) => {
+      const upperCaseType = typeName.toUpperCase();
+      return {
+        type: Object.values(GeminiType).includes(upperCaseType) ? upperCaseType : GeminiType.TYPE_UNSPECIFIED
+      };
+    });
+  }
+}
+function processJsonSchema(jsonSchema) {
+  const genAISchema = {};
+  const schemaFieldNames = ["items"];
+  const listSchemaFieldNames = ["anyOf"];
+  const dictSchemaFieldNames = ["properties"];
+  let workingSchema = jsonSchema;
+  if (workingSchema.type && workingSchema.anyOf) {
+    throw new Error("type and anyOf cannot be both populated.");
+  }
+  const incomingAnyOf = workingSchema.anyOf;
+  if (incomingAnyOf && Array.isArray(incomingAnyOf) && incomingAnyOf.length === 2) {
+    if (incomingAnyOf[0]?.type === "null") {
+      genAISchema.nullable = true;
+      workingSchema = incomingAnyOf[1];
+    } else if (incomingAnyOf[1]?.type === "null") {
+      genAISchema.nullable = true;
+      workingSchema = incomingAnyOf[0];
+    }
+  }
+  if (workingSchema.type && Array.isArray(workingSchema.type)) {
+    flattenTypeArrayToAnyOf(workingSchema.type, genAISchema);
+  }
+  for (const [fieldName, fieldValue] of Object.entries(workingSchema)) {
+    if (fieldValue == null) {
+      continue;
+    }
+    if (fieldName === "type") {
+      if (fieldValue === "null") {
+        throw new Error("type: null cannot be the only possible type for the field.");
+      }
+      if (Array.isArray(fieldValue)) {
+        continue;
+      }
+      const upperCaseValue = fieldValue.toUpperCase();
+      genAISchema.type = Object.values(GeminiType).includes(upperCaseValue) ? upperCaseValue : GeminiType.TYPE_UNSPECIFIED;
+    } else if (schemaFieldNames.includes(fieldName)) {
+      genAISchema[fieldName] = processJsonSchema(fieldValue);
+    } else if (listSchemaFieldNames.includes(fieldName)) {
+      const listValue = [];
+      for (const item of fieldValue) {
+        if (item.type === "null") {
+          genAISchema.nullable = true;
+          continue;
+        }
+        listValue.push(processJsonSchema(item));
+      }
+      genAISchema[fieldName] = listValue;
+    } else if (dictSchemaFieldNames.includes(fieldName)) {
+      const dictValue = {};
+      for (const [key, value] of Object.entries(fieldValue)) {
+        dictValue[key] = processJsonSchema(value);
+      }
+      genAISchema[fieldName] = dictValue;
+    } else {
+      if (fieldName === "additionalProperties") {
+        continue;
+      }
+      genAISchema[fieldName] = fieldValue;
+    }
+  }
+  return genAISchema;
+}
+function transformTool(tool) {
+  const functionDeclarations = tool.functionDeclarations;
+  if (functionDeclarations) {
+    for (const functionDeclaration of functionDeclarations) {
+      if (functionDeclaration.parameters) {
+        const params = functionDeclaration.parameters;
+        if (!Object.keys(params).includes("$schema")) {
+          functionDeclaration.parameters = processJsonSchema(params);
+        } else {
+          if (!functionDeclaration.parametersJsonSchema) {
+            functionDeclaration.parametersJsonSchema = functionDeclaration.parameters;
+            delete functionDeclaration.parameters;
+          }
+        }
+      }
+      if (functionDeclaration.response) {
+        const response = functionDeclaration.response;
+        if (!Object.keys(response).includes("$schema")) {
+          functionDeclaration.response = processJsonSchema(response);
+        } else {
+          if (!functionDeclaration.responseJsonSchema) {
+            functionDeclaration.responseJsonSchema = functionDeclaration.response;
+            delete functionDeclaration.response;
+          }
+        }
+      }
+    }
+  }
+  return tool;
+}
+
+// src/transformer/transformers/utils/gemini.util.ts
+function buildRequestBody(request) {
+  const tools = [];
+  const functionDeclarations = request.tools?.filter((tool) => tool.function.name !== "web_search")?.map((tool) => ({
+    name: tool.function.name,
+    description: tool.function.description,
+    parametersJsonSchema: tool.function.parameters
+  }));
+  if (functionDeclarations?.length) {
+    tools.push(
+      transformTool({
+        functionDeclarations
+      })
+    );
+  }
+  const webSearch = request.tools?.find((tool) => tool.function.name === "web_search");
+  if (webSearch) {
+    tools.push({ googleSearch: {} });
+  }
+  const contents = [];
+  const toolResponses = request.messages.filter((item) => item.role === "tool");
+  request.messages.filter((item) => item.role !== "tool").forEach((message) => {
+    let role;
+    if (message.role === "assistant") {
+      role = "model";
+    } else if (["user", "system"].includes(message.role)) {
+      role = "user";
+    } else {
+      role = "user";
+    }
+    const parts = [];
+    if (typeof message.content === "string") {
+      const part = { text: message.content };
+      if (message.thinking?.signature) {
+        part.thoughtSignature = message.thinking.signature;
+      }
+      parts.push(part);
+    } else if (Array.isArray(message.content)) {
+      for (const content of message.content) {
+        if (content.type === "text") {
+          parts.push({ text: content.text || "" });
+        } else if (content.type === "image_url") {
+          const imageUrl = content.image_url?.url ?? "";
+          if (imageUrl.startsWith("http")) {
+            parts.push({
+              file_data: {
+                mime_type: content.media_type,
+                file_uri: imageUrl
+              }
+            });
+          } else {
+            const data = imageUrl.split(",").pop() || imageUrl;
+            parts.push({
+              inlineData: {
+                mime_type: content.media_type || "image/png",
+                data
+              }
+            });
+          }
+        }
+      }
+    } else if (message.content && typeof message.content === "object") {
+      const contentObj = message.content;
+      if (contentObj.text) {
+        parts.push({ text: contentObj.text });
+      } else {
+        parts.push({ text: JSON.stringify(message.content) });
+      }
+    }
+    if (Array.isArray(message.tool_calls)) {
+      for (let index = 0; index < message.tool_calls.length; index++) {
+        const toolCall = message.tool_calls[index];
+        const functionCallPart = {
+          functionCall: {
+            id: toolCall.id || `tool_${Math.random().toString(36).substring(2, 15)}`,
+            name: toolCall.function.name,
+            args: JSON.parse(toolCall.function.arguments || "{}")
+          }
+        };
+        if (index === 0 && message.thinking?.signature) {
+          functionCallPart.thoughtSignature = message.thinking.signature;
+        }
+        parts.push(functionCallPart);
+      }
+    }
+    if (parts.length === 0) {
+      parts.push({ text: "" });
+    }
+    contents.push({ role, parts });
+    if (role === "model" && message.tool_calls) {
+      const functionResponses = message.tool_calls.map(
+        (tool) => {
+          const response = toolResponses.find((item) => item.tool_call_id === tool.id);
+          return {
+            functionResponse: {
+              name: tool.function?.name ?? "",
+              response: { result: response?.content }
+            }
+          };
+        }
+      );
+      contents.push({
+        role: "user",
+        parts: functionResponses
+      });
+    }
+  });
+  const generationConfig = {};
+  if (request.reasoning?.effort && request.reasoning.effort !== "none") {
+    generationConfig.thinkingConfig = {
+      includeThoughts: true
+    };
+    if (request.model.includes("gemini-3")) {
+      generationConfig.thinkingConfig.thinkingLevel = request.reasoning.effort;
+    } else {
+      const thinkingBudgets = request.model.includes("pro") ? [128, 32768] : [0, 24576];
+      const maxTokens = request.reasoning.max_tokens;
+      if (typeof maxTokens !== "undefined") {
+        let thinkingBudget;
+        if (maxTokens >= thinkingBudgets[0] && maxTokens <= thinkingBudgets[1]) {
+          thinkingBudget = maxTokens;
+        } else if (maxTokens < thinkingBudgets[0]) {
+          thinkingBudget = thinkingBudgets[0];
+        } else {
+          thinkingBudget = thinkingBudgets[1];
+        }
+        generationConfig.thinkingConfig.thinkingBudget = thinkingBudget;
+      }
+    }
+  }
+  const body = {
+    contents,
+    tools: tools.length > 0 ? tools : void 0,
+    generationConfig: Object.keys(generationConfig).length > 0 ? generationConfig : void 0
+  };
+  if (request.tool_choice) {
+    const toolConfig = {
+      functionCallingConfig: {}
+    };
+    if (request.tool_choice === "auto") {
+      toolConfig.functionCallingConfig.mode = "auto";
+    } else if (request.tool_choice === "none") {
+      toolConfig.functionCallingConfig.mode = "none";
+    } else if (request.tool_choice === "required") {
+      toolConfig.functionCallingConfig.mode = "any";
+    } else if (typeof request.tool_choice === "object" && request.tool_choice.function?.name) {
+      toolConfig.functionCallingConfig.mode = "any";
+      toolConfig.functionCallingConfig.allowedFunctionNames = [
+        request.tool_choice.function.name
+      ];
+    }
+    body.toolConfig = toolConfig;
+  }
+  return body;
+}
+function transformRequestOut(request) {
+  const contents = request.contents;
+  const tools = request.tools;
+  const model = request.model;
+  const maxTokens = request.max_tokens;
+  const temperature = request.temperature;
+  const stream = request.stream;
+  const toolChoice = request.tool_choice;
+  const unifiedRequest = {
+    messages: [],
+    model,
+    max_tokens: maxTokens,
+    temperature,
+    stream,
+    tool_choice: toolChoice
+  };
+  if (Array.isArray(contents)) {
+    for (const content of contents) {
+      if (typeof content === "string") {
+        unifiedRequest.messages.push({
+          role: "user",
+          content
+        });
+      } else if ("text" in content && typeof content.text === "string") {
+        unifiedRequest.messages.push({
+          role: "user",
+          content: content.text || null
+        });
+      } else if ("role" in content && content.role === "user") {
+        const geminiContent = content;
+        unifiedRequest.messages.push({
+          role: "user",
+          content: geminiContent.parts?.map((part) => ({
+            type: "text",
+            text: part.text || ""
+          })) || []
+        });
+      } else if (content.role === "model") {
+        unifiedRequest.messages.push({
+          role: "assistant",
+          content: content.parts?.map((part) => ({
+            type: "text",
+            text: part.text || ""
+          })) || []
+        });
+      }
+    }
+  }
+  if (Array.isArray(tools)) {
+    unifiedRequest.tools = [];
+    for (const tool of tools) {
+      if (Array.isArray(tool.functionDeclarations)) {
+        for (const funcDecl of tool.functionDeclarations) {
+          unifiedRequest.tools.push({
+            type: "function",
+            function: {
+              name: funcDecl.name,
+              description: funcDecl.description ?? "",
+              parameters: funcDecl.parameters ?? {}
+            }
+          });
+        }
+      }
+    }
+  }
+  return unifiedRequest;
+}
+
+// src/transformer/transformers/GeminiTransformer.ts
+var GeminiTransformer = class {
+  static TransformerName = "gemini";
+  name = "gemini";
+  logger;
+  /**
+   * API endpoint pattern for Gemini
+   * :modelAndAction will be replaced with actual model and action
+   */
+  endPoint = "/v1beta/models/:modelAndAction";
+  /** Use Bearer token instead of x-goog-api-key (for relay providers) */
+  useBearer;
+  constructor(options) {
+    this.useBearer = options?.UseBearer ?? false;
+  }
+  /**
+   * Handle authentication
+   * - Official Gemini: x-goog-api-key header
+   * - Relay providers: Authorization: Bearer header
+   */
+  async auth(request, provider, _context) {
+    const headers = {};
+    if (this.useBearer) {
+      headers["authorization"] = `Bearer ${provider.apiKey}`;
+      headers["x-goog-api-key"] = void 0;
+    } else {
+      headers["x-goog-api-key"] = provider.apiKey;
+      headers["authorization"] = void 0;
+    }
+    return {
+      body: request,
+      config: { headers }
+    };
+  }
+  /**
+   * Transform request from unified format to Gemini format
+   * Also builds the correct URL for the Gemini API
+   */
+  async transformRequestIn(request, provider, _context) {
+    const body = buildRequestBody(request);
+    const action = request.stream ? "streamGenerateContent?alt=sse" : "generateContent";
+    const url = new URL(`./${request.model}:${action}`, provider.baseUrl);
+    const headers = {};
+    if (this.useBearer) {
+      headers["authorization"] = `Bearer ${provider.apiKey}`;
+      headers["x-goog-api-key"] = void 0;
+    } else {
+      headers["x-goog-api-key"] = provider.apiKey;
+      headers["Authorization"] = void 0;
+    }
+    return {
+      body,
+      config: { url, headers }
+    };
+  }
+  /**
+   * Transform incoming request to unified format
+   * (For requests coming into the Gemini endpoint)
+   */
+  async transformRequestOut(request, _context) {
+    return transformRequestOut(request);
+  }
+  /**
+   * Transform Gemini response to OpenAI-compatible format
+   */
+  async transformResponseOut(response, _context) {
+    return transformResponseOut(response, this.name, this.logger);
+  }
+  /**
+   * Transform OpenAI-compatible response back to Gemini format
+   * (For endpoint mode — returning Gemini-format responses to the client)
+   */
+  async transformResponseIn(response, _context) {
+    return transformResponseIn(response, this.logger);
+  }
+};
+
+// src/transformer/transformers/OpenAIResponseTransformer.ts
+var OpenAIResponseTransformer = class {
+  static TransformerName = "openai-response";
+  name = "openai-response";
+  endPoint = "/v1/responses";
+  logger;
+  /**
+   * Handle authentication - Bearer token
+   */
+  async auth(request, provider, _context) {
+    return {
+      body: request,
+      config: {
+        headers: {
+          Authorization: `Bearer ${provider.apiKey}`,
+          "Content-Type": "application/json"
+        }
+      }
+    };
+  }
+  /**
+   * Transform unified request → Response API format
+   */
+  async transformRequestIn(request, provider, _context) {
+    const input = [];
+    for (const msg of request.messages) {
+      if (msg.role === "system") {
+        input.push({
+          role: "developer",
+          content: typeof msg.content === "string" ? msg.content : flattenContent(msg.content)
+        });
+      } else if (msg.role === "tool") {
+        input.push({
+          type: "function_call_output",
+          call_id: msg.tool_call_id,
+          output: typeof msg.content === "string" ? msg.content : ""
+        });
+      } else {
+        const entry = {
+          role: msg.role,
+          content: typeof msg.content === "string" ? msg.content : flattenContent(msg.content)
+        };
+        if (msg.role === "assistant" && msg.tool_calls?.length) {
+          input.push(entry);
+          for (const tc of msg.tool_calls) {
+            input.push({
+              type: "function_call",
+              id: tc.id,
+              call_id: tc.id,
+              name: tc.function.name,
+              arguments: tc.function.arguments
+            });
+          }
+          continue;
+        }
+        input.push(entry);
+      }
+    }
+    const body = {
+      model: request.model,
+      input,
+      stream: request.stream ?? false,
+      ...request.max_tokens ? { max_output_tokens: request.max_tokens } : {},
+      ...request.temperature !== void 0 ? { temperature: request.temperature } : {}
+    };
+    if (request.reasoning?.effort && request.reasoning.effort !== "none") {
+      body.reasoning = { effort: request.reasoning.effort, summary: "auto" };
+    }
+    if (request.tools?.length) {
+      body.tools = request.tools.map((tool) => ({
+        type: "function",
+        name: tool.function.name,
+        description: tool.function.description,
+        parameters: tool.function.parameters
+      }));
+    }
+    if (request.tool_choice) {
+      if (typeof request.tool_choice === "string") {
+        body.tool_choice = request.tool_choice;
+      } else if (typeof request.tool_choice === "object" && "function" in request.tool_choice) {
+        body.tool_choice = { type: "function", name: request.tool_choice.function.name };
+      }
+    }
+    const url = new URL("/v1/responses", provider.baseUrl);
+    return { body, config: { url } };
+  }
+  /**
+   * Transform Response API request → unified format
+   */
+  async transformRequestOut(request, _context) {
+    const req = request;
+    const messages = [];
+    if (req.input) {
+      for (const item of req.input) {
+        const entry = item;
+        if (entry.type === "function_call_output") {
+          messages.push({
+            role: "tool",
+            content: entry.output || "",
+            tool_call_id: entry.call_id || void 0
+          });
+          continue;
+        }
+        if (entry.type === "function_call") {
+          const toolCall = {
+            id: (entry.call_id ?? entry.id) || "",
+            type: "function",
+            function: {
+              name: entry.name || "",
+              arguments: typeof entry.arguments === "string" ? entry.arguments : ""
+            }
+          };
+          const last = messages[messages.length - 1];
+          if (last && last.role === "assistant") {
+            (last.tool_calls ??= []).push(toolCall);
+          } else {
+            messages.push({ role: "assistant", content: null, tool_calls: [toolCall] });
+          }
+          continue;
+        }
+        const role = entry.role;
+        if (role === "developer") {
+          messages.push({
+            role: "system",
+            content: typeof entry.content === "string" ? entry.content : JSON.stringify(entry.content)
+          });
+        } else if (role === "user" || role === "assistant") {
+          messages.push({
+            role,
+            content: typeof entry.content === "string" ? entry.content : JSON.stringify(entry.content)
+          });
+        }
+      }
+    }
+    const result = {
+      messages,
+      model: req.model,
+      max_tokens: req.max_output_tokens,
+      temperature: req.temperature,
+      stream: req.stream
+    };
+    if (req.reasoning?.effort) {
+      result.reasoning = {
+        effort: req.reasoning.effort,
+        enabled: true
+      };
+    }
+    if (req.tools?.length) {
+      result.tools = req.tools.filter((t) => t.type === "function").map((t) => ({
+        type: "function",
+        function: {
+          name: t.name || "",
+          description: t.description || "",
+          parameters: t.parameters || {}
+        }
+      }));
+    }
+    return result;
+  }
+  /**
+   * Transform Response API response → unified (OpenAI CC) format
+   */
+  async transformResponseOut(response, _context) {
+    const contentType = response.headers.get("Content-Type") ?? "";
+    if (contentType.includes("text/event-stream")) {
+      if (!response.body) {
+        throw new Error("Stream response body is null");
+      }
+      return new Response(convertResponseApiStreamToOpenAI(response.body), {
+        headers: {
+          "Content-Type": "text/event-stream",
+          "Cache-Control": "no-cache",
+          Connection: "keep-alive"
+        }
+      });
+    }
+    const data = await response.json();
+    return new Response(JSON.stringify(convertResponseApiJsonToOpenAI(data)), {
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+  /**
+   * Transform OpenAI CC response → Response API format
+   */
+  async transformResponseIn(response, _context) {
+    const contentType = response.headers.get("Content-Type") ?? "";
+    if (contentType.includes("text/event-stream")) {
+      if (!response.body) {
+        throw new Error("Stream response body is null");
+      }
+      return new Response(convertOpenAIStreamToResponseApi(response.body), {
+        headers: {
+          "Content-Type": "text/event-stream",
+          "Cache-Control": "no-cache",
+          Connection: "keep-alive"
+        }
+      });
+    }
+    const data = await response.json();
+    return new Response(JSON.stringify(convertOpenAIJsonToResponseApi(data)), {
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+};
+function flattenContent(content) {
+  if (typeof content === "string") return content;
+  if (!content) return "";
+  if (Array.isArray(content)) {
+    return content.filter((c) => c.type === "text").map((c) => c.text || "").join("\n");
+  }
+  return "";
+}
+function convertResponseApiJsonToOpenAI(data) {
+  let textContent = "";
+  const toolCalls = [];
+  const output = data.output;
+  if (output) {
+    for (const item of output) {
+      if (item.type === "message") {
+        const content = item.content;
+        if (content) {
+          for (const part of content) {
+            if (part.type === "output_text" && typeof part.text === "string") {
+              textContent += part.text;
+            }
+          }
+        }
+      } else if (item.type === "function_call") {
+        toolCalls.push({
+          id: item.call_id || item.id || `call_${Date.now()}`,
+          type: "function",
+          function: {
+            name: item.name,
+            arguments: typeof item.arguments === "string" ? item.arguments : JSON.stringify(item.arguments || {})
+          }
+        });
+      }
+    }
+  }
+  const usage = data.usage;
+  const message = {
+    role: "assistant",
+    content: textContent || null
+  };
+  if (toolCalls.length > 0) {
+    message.tool_calls = toolCalls;
+  }
+  return {
+    id: data.id || `chatcmpl-${Date.now()}`,
+    object: "chat.completion",
+    created: Math.floor(Date.now() / 1e3),
+    model: data.model || "unknown",
+    choices: [
+      {
+        index: 0,
+        message,
+        finish_reason: toolCalls.length > 0 ? "tool_calls" : "stop"
+      }
+    ],
+    usage: usage ? {
+      prompt_tokens: usage.input_tokens || 0,
+      completion_tokens: usage.output_tokens || 0,
+      total_tokens: (usage.input_tokens || 0) + (usage.output_tokens || 0)
+    } : void 0
+  };
+}
+function convertOpenAIJsonToResponseApi(data) {
+  const choices = data.choices;
+  const message = choices?.[0]?.message;
+  const output = [];
+  if (message) {
+    const contentParts = [];
+    if (message.content) {
+      contentParts.push({ type: "output_text", text: message.content });
+    }
+    if (contentParts.length > 0) {
+      output.push({ type: "message", role: "assistant", content: contentParts });
+    }
+    const toolCalls = message.tool_calls;
+    if (toolCalls?.length) {
+      for (const tc of toolCalls) {
+        const func = tc.function;
+        output.push({
+          type: "function_call",
+          id: tc.id,
+          call_id: tc.id,
+          name: func?.name,
+          arguments: func?.arguments
+        });
+      }
+    }
+  }
+  const usage = data.usage;
+  return {
+    id: data.id || `resp_${Date.now()}`,
+    object: "response",
+    status: "completed",
+    model: data.model || "unknown",
+    output,
+    usage: usage ? {
+      input_tokens: usage.prompt_tokens || 0,
+      output_tokens: usage.completion_tokens || 0,
+      total_tokens: usage.total_tokens || (usage.prompt_tokens || 0) + (usage.completion_tokens || 0)
+    } : void 0
+  };
+}
+function convertResponseApiStreamToOpenAI(responseApiStream) {
+  const decoder = new TextDecoder();
+  const encoder = new TextEncoder();
+  return new ReadableStream({
+    start: async (controller) => {
+      const reader = responseApiStream.getReader();
+      let buffer = "";
+      let isClosed = false;
+      const messageId = `chatcmpl-${Date.now()}`;
+      let model = "unknown";
+      let hasEmittedRole = false;
+      const safeEnqueue = (str) => {
+        if (!isClosed) {
+          try {
+            controller.enqueue(encoder.encode(str));
+          } catch {
+            isClosed = true;
+          }
+        }
+      };
+      const emitChunk = (choices, usage) => {
+        const chunk = {
+          id: messageId,
+          object: "chat.completion.chunk",
+          created: Math.floor(Date.now() / 1e3),
+          model,
+          choices
+        };
+        if (usage) chunk.usage = usage;
+        safeEnqueue(`data: ${JSON.stringify(chunk)}
+
+`);
+      };
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          buffer += decoder.decode(value, { stream: true });
+          const lines = buffer.split("\n");
+          buffer = lines.pop() || "";
+          for (const line of lines) {
+            if (isClosed) break;
+            if (!line.startsWith("data:")) continue;
+            const data = line.slice(5).trim();
+            if (data === "[DONE]") continue;
+            try {
+              const event = JSON.parse(data);
+              model = event.model || event.response?.model || model;
+              switch (event.type) {
+                case "response.output_text.delta":
+                  if (event.delta) {
+                    if (!hasEmittedRole) {
+                      emitChunk([{ index: 0, delta: { role: "assistant", content: "" }, finish_reason: null }]);
+                      hasEmittedRole = true;
+                    }
+                    emitChunk([{ index: 0, delta: { content: event.delta }, finish_reason: null }]);
+                  }
+                  break;
+                case "response.reasoning_summary_text.delta":
+                  if (event.delta) {
+                    emitChunk([{
+                      index: 0,
+                      delta: { thinking: { content: event.delta } },
+                      finish_reason: null
+                    }]);
+                  }
+                  break;
+                case "response.completed": {
+                  const resp = event.response;
+                  const respUsage = resp?.usage;
+                  const usage = respUsage ? {
+                    prompt_tokens: respUsage.input_tokens || 0,
+                    completion_tokens: respUsage.output_tokens || 0,
+                    total_tokens: (respUsage.input_tokens || 0) + (respUsage.output_tokens || 0)
+                  } : void 0;
+                  emitChunk([{ index: 0, delta: {}, finish_reason: "stop" }], usage);
+                  safeEnqueue("data: [DONE]\n\n");
+                  break;
+                }
+                case "error":
+                  emitChunk([{
+                    index: 0,
+                    delta: { content: `[Error: ${event.error?.message || "Unknown error"}]` },
+                    finish_reason: "stop"
+                  }]);
+                  break;
+                default:
+                  break;
+              }
+            } catch {
+            }
+          }
+        }
+      } catch (e) {
+        if (!isClosed) controller.error(e);
+      } finally {
+        if (!isClosed) {
+          try {
+            controller.close();
+          } catch {
+          }
+        }
+        reader.releaseLock();
+      }
+    }
+  });
+}
+function convertOpenAIStreamToResponseApi(openaiStream) {
+  const decoder = new TextDecoder();
+  const encoder = new TextEncoder();
+  return new ReadableStream({
+    start: async (controller) => {
+      const reader = openaiStream.getReader();
+      let buffer = "";
+      let isClosed = false;
+      let accumulatedContent = "";
+      let model = "unknown";
+      const responseId = `resp_${Date.now()}`;
+      const safeEnqueue = (str) => {
+        if (!isClosed) {
+          try {
+            controller.enqueue(encoder.encode(str));
+          } catch {
+            isClosed = true;
+          }
+        }
+      };
+      const emitEvent = (event) => {
+        safeEnqueue(`data: ${JSON.stringify(event)}
+
+`);
+      };
+      emitEvent({
+        type: "response.created",
+        response: { id: responseId, status: "in_progress" }
+      });
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          buffer += decoder.decode(value, { stream: true });
+          const lines = buffer.split("\n");
+          buffer = lines.pop() || "";
+          for (const line of lines) {
+            if (isClosed) break;
+            if (!line.startsWith("data:")) continue;
+            const data = line.slice(5).trim();
+            if (data === "[DONE]") continue;
+            try {
+              const chunk = JSON.parse(data);
+              const choice = chunk.choices?.[0];
+              model = chunk.model || model;
+              if (!choice) continue;
+              if (choice.delta?.content) {
+                accumulatedContent += choice.delta.content;
+                emitEvent({ type: "response.output_text.delta", delta: choice.delta.content });
+              }
+              if (choice.delta?.thinking?.content) {
+                emitEvent({
+                  type: "response.reasoning_summary_text.delta",
+                  delta: choice.delta.thinking.content
+                });
+              }
+              if (choice.finish_reason) {
+                emitEvent({ type: "response.output_text.done", text: accumulatedContent });
+                emitEvent({
+                  type: "response.completed",
+                  response: {
+                    id: responseId,
+                    status: "completed",
+                    model,
+                    output: [
+                      {
+                        type: "message",
+                        role: "assistant",
+                        content: [{ type: "output_text", text: accumulatedContent }]
+                      }
+                    ],
+                    usage: chunk.usage ? {
+                      input_tokens: chunk.usage.prompt_tokens || 0,
+                      output_tokens: chunk.usage.completion_tokens || 0,
+                      total_tokens: chunk.usage.total_tokens || 0
+                    } : void 0
+                  }
+                });
+              }
+            } catch {
+            }
+          }
+        }
+      } catch (e) {
+        if (!isClosed) controller.error(e);
+      } finally {
+        if (!isClosed) {
+          try {
+            controller.close();
+          } catch {
+          }
+        }
+        reader.releaseLock();
+      }
+    }
+  });
+}
+
+// src/transformer/transformers/ReasoningTransformer.ts
+import {
+  buildAnthropicThinking,
+  buildQwenThinkingConfig,
+  calculateThinkingBudget,
+  getOpenAIReasoningEffort
+} from "@omnicross/contracts/thinking-config";
+
+// src/completion/StreamHandler.ts
+import { buildAnthropicThinking as buildAnthropicThinking2, getOpenAIReasoningEffort as getOpenAIReasoningEffort3 } from "@omnicross/contracts/thinking-config";
+
+// src/completion/ThinkingResolver.ts
+import {
+  buildAnthropicThinking as buildAnthropicThinking3,
+  calculateThinkingBudget as calculateThinkingBudget2,
+  DEFAULT_MAX_TOKENS,
+  getClaudeMaxTokens,
+  isReasoningModel
+} from "@omnicross/contracts/thinking-config";
+
+// src/completion/url-builder.ts
+import { resolveProviderEndpoint as resolveProviderEndpointShared } from "@omnicross/contracts/endpoint-resolver";
+function resolveApiFormat(provider) {
+  if (provider.apiFormat) {
+    return provider.apiFormat;
+  }
+  if (provider.chatApiFormat) {
+    return provider.chatApiFormat;
+  }
+  if (provider.apiType === "claudecode" || provider.apiType === "anthropic") {
+    return "anthropic";
+  }
+  if (provider.apiType === "google") {
+    return "google";
+  }
+  return "openai";
+}
+function buildOpenAIApiUrl(baseUrl) {
+  const url = baseUrl.replace(/\/+$/, "");
+  if (url.endsWith("/chat/completions")) {
+    return url;
+  }
+  if (/\/v\d+$/.test(url)) {
+    return url + "/chat/completions";
+  }
+  if (url.includes("/chat/completions")) {
+    return url;
+  }
+  return url + "/v1/chat/completions";
+}
+function buildAnthropicApiUrl(baseUrl) {
+  const url = baseUrl.replace(/\/+$/, "");
+  if (url.endsWith("/messages")) {
+    return url;
+  }
+  if (url.includes("/messages")) {
+    return url;
+  }
+  if (/\/v\d+$/.test(url)) {
+    return url + "/messages";
+  }
+  return url + "/v1/messages";
+}
+function buildGeminiModelActionUrl(baseUrl, model, action) {
+  let url = baseUrl.replace(/\/+$/, "");
+  if (url.includes("/models/")) {
+    return url;
+  }
+  if (!/\/v\d+(?:beta)?(?:$|\/)/.test(url)) {
+    url += "/v1beta";
+  }
+  return `${url}/models/${model}:${action}`;
+}
+function buildGeminiApiUrl(baseUrl, model, stream) {
+  const action = stream ? "streamGenerateContent?alt=sse" : "generateContent";
+  return buildGeminiModelActionUrl(baseUrl, model, action);
+}
+function normalizeAzureEndpoint(endpoint) {
+  return endpoint.replace(/\/+$/, "").replace(/\/openai(\/v\d+)?$/, "");
+}
+function buildAzureOpenAIApiUrl(baseUrl, model, apiVersion) {
+  const endpoint = normalizeAzureEndpoint(baseUrl);
+  return `${endpoint}/openai/deployments/${model}/chat/completions?api-version=${apiVersion}`;
+}
+function buildOpenAIResponseApiUrl(baseUrl) {
+  const url = baseUrl.replace(/\/+$/, "");
+  if (url.endsWith("/responses")) {
+    return url;
+  }
+  if (/\/v\d+$/.test(url)) {
+    return url + "/responses";
+  }
+  return url + "/v1/responses";
+}
+var resolveProviderEndpoint = resolveProviderEndpointShared;
+function buildProviderApiUrl(provider, options = {}) {
+  const format = resolveApiFormat(provider);
+  const { baseUrl } = resolveProviderEndpoint(provider);
+  switch (format) {
+    case "anthropic":
+      return buildAnthropicApiUrl(baseUrl);
+    case "google":
+      return buildGeminiApiUrl(baseUrl, options.model || "", options.stream || false);
+    case "azure-openai":
+      return buildAzureOpenAIApiUrl(baseUrl, options.model || "", provider.apiVersion || "2024-08-01-preview");
+    case "openai-response":
+      return buildOpenAIResponseApiUrl(baseUrl);
+    case "openai":
+    default:
+      return buildOpenAIApiUrl(baseUrl);
+  }
+}
+
+// src/pipeline/executeProviderCall.ts
+async function executeProviderCall(ctx) {
+  const {
+    executor,
+    request,
+    provider,
+    chain,
+    endpointTransformer,
+    extendedContext,
+    resolveUrl,
+    buildHeaders,
+    prepareBody,
+    fetchFn,
+    runResponseChain = false,
+    responseChainRequest
+  } = ctx;
+  const { requestBody, config } = await executor.executeRequestChain(
+    request,
+    provider,
+    chain,
+    { endpointTransformer, extendedContext }
+  );
+  const finalBody = prepareBody ? await prepareBody(requestBody, config) : requestBody;
+  const url = resolveUrl(config);
+  const headers = buildHeaders(config);
+  const fetched = await fetchFn(url, headers, finalBody);
+  let response = fetched;
+  if (runResponseChain) {
+    response = await executor.executeResponseChain(
+      // Preserve the EXACT first arg each site passed: proxy → requestBody,
+      // unified ingresses → their pre-transform request. The caller supplies
+      // it via `responseChainRequest`; fall back to `requestBody` (the proxy
+      // shape) so the contract is never silently `undefined`.
+      responseChainRequest ?? requestBody,
+      fetched,
+      provider,
+      chain,
+      { endpointTransformer }
+    );
+  }
+  return { response, requestBody, finalBody, config, url, headers };
+}
+
+// src/pipeline/resolveProviderChain.ts
+async function resolveProviderChain(llmConfig, providerId, model) {
+  const cachedChain = await llmConfig.resolveTransformerChain(providerId, model);
+  const mainTransformer = await llmConfig.getMainTransformer(providerId);
+  const chain = {
+    providerTransformers: [...cachedChain.providerTransformers],
+    modelTransformers: [...cachedChain.modelTransformers]
+  };
+  if (mainTransformer) {
+    const alreadyInChain = chain.providerTransformers.some(
+      (t) => t.name === mainTransformer.name
+    );
+    if (!alreadyInChain) {
+      chain.providerTransformers.unshift(mainTransformer);
+    }
+  }
+  const hasTransformers = chain.providerTransformers.length > 0 || chain.modelTransformers.length > 0;
+  return { chain, mainTransformer, hasTransformers };
+}
+
+// src/completion/header-builder.ts
+function getProviderHeaders(provider, apiKey) {
+  const format = resolveApiFormat(provider);
+  let headers;
+  switch (format) {
+    case "anthropic":
+      headers = {
+        "Content-Type": "application/json",
+        "x-api-key": apiKey,
+        "anthropic-version": "2025-01-10"
+        // Required for extended thinking feature
+      };
+      break;
+    case "google":
+      headers = {
+        "Content-Type": "application/json",
+        "x-goog-api-key": apiKey
+      };
+      break;
+    case "azure-openai":
+      headers = {
+        "Content-Type": "application/json",
+        "api-key": apiKey
+      };
+      break;
+    case "openai":
+    case "openai-response":
+    default:
+      headers = {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${apiKey}`
+      };
+      break;
+  }
+  if (isOpenRouterProvider(provider)) {
+    return { ...headers, ...OPENROUTER_APP_HEADERS };
+  }
+  return headers;
+}
+
+// src/completion/message-converter.ts
+var MAX_INLINE_VIDEO_BYTES = 25 * 1024 * 1024;
+
+// src/pipeline/LlmConfigProviderAuth.ts
+function isReportableStatus(status) {
+  return status === 429 || status === 529 || status === 401 || status === 403;
+}
+var LlmConfigProviderAuth = class {
+  provider;
+  apiKeyPool;
+  providerId;
+  sessionId;
+  /**
+   * The current resolved key. Mutable so a Phase-3 caller can read the
+   * rotated key after `onResult`; this phase it is only set at construction
+   * and updated inside `onResult` (mirroring the inline re-point in
+   * `callWithPoolReporting`).
+   */
+  apiKey;
+  constructor(opts) {
+    this.provider = opts.provider;
+    this.apiKey = opts.apiKey;
+    this.apiKeyPool = opts.apiKeyPool ?? null;
+    this.providerId = opts.providerId;
+    this.sessionId = opts.sessionId;
+  }
+  /**
+   * Merge the provider auth headers (and content-type / OpenRouter app
+   * headers) into `headers`, exactly as a direct `getProviderHeaders` call
+   * would produce them. `hints` are accepted for contract symmetry but the
+   * provider-key path does not vary headers by URL/model.
+   */
+  applyHeaders(headers, _hints) {
+    const authHeaders = getProviderHeaders(this.provider, this.apiKey);
+    for (const [k, v] of Object.entries(authHeaders)) {
+      headers[k] = v;
+    }
+  }
+  /**
+   * React to the final HTTP status — the pool-rotation seam (design D5).
+   *
+   * Reproduces `callWithPoolReporting`'s reportable + success branches:
+   *  - reportable status (429/529/401/403) on a pool-backed request →
+   *    `reportError(providerId, sessionId, status)`; when it hands back a
+   *    `newKey` the session was re-bound, so we adopt it (`this.apiKey`) and
+   *    return `{ rebound: true, newKey }`. When no key is available it returns
+   *    `{ rebound: false }` (the session is still cooled/disabled by the report).
+   *  - success / any 2xx → `reportSuccess(sessionId)`; `{ rebound: false }`.
+   *  - non-reportable, non-success, or non-pool request → no-op
+   *    `{ rebound: false }`.
+   *
+   * NOTE: no caller invokes this in Phase 2; it is unit-tested in isolation.
+   */
+  async onResult(status) {
+    const pool = this.apiKeyPool;
+    const providerId = this.providerId;
+    const sessionId = this.sessionId;
+    if (!pool || !providerId || !sessionId) {
+      return { rebound: false };
+    }
+    if (isReportableStatus(status)) {
+      const newKey = await pool.reportError(providerId, sessionId, status);
+      if (newKey) {
+        this.apiKey = newKey;
+        return { rebound: true, newKey };
+      }
+      return { rebound: false };
+    }
+    if (status !== null && status >= 200 && status < 300) {
+      pool.reportSuccess(sessionId);
+    }
+    return { rebound: false };
+  }
+};
+
+// src/provider-proxy/usage/recordAnthropicUsage.ts
+function readAnthropicUsage(usage) {
+  if (!usage) return null;
+  const inputTokens = Number(usage.input_tokens) || 0;
+  const outputTokens = Number(usage.output_tokens) || 0;
+  const cacheReadTokens = Number(usage.cache_read_input_tokens) || 0;
+  const cacheCreationTokens = Number(usage.cache_creation_input_tokens) || 0;
+  return {
+    inputTokens,
+    outputTokens,
+    cacheReadTokens,
+    cacheCreationTokens,
+    // The Anthropic wire carries no separate reasoning-token field; thinking
+    // tokens are folded into `output_tokens`.
+    reasoningTokens: 0
+  };
+}
+function recordAnthropicNonStreamUsage(recorder, bodyText, attribution) {
+  try {
+    const parsed = JSON.parse(bodyText);
+    const tapped = readAnthropicUsage(parsed.usage);
+    if (!tapped) return;
+    recorder.record({
+      messageId: null,
+      parentMessageId: null,
+      sessionId: attribution.sessionId,
+      providerId: attribution.providerId,
+      model: attribution.model,
+      apiKeyId: null,
+      engineOrigin: "codex-ingress",
+      usage: tapped,
+      rawUsage: parsed.usage
+    });
+  } catch {
+  }
+}
+
+// src/pipeline/resolveSubscriptionChain.ts
+function resolveOne(transformerService, name) {
+  const t = transformerService.getTransformer(name);
+  if (!t) return null;
+  return typeof t === "function" ? new t() : t;
+}
+function resolveSubscriptionChain(profile, transformerService, fallbackEndpoint, overrideNames) {
+  const providerNames = overrideNames ?? profile.providerTransformerNames ?? [];
+  const modelNames = profile.modelTransformerNames ?? [];
+  if (providerNames.length === 0) {
+    return { providerTransformers: [fallbackEndpoint], modelTransformers: [] };
+  }
+  if (!transformerService) {
+    throw new Error(
+      "[resolveSubscriptionChain] profile declares providerTransformerNames but no TransformerService is wired"
+    );
+  }
+  const providerTransformers = [];
+  for (const name of providerNames) {
+    const instance = resolveOne(transformerService, name);
+    if (!instance) {
+      console.warn(`[resolveSubscriptionChain] Transformer not registered: ${name}`);
+      continue;
+    }
+    providerTransformers.push(instance);
+  }
+  const modelTransformers = [];
+  for (const name of modelNames) {
+    const instance = resolveOne(transformerService, name);
+    if (!instance) {
+      console.warn(`[resolveSubscriptionChain] Model transformer not registered: ${name}`);
+      continue;
+    }
+    modelTransformers.push(instance);
+  }
+  if (providerTransformers.length === 0) {
+    return { providerTransformers: [fallbackEndpoint], modelTransformers };
+  }
+  return { providerTransformers, modelTransformers };
+}
+
+// src/pipeline/SubscriptionAuthSource.ts
+function stripAuthHeaders(headers) {
+  delete headers.authorization;
+  delete headers.Authorization;
+  delete headers["x-api-key"];
+  delete headers["X-Api-Key"];
+  delete headers["x-goog-api-key"];
+  delete headers["X-Goog-Api-Key"];
+}
+var SubscriptionAuthSource = class {
+  constructor(profile) {
+    this.profile = profile;
+  }
+  profile;
+  /**
+   * Strip any transformer-set auth headers, then delegate to the bound
+   * strategy. Mirrors `SubscriptionDispatcher`'s
+   * `stripAuthHeaders(...)` + `applyHeadersWithRetry(...)` sequence, including
+   * the best-effort swallow-and-warn around a throwing `applyHeaders`.
+   *
+   * The strategy's looser `AuthApplyHints` (optional `upstreamUrl` /
+   * `resolvedModel`) is fed from the pipeline's required `{ upstreamUrl,
+   * model }` at the boundary.
+   */
+  async applyHeaders(headers, hints) {
+    stripAuthHeaders(headers);
+    try {
+      await this.profile.authStrategy.applyHeaders(headers, {
+        upstreamUrl: hints.upstreamUrl,
+        resolvedModel: hints.model
+      });
+    } catch (err) {
+      console.warn("[SubscriptionAuthSource] authStrategy.applyHeaders threw:", serializeError(err));
+    }
+  }
+  /** Delegate the 401-refresh decision to the bound strategy. */
+  async onUnauthorized() {
+    return this.profile.authStrategy.onUnauthorized();
+  }
+  /** Resolve the upstream URL from the profile, when it provides one. */
+  resolveUpstreamUrl(model) {
+    return this.profile.resolveUpstreamUrl?.(model);
+  }
+};
+
+// src/provider-proxy/matchText.ts
+var MATCH_TEXT_PER_MESSAGE_CAP = 8192;
+var MATCH_TEXT_RECENT_MESSAGES = 6;
+function flattenMatchText(value) {
+  if (typeof value === "string") return value;
+  if (Array.isArray(value)) {
+    const parts = [];
+    for (const item of value) {
+      const text = flattenMatchText(item);
+      if (text) parts.push(text);
+    }
+    return parts.join("\n");
+  }
+  if (value && typeof value === "object") {
+    const obj = value;
+    if (obj.type === "tool_result" && obj.content !== void 0) {
+      return flattenMatchText(obj.content);
+    }
+    if (typeof obj.text === "string") return obj.text;
+  }
+  return "";
+}
+function collectMatchText(anthropicBody) {
+  const messages = Array.isArray(anthropicBody.messages) ? anthropicBody.messages : [];
+  const slices = [];
+  const sys = flattenMatchText(anthropicBody.system).trim();
+  if (sys) slices.push(sys.slice(0, MATCH_TEXT_PER_MESSAGE_CAP));
+  const recent = [];
+  for (let i = messages.length - 1; i >= 0 && recent.length < MATCH_TEXT_RECENT_MESSAGES; i--) {
+    const message = messages[i];
+    if (!message || typeof message !== "object") continue;
+    const role = message.role;
+    if (role !== "user" && role !== "system") continue;
+    const text = flattenMatchText(message.content).trim();
+    if (text) recent.push(text.slice(0, MATCH_TEXT_PER_MESSAGE_CAP));
+  }
+  for (let i = recent.length - 1; i >= 0; i--) slices.push(recent[i]);
+  return slices;
+}
+
+// src/provider-proxy/ingress/providerProxyShared.ts
+var sharedExecutor = null;
+function getSharedExecutor() {
+  if (!sharedExecutor) {
+    sharedExecutor = new TransformerChainExecutor();
+  }
+  return sharedExecutor;
+}
+var sharedResponses = null;
+function getResponsesEndpointTransformer() {
+  if (!sharedResponses) sharedResponses = new OpenAIResponseTransformer();
+  return sharedResponses;
+}
+var sharedAnthropic = null;
+function getAnthropicEndpointTransformer() {
+  if (!sharedAnthropic) sharedAnthropic = new AnthropicTransformer();
+  return sharedAnthropic;
+}
+var sharedGemini = null;
+function getGeminiEndpointTransformer() {
+  if (!sharedGemini) sharedGemini = new GeminiTransformer();
+  return sharedGemini;
+}
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk));
+    req.on("end", () => resolve(Buffer.concat(chunks).toString("utf-8")));
+    req.on("error", reject);
+  });
+}
+async function relayResponse(res, providerResponse, isStream) {
+  const contentType = providerResponse.headers.get("Content-Type") ?? "";
+  const status = providerResponse.status && providerResponse.status >= 100 ? providerResponse.status : 200;
+  if (isStream || contentType.includes("text/event-stream")) {
+    res.writeHead(status, {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive"
+    });
+    if (!providerResponse.body) {
+      res.end();
+      return null;
+    }
+    const reader = providerResponse.body.getReader();
+    try {
+      for (; ; ) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        res.write(value);
+      }
+    } finally {
+      reader.releaseLock();
+      res.end();
+    }
+    return null;
+  }
+  const bodyText = await providerResponse.text();
+  res.writeHead(status, { "Content-Type": contentType.includes("json") ? contentType : "application/json" });
+  res.end(bodyText);
+  return bodyText;
+}
+function writeError(res, status, message) {
+  if (res.headersSent) return;
+  res.writeHead(status, { "Content-Type": "application/json" });
+  res.end(JSON.stringify({ error: { type: "provider_proxy_error", message } }));
+}
+function resolveApiKey(apiKey) {
+  if (!apiKey) return "";
+  if (apiKey.startsWith("$")) {
+    return process.env[apiKey.slice(1)] || "";
+  }
+  return apiKey;
+}
+async function resolvePoolBoundKey(deps, providerId, provider, sessionId) {
+  if (deps.apiKeyPool && sessionId) {
+    const poolKey = await deps.apiKeyPool.getKeyForSession(providerId, sessionId);
+    if (poolKey) return poolKey;
+  }
+  return resolveApiKey(resolveProviderEndpoint(provider).apiKey);
+}
+
+// src/provider-proxy/ingress/anthropicSubscriptionPlan.ts
+async function buildSubscriptionPlan(res, route, deps, anthropicBody, routeModel, isStream) {
+  const profile = route.subscriptionProfile;
+  if (!profile) {
+    writeError(res, 502, "Subscription mode requires an Anthropic subscription profile");
+    return null;
+  }
+  let resolvedModel = routeModel;
+  let scenario;
+  if (profile.modelMapper) {
+    const summary = buildSubscriptionRequestSummary(anthropicBody);
+    const mapped = profile.modelMapper(routeModel, summary, route.subscriptionConfig);
+    resolvedModel = mapped.resolvedModel;
+    scenario = mapped.scenario;
+  }
+  const plan = buildSubscriptionIterationPlan(profile, route, deps, resolvedModel, isStream, scenario);
+  if (!plan) {
+    writeError(res, 502, "Subscription profile is missing resolveUpstreamUrl");
+    return null;
+  }
+  return plan;
+}
+function buildSubscriptionIterationPlan(profile, route, deps, resolvedModel, isStream, scenario) {
+  const upstreamUrl = profile.resolveUpstreamUrl?.(resolvedModel, route.subscriptionConfig);
+  if (!upstreamUrl) return null;
+  const auth = route.auth ?? new SubscriptionAuthSource(profile);
+  const sameFormat = profile.mode === "pass-through" || upstreamUrl.endsWith("/v1/messages");
+  const overrideNames = profile.resolveProviderTransformerNames?.(
+    resolvedModel,
+    route.subscriptionConfig
+  );
+  const chain = sameFormat ? { providerTransformers: [], modelTransformers: [] } : resolveSubscriptionChain(
+    profile,
+    deps.llmConfig.getTransformerService(),
+    getAnthropicEndpointTransformer(),
+    overrideNames
+  );
+  const transformerProvider = {
+    name: profile.authStrategy.providerId,
+    baseUrl: upstreamUrl,
+    apiKey: "",
+    models: [resolvedModel]
+  };
+  return {
+    auth,
+    chain,
+    transformerProvider,
+    resolvedModel,
+    isStream,
+    // EXCEPTION (the Responses chain) (Phase 3 task 3.3): the `openai-response`
+    // provider transformer emits an ABSOLUTE-path `config.url`
+    // (`new URL('/v1/responses', baseUrl)`) that DISCARDS any base PATH prefix — so
+    // for a path-prefixed base (zen `https://opencode.ai/zen/v1/responses` → drops
+    // `/zen/`; codex `https://chatgpt.com/backend-api/codex/responses` → drops
+    // `/backend-api/codex/`). On the core `/v1/messages` plan the endpoint
+    // transformer is `anthropic` and the codex/zen-responses chain is
+    // `['openai-response']` (endpoint != provider), so `transformRequestIn` RUNS
+    // and emits the lossy URL. The guard makes this safe REGARDLESS of whether it
+    // ran: `usesResponsesChain(['openai-response'])` captures BOTH codex and zen
+    // responses, so the profile's complete `upstreamUrl` always wins (codex → its
+    // backend-api/codex/responses; zen → its `/zen/...` endpoint). The gemini
+    // chain's `config.url` is RELATIVE (`./{model}:{action}`) and PRESERVES the
+    // base path, so it correctly wins. The bypass-by-name optimization only applies
+    // on the core OpenAI-Responses ingress (endpoint == `openai-response`), NOT
+    // here. `// UNVERIFIED (no live zen key)`.
+    resolveUrl: usesResponsesChain(overrideNames ?? profile.providerTransformerNames) ? () => upstreamUrl : (config) => config.url instanceof URL ? config.url.toString() : typeof config.url === "string" ? config.url : upstreamUrl,
+    upstreamUrl,
+    sameFormat,
+    isSubscription: true,
+    scenario
+  };
+}
+function usesResponsesChain(names) {
+  return !!names && names.includes("openai-response");
+}
+function buildSubscriptionRequestSummary(anthropicBody) {
+  const messages = Array.isArray(anthropicBody.messages) ? anthropicBody.messages : [];
+  let totalChars = collectText(anthropicBody.system);
+  for (const message of messages) {
+    if (message && typeof message === "object") {
+      totalChars += collectText(message.content);
+    }
+  }
+  return {
+    messageCount: messages.length,
+    estimatedInputTokens: Math.ceil(totalChars / 4),
+    // Single source of truth (shared with the dispatcher builder) so both
+    // ingress paths yield identical `matchText` for the same body.
+    matchText: collectMatchText(anthropicBody)
+  };
+}
+function collectText(value) {
+  if (typeof value === "string") return value.length;
+  if (Array.isArray(value)) {
+    let sum = 0;
+    for (const item of value) sum += collectText(item);
+    return sum;
+  }
+  if (value && typeof value === "object") {
+    const text = value.text;
+    if (typeof text === "string") return text.length;
+  }
+  return 0;
+}
+async function runPipeline(anthropicBody, plan) {
+  const executor = getSharedExecutor();
+  const endpointTransformer = getAnthropicEndpointTransformer();
+  const { auth, chain, transformerProvider, resolvedModel, isStream, resolveUrl, upstreamUrl } = plan;
+  const authHeaders = {};
+  await auth.applyHeaders(authHeaders, { upstreamUrl, model: resolvedModel });
+  let rawStatus = null;
+  const { response } = await executeProviderCall({
+    executor,
+    request: anthropicBody,
+    provider: transformerProvider,
+    chain,
+    endpointTransformer,
+    resolveUrl,
+    buildHeaders: (config) => {
+      const headers = { ...authHeaders };
+      if (config.headers) {
+        for (const [key, value] of Object.entries(config.headers)) {
+          if (value !== void 0 && !(key in headers)) headers[key] = value;
+        }
+      }
+      return headers;
+    },
+    fetchFn: (url, headers, body) => {
+      console.info(`[ProviderProxy:anthropic] -> ${url} model=${resolvedModel} stream=${isStream}`);
+      return fetch(url, { method: "POST", headers, body: JSON.stringify(body) }).then((r) => {
+        rawStatus = r.status;
+        return r;
+      });
+    },
+    runResponseChain: true
+  });
+  return { response, rawStatus };
+}
+async function runSubscriptionSameFormatFetch(rawBody, plan) {
+  const headers = { "content-type": "application/json" };
+  await plan.auth.applyHeaders(headers, {
+    upstreamUrl: plan.upstreamUrl,
+    model: plan.resolvedModel
+  });
+  console.info(
+    `[ProviderProxy:anthropic] (subscription same-format) -> ${plan.upstreamUrl} model=${plan.resolvedModel} stream=${plan.isStream}`
+  );
+  const response = await fetch(plan.upstreamUrl, { method: "POST", headers, body: rawBody });
+  return { response, rawStatus: response.status };
+}
+async function runSubscriptionAttemptWith401Retry(anthropicBody, relayBody, plan) {
+  const runOnce = () => plan.sameFormat ? runSubscriptionSameFormatFetch(relayBody, plan) : runPipeline(anthropicBody, plan);
+  const first = await runOnce();
+  if (first.rawStatus !== 401) return first;
+  const refreshed = await plan.auth.onUnauthorized?.();
+  if (!refreshed) {
+    console.warn("[ProviderProxy:anthropic] 401 not recoverable (onUnauthorized returned false)");
+    return first;
+  }
+  console.info("[ProviderProxy:anthropic] 401 \u2192 token refreshed; retrying once");
+  return runOnce();
+}
+function isFallbackEligibleStatus(rawStatus) {
+  return rawStatus === null || rawStatus >= 500 || rawStatus === 429;
+}
+function breakerOutcome(rawStatus) {
+  if (isFallbackEligibleStatus(rawStatus)) return "failure";
+  if (rawStatus !== null && rawStatus >= 200 && rawStatus < 300) return "success";
+  return "neutral";
+}
+function recordBreakerOutcome(profile, modelId, rawStatus) {
+  const outcome = breakerOutcome(rawStatus);
+  if (outcome === "neutral") return;
+  profile?.recordModelOutcome?.(modelId, outcome === "success");
+}
+async function runSubscriptionAttemptOutcome(anthropicBody, relayBody, plan) {
+  try {
+    return { kind: "result", result: await runSubscriptionAttemptWith401Retry(anthropicBody, relayBody, plan) };
+  } catch (error) {
+    return { kind: "thrown", error };
+  }
+}
+function outcomeStatus(outcome) {
+  return outcome.kind === "thrown" ? null : outcome.result.rawStatus;
+}
+function settleOutcome(outcome) {
+  if (outcome.kind === "thrown") throw outcome.error;
+  return outcome.result;
+}
+async function runPipelineWithSubscriptionRetry(anthropicBody, rawBody, initialPlan, route, deps) {
+  const profile = route.subscriptionProfile;
+  const scenario = initialPlan.scenario;
+  if (!profile?.nextFallback || scenario === void 0) {
+    const loneOutcome = await runSubscriptionAttemptOutcome(anthropicBody, rawBody, initialPlan);
+    recordBreakerOutcome(profile, initialPlan.resolvedModel, outcomeStatus(loneOutcome));
+    return settleOutcome(loneOutcome);
+  }
+  const attempted = [];
+  let plan = initialPlan;
+  let firstRelayBody = rawBody;
+  let firstBodyObj = anthropicBody;
+  if (profile.allowModel && !profile.allowModel(initialPlan.resolvedModel)) {
+    attempted.push(initialPlan.resolvedModel);
+    const firstAdmitting = profile.nextFallback(scenario, attempted, route.subscriptionConfig);
+    const gatedPlan = firstAdmitting ? buildSubscriptionIterationPlan(profile, route, deps, firstAdmitting.modelId, initialPlan.isStream, scenario) : null;
+    if (firstAdmitting && gatedPlan) {
+      console.warn(
+        `[ProviderProxy:anthropic] subscription primary ${initialPlan.resolvedModel} circuit open -> first admitting fallback ${firstAdmitting.modelId}`
+      );
+      plan = gatedPlan;
+      firstBodyObj = { ...anthropicBody, model: firstAdmitting.modelId };
+      firstRelayBody = gatedPlan.sameFormat ? JSON.stringify(firstBodyObj) : rawBody;
+    } else {
+      attempted.length = 0;
+      console.warn(
+        `[ProviderProxy:anthropic] subscription all opencodego circuits open -> fail open to primary ${initialPlan.resolvedModel}`
+      );
+    }
+  }
+  let outcome = await runSubscriptionAttemptOutcome(firstBodyObj, firstRelayBody, plan);
+  recordBreakerOutcome(profile, plan.resolvedModel, outcomeStatus(outcome));
+  if (!attempted.includes(plan.resolvedModel)) attempted.push(plan.resolvedModel);
+  while (attempted.length < MAX_FALLBACK_ATTEMPTS) {
+    if (!isFallbackEligibleStatus(outcomeStatus(outcome))) return settleOutcome(outcome);
+    const next = profile.nextFallback(scenario, attempted, route.subscriptionConfig);
+    if (!next) return settleOutcome(outcome);
+    const nextPlan = buildSubscriptionIterationPlan(
+      profile,
+      route,
+      deps,
+      next.modelId,
+      plan.isStream,
+      scenario
+    );
+    if (!nextPlan) return settleOutcome(outcome);
+    const sinceLabel = outcome.kind === "thrown" ? "thrown error" : `status ${String(outcome.result.rawStatus)}`;
+    console.warn(
+      `[ProviderProxy:anthropic] subscription fallback ${plan.resolvedModel} -> ${next.modelId} after ${sinceLabel}`
+    );
+    const fallbackBodyObj = { ...anthropicBody, model: next.modelId };
+    const fallbackRelayBody = nextPlan.sameFormat ? JSON.stringify(fallbackBodyObj) : rawBody;
+    plan = nextPlan;
+    attempted.push(next.modelId);
+    outcome = await runSubscriptionAttemptOutcome(fallbackBodyObj, fallbackRelayBody, plan);
+    recordBreakerOutcome(profile, plan.resolvedModel, outcomeStatus(outcome));
+  }
+  return settleOutcome(outcome);
+}
+var MAX_FALLBACK_ATTEMPTS = 3;
+
+// src/provider-proxy/ingress/anthropicMessagesByo.ts
+async function handleAnthropicMessagesByo(res, rawBody, route, deps, options = {}) {
+  let anthropicBody;
+  try {
+    anthropicBody = JSON.parse(rawBody);
+  } catch {
+    writeError(res, 400, "Invalid JSON in request body");
+    return;
+  }
+  const isStream = anthropicBody.stream === true;
+  const resolvedModel = route.model;
+  anthropicBody.model = resolvedModel;
+  try {
+    const plan = route.authMode === "subscription" ? await buildSubscriptionPlan(res, route, deps, anthropicBody, resolvedModel, isStream) : await buildByoPlan(res, route, deps, resolvedModel, isStream);
+    if (!plan) return;
+    anthropicBody.model = plan.resolvedModel;
+    const providerResponse = route.authMode === "subscription" ? await runPipelineWithSubscriptionRetry(anthropicBody, rawBody, plan, route, deps) : await runPipelineWithPoolReporting(anthropicBody, rawBody, plan, options);
+    const bodyText = await relayResponse(res, providerResponse.response, isStream);
+    if (bodyText && deps.usageRecorder) {
+      recordAnthropicNonStreamUsage(deps.usageRecorder, bodyText, {
+        sessionId: route.sessionId,
+        providerId: route.providerId ?? "anthropic",
+        model: plan.resolvedModel
+      });
+    }
+  } catch (err) {
+    const errMsg = serializeError(err);
+    console.error("[ProviderProxy:anthropic] Pipeline error:", errMsg);
+    writeError(res, 502, errMsg);
+  }
+}
+async function buildByoPlan(res, route, deps, resolvedModel, isStream) {
+  const providerId = route.providerId;
+  if (!providerId) {
+    writeError(res, 502, "BYO route is missing a providerId");
+    return null;
+  }
+  const provider = await deps.llmConfig.getProvider(providerId);
+  if (!provider) {
+    writeError(res, 502, `Provider not found: ${providerId}`);
+    return null;
+  }
+  const apiKey = await resolvePoolBoundKey(deps, providerId, provider, route.sessionId);
+  if (!apiKey) {
+    writeError(res, 502, "API key not configured");
+    return null;
+  }
+  const auth = route.auth ?? new LlmConfigProviderAuth({
+    provider,
+    apiKey,
+    apiKeyPool: deps.apiKeyPool ?? null,
+    providerId,
+    sessionId: route.sessionId
+  });
+  const { chain } = await resolveProviderChain(deps.llmConfig, providerId, resolvedModel);
+  const transformerProvider = {
+    name: provider.name,
+    baseUrl: provider.api_base_url,
+    apiKey,
+    models: provider.models || []
+  };
+  const byoUrl = buildProviderApiUrl(provider, { model: resolvedModel, stream: isStream });
+  const sameFormat = route.targetProviderFormat === "anthropic" || resolveApiFormat(provider) === "anthropic";
+  return {
+    auth,
+    chain,
+    transformerProvider,
+    resolvedModel,
+    isStream,
+    resolveUrl: (config) => config.url instanceof URL ? config.url.toString() : byoUrl,
+    upstreamUrl: byoUrl,
+    sameFormat,
+    isSubscription: false,
+    provider,
+    apiKey,
+    extendedContextEnabled: route.anthropicSdkHints?.extendedContext?.enabled ?? false
+  };
+}
+async function runSameFormatFetch(rawBody, plan, options, keyOverride) {
+  const { provider, apiKey, resolvedModel, isStream, extendedContextEnabled } = plan;
+  if (!provider) {
+    throw new Error("[ProviderProxy:anthropic] same-format BYO path requires a provider row");
+  }
+  const effectiveKey = keyOverride ?? apiKey ?? "";
+  const headers = getProviderHeaders(provider, effectiveKey);
+  const callerBeta = options.callerAnthropicBeta?.trim();
+  if (callerBeta) {
+    const existing = headers["anthropic-beta"] ?? headers["Anthropic-Beta"];
+    const parts = new Set(
+      [existing, callerBeta].filter((v) => typeof v === "string" && v.length > 0).flatMap((v) => v.split(",").map((s) => s.trim()).filter((s) => s.length > 0))
+    );
+    if (parts.size > 0) {
+      delete headers["Anthropic-Beta"];
+      headers["anthropic-beta"] = [...parts].join(",");
+    }
+  }
+  injectExtendedContextBeta(headers, resolvedModel, extendedContextEnabled ?? false);
+  const url = buildProviderApiUrl(provider, { model: resolvedModel, stream: isStream });
+  console.info(`[ProviderProxy:anthropic] (same-format) -> ${url} model=${resolvedModel} stream=${isStream}`);
+  const response = await fetch(url, { method: "POST", headers, body: rawBody });
+  return { response, rawStatus: response.status };
+}
+async function runPipelineWithPoolReporting(anthropicBody, rawBody, plan, options) {
+  const runOnce = (keyOverride) => plan.sameFormat ? runSameFormatFetch(rawBody, plan, options, keyOverride) : runPipeline(anthropicBody, plan);
+  const first = await runOnce();
+  const outcome = await plan.auth.onResult?.(first.rawStatus);
+  if (outcome?.rebound) {
+    console.info(
+      "[ProviderProxy:anthropic] pool re-bound key after status",
+      first.rawStatus,
+      "\u2192 retrying once"
+    );
+    return runOnce(outcome.newKey);
+  }
+  return first;
+}
+
+// src/provider-proxy/ingress/anthropicMessagesIngress.ts
+function isAnthropicMessagesRequest(method, url) {
+  return method === "POST" && !!url && url.includes("/v1/messages");
+}
+async function handleAnthropicMessagesRequest(req, res, route, deps) {
+  const handlerFactory = deps.anthropicIngressHandlerFactory;
+  if (!handlerFactory) {
+    const rawBody = await readBody(req);
+    const callerBetaRaw = req.headers["anthropic-beta"];
+    const callerAnthropicBeta = Array.isArray(callerBetaRaw) ? callerBetaRaw.join(",") : callerBetaRaw;
+    await handleAnthropicMessagesByo(res, rawBody, route, deps, { callerAnthropicBeta });
+    return;
+  }
+  const hints = route.anthropicSdkHints;
+  if (!hints) {
+    writeError(res, 502, "Anthropic route is missing anthropicSdkHints");
+    return;
+  }
+  if (!hints.passThrough && !route.providerId) {
+    writeError(res, 502, "Anthropic route is missing a providerId");
+    return;
+  }
+  const handler = handlerFactory({
+    llmConfig: deps.llmConfig,
+    providerId: route.providerId ?? "",
+    model: route.model,
+    apiKey: hints.apiKey,
+    backgroundTaskModel: route.backgroundTaskModel,
+    isOfficialProvider: hints.isOfficialProvider,
+    thinkingLevel: hints.thinkingLevel,
+    extendedContext: hints.extendedContext ?? null,
+    passThrough: hints.passThrough,
+    passThroughAuthToken: hints.passThroughAuthToken ?? null,
+    resolvePassThroughAuthToken: hints.resolvePassThroughAuthToken ?? null,
+    subscriptionProfile: hints.subscriptionProfile ?? null,
+    maxConcurrency: hints.maxConcurrency,
+    webSearchService: hints.webSearchService ?? null,
+    onRetry: hints.onRetry,
+    onStreamEvent: hints.onStreamEvent,
+    usageRecorder: hints.usageRecorder ?? null,
+    attribution: hints.attribution ?? null
+  });
+  await handler.handle(req, res);
+}
+
+// src/provider-proxy/usage/recordGeminiUsage.ts
+function readGeminiUsage(usage) {
+  if (!usage) return null;
+  const promptTokens = Number(usage.promptTokenCount) || 0;
+  const candidatesTokens = Number(usage.candidatesTokenCount) || 0;
+  const cacheReadTokens = Number(usage.cachedContentTokenCount) || 0;
+  const reasoningTokens = Number(usage.thoughtsTokenCount) || 0;
+  const billableInput = Math.max(0, promptTokens - cacheReadTokens);
+  return {
+    inputTokens: billableInput,
+    outputTokens: candidatesTokens,
+    cacheReadTokens,
+    cacheCreationTokens: 0,
+    reasoningTokens
+  };
+}
+function recordGeminiNonStreamUsage(recorder, bodyText, attribution) {
+  try {
+    const parsed = JSON.parse(bodyText);
+    const tapped = readGeminiUsage(parsed.usageMetadata);
+    if (!tapped) return;
+    recorder.record({
+      messageId: null,
+      parentMessageId: null,
+      sessionId: attribution.sessionId,
+      providerId: attribution.providerId,
+      model: attribution.model,
+      apiKeyId: null,
+      engineOrigin: "codex-ingress",
+      usage: tapped,
+      rawUsage: parsed.usageMetadata
+    });
+  } catch {
+  }
+}
+
+// src/provider-proxy/ingress/geminiGenerateContentIngress.ts
+var GENERATE_CONTENT_ACTION = ":generateContent";
+var STREAM_GENERATE_CONTENT_ACTION = ":streamGenerateContent";
+function isGeminiGenerateContentRequest(method, url) {
+  if (method !== "POST" || !url) return false;
+  const path = url.split("?")[0]?.replace(/\/+$/, "") ?? "";
+  const lastSegment = path.split("/").pop() ?? "";
+  return lastSegment.includes(STREAM_GENERATE_CONTENT_ACTION) || lastSegment.includes(GENERATE_CONTENT_ACTION);
+}
+function isGeminiStreamRequest(url) {
+  if (!url) return false;
+  const [path, query = ""] = url.split("?");
+  const lastSegment = (path?.replace(/\/+$/, "") ?? "").split("/").pop() ?? "";
+  if (lastSegment.includes(STREAM_GENERATE_CONTENT_ACTION)) return true;
+  return /(^|&)alt=sse(&|$)/.test(query);
+}
+async function handleGeminiGenerateContentRequest(res, rawBody, url, route, deps) {
+  let geminiBody;
+  try {
+    geminiBody = JSON.parse(rawBody);
+  } catch {
+    writeError(res, 400, "Invalid JSON in request body");
+    return;
+  }
+  if (route.authMode === "subscription") {
+    writeError(res, 502, "Gemini generateContent ingress does not support subscription auth");
+    return;
+  }
+  const isStream = isGeminiStreamRequest(url);
+  geminiBody.stream = isStream;
+  const resolvedModel = route.model;
+  geminiBody.model = resolvedModel;
+  try {
+    const plan = await buildByoPlan2(res, route, deps, resolvedModel, isStream);
+    if (!plan) return;
+    const providerResponse = await runPipelineWithPoolReporting2(geminiBody, plan);
+    const bodyText = await relayResponse(res, providerResponse.response, isStream);
+    if (bodyText && deps.usageRecorder) {
+      recordGeminiNonStreamUsage(deps.usageRecorder, bodyText, {
+        sessionId: route.sessionId,
+        providerId: route.providerId ?? "gemini",
+        model: resolvedModel
+      });
+    }
+  } catch (err) {
+    const errMsg = serializeError(err);
+    console.error("[ProviderProxy:gemini] Pipeline error:", errMsg);
+    writeError(res, 502, errMsg);
+  }
+}
+async function buildByoPlan2(res, route, deps, resolvedModel, isStream) {
+  const providerId = route.providerId;
+  if (!providerId) {
+    writeError(res, 502, "BYO route is missing a providerId");
+    return null;
+  }
+  const provider = await deps.llmConfig.getProvider(providerId);
+  if (!provider) {
+    writeError(res, 502, `Provider not found: ${providerId}`);
+    return null;
+  }
+  const apiKey = await resolvePoolBoundKey(deps, providerId, provider, route.sessionId);
+  if (!apiKey) {
+    writeError(res, 502, "API key not configured");
+    return null;
+  }
+  const auth = route.auth ?? new LlmConfigProviderAuth({
+    provider,
+    apiKey,
+    apiKeyPool: deps.apiKeyPool ?? null,
+    providerId,
+    sessionId: route.sessionId
+  });
+  const { chain } = await resolveProviderChain(deps.llmConfig, providerId, resolvedModel);
+  const transformerProvider = {
+    name: provider.name,
+    baseUrl: provider.api_base_url,
+    apiKey,
+    models: provider.models || []
+  };
+  const byoUrl = buildProviderApiUrl(provider, { model: resolvedModel, stream: isStream });
+  return {
+    auth,
+    chain,
+    transformerProvider,
+    resolvedModel,
+    isStream,
+    resolveUrl: (config) => config.url instanceof URL ? config.url.toString() : byoUrl,
+    upstreamUrl: byoUrl
+  };
+}
+async function runPipeline2(geminiBody, plan) {
+  const executor = getSharedExecutor();
+  const endpointTransformer = getGeminiEndpointTransformer();
+  const { auth, chain, transformerProvider, resolvedModel, isStream, resolveUrl, upstreamUrl } = plan;
+  const authHeaders = {};
+  await auth.applyHeaders(authHeaders, { upstreamUrl, model: resolvedModel });
+  let rawStatus = null;
+  const { response } = await executeProviderCall({
+    executor,
+    request: geminiBody,
+    provider: transformerProvider,
+    chain,
+    endpointTransformer,
+    resolveUrl,
+    buildHeaders: (config) => {
+      const headers = { ...authHeaders };
+      if (config.headers) {
+        for (const [key, value] of Object.entries(config.headers)) {
+          if (value !== void 0 && !(key in headers)) headers[key] = value;
+        }
+      }
+      return headers;
+    },
+    fetchFn: (url, headers, body) => {
+      console.log(`[ProviderProxy:gemini] -> ${url} model=${resolvedModel} stream=${isStream}`);
+      return fetch(url, { method: "POST", headers, body: JSON.stringify(body) }).then((r) => {
+        rawStatus = r.status;
+        return r;
+      });
+    },
+    runResponseChain: true
+  });
+  return { response, rawStatus };
+}
+async function runPipelineWithPoolReporting2(geminiBody, plan) {
+  const first = await runPipeline2(geminiBody, plan);
+  const outcome = await plan.auth.onResult?.(first.rawStatus);
+  if (outcome?.rebound) {
+    console.log(
+      "[ProviderProxy:gemini] pool re-bound key after status",
+      first.rawStatus,
+      "\u2192 retrying once"
+    );
+    return runPipeline2(geminiBody, plan);
+  }
+  return first;
+}
+
+// src/provider-proxy/usage/recordChatCompletionsUsage.ts
+function readChatCompletionsUsage(usage) {
+  if (!usage) return null;
+  const promptTokens = Number(usage.prompt_tokens) || 0;
+  const completionTokens = Number(usage.completion_tokens) || 0;
+  const promptDetails = usage.prompt_tokens_details ?? {};
+  const cacheReadTokens = Number(promptDetails.cached_tokens) || 0;
+  const completionDetails = usage.completion_tokens_details ?? {};
+  const reasoningTokens = Number(completionDetails.reasoning_tokens) || 0;
+  const billableInput = Math.max(0, promptTokens - cacheReadTokens);
+  return {
+    inputTokens: billableInput,
+    outputTokens: completionTokens,
+    cacheReadTokens,
+    cacheCreationTokens: 0,
+    reasoningTokens
+  };
+}
+function recordChatCompletionsNonStreamUsage(recorder, bodyText, attribution) {
+  try {
+    const parsed = JSON.parse(bodyText);
+    const tapped = readChatCompletionsUsage(parsed.usage);
+    if (!tapped) return;
+    recorder.record({
+      messageId: null,
+      parentMessageId: null,
+      sessionId: attribution.sessionId,
+      providerId: attribution.providerId,
+      model: attribution.model,
+      apiKeyId: null,
+      engineOrigin: "codex-ingress",
+      usage: tapped,
+      rawUsage: parsed.usage
+    });
+  } catch {
+  }
+}
+
+// src/provider-proxy/ingress/openaiChatIngress.ts
+function isOpenAIChatRequest(method, url) {
+  if (method !== "POST" || !url) return false;
+  const path = url.split("?")[0]?.replace(/\/+$/, "") ?? "";
+  return path.endsWith("/chat/completions");
+}
+async function handleOpenAIChatRequest(res, rawBody, route, deps) {
+  let chatBody;
+  try {
+    chatBody = JSON.parse(rawBody);
+  } catch {
+    writeError(res, 400, "Invalid JSON in request body");
+    return;
+  }
+  if (route.authMode === "subscription") {
+    writeError(res, 502, "OpenAI Chat Completions ingress does not support subscription auth");
+    return;
+  }
+  const isStream = chatBody.stream === true;
+  const resolvedModel = route.model;
+  chatBody.model = resolvedModel;
+  try {
+    const plan = await buildByoPlan3(res, route, deps, resolvedModel, isStream);
+    if (!plan) return;
+    const providerResponse = await runPipelineWithPoolReporting3(chatBody, plan);
+    const bodyText = await relayResponse(res, providerResponse.response, isStream);
+    if (bodyText && deps.usageRecorder) {
+      recordChatCompletionsNonStreamUsage(deps.usageRecorder, bodyText, {
+        sessionId: route.sessionId,
+        providerId: route.providerId ?? "openai",
+        model: resolvedModel
+      });
+    }
+  } catch (err) {
+    const errMsg = serializeError(err);
+    console.error("[ProviderProxy:chat] Pipeline error:", errMsg);
+    writeError(res, 502, errMsg);
+  }
+}
+async function buildByoPlan3(res, route, deps, resolvedModel, isStream) {
+  const providerId = route.providerId;
+  if (!providerId) {
+    writeError(res, 502, "BYO route is missing a providerId");
+    return null;
+  }
+  const provider = await deps.llmConfig.getProvider(providerId);
+  if (!provider) {
+    writeError(res, 502, `Provider not found: ${providerId}`);
+    return null;
+  }
+  const apiKey = await resolvePoolBoundKey(deps, providerId, provider, route.sessionId);
+  if (!apiKey) {
+    writeError(res, 502, "API key not configured");
+    return null;
+  }
+  const auth = route.auth ?? new LlmConfigProviderAuth({
+    provider,
+    apiKey,
+    apiKeyPool: deps.apiKeyPool ?? null,
+    providerId,
+    sessionId: route.sessionId
+  });
+  const { chain } = await resolveProviderChain(deps.llmConfig, providerId, resolvedModel);
+  const transformerProvider = {
+    name: provider.name,
+    baseUrl: provider.api_base_url,
+    apiKey,
+    models: provider.models || []
+  };
+  const byoUrl = buildProviderApiUrl(provider, { model: resolvedModel, stream: isStream });
+  return {
+    auth,
+    chain,
+    transformerProvider,
+    resolvedModel,
+    isStream,
+    resolveUrl: (config) => config.url instanceof URL ? config.url.toString() : byoUrl,
+    upstreamUrl: byoUrl
+  };
+}
+async function runPipeline3(chatBody, plan) {
+  const executor = getSharedExecutor();
+  const { auth, chain, transformerProvider, resolvedModel, isStream, resolveUrl, upstreamUrl } = plan;
+  const authHeaders = {};
+  await auth.applyHeaders(authHeaders, { upstreamUrl, model: resolvedModel });
+  let rawStatus = null;
+  const { response } = await executeProviderCall({
+    executor,
+    request: chatBody,
+    provider: transformerProvider,
+    chain,
+    resolveUrl,
+    buildHeaders: (config) => {
+      const headers = { ...authHeaders };
+      if (config.headers) {
+        for (const [key, value] of Object.entries(config.headers)) {
+          if (value !== void 0 && !(key in headers)) headers[key] = value;
+        }
+      }
+      return headers;
+    },
+    fetchFn: (url, headers, body) => {
+      console.log(`[ProviderProxy:chat] -> ${url} model=${resolvedModel} stream=${isStream}`);
+      return fetch(url, { method: "POST", headers, body: JSON.stringify(body) }).then((r) => {
+        rawStatus = r.status;
+        return r;
+      });
+    },
+    runResponseChain: true
+  });
+  return { response, rawStatus };
+}
+async function runPipelineWithPoolReporting3(chatBody, plan) {
+  const first = await runPipeline3(chatBody, plan);
+  const outcome = await plan.auth.onResult?.(first.rawStatus);
+  if (outcome?.rebound) {
+    console.log(
+      "[ProviderProxy:chat] pool re-bound key after status",
+      first.rawStatus,
+      "\u2192 retrying once"
+    );
+    return runPipeline3(chatBody, plan);
+  }
+  return first;
+}
+
+// src/ports/gemini-code-assist-resolver.ts
+var resolver = null;
+function getGeminiCodeAssistResolver() {
+  return resolver;
+}
+
+// src/provider-proxy/usage/recordResponsesUsage.ts
+function readResponsesUsage(usage) {
+  if (!usage) return null;
+  const inputTokens = Number(usage.input_tokens) || 0;
+  const outputTokens = Number(usage.output_tokens) || 0;
+  const inputDetails = usage.input_tokens_details ?? {};
+  const cacheReadTokens = Number(inputDetails.cached_tokens) || 0;
+  const outputDetails = usage.output_tokens_details ?? {};
+  const reasoningTokens = Number(outputDetails.reasoning_tokens) || 0;
+  const billableInput = Math.max(0, inputTokens - cacheReadTokens);
+  return {
+    inputTokens: billableInput,
+    outputTokens,
+    cacheReadTokens,
+    cacheCreationTokens: 0,
+    reasoningTokens
+  };
+}
+function recordResponsesNonStreamUsage(recorder, bodyText, attribution) {
+  try {
+    const parsed = JSON.parse(bodyText);
+    const tapped = readResponsesUsage(parsed.usage);
+    if (!tapped) return;
+    recorder.record({
+      messageId: null,
+      parentMessageId: null,
+      sessionId: attribution.sessionId,
+      providerId: attribution.providerId,
+      model: attribution.model,
+      apiKeyId: null,
+      engineOrigin: "codex-ingress",
+      usage: tapped,
+      rawUsage: parsed.usage
+    });
+  } catch {
+  }
+}
+
+// src/provider-proxy/ingress/openaiResponsesIngress.ts
+function isOpenAIResponsesRequest(method, url) {
+  if (method !== "POST" || !url) return false;
+  const path = url.split("?")[0]?.replace(/\/+$/, "") ?? "";
+  return path.endsWith("/responses");
+}
+async function handleOpenAIResponsesRequest(res, rawBody, route, deps) {
+  let responsesBody;
+  try {
+    responsesBody = JSON.parse(rawBody);
+  } catch {
+    writeError(res, 400, "Invalid JSON in request body");
+    return;
+  }
+  const isStream = responsesBody.stream === true;
+  const resolvedModel = route.model;
+  responsesBody.model = resolvedModel;
+  try {
+    const plan = route.authMode === "subscription" ? await buildSubscriptionPlan2(res, route, deps, resolvedModel, isStream) : await buildByoPlan4(res, route, deps, resolvedModel, isStream);
+    if (!plan) return;
+    const providerResponse = route.authMode === "subscription" ? await runPipelineWithSubscriptionRetry2(responsesBody, plan) : await runPipelineWithPoolReporting4(responsesBody, plan);
+    const bodyText = await relayResponse(res, providerResponse.response, isStream);
+    if (bodyText && deps.usageRecorder) {
+      recordResponsesNonStreamUsage(deps.usageRecorder, bodyText, {
+        sessionId: route.sessionId,
+        providerId: route.providerId ?? "codex",
+        model: resolvedModel
+      });
+    }
+  } catch (err) {
+    const errMsg = serializeError(err);
+    console.error("[ProviderProxy:responses] Pipeline error:", errMsg);
+    writeError(res, 502, errMsg);
+  }
+}
+async function buildByoPlan4(res, route, deps, resolvedModel, isStream) {
+  const providerId = route.providerId;
+  if (!providerId) {
+    writeError(res, 502, "BYO route is missing a providerId");
+    return null;
+  }
+  const provider = await deps.llmConfig.getProvider(providerId);
+  if (!provider) {
+    writeError(res, 502, `Provider not found: ${providerId}`);
+    return null;
+  }
+  const apiKey = await resolvePoolBoundKey(deps, providerId, provider, route.sessionId);
+  if (!apiKey) {
+    writeError(res, 502, "API key not configured");
+    return null;
+  }
+  const auth = route.auth ?? new LlmConfigProviderAuth({
+    provider,
+    apiKey,
+    apiKeyPool: deps.apiKeyPool ?? null,
+    providerId,
+    sessionId: route.sessionId
+  });
+  const { chain } = await resolveProviderChain(deps.llmConfig, providerId, resolvedModel);
+  const transformerProvider = {
+    name: provider.name,
+    baseUrl: provider.api_base_url,
+    apiKey,
+    models: provider.models || []
+  };
+  const byoUrl = buildProviderApiUrl(provider, { model: resolvedModel, stream: isStream });
+  return {
+    auth,
+    chain,
+    transformerProvider,
+    resolvedModel,
+    isStream,
+    resolveUrl: (config) => config.url instanceof URL ? config.url.toString() : byoUrl,
+    upstreamUrl: byoUrl
+  };
+}
+async function buildSubscriptionPlan2(res, route, deps, resolvedModel, isStream) {
+  const profile = route.subscriptionProfile;
+  if (!profile) {
+    writeError(res, 502, "Subscription mode requires a codex subscription profile");
+    return null;
+  }
+  const upstreamUrl = profile.resolveUpstreamUrl?.(resolvedModel);
+  if (!upstreamUrl) {
+    writeError(res, 502, "Subscription profile is missing resolveUpstreamUrl");
+    return null;
+  }
+  const auth = route.auth ?? new SubscriptionAuthSource(profile);
+  const chain = resolveSubscriptionChain(
+    profile,
+    deps.llmConfig.getTransformerService(),
+    getResponsesEndpointTransformer()
+  );
+  const transformerProvider = {
+    name: profile.authStrategy.providerId,
+    baseUrl: upstreamUrl,
+    apiKey: "",
+    models: [resolvedModel]
+  };
+  if (profile.authStrategy.providerId === "gemini") {
+    try {
+      transformerProvider.geminiProject = await resolveGeminiCodeAssistProject(profile);
+    } catch (err) {
+      writeError(res, 502, serializeError(err));
+      return null;
+    }
+  }
+  return {
+    auth,
+    chain,
+    transformerProvider,
+    resolvedModel,
+    isStream,
+    // Prefer the transformer-supplied URL (Code Assist carries the correct
+    // stream vs non-stream colon-method URL in `config.url`); fall back to the
+    // profile's `resolveUpstreamUrl` for non-Code-Assist subscriptions.
+    resolveUrl: (config) => config.url instanceof URL ? config.url.toString() : typeof config.url === "string" ? config.url : upstreamUrl,
+    upstreamUrl
+  };
+}
+async function resolveGeminiCodeAssistProject(profile) {
+  const probe = {};
+  await profile.authStrategy.applyHeaders(probe);
+  const bearer = probe.Authorization ?? probe.authorization ?? "";
+  const accessToken = bearer.replace(/^Bearer\s+/i, "").trim();
+  if (!accessToken) return void 0;
+  const resolver2 = getGeminiCodeAssistResolver();
+  if (!resolver2) return void 0;
+  return resolver2.resolveProject(accessToken);
+}
+async function runPipeline4(responsesBody, plan) {
+  const executor = getSharedExecutor();
+  const endpointTransformer = getResponsesEndpointTransformer();
+  const { auth, chain, transformerProvider, resolvedModel, isStream, resolveUrl, upstreamUrl } = plan;
+  const authHeaders = {};
+  await auth.applyHeaders(authHeaders, { upstreamUrl, model: resolvedModel });
+  let rawStatus = null;
+  const { response } = await executeProviderCall({
+    executor,
+    request: responsesBody,
+    provider: transformerProvider,
+    chain,
+    endpointTransformer,
+    resolveUrl,
+    buildHeaders: (config) => {
+      const headers = { ...authHeaders };
+      if (config.headers) {
+        for (const [key, value] of Object.entries(config.headers)) {
+          if (value !== void 0 && !(key in headers)) headers[key] = value;
+        }
+      }
+      return headers;
+    },
+    fetchFn: (url, headers, body) => {
+      console.log(`[ProviderProxy:responses] -> ${url} model=${resolvedModel} stream=${isStream}`);
+      return fetch(url, { method: "POST", headers, body: JSON.stringify(body) }).then((r) => {
+        rawStatus = r.status;
+        return r;
+      });
+    },
+    runResponseChain: true
+  });
+  return { response, rawStatus };
+}
+async function runPipelineWithPoolReporting4(responsesBody, plan) {
+  const first = await runPipeline4(responsesBody, plan);
+  const outcome = await plan.auth.onResult?.(first.rawStatus);
+  if (outcome?.rebound) {
+    console.log(
+      "[ProviderProxy:responses] pool re-bound key after status",
+      first.rawStatus,
+      "\u2192 retrying once"
+    );
+    return runPipeline4(responsesBody, plan);
+  }
+  return first;
+}
+async function runPipelineWithSubscriptionRetry2(responsesBody, plan) {
+  const first = await runPipeline4(responsesBody, plan);
+  if (first.rawStatus !== 401) return first;
+  const refreshed = await plan.auth.onUnauthorized?.();
+  if (!refreshed) {
+    console.warn("[ProviderProxy:responses] 401 not recoverable (onUnauthorized returned false)");
+    return first;
+  }
+  console.log("[ProviderProxy:responses] 401 \u2192 token refreshed; retrying once");
+  return runPipeline4(responsesBody, plan);
+}
+
+// src/provider-proxy/providerProxyRouter.ts
+function extractRouteToken(authHeader) {
+  if (!authHeader) return void 0;
+  const trimmed = authHeader.trim();
+  if (!trimmed) return void 0;
+  const m = /^Bearer\s+(.+)$/i.exec(trimmed);
+  return (m ? m[1] : trimmed).trim() || void 0;
+}
+function resolveRouteToken(req) {
+  const fromAuth = extractRouteToken(req.headers["authorization"]);
+  if (fromAuth) return fromAuth;
+  const googKey = req.headers["x-goog-api-key"];
+  const value = Array.isArray(googKey) ? googKey[0] : googKey;
+  return value?.trim() || void 0;
+}
+async function routeRequest(req, res, routes, deps) {
+  const token = resolveRouteToken(req);
+  const route = routes.lookup(token);
+  if (!route) {
+    writeError(res, 401, "Invalid or expired route token");
+    return;
+  }
+  const method = req.method;
+  const url = req.url;
+  if (isAnthropicMessagesRequest(method, url)) {
+    await handleAnthropicMessagesRequest(req, res, route, deps);
+    return;
+  }
+  if (isOpenAIResponsesRequest(method, url)) {
+    const rawBody = await readBody(req);
+    await handleOpenAIResponsesRequest(res, rawBody, route, deps);
+    return;
+  }
+  if (isOpenAIChatRequest(method, url)) {
+    const rawBody = await readBody(req);
+    await handleOpenAIChatRequest(res, rawBody, route, deps);
+    return;
+  }
+  if (isGeminiGenerateContentRequest(method, url)) {
+    const rawBody = await readBody(req);
+    await handleGeminiGenerateContentRequest(res, rawBody, url, route, deps);
+    return;
+  }
+  writeError(res, 404, `Unsupported: ${method} ${url}`);
+}
+
+// src/provider-proxy/ProviderProxy.ts
+function isLoopbackAddress(addr) {
+  if (!addr) return false;
+  const normalized = addr.startsWith("::ffff:") ? addr.slice("::ffff:".length) : addr;
+  return normalized === "127.0.0.1" || normalized.startsWith("127.") || normalized === "::1" || addr === "::1";
+}
+var ProviderProxy = class {
+  constructor(deps, routes) {
+    this.deps = deps;
+    this.routes = routes ?? new ProviderProxyRouteMap();
+  }
+  deps;
+  server = null;
+  port = 0;
+  routes;
+  /**
+   * Start the resident listener on a stable port on 127.0.0.1. Idempotent —
+   * a second `start()` returns the already-bound port.
+   */
+  async start() {
+    if (this.server) return this.port;
+    return new Promise((resolve, reject) => {
+      const server = http2.createServer((req, res) => {
+        const peer = req.socket.remoteAddress;
+        if (!isLoopbackAddress(peer)) {
+          res.writeHead(403, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: { type: "provider_proxy_error", message: "Loopback only" } }));
+          req.socket.destroy();
+          return;
+        }
+        routeRequest(req, res, this.routes, this.deps).catch((err) => {
+          const errMsg = serializeError(err);
+          console.error("[ProviderProxy] Unhandled error:", errMsg);
+          if (!res.headersSent) {
+            res.writeHead(500, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: { type: "provider_proxy_error", message: errMsg } }));
+          }
+        });
+      });
+      server.listen(0, "127.0.0.1", () => {
+        const addr = server.address();
+        if (addr && typeof addr === "object") {
+          this.port = addr.port;
+          this.server = server;
+          console.log(`[ProviderProxy] Listening on 127.0.0.1:${this.port}`);
+          resolve(this.port);
+        } else {
+          reject(new Error("Failed to get server address"));
+        }
+      });
+      server.on("error", reject);
+    });
+  }
+  /** Stop the listener, clear all routes, and release the port. */
+  async stop() {
+    this.routes.clear();
+    const server = this.server;
+    if (!server) return;
+    return new Promise((resolve) => {
+      server.close(() => {
+        console.log(`[ProviderProxy] Stopped (port=${this.port})`);
+        this.server = null;
+        this.port = 0;
+        resolve();
+      });
+    });
+  }
+  /** Base URL for injector wiring (`ANTHROPIC_BASE_URL` / codex `base_url`). */
+  getBaseUrl() {
+    return `http://127.0.0.1:${this.port}`;
+  }
+  /**
+   * The SHARED route map. Exposed so the outbound API server
+   * (`outbound-api-server`) can mint per-request routes on the SAME map and
+   * delegate to the existing `routeRequest()` dispatch — guaranteeing a single
+   * conversion stack. Not used by the resident per-run flow.
+   */
+  getRouteMap() {
+    return this.routes;
+  }
+  /**
+   * The app-session deps the proxy services all routes with. Exposed so the
+   * outbound server can pass them verbatim into `routeRequest()`.
+   */
+  getDeps() {
+    return this.deps;
+  }
+  /** Register a route for one run; returns the crypto route token (task 2.2). */
+  addRoute(context, idleMs) {
+    return this.routes.addRoute(context, idleMs);
+  }
+  /** Remove a route at run end. Returns true if an entry existed. */
+  removeRoute(token) {
+    return this.routes.removeRoute(token);
+  }
+  /** Live-route count (diagnostics / tests). */
+  routeCount() {
+    return this.routes.size();
+  }
+};
+export {
+  ProviderProxy,
+  isLoopbackAddress
+};