indusagi 0.13.5 → 0.13.7

package/dist/llmgateway.js

@@ -1,3243 +0,0 @@
-// src/llmgateway/contract/errors.ts
-var GatewayError = class _GatewayError extends Error {
-  kind;
-  status;
-  provider;
-  constructor(kind, message, extra) {
-    super(message, extra?.cause !== void 0 ? { cause: extra.cause } : void 0);
-    this.name = "GatewayError";
-    this.kind = kind;
-    this.status = extra?.status;
-    this.provider = extra?.provider;
-    Object.setPrototypeOf(this, _GatewayError.prototype);
-  }
-};
-function gatewayError(kind, message, extra) {
-  return new GatewayError(kind, message, extra);
-}
-
-// src/llmgateway/catalog/cards.ts
-var MODEL_CARDS = [
-  // ── Anthropic (Claude) ──────────────────────────────────────────────────
-  {
-    id: "claude-opus-4",
-    provider: "anthropic",
-    api: "anthropic-messages",
-    displayName: "Claude Opus 4",
-    contextWindow: 2e5,
-    maxOutputTokens: 32e3,
-    modalities: ["text", "image"],
-    reasoning: true,
-    cost: {
-      // approximate — flagship tier
-      inputPerMTok: 15,
-      outputPerMTok: 75,
-      cacheReadPerMTok: 1.5,
-      cacheWritePerMTok: 18.75
-    }
-  },
-  {
-    id: "claude-opus-4-7",
-    provider: "anthropic",
-    api: "anthropic-messages",
-    displayName: "Claude Opus 4.7",
-    contextWindow: 1e6,
-    maxOutputTokens: 128e3,
-    modalities: ["text", "image"],
-    reasoning: true,
-    cost: {
-      // approximate — flagship tier
-      inputPerMTok: 5,
-      outputPerMTok: 25,
-      cacheReadPerMTok: 0.5,
-      cacheWritePerMTok: 6.25
-    }
-  },
-  {
-    id: "claude-opus-4-8",
-    provider: "anthropic",
-    api: "anthropic-messages",
-    displayName: "Claude Opus 4.8",
-    contextWindow: 1e6,
-    maxOutputTokens: 128e3,
-    modalities: ["text", "image"],
-    reasoning: true,
-    cost: {
-      // approximate — flagship tier
-      inputPerMTok: 5,
-      outputPerMTok: 25,
-      cacheReadPerMTok: 0.5,
-      cacheWritePerMTok: 6.25
-    }
-  },
-  {
-    id: "claude-sonnet-4",
-    provider: "anthropic",
-    api: "anthropic-messages",
-    displayName: "Claude Sonnet 4",
-    contextWindow: 2e5,
-    maxOutputTokens: 64e3,
-    modalities: ["text", "image"],
-    reasoning: true,
-    cost: {
-      // approximate — mid tier
-      inputPerMTok: 3,
-      outputPerMTok: 15,
-      cacheReadPerMTok: 0.3,
-      cacheWritePerMTok: 3.75
-    }
-  },
-  {
-    id: "claude-haiku-3-5",
-    provider: "anthropic",
-    api: "anthropic-messages",
-    displayName: "Claude Haiku 3.5",
-    contextWindow: 2e5,
-    maxOutputTokens: 8192,
-    modalities: ["text", "image"],
-    reasoning: false,
-    cost: {
-      // approximate — fast/cheap tier
-      inputPerMTok: 0.8,
-      outputPerMTok: 4,
-      cacheReadPerMTok: 0.08,
-      cacheWritePerMTok: 1
-    }
-  },
-  // ── OpenAI (GPT + o-series) ─────────────────────────────────────────────
-  {
-    id: "gpt-4o",
-    provider: "openai",
-    api: "openai-completions",
-    displayName: "GPT-4o",
-    contextWindow: 128e3,
-    maxOutputTokens: 16384,
-    modalities: ["text", "image", "audio"],
-    reasoning: false,
-    cost: {
-      // approximate — omni flagship
-      inputPerMTok: 2.5,
-      outputPerMTok: 10,
-      cacheReadPerMTok: 1.25
-    }
-  },
-  {
-    id: "gpt-4o-mini",
-    provider: "openai",
-    api: "openai-completions",
-    displayName: "GPT-4o mini",
-    contextWindow: 128e3,
-    maxOutputTokens: 16384,
-    modalities: ["text", "image"],
-    reasoning: false,
-    cost: {
-      // approximate — small omni
-      inputPerMTok: 0.15,
-      outputPerMTok: 0.6,
-      cacheReadPerMTok: 0.075
-    }
-  },
-  {
-    id: "o3",
-    provider: "openai",
-    api: "openai-responses",
-    displayName: "OpenAI o3",
-    contextWindow: 2e5,
-    maxOutputTokens: 1e5,
-    modalities: ["text", "image"],
-    reasoning: true,
-    cost: {
-      // approximate — reasoning flagship
-      inputPerMTok: 10,
-      outputPerMTok: 40,
-      cacheReadPerMTok: 2.5
-    }
-  },
-  {
-    id: "o4-mini",
-    provider: "openai",
-    api: "openai-responses",
-    displayName: "OpenAI o4-mini",
-    contextWindow: 2e5,
-    maxOutputTokens: 1e5,
-    modalities: ["text", "image"],
-    reasoning: true,
-    cost: {
-      // approximate — small reasoning
-      inputPerMTok: 1.1,
-      outputPerMTok: 4.4,
-      cacheReadPerMTok: 0.275
-    }
-  },
-  // ── Google (Gemini) ─────────────────────────────────────────────────────
-  {
-    id: "gemini-2.5-pro",
-    provider: "google",
-    api: "google-generative",
-    displayName: "Gemini 2.5 Pro",
-    contextWindow: 1e6,
-    maxOutputTokens: 65536,
-    modalities: ["text", "image", "audio"],
-    reasoning: true,
-    cost: {
-      // approximate — long-context pro tier
-      inputPerMTok: 1.25,
-      outputPerMTok: 10,
-      cacheReadPerMTok: 0.31
-    }
-  },
-  {
-    id: "gemini-2.5-flash",
-    provider: "google",
-    api: "google-generative",
-    displayName: "Gemini 2.5 Flash",
-    contextWindow: 1e6,
-    maxOutputTokens: 65536,
-    modalities: ["text", "image", "audio"],
-    reasoning: true,
-    cost: {
-      // approximate — fast flash tier
-      inputPerMTok: 0.3,
-      outputPerMTok: 2.5,
-      cacheReadPerMTok: 0.075
-    }
-  },
-  // ── NVIDIA (OpenAI-compatible NIM endpoint) ─────────────────────────────
-  {
-    id: "nvidia/llama-3.1-nemotron-70b-instruct",
-    provider: "nvidia",
-    api: "nvidia-openai-compatible",
-    displayName: "Nemotron 70B Instruct",
-    baseUrl: "https://integrate.api.nvidia.com/v1",
-    contextWindow: 128e3,
-    maxOutputTokens: 4096,
-    modalities: ["text"],
-    reasoning: false,
-    cost: {
-      // approximate — hosted NIM inference
-      inputPerMTok: 0.2,
-      outputPerMTok: 0.2
-    }
-  },
-  // ── Kimi / Moonshot (OpenAI-compatible) ─────────────────────────────────
-  {
-    id: "kimi-k2",
-    provider: "kimi",
-    api: "kimi-openai-compatible",
-    displayName: "Kimi K2",
-    baseUrl: "https://api.moonshot.ai/v1",
-    contextWindow: 256e3,
-    maxOutputTokens: 16384,
-    modalities: ["text"],
-    reasoning: true,
-    cost: {
-      // approximate — Moonshot hosted
-      inputPerMTok: 0.6,
-      outputPerMTok: 2.5,
-      cacheReadPerMTok: 0.15
-    }
-  },
-  // ── Ollama (local; pricing is zero — your own hardware) ─────────────────
-  {
-    id: "llama3.1:8b",
-    provider: "ollama",
-    api: "ollama",
-    displayName: "Llama 3.1 8B (local)",
-    baseUrl: "http://localhost:11434",
-    contextWindow: 128e3,
-    maxOutputTokens: 8192,
-    modalities: ["text"],
-    reasoning: false,
-    cost: {
-      // local inference — no per-token cost
-      inputPerMTok: 0,
-      outputPerMTok: 0
-    }
-  },
-  // ── Mock (deterministic test fixture; free) ─────────────────────────────
-  {
-    id: "mock-1",
-    provider: "mock",
-    api: "mock",
-    displayName: "Mock Model",
-    contextWindow: 32e3,
-    maxOutputTokens: 4096,
-    modalities: ["text"],
-    reasoning: false,
-    cost: {
-      inputPerMTok: 0,
-      outputPerMTok: 0
-    }
-  }
-];
-
-// src/llmgateway/catalog/query.ts
-var CardSelection = class _CardSelection {
-  constructor(pool, tests) {
-    this.pool = pool;
-    this.tests = tests;
-  }
-  pool;
-  tests;
-  /** Begin a query over the given pool (defaults to the full catalog). */
-  static over(pool) {
-    return new _CardSelection(pool, []);
-  }
-  withTest(test) {
-    return new _CardSelection(this.pool, [...this.tests, test]);
-  }
-  /** Keep only cards from a specific vendor. */
-  byProvider(provider) {
-    return this.withTest((card) => card.provider === provider);
-  }
-  /** Keep only cards served over a specific wire dialect. */
-  byApi(api) {
-    return this.withTest((card) => card.api === api);
-  }
-  /** Keep cards whose reasoning capability matches `enabled`. */
-  reasoning(enabled) {
-    return this.withTest((card) => card.reasoning === enabled);
-  }
-  /** Materialize every card that satisfies all accumulated predicates. */
-  all() {
-    return this.pool.filter((card) => this.tests.every((test) => test(card)));
-  }
-  /**
-   * Terminal lookup by exact `id`, also respecting any accumulated predicates.
-   * Returns `undefined` when no surviving card matches.
-   */
-  find(id) {
-    return this.all().find((card) => card.id === id);
-  }
-};
-function models() {
-  return CardSelection.over(MODEL_CARDS);
-}
-function getCard(id) {
-  return MODEL_CARDS.find((card) => card.id === id);
-}
-
-// src/llmgateway/catalog/cost.ts
-var TOKENS_PER_MTOK = 1e6;
-function estimateCost(card, usage) {
-  const { cost } = card;
-  let dollars = 0;
-  dollars += usage.inputTokens / TOKENS_PER_MTOK * cost.inputPerMTok;
-  dollars += usage.outputTokens / TOKENS_PER_MTOK * cost.outputPerMTok;
-  if (usage.cacheReadTokens && cost.cacheReadPerMTok !== void 0) {
-    dollars += usage.cacheReadTokens / TOKENS_PER_MTOK * cost.cacheReadPerMTok;
-  }
-  if (usage.cacheWriteTokens && cost.cacheWritePerMTok !== void 0) {
-    dollars += usage.cacheWriteTokens / TOKENS_PER_MTOK * cost.cacheWritePerMTok;
-  }
-  return dollars;
-}
-
-// src/llmgateway/credentials/secrets.ts
-var SECRET_TABLE = {
-  anthropic: {
-    provider: "anthropic",
-    scheme: "api-key",
-    envVars: ["ANTHROPIC_API_KEY"],
-    hint: "Anthropic Messages API bearer key."
-  },
-  openai: {
-    provider: "openai",
-    scheme: "api-key",
-    envVars: ["OPENAI_API_KEY"],
-    hint: "OpenAI platform API key."
-  },
-  google: {
-    provider: "google",
-    scheme: "api-key",
-    // Gemini Developer API: GEMINI_API_KEY is canonical; GOOGLE_API_KEY is the
-    // legacy/alias name still honored by the Generative Language API.
-    envVars: ["GEMINI_API_KEY", "GOOGLE_API_KEY"],
-    hint: "Google Generative Language (Gemini) API key."
-  },
-  "google-vertex": {
-    provider: "google-vertex",
-    scheme: "cloud-iam",
-    // Vertex authenticates via Application Default Credentials; these point at
-    // a service-account key file and the target project/region.
-    envVars: [
-      "GOOGLE_APPLICATION_CREDENTIALS",
-      "GOOGLE_VERTEX_PROJECT",
-      "GOOGLE_CLOUD_PROJECT"
-    ],
-    hint: "Vertex AI via Application Default Credentials (service account)."
-  },
-  amazon: {
-    provider: "amazon",
-    scheme: "cloud-iam",
-    // Bedrock supports a short-lived bearer token, otherwise the standard
-    // AWS SigV4 credential chain.
-    envVars: [
-      "AWS_BEARER_TOKEN_BEDROCK",
-      "AWS_ACCESS_KEY_ID",
-      "AWS_PROFILE"
-    ],
-    hint: "Amazon Bedrock via bearer token or AWS credential chain."
-  },
-  azure: {
-    provider: "azure",
-    scheme: "api-key",
-    envVars: ["AZURE_OPENAI_API_KEY", "AZURE_API_KEY"],
-    hint: "Azure OpenAI resource key (paired with endpoint + deployment)."
-  },
-  nvidia: {
-    provider: "nvidia",
-    scheme: "api-key",
-    envVars: ["NVIDIA_API_KEY"],
-    hint: "NVIDIA NIM / build.nvidia.com API key."
-  },
-  kimi: {
-    provider: "kimi",
-    scheme: "api-key",
-    // Moonshot AI ships the Kimi models; MOONSHOT_API_KEY is the documented
-    // name, KIMI_API_KEY is a common community alias.
-    envVars: ["MOONSHOT_API_KEY", "KIMI_API_KEY"],
-    hint: "Moonshot AI (Kimi) API key."
-  },
-  ollama: {
-    provider: "ollama",
-    scheme: "none",
-    envVars: [],
-    hint: "Local Ollama server \u2014 no credential required."
-  },
-  mock: {
-    provider: "mock",
-    scheme: "none",
-    envVars: [],
-    hint: "In-process mock transport \u2014 no credential required."
-  }
-};
-function readEnv(name) {
-  const raw = process.env[name];
-  if (raw === void 0) return void 0;
-  const trimmed = raw.trim();
-  return trimmed.length > 0 ? trimmed : void 0;
-}
-async function resolveSecret(provider, override) {
-  if (override !== void 0) {
-    const trimmed = override.trim();
-    if (trimmed.length > 0) return trimmed;
-  }
-  const descriptor = SECRET_TABLE[provider];
-  if (descriptor.scheme === "none") return void 0;
-  for (const name of descriptor.envVars) {
-    const value = readEnv(name);
-    if (value !== void 0) return value;
-  }
-  return void 0;
-}
-
-// src/llmgateway/streaming/sse.ts
-var LF = "\n";
-var CR = "\r";
-async function* sseEvents(body, signal) {
-  if (signal?.aborted) {
-    throw gatewayError("aborted", "request aborted before reading the event stream");
-  }
-  const reader = body.getReader();
-  const decoder = new TextDecoder("utf-8");
-  let pending = "";
-  let eventType = "message";
-  let dataLines = [];
-  let sawData = false;
-  const onAbort = () => {
-    void reader.cancel().catch(() => {
-    });
-  };
-  signal?.addEventListener("abort", onAbort, { once: true });
-  const resetEvent = () => {
-    eventType = "message";
-    dataLines = [];
-    sawData = false;
-  };
-  const dispatch = () => {
-    if (!sawData) {
-      resetEvent();
-      return void 0;
-    }
-    const out = { event: eventType, data: dataLines.join(LF) };
-    resetEvent();
-    return out;
-  };
-  const consumeLine = (line) => {
-    if (line === "") {
-      return dispatch();
-    }
-    if (line.startsWith(":")) {
-      return void 0;
-    }
-    const colon = line.indexOf(":");
-    let field;
-    let value;
-    if (colon === -1) {
-      field = line;
-      value = "";
-    } else {
-      field = line.slice(0, colon);
-      value = line.slice(colon + 1);
-      if (value.startsWith(" ")) {
-        value = value.slice(1);
-      }
-    }
-    switch (field) {
-      case "event":
-        eventType = value;
-        break;
-      case "data":
-        dataLines.push(value);
-        sawData = true;
-        break;
-      // "id" and "retry" are valid SSE fields but irrelevant to LLM streams.
-      default:
-        break;
-    }
-    return void 0;
-  };
-  function* drainLines(atEnd) {
-    let start = 0;
-    let i = 0;
-    while (i < pending.length) {
-      const ch = pending[i];
-      if (ch === LF) {
-        yield pending.slice(start, i);
-        i += 1;
-        start = i;
-      } else if (ch === CR) {
-        if (i === pending.length - 1 && !atEnd) {
-          break;
-        }
-        yield pending.slice(start, i);
-        if (pending[i + 1] === LF) {
-          i += 2;
-        } else {
-          i += 1;
-        }
-        start = i;
-      } else {
-        i += 1;
-      }
-    }
-    pending = pending.slice(start);
-    if (atEnd && pending.length > 0) {
-      const last = pending;
-      pending = "";
-      yield last;
-    }
-  }
-  try {
-    for (; ; ) {
-      if (signal?.aborted) {
-        throw gatewayError("aborted", "request aborted while reading the event stream");
-      }
-      const { value, done } = await reader.read();
-      if (done) {
-        break;
-      }
-      pending += decoder.decode(value, { stream: true });
-      for (const line of drainLines(false)) {
-        const ev = consumeLine(line);
-        if (ev !== void 0) {
-          yield ev;
-        }
-      }
-    }
-    pending += decoder.decode();
-    for (const line of drainLines(true)) {
-      const ev = consumeLine(line);
-      if (ev !== void 0) {
-        yield ev;
-      }
-    }
-  } catch (cause) {
-    if (signal?.aborted) {
-      throw gatewayError("aborted", "request aborted while reading the event stream", { cause });
-    }
-    if (cause instanceof Error && cause.name === "GatewayError") {
-      throw cause;
-    }
-    throw gatewayError("transport", "failed reading the server-sent event stream", { cause });
-  } finally {
-    signal?.removeEventListener("abort", onAbort);
-    reader.releaseLock();
-  }
-}
-
-// src/llmgateway/conversion/reduce.ts
-var EMPTY_USAGE = { inputTokens: 0, outputTokens: 0 };
-function initial() {
-  return {
-    thinking: "",
-    text: "",
-    order: [],
-    calls: /* @__PURE__ */ new Map(),
-    usage: EMPTY_USAGE,
-    stop: "complete"
-  };
-}
-function ensureCall(state, id, name) {
-  const existing = state.calls.get(id);
-  if (existing === void 0) {
-    state.order.push(id);
-    state.calls.set(id, { name, args: "" });
-  } else if (name !== "" && existing.name === "") {
-    existing.name = name;
-  }
-}
-function step(state, emission) {
-  switch (emission.kind) {
-    case "text":
-      state.text += emission.delta;
-      break;
-    case "thinking":
-      state.thinking += emission.delta;
-      break;
-    case "tool_call_start":
-      ensureCall(state, emission.id, emission.name);
-      break;
-    case "tool_call_delta": {
-      ensureCall(state, emission.id, "");
-      const slot = state.calls.get(emission.id);
-      if (slot !== void 0) {
-        slot.args += emission.argsDelta;
-      }
-      break;
-    }
-    case "usage":
-      state.usage = emission.usage;
-      break;
-    case "stop":
-      state.stop = emission.stop;
-      break;
-    // `done` and `error` are terminal envelopes, not deltas to fold; a caller
-    // that hands them to the reducer simply contributes nothing.
-    case "done":
-    case "error":
-      break;
-  }
-}
-function parseArgs(raw) {
-  const trimmed = raw.trim();
-  if (trimmed === "") {
-    return {};
-  }
-  try {
-    return JSON.parse(trimmed);
-  } catch {
-    return raw;
-  }
-}
-function toBlocks(state) {
-  const blocks = [];
-  if (state.thinking !== "") {
-    const block = { kind: "thinking", text: state.thinking };
-    blocks.push(block);
-  }
-  if (state.text !== "") {
-    const block = { kind: "text", text: state.text };
-    blocks.push(block);
-  }
-  for (const id of state.order) {
-    const call = state.calls.get(id);
-    if (call === void 0) {
-      continue;
-    }
-    const block = {
-      kind: "tool_call",
-      id,
-      name: call.name,
-      input: parseArgs(call.args)
-    };
-    blocks.push(block);
-  }
-  return blocks;
-}
-function foldReply(model, emissions) {
-  const state = initial();
-  for (const emission of emissions) {
-    step(state, emission);
-  }
-  const blocks = toBlocks(state);
-  let stop = state.stop;
-  if (stop === "complete" && state.order.length > 0) {
-    stop = "tool_calls";
-  }
-  return {
-    role: "assistant",
-    model,
-    blocks,
-    usage: state.usage,
-    stop
-  };
-}
-
-// src/llmgateway/streaming/channel.ts
-function channelOf(gen) {
-  return {
-    [Symbol.asyncIterator]() {
-      return gen();
-    }
-  };
-}
-async function collectReply(channel) {
-  const buffer = [];
-  let model = "unknown";
-  for await (const emission of channel) {
-    if (emission.kind === "done") {
-      return emission.reply;
-    }
-    if (emission.kind === "error") {
-      throw emission.error;
-    }
-    buffer.push(emission);
-  }
-  if (buffer.length === 0) {
-    throw gatewayError("transport", "channel closed without emitting any data");
-  }
-  return foldReply(model, buffer);
-}
-
-// src/llmgateway/conversion/mappers.ts
-function stringifyToolOutput(output) {
-  if (typeof output === "string") {
-    return output;
-  }
-  try {
-    return JSON.stringify(output);
-  } catch {
-    return String(output);
-  }
-}
-function toArgumentString(input) {
-  if (typeof input === "string") {
-    return input;
-  }
-  try {
-    return JSON.stringify(input ?? {});
-  } catch {
-    return "{}";
-  }
-}
-function toOpenAIChatMessages(c) {
-  const messages = [];
-  if (c.system !== void 0 && c.system !== "") {
-    messages.push({ role: "system", content: c.system });
-  }
-  for (const turn of c.turns) {
-    switch (turn.role) {
-      case "user":
-        messages.push(openAiUserMessage(turn.blocks));
-        break;
-      case "assistant":
-        messages.push(openAiAssistantMessage(turn.blocks));
-        break;
-      case "tool":
-        for (const message of openAiToolMessages(turn.blocks)) {
-          messages.push(message);
-        }
-        break;
-    }
-  }
-  return messages;
-}
-function openAiUserMessage(blocks) {
-  const parts = [];
-  let hasImage = false;
-  for (const block of blocks) {
-    if (block.kind === "text") {
-      parts.push({ type: "text", text: block.text });
-    } else if (block.kind === "image") {
-      hasImage = true;
-      parts.push({
-        type: "image_url",
-        image_url: { url: `data:${block.mediaType};base64,${block.dataBase64}` }
-      });
-    }
-  }
-  if (!hasImage) {
-    const text = parts.map((p) => p.text ?? "").join("");
-    return { role: "user", content: text };
-  }
-  return { role: "user", content: parts };
-}
-function openAiAssistantMessage(blocks) {
-  let text = "";
-  const toolCalls = [];
-  for (const block of blocks) {
-    if (block.kind === "text") {
-      text += block.text;
-    } else if (block.kind === "tool_call") {
-      toolCalls.push({
-        id: block.id,
-        type: "function",
-        function: { name: block.name, arguments: toArgumentString(block.input) }
-      });
-    }
-  }
-  const message = { role: "assistant", content: text === "" ? null : text };
-  if (toolCalls.length > 0) {
-    message.tool_calls = toolCalls;
-  }
-  return message;
-}
-function openAiToolMessages(blocks) {
-  const out = [];
-  for (const block of blocks) {
-    if (block.kind === "tool_result") {
-      out.push({
-        role: "tool",
-        tool_call_id: block.callId,
-        content: stringifyToolOutput(block.output)
-      });
-    }
-  }
-  return out;
-}
-function toOpenAITools(tools) {
-  if (tools === void 0 || tools.length === 0) {
-    return void 0;
-  }
-  return tools.map((tool) => ({
-    type: "function",
-    function: {
-      name: tool.name,
-      description: tool.description,
-      parameters: tool.parameters
-    }
-  }));
-}
-function toOpenAIToolChoice(choice) {
-  if (choice === void 0) {
-    return void 0;
-  }
-  return choice;
-}
-function anthropicThinkingBudget(level, maxOutput) {
-  const fraction = {
-    low: 0.2,
-    medium: 0.4,
-    high: 0.6,
-    max: 0.8
-  };
-  if (level === "off") {
-    return 0;
-  }
-  const budget = Math.floor(maxOutput * fraction[level]);
-  return Math.max(1024, budget);
-}
-function toAnthropicRequest(c, model, opts) {
-  const body = {
-    model: model.id,
-    max_tokens: opts.maxOutputTokens ?? model.maxOutputTokens,
-    messages: toAnthropicMessages(c)
-  };
-  if (c.system !== void 0 && c.system !== "") {
-    body.system = c.system;
-  }
-  const tools = toAnthropicTools(c.tools);
-  if (tools !== void 0) {
-    body.tools = tools;
-  }
-  const toolChoice = toAnthropicToolChoice(opts.toolChoice);
-  if (toolChoice !== void 0) {
-    body.tool_choice = toolChoice;
-  }
-  if (opts.temperature !== void 0) {
-    body.temperature = opts.temperature;
-  }
-  if (opts.topP !== void 0) {
-    body.top_p = opts.topP;
-  }
-  if (model.reasoning && opts.thinking !== void 0 && opts.thinking !== "off") {
-    const max = opts.maxOutputTokens ?? model.maxOutputTokens;
-    body.thinking = { type: "enabled", budget_tokens: anthropicThinkingBudget(opts.thinking, max) };
-  }
-  return body;
-}
-function toAnthropicMessages(c) {
-  const messages = [];
-  for (const turn of c.turns) {
-    if (turn.role === "tool") {
-      messages.push({ role: "user", content: anthropicContent(turn) });
-    } else {
-      messages.push({ role: turn.role, content: anthropicContent(turn) });
-    }
-  }
-  return messages;
-}
-function anthropicContent(turn) {
-  const content = [];
-  for (const block of turn.blocks) {
-    switch (block.kind) {
-      case "text":
-        content.push({ type: "text", text: block.text });
-        break;
-      case "thinking":
-        content.push(
-          block.signature !== void 0 ? { type: "thinking", thinking: block.text, signature: block.signature } : { type: "thinking", thinking: block.text }
-        );
-        break;
-      case "tool_call":
-        content.push({
-          type: "tool_use",
-          id: block.id,
-          name: block.name,
-          input: typeof block.input === "string" ? safeParse(block.input) : block.input ?? {}
-        });
-        break;
-      case "tool_result":
-        content.push({
-          type: "tool_result",
-          tool_use_id: block.callId,
-          content: stringifyToolOutput(block.output),
-          ...block.isError === true ? { is_error: true } : {}
-        });
-        break;
-      case "image":
-        content.push({
-          type: "image",
-          source: { type: "base64", media_type: block.mediaType, data: block.dataBase64 }
-        });
-        break;
-    }
-  }
-  return content;
-}
-function toAnthropicTools(tools) {
-  if (tools === void 0 || tools.length === 0) {
-    return void 0;
-  }
-  return tools.map((tool) => ({
-    name: tool.name,
-    description: tool.description,
-    input_schema: tool.parameters
-  }));
-}
-function toAnthropicToolChoice(choice) {
-  switch (choice) {
-    case "auto":
-      return { type: "auto" };
-    case "required":
-      return { type: "any" };
-    case "none":
-      return { type: "none" };
-    default:
-      return void 0;
-  }
-}
-function toGoogleContents(c) {
-  const contents = [];
-  for (const turn of c.turns) {
-    const role = turn.role === "assistant" ? "model" : "user";
-    contents.push({ role, parts: googleParts(turn) });
-  }
-  return contents;
-}
-function googleParts(turn) {
-  const parts = [];
-  for (const block of turn.blocks) {
-    switch (block.kind) {
-      case "text":
-        parts.push({ text: block.text });
-        break;
-      case "thinking":
-        parts.push({ text: block.text, thought: true });
-        break;
-      case "tool_call":
-        parts.push({
-          functionCall: {
-            name: block.name,
-            args: typeof block.input === "string" ? safeParse(block.input) : block.input ?? {}
-          }
-        });
-        break;
-      case "tool_result":
-        parts.push({
-          functionResponse: {
-            name: block.callId,
-            response: { result: stringifyToolOutput(block.output) }
-          }
-        });
-        break;
-      case "image":
-        parts.push({ inlineData: { mimeType: block.mediaType, data: block.dataBase64 } });
-        break;
-    }
-  }
-  return parts;
-}
-function toGoogleSystemInstruction(c) {
-  if (c.system === void 0 || c.system === "") {
-    return void 0;
-  }
-  return { role: "system", parts: [{ text: c.system }] };
-}
-function toGoogleTools(tools) {
-  if (tools === void 0 || tools.length === 0) {
-    return void 0;
-  }
-  return [
-    {
-      functionDeclarations: tools.map((tool) => ({
-        name: tool.name,
-        description: tool.description,
-        parameters: tool.parameters
-      }))
-    }
-  ];
-}
-function toResponsesInput(c) {
-  const input = [];
-  for (const turn of c.turns) {
-    switch (turn.role) {
-      case "user":
-        input.push({ type: "message", role: "user", content: responsesUserContent(turn.blocks) });
-        break;
-      case "assistant":
-        for (const item of responsesAssistantItems(turn.blocks)) {
-          input.push(item);
-        }
-        break;
-      case "tool":
-        for (const block of turn.blocks) {
-          if (block.kind === "tool_result") {
-            input.push({
-              type: "function_call_output",
-              call_id: block.callId,
-              output: stringifyToolOutput(block.output)
-            });
-          }
-        }
-        break;
-    }
-  }
-  return input;
-}
-function responsesUserContent(blocks) {
-  const parts = [];
-  for (const block of blocks) {
-    if (block.kind === "text") {
-      parts.push({ type: "input_text", text: block.text });
-    } else if (block.kind === "image") {
-      parts.push({
-        type: "input_image",
-        image_url: `data:${block.mediaType};base64,${block.dataBase64}`
-      });
-    }
-  }
-  return parts;
-}
-function responsesAssistantItems(blocks) {
-  const items = [];
-  const content = [];
-  for (const block of blocks) {
-    if (block.kind === "text") {
-      content.push({ type: "output_text", text: block.text });
-    } else if (block.kind === "tool_call") {
-      items.push({
-        type: "function_call",
-        call_id: block.id,
-        name: block.name,
-        arguments: toArgumentString(block.input)
-      });
-    }
-  }
-  if (content.length > 0) {
-    items.unshift({ type: "message", role: "assistant", content });
-  }
-  return items;
-}
-function toResponsesTools(tools) {
-  if (tools === void 0 || tools.length === 0) {
-    return void 0;
-  }
-  return tools.map((tool) => ({
-    type: "function",
-    name: tool.name,
-    description: tool.description,
-    parameters: tool.parameters
-  }));
-}
-function safeParse(raw) {
-  try {
-    return JSON.parse(raw);
-  } catch {
-    return {};
-  }
-}
-
-// src/llmgateway/connectors/anthropic.ts
-var DEFAULT_BASE_URL = "https://api.anthropic.com";
-var ANTHROPIC_VERSION = "2023-06-01";
-function isObject(v) {
-  return typeof v === "object" && v !== null;
-}
-function readString(o, key) {
-  const v = o[key];
-  return typeof v === "string" ? v : void 0;
-}
-function readNumber(o, key) {
-  const v = o[key];
-  return typeof v === "number" && Number.isFinite(v) ? v : void 0;
-}
-function mapStopReason(reason) {
-  switch (reason) {
-    case "end_turn":
-    case "stop_sequence":
-      return "complete";
-    case "tool_use":
-      return "tool_calls";
-    case "max_tokens":
-      return "max_output";
-    case "refusal":
-      return "refusal";
-    case null:
-    case void 0:
-    case "":
-      return void 0;
-    default:
-      return "complete";
-  }
-}
-function mergeUsage(current, raw) {
-  if (!isObject(raw)) {
-    return current;
-  }
-  const next = { ...current };
-  const input = readNumber(raw, "input_tokens");
-  if (input !== void 0) {
-    next.inputTokens = input;
-  }
-  const output = readNumber(raw, "output_tokens");
-  if (output !== void 0) {
-    next.outputTokens = output;
-  }
-  const cacheRead = readNumber(raw, "cache_read_input_tokens");
-  if (cacheRead !== void 0) {
-    next.cacheReadTokens = cacheRead;
-  }
-  const cacheWrite = readNumber(raw, "cache_creation_input_tokens");
-  if (cacheWrite !== void 0) {
-    next.cacheWriteTokens = cacheWrite;
-  }
-  return next;
-}
-function parseEventData(event, provider) {
-  if (event.data === "") {
-    return void 0;
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(event.data);
-  } catch (cause) {
-    throw gatewayError("parse", "could not decode an Anthropic stream event", { provider, cause });
-  }
-  return isObject(parsed) ? parsed : void 0;
-}
-function* emitFromEvent(type, payload, state) {
-  switch (type) {
-    case "message_start": {
-      const message = payload.message;
-      if (isObject(message)) {
-        state.usage = mergeUsage(state.usage, message.usage);
-        yield { kind: "usage", usage: state.usage };
-      }
-      return;
-    }
-    case "content_block_start": {
-      yield* emitBlockStart(payload, state);
-      return;
-    }
-    case "content_block_delta": {
-      yield* emitBlockDelta(payload, state);
-      return;
-    }
-    case "content_block_stop": {
-      return;
-    }
-    case "message_delta": {
-      const delta = payload.delta;
-      if (isObject(delta)) {
-        const stop = mapStopReason(readString(delta, "stop_reason"));
-        if (stop !== void 0) {
-          yield { kind: "stop", stop };
-        }
-      }
-      const usage = payload.usage;
-      if (usage !== void 0) {
-        state.usage = mergeUsage(state.usage, usage);
-        yield { kind: "usage", usage: state.usage };
-      }
-      return;
-    }
-    case "message_stop":
-    case "ping":
-      return;
-    case "error": {
-      const error = payload.error;
-      const detail = isObject(error) ? readString(error, "message") : void 0;
-      throw gatewayError("http", `Anthropic reported a stream error${detail !== void 0 ? `: ${detail}` : ""}`);
-    }
-    default:
-      return;
-  }
-}
-function* emitBlockStart(payload, state) {
-  const index = readNumber(payload, "index") ?? 0;
-  const block = payload.content_block;
-  if (!isObject(block)) {
-    return;
-  }
-  if (readString(block, "type") === "tool_use") {
-    const id = readString(block, "id") ?? `tool_${index}`;
-    const name = readString(block, "name") ?? "";
-    state.toolIds.set(index, id);
-    yield { kind: "tool_call_start", id, name };
-  }
-}
-function* emitBlockDelta(payload, state) {
-  const index = readNumber(payload, "index") ?? 0;
-  const delta = payload.delta;
-  if (!isObject(delta)) {
-    return;
-  }
-  switch (readString(delta, "type")) {
-    case "text_delta": {
-      const text = readString(delta, "text");
-      if (text !== void 0 && text !== "") {
-        yield { kind: "text", delta: text };
-      }
-      return;
-    }
-    case "thinking_delta": {
-      const thinking = readString(delta, "thinking");
-      if (thinking !== void 0 && thinking !== "") {
-        yield { kind: "thinking", delta: thinking };
-      }
-      return;
-    }
-    case "input_json_delta": {
-      const fragment = readString(delta, "partial_json");
-      if (fragment !== void 0 && fragment !== "") {
-        const id = state.toolIds.get(index);
-        if (id !== void 0) {
-          yield { kind: "tool_call_delta", id, argsDelta: fragment };
-        }
-      }
-      return;
-    }
-    // `signature_delta` (thinking signatures) carries no user-visible content.
-    default:
-      return;
-  }
-}
-function endpointFor(model) {
-  const base = (model.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
-  return `${base}/v1/messages`;
-}
-async function postMessages(url, apiKey, body, signal) {
-  let response;
-  try {
-    response = await fetch(url, {
-      method: "POST",
-      headers: {
-        "content-type": "application/json",
-        "x-api-key": apiKey,
-        "anthropic-version": ANTHROPIC_VERSION
-      },
-      body: JSON.stringify(body),
-      ...signal !== void 0 ? { signal } : {}
-    });
-  } catch (cause) {
-    if (signal?.aborted) {
-      throw gatewayError("aborted", "request canceled before Anthropic responded", {
-        provider: "anthropic",
-        cause
-      });
-    }
-    throw gatewayError("transport", "network call to Anthropic failed", { provider: "anthropic", cause });
-  }
-  if (!response.ok) {
-    const detail = await readErrorBody(response);
-    const kind = response.status === 401 || response.status === 403 ? "auth" : response.status === 429 ? "rate_limit" : "http";
-    throw gatewayError(kind, `Anthropic returned HTTP ${response.status}${detail}`, {
-      provider: "anthropic",
-      status: response.status
-    });
-  }
-  if (response.body === null) {
-    throw gatewayError("transport", "Anthropic response arrived with no body", {
-      provider: "anthropic",
-      status: response.status
-    });
-  }
-  return response;
-}
-async function readErrorBody(response) {
-  try {
-    const text = await response.text();
-    return text === "" ? "" : `: ${text.slice(0, 500)}`;
-  } catch {
-    return "";
-  }
-}
-function asGatewayError(cause) {
-  if (cause instanceof Error && cause.name === "GatewayError") {
-    return cause;
-  }
-  return gatewayError("transport", "Anthropic stream failed", { provider: "anthropic", cause });
-}
-function createanthropicConnector(deps2) {
-  const api = "anthropic-messages";
-  async function requireKey(options) {
-    const key = await deps2.resolveSecret("anthropic", options.apiKey);
-    if (key === void 0 || key === "") {
-      throw gatewayError("auth", "no Anthropic API key found (set ANTHROPIC_API_KEY or pass options.apiKey)", {
-        provider: "anthropic"
-      });
-    }
-    return key;
-  }
-  function stream2(model, conversation, options) {
-    return channelOf(async function* run() {
-      const collected = [];
-      try {
-        const apiKey = await requireKey(options);
-        const body = toAnthropicRequest(conversation, model, options);
-        body.stream = true;
-        const response = await postMessages(endpointFor(model), apiKey, body, options.signal);
-        const wire = response.body;
-        const state = { toolIds: /* @__PURE__ */ new Map(), usage: { inputTokens: 0, outputTokens: 0 } };
-        for await (const event of sseEvents(wire, options.signal)) {
-          const payload = parseEventData(event, "anthropic");
-          if (payload === void 0) {
-            continue;
-          }
-          const type = event.event !== "message" ? event.event : readString(payload, "type") ?? event.event;
-          for (const emission of emitFromEvent(type, payload, state)) {
-            collected.push(emission);
-            yield emission;
-          }
-        }
-        const reply = foldReply(model.id, collected);
-        yield { kind: "done", reply };
-      } catch (cause) {
-        yield { kind: "error", error: asGatewayError(cause) };
-      }
-    });
-  }
-  function complete2(model, conversation, options) {
-    return collectReply(stream2(model, conversation, options));
-  }
-  return {
-    id: "anthropic",
-    api,
-    stream: stream2,
-    complete: complete2
-  };
-}
-
-// src/llmgateway/conversion/openai-compatible.ts
-function isObject2(v) {
-  return typeof v === "object" && v !== null;
-}
-function str(o, key) {
-  const v = o[key];
-  return typeof v === "string" ? v : void 0;
-}
-function num(o, key) {
-  const v = o[key];
-  return typeof v === "number" && Number.isFinite(v) ? v : void 0;
-}
-function mapFinishReason(reason) {
-  switch (reason) {
-    case "stop":
-      return "complete";
-    case "length":
-      return "max_output";
-    case "tool_calls":
-    case "function_call":
-      return "tool_calls";
-    case "content_filter":
-      return "refusal";
-    case null:
-    case void 0:
-    case "":
-      return void 0;
-    default:
-      return "complete";
-  }
-}
-function readUsage(chunk) {
-  const usage = chunk.usage;
-  if (!isObject2(usage)) {
-    return void 0;
-  }
-  const inputTokens = num(usage, "prompt_tokens") ?? 0;
-  const outputTokens = num(usage, "completion_tokens") ?? 0;
-  const result = { inputTokens, outputTokens };
-  const details = usage.prompt_tokens_details;
-  if (isObject2(details)) {
-    const cached = num(details, "cached_tokens");
-    if (cached !== void 0) {
-      result.cacheReadTokens = cached;
-    }
-  }
-  return result;
-}
-function buildBody(model, c, opts, cfg, stream2) {
-  const body = {
-    model: model.id,
-    messages: toOpenAIChatMessages(c),
-    stream: stream2
-  };
-  if (stream2) {
-    body.stream_options = { include_usage: true };
-  }
-  const tools = toOpenAITools(c.tools);
-  if (tools !== void 0) {
-    body.tools = tools;
-    const choice = toOpenAIToolChoice(opts.toolChoice);
-    if (choice !== void 0) {
-      body.tool_choice = choice;
-    }
-  }
-  const maxTokens = opts.maxOutputTokens ?? model.maxOutputTokens;
-  if (maxTokens > 0) {
-    body.max_tokens = maxTokens;
-  }
-  if (opts.temperature !== void 0) {
-    body.temperature = opts.temperature;
-  }
-  if (opts.topP !== void 0) {
-    body.top_p = opts.topP;
-  }
-  if (cfg.bodyExtra !== void 0) {
-    for (const [k, v] of Object.entries(cfg.bodyExtra)) {
-      body[k] = v;
-    }
-  }
-  return body;
-}
-async function postChat(cfg, body, provider, signal) {
-  const headers = { "content-type": "application/json", ...cfg.headers };
-  let response;
-  try {
-    response = await fetch(cfg.url, {
-      method: "POST",
-      headers,
-      body: JSON.stringify(body),
-      ...signal !== void 0 ? { signal } : {}
-    });
-  } catch (cause) {
-    if (signal?.aborted) {
-      throw gatewayError("aborted", "request aborted before a response arrived", { provider, cause });
-    }
-    throw gatewayError("transport", "network request to the provider failed", { provider, cause });
-  }
-  if (!response.ok) {
-    const detail = await readErrorBody2(response);
-    const kind = response.status === 401 || response.status === 403 ? "auth" : response.status === 429 ? "rate_limit" : "http";
-    throw gatewayError(kind, `provider returned HTTP ${response.status}${detail}`, {
-      provider,
-      status: response.status
-    });
-  }
-  if (response.body === null) {
-    throw gatewayError("transport", "provider response had no body", { provider, status: response.status });
-  }
-  return response;
-}
-async function readErrorBody2(response) {
-  try {
-    const text = await response.text();
-    return text === "" ? "" : `: ${text.slice(0, 500)}`;
-  } catch {
-    return "";
-  }
-}
-function* emitFromChunk(chunk, tracker) {
-  const usage = readUsage(chunk);
-  if (usage !== void 0) {
-    yield { kind: "usage", usage };
-  }
-  const choices = chunk.choices;
-  if (!Array.isArray(choices) || choices.length === 0) {
-    return;
-  }
-  const choice = choices[0];
-  if (!isObject2(choice)) {
-    return;
-  }
-  const delta = choice.delta;
-  if (isObject2(delta)) {
-    const content = str(delta, "content");
-    if (content !== void 0 && content !== "") {
-      yield { kind: "text", delta: content };
-    }
-    const reasoning = str(delta, "reasoning_content") ?? str(delta, "reasoning");
-    if (reasoning !== void 0 && reasoning !== "") {
-      yield { kind: "thinking", delta: reasoning };
-    }
-    const toolCalls = delta.tool_calls;
-    if (Array.isArray(toolCalls)) {
-      for (const tc of toolCalls) {
-        yield* emitToolCall(tc, tracker);
-      }
-    }
-  }
-  const finish = mapFinishReason(str(choice, "finish_reason"));
-  if (finish !== void 0) {
-    yield { kind: "stop", stop: finish };
-  }
-}
-function* emitToolCall(tc, tracker) {
-  if (!isObject2(tc)) {
-    return;
-  }
-  const index = num(tc, "index") ?? 0;
-  const explicitId = str(tc, "id");
-  const fn = tc.function;
-  const name = isObject2(fn) ? str(fn, "name") : void 0;
-  const args = isObject2(fn) ? str(fn, "arguments") : void 0;
-  let id = tracker.ids.get(index);
-  if (id === void 0) {
-    id = explicitId ?? `call_${index}`;
-    tracker.ids.set(index, id);
-    yield { kind: "tool_call_start", id, name: name ?? "" };
-  } else if (explicitId !== void 0 && explicitId !== id) {
-  }
-  if (args !== void 0 && args !== "") {
-    yield { kind: "tool_call_delta", id, argsDelta: args };
-  }
-}
-function streamOpenAICompatibleChat(cfg, model, c, opts) {
-  return channelOf(async function* run() {
-    const provider = model.provider;
-    const collected = [];
-    try {
-      const body = buildBody(model, c, opts, cfg, true);
-      const response = await postChat(cfg, body, provider, opts.signal);
-      const stream2 = response.body;
-      const tracker = { ids: /* @__PURE__ */ new Map() };
-      for await (const sse of sseEvents(stream2, opts.signal)) {
-        const payload = sse.data;
-        if (payload === "[DONE]") {
-          break;
-        }
-        let chunk;
-        try {
-          chunk = JSON.parse(payload);
-        } catch (cause) {
-          throw gatewayError("parse", "failed to parse an OpenAI stream chunk", { provider, cause });
-        }
-        if (!isObject2(chunk)) {
-          continue;
-        }
-        for (const emission of emitFromChunk(chunk, tracker)) {
-          collected.push(emission);
-          yield emission;
-        }
-      }
-      const reply = foldReply(model.id, collected);
-      yield { kind: "done", reply };
-    } catch (cause) {
-      const error = cause instanceof Error && cause.name === "GatewayError" ? cause : gatewayError("transport", "OpenAI-compatible stream failed", { provider, cause });
-      yield { kind: "error", error };
-    }
-  });
-}
-
-// src/llmgateway/connectors/openai-chat.ts
-var DEFAULT_OPENAI_BASE_URL = "https://api.openai.com/v1";
-function endpointFor2(model) {
-  const base = (model.baseUrl ?? DEFAULT_OPENAI_BASE_URL).replace(/\/+$/, "");
-  return `${base}/chat/completions`;
-}
-var OpenAIChatConnector = class {
-  constructor(deps2) {
-    this.deps = deps2;
-  }
-  deps;
-  id = "openai-chat";
-  api = "openai-completions";
-  stream(model, conversation, options) {
-    const deps2 = this.deps;
-    return channelOf(async function* run() {
-      let cfg;
-      try {
-        cfg = await resolveConfig(deps2, model, options);
-      } catch (cause) {
-        const error = cause instanceof Error && cause.name === "GatewayError" ? cause : gatewayError("auth", "could not prepare the OpenAI request", {
-          provider: model.provider,
-          cause
-        });
-        yield { kind: "error", error };
-        return;
-      }
-      yield* streamOpenAICompatibleChat(cfg, model, conversation, options);
-    });
-  }
-  async complete(model, conversation, options) {
-    return collectReply(this.stream(model, conversation, options));
-  }
-};
-async function resolveConfig(deps2, model, options) {
-  const key = await deps2.resolveSecret(model.provider, options.apiKey);
-  if (key === void 0 || key === "") {
-    throw gatewayError(
-      "auth",
-      "no OpenAI credential found \u2014 set OPENAI_API_KEY or pass options.apiKey",
-      { provider: model.provider }
-    );
-  }
-  return {
-    url: endpointFor2(model),
-    headers: { authorization: `Bearer ${key}` }
-  };
-}
-function createopenaichatConnector(deps2) {
-  return new OpenAIChatConnector(deps2);
-}
-
-// src/llmgateway/connectors/openai-responses.ts
-var DEFAULT_ORIGIN = "https://api.openai.com/v1";
-function isObject3(v) {
-  return typeof v === "object" && v !== null && !Array.isArray(v);
-}
-function readString2(o, key) {
-  const v = o[key];
-  return typeof v === "string" ? v : void 0;
-}
-function readNumber2(o, key) {
-  const v = o[key];
-  return typeof v === "number" && Number.isFinite(v) ? v : void 0;
-}
-function reasoningEffort(level) {
-  switch (level) {
-    case "low":
-      return "low";
-    case "medium":
-      return "medium";
-    case "high":
-    case "max":
-      return "high";
-  }
-}
-function mapStatus(status, incompleteReason) {
-  switch (status) {
-    case "completed":
-      return "complete";
-    case "incomplete":
-      return incompleteReason === "max_output_tokens" ? "max_output" : "complete";
-    case "failed":
-    case "cancelled":
-      return "error";
-    default:
-      return "complete";
-  }
-}
-function joinUrl(origin, path) {
-  return origin.endsWith("/") ? origin.slice(0, -1) + path : origin + path;
-}
-function buildBody2(model, c, opts) {
-  const body = {
-    model: model.id,
-    input: toResponsesInput(c),
-    stream: true
-  };
-  if (c.system !== void 0 && c.system !== "") {
-    body.instructions = c.system;
-  }
-  const tools = toResponsesTools(c.tools);
-  if (tools !== void 0) {
-    body.tools = tools;
-    if (opts.toolChoice !== void 0) {
-      body.tool_choice = opts.toolChoice;
-    }
-  }
-  const ceiling = opts.maxOutputTokens ?? model.maxOutputTokens;
-  if (ceiling > 0) {
-    body.max_output_tokens = ceiling;
-  }
-  if (opts.temperature !== void 0) {
-    body.temperature = opts.temperature;
-  }
-  if (opts.topP !== void 0) {
-    body.top_p = opts.topP;
-  }
-  if (model.reasoning && opts.thinking !== void 0 && opts.thinking !== "off") {
-    body.reasoning = { effort: reasoningEffort(opts.thinking) };
-  }
-  return body;
-}
-async function postResponses(url, apiKey, body, provider, signal) {
-  let response;
-  try {
-    response = await fetch(url, {
-      method: "POST",
-      headers: {
-        "content-type": "application/json",
-        authorization: `Bearer ${apiKey}`
-      },
-      body: JSON.stringify(body),
-      ...signal !== void 0 ? { signal } : {}
-    });
-  } catch (cause) {
-    if (signal?.aborted) {
-      throw gatewayError("aborted", "the Responses request was cancelled before a reply arrived", {
-        provider,
-        cause
-      });
-    }
-    throw gatewayError("transport", "could not reach the OpenAI Responses endpoint", { provider, cause });
-  }
-  if (!response.ok) {
-    const detail = await describeFailure(response);
-    const kind = response.status === 401 || response.status === 403 ? "auth" : response.status === 429 ? "rate_limit" : "http";
-    throw gatewayError(kind, `OpenAI Responses replied with HTTP ${response.status}${detail}`, {
-      provider,
-      status: response.status
-    });
-  }
-  if (response.body === null) {
-    throw gatewayError("transport", "OpenAI Responses returned an empty body", {
-      provider,
-      status: response.status
-    });
-  }
-  return response;
-}
-async function describeFailure(response) {
-  try {
-    const text = await response.text();
-    return text === "" ? "" : ` \u2014 ${text.slice(0, 500)}`;
-  } catch {
-    return "";
-  }
-}
-function extractUsage(response) {
-  const usage = response.usage;
-  if (!isObject3(usage)) {
-    return void 0;
-  }
-  const inputTokens = readNumber2(usage, "input_tokens") ?? 0;
-  const outputTokens = readNumber2(usage, "output_tokens") ?? 0;
-  const result = { inputTokens, outputTokens };
-  const inputDetails = usage.input_tokens_details;
-  if (isObject3(inputDetails)) {
-    const cached = readNumber2(inputDetails, "cached_tokens");
-    if (cached !== void 0) {
-      result.cacheReadTokens = cached;
-    }
-  }
-  return result;
-}
-function* translateEvent(payload, calls) {
-  const type = readString2(payload, "type");
-  switch (type) {
-    case "response.output_text.delta": {
-      const delta = readString2(payload, "delta");
-      if (delta !== void 0 && delta !== "") {
-        yield { kind: "text", delta };
-      }
-      return;
-    }
-    case "response.reasoning_summary_text.delta":
-    case "response.reasoning_text.delta": {
-      const delta = readString2(payload, "delta");
-      if (delta !== void 0 && delta !== "") {
-        yield { kind: "thinking", delta };
-      }
-      return;
-    }
-    case "response.output_item.added": {
-      yield* announceItem(payload, calls);
-      return;
-    }
-    case "response.function_call_arguments.delta": {
-      const itemId = readString2(payload, "item_id");
-      const delta = readString2(payload, "delta");
-      if (itemId === void 0 || delta === void 0 || delta === "") {
-        return;
-      }
-      const id = calls.byItem.get(itemId) ?? itemId;
-      yield { kind: "tool_call_delta", id, argsDelta: delta };
-      return;
-    }
-    case "response.completed":
-    case "response.incomplete":
-    case "response.failed": {
-      yield* finishResponse(payload);
-      return;
-    }
-    default:
-      return;
-  }
-}
-function* announceItem(payload, calls) {
-  const item = payload.item;
-  if (!isObject3(item)) {
-    return;
-  }
-  if (readString2(item, "type") !== "function_call") {
-    return;
-  }
-  const name = readString2(item, "name") ?? "";
-  const callId = readString2(item, "call_id") ?? readString2(item, "id") ?? `call_${calls.byItem.size}`;
-  const itemId = readString2(item, "id");
-  if (itemId !== void 0) {
-    calls.byItem.set(itemId, callId);
-  }
-  yield { kind: "tool_call_start", id: callId, name };
-}
-function* finishResponse(payload) {
-  const response = isObject3(payload.response) ? payload.response : payload;
-  const usage = extractUsage(response);
-  if (usage !== void 0) {
-    yield { kind: "usage", usage };
-  }
-  const status = readString2(response, "status");
-  const incomplete = isObject3(response.incomplete_details) ? readString2(response.incomplete_details, "reason") : void 0;
-  yield { kind: "stop", stop: mapStatus(status, incomplete) };
-}
-function createopenairesponsesConnector(deps2) {
-  const { resolveSecret: resolveSecret2 } = deps2;
-  const stream2 = (model, conversation, options) => {
-    return channelOf(async function* run() {
-      const provider = model.provider;
-      const collected = [];
-      try {
-        const apiKey = await resolveSecret2(provider, options.apiKey);
-        if (apiKey === void 0 || apiKey === "") {
-          throw gatewayError("auth", "no OpenAI API key was found for the Responses endpoint", { provider });
-        }
-        const origin = model.baseUrl ?? DEFAULT_ORIGIN;
-        const url = joinUrl(origin, "/responses");
-        const body = buildBody2(model, conversation, options);
-        const response = await postResponses(url, apiKey, body, provider, options.signal);
-        const wire = response.body;
-        const calls = { byItem: /* @__PURE__ */ new Map() };
-        for await (const sse of sseEvents(wire, options.signal)) {
-          const raw = sse.data;
-          if (raw === "" || raw === "[DONE]") {
-            continue;
-          }
-          let payload;
-          try {
-            payload = JSON.parse(raw);
-          } catch (cause) {
-            throw gatewayError("parse", "could not parse an OpenAI Responses stream event", {
-              provider,
-              cause
-            });
-          }
-          if (!isObject3(payload)) {
-            continue;
-          }
-          for (const emission of translateEvent(payload, calls)) {
-            collected.push(emission);
-            yield emission;
-          }
-        }
-        yield { kind: "done", reply: foldReply(model.id, collected) };
-      } catch (cause) {
-        const error = cause instanceof Error && cause.name === "GatewayError" ? cause : gatewayError("transport", "the OpenAI Responses stream failed", { provider, cause });
-        yield { kind: "error", error };
-      }
-    });
-  };
-  const complete2 = (model, conversation, options) => {
-    return collectReply(stream2(model, conversation, options));
-  };
-  return {
-    id: "openai-responses",
-    api: "openai-responses",
-    stream: stream2,
-    complete: complete2
-  };
-}
-
-// src/llmgateway/streaming/ndjson.ts
-async function* ndjsonLines(body, signal) {
-  if (signal?.aborted) {
-    throw gatewayError("aborted", "request aborted before reading the ndjson stream");
-  }
-  const reader = body.getReader();
-  const decoder = new TextDecoder("utf-8");
-  let pending = "";
-  const onAbort = () => {
-    void reader.cancel().catch(() => {
-    });
-  };
-  signal?.addEventListener("abort", onAbort, { once: true });
-  const parseLine = (raw) => {
-    const line = raw.endsWith("\r") ? raw.slice(0, -1) : raw;
-    const trimmed = line.trim();
-    if (trimmed === "") {
-      return void 0;
-    }
-    try {
-      return JSON.parse(trimmed);
-    } catch (cause) {
-      throw gatewayError("parse", "failed to parse an ndjson line as JSON", { cause });
-    }
-  };
-  try {
-    for (; ; ) {
-      if (signal?.aborted) {
-        throw gatewayError("aborted", "request aborted while reading the ndjson stream");
-      }
-      const { value, done } = await reader.read();
-      if (done) {
-        break;
-      }
-      pending += decoder.decode(value, { stream: true });
-      let nl = pending.indexOf("\n");
-      while (nl !== -1) {
-        const raw = pending.slice(0, nl);
-        pending = pending.slice(nl + 1);
-        const parsed = parseLine(raw);
-        if (parsed !== void 0) {
-          yield parsed;
-        }
-        nl = pending.indexOf("\n");
-      }
-    }
-    pending += decoder.decode();
-    const tail = parseLine(pending);
-    if (tail !== void 0) {
-      yield tail;
-    }
-  } catch (cause) {
-    if (signal?.aborted) {
-      throw gatewayError("aborted", "request aborted while reading the ndjson stream", { cause });
-    }
-    if (cause instanceof Error && cause.name === "GatewayError") {
-      throw cause;
-    }
-    throw gatewayError("transport", "failed reading the ndjson stream", { cause });
-  } finally {
-    signal?.removeEventListener("abort", onAbort);
-    reader.releaseLock();
-  }
-}
-
-// src/llmgateway/connectors/google.ts
-var DEFAULT_BASE_URL2 = "https://generativelanguage.googleapis.com";
-var PROVIDER = "google";
-function isObject4(value) {
-  return typeof value === "object" && value !== null;
-}
-function readString3(o, key) {
-  const v = o[key];
-  return typeof v === "string" ? v : void 0;
-}
-function readNumber3(o, key) {
-  const v = o[key];
-  return typeof v === "number" && Number.isFinite(v) ? v : void 0;
-}
-function geminiThinkingBudget(level, maxOutput) {
-  const fraction = {
-    low: 0.2,
-    medium: 0.4,
-    high: 0.6,
-    max: 0.8
-  };
-  const budget = Math.floor(maxOutput * fraction[level]);
-  return Math.max(1024, budget);
-}
-function buildGenerationConfig(model, opts) {
-  const maxOutputTokens = opts.maxOutputTokens ?? model.maxOutputTokens;
-  const config = { maxOutputTokens };
-  if (opts.temperature !== void 0) {
-    config.temperature = opts.temperature;
-  }
-  if (opts.topP !== void 0) {
-    config.topP = opts.topP;
-  }
-  if (model.reasoning && opts.thinking !== void 0 && opts.thinking !== "off") {
-    config.thinkingConfig = {
-      includeThoughts: true,
-      thinkingBudget: geminiThinkingBudget(opts.thinking, maxOutputTokens)
-    };
-  }
-  return config;
-}
-function buildRequestBody(model, conversation, opts) {
-  const body = {
-    contents: toGoogleContents(conversation),
-    generationConfig: buildGenerationConfig(model, opts)
-  };
-  const systemInstruction = toGoogleSystemInstruction(conversation);
-  if (systemInstruction !== void 0) {
-    body.systemInstruction = systemInstruction;
-  }
-  const tools = toGoogleTools(conversation.tools);
-  if (tools !== void 0) {
-    body.tools = tools;
-  }
-  return body;
-}
-function streamEndpoint(model) {
-  const base = (model.baseUrl ?? DEFAULT_BASE_URL2).replace(/\/+$/u, "");
-  return `${base}/v1beta/models/${model.id}:streamGenerateContent?alt=sse`;
-}
-async function openStream(url, apiKey, body, signal) {
-  let response;
-  try {
-    response = await fetch(url, {
-      method: "POST",
-      headers: {
-        "content-type": "application/json",
-        "x-goog-api-key": apiKey
-      },
-      body: JSON.stringify(body),
-      ...signal !== void 0 ? { signal } : {}
-    });
-  } catch (cause) {
-    if (signal?.aborted) {
-      throw gatewayError("aborted", "the Gemini request was aborted before a response arrived", {
-        provider: PROVIDER,
-        cause
-      });
-    }
-    throw gatewayError("transport", "could not reach the Gemini endpoint", {
-      provider: PROVIDER,
-      cause
-    });
-  }
-  if (!response.ok) {
-    const detail = await readErrorDetail(response);
-    const kind = response.status === 401 || response.status === 403 ? "auth" : response.status === 429 ? "rate_limit" : "http";
-    throw gatewayError(kind, `Gemini replied with HTTP ${response.status}${detail}`, {
-      provider: PROVIDER,
-      status: response.status
-    });
-  }
-  if (response.body === null) {
-    throw gatewayError("transport", "the Gemini response carried no body to stream", {
-      provider: PROVIDER,
-      status: response.status
-    });
-  }
-  return response;
-}
-async function readErrorDetail(response) {
-  try {
-    const text = await response.text();
-    return text === "" ? "" : `: ${text.slice(0, 500)}`;
-  } catch {
-    return "";
-  }
-}
-function mapFinishReason2(reason) {
-  switch (reason) {
-    case "STOP":
-      return "complete";
-    case "MAX_TOKENS":
-      return "max_output";
-    case "SAFETY":
-    case "RECITATION":
-    case "BLOCKLIST":
-    case "PROHIBITED_CONTENT":
-    case "SPII":
-      return "refusal";
-    case void 0:
-    case "":
-    case "FINISH_REASON_UNSPECIFIED":
-    case "OTHER":
-      return void 0;
-    default:
-      return "complete";
-  }
-}
-function readUsage2(frame) {
-  const meta = frame.usageMetadata;
-  if (!isObject4(meta)) {
-    return void 0;
-  }
-  const inputTokens = readNumber3(meta, "promptTokenCount") ?? 0;
-  const outputTokens = readNumber3(meta, "candidatesTokenCount") ?? 0;
-  const usage = { inputTokens, outputTokens };
-  const cachedRead = readNumber3(meta, "cachedContentTokenCount");
-  if (cachedRead !== void 0) {
-    usage.cacheReadTokens = cachedRead;
-  }
-  return usage;
-}
-function* emitFromParts(parts, tracker) {
-  for (const part of parts) {
-    if (!isObject4(part)) {
-      continue;
-    }
-    const text = readString3(part, "text");
-    if (text !== void 0 && text !== "") {
-      if (part.thought === true) {
-        yield { kind: "thinking", delta: text };
-      } else {
-        yield { kind: "text", delta: text };
-      }
-      continue;
-    }
-    const functionCall = part.functionCall;
-    if (isObject4(functionCall)) {
-      const name = readString3(functionCall, "name") ?? "";
-      const id = `gemini_call_${tracker.next}`;
-      tracker.next += 1;
-      yield { kind: "tool_call_start", id, name };
-      const args = "args" in functionCall ? functionCall.args : {};
-      yield { kind: "tool_call_delta", id, argsDelta: serializeArgs(args) };
-    }
-  }
-}
-function serializeArgs(args) {
-  if (typeof args === "string") {
-    return args;
-  }
-  try {
-    return JSON.stringify(args ?? {});
-  } catch {
-    return "{}";
-  }
-}
-function* emitFromFrame(frame, tracker) {
-  const usage = readUsage2(frame);
-  if (usage !== void 0) {
-    yield { kind: "usage", usage };
-  }
-  const candidates = frame.candidates;
-  if (!Array.isArray(candidates) || candidates.length === 0) {
-    return;
-  }
-  const candidate = candidates[0];
-  if (!isObject4(candidate)) {
-    return;
-  }
-  const content = candidate.content;
-  if (isObject4(content) && Array.isArray(content.parts)) {
-    yield* emitFromParts(content.parts, tracker);
-  }
-  const stop = mapFinishReason2(readString3(candidate, "finishReason"));
-  if (stop !== void 0) {
-    yield { kind: "stop", stop };
-  }
-}
-function creategoogleConnector(deps2) {
-  const { resolveSecret: resolveSecret2 } = deps2;
-  return {
-    id: "google-generative",
-    api: "google-generative",
-    stream(model, conversation, options) {
-      return channelOf(async function* run() {
-        const collected = [];
-        try {
-          const apiKey = await resolveSecret2(PROVIDER, options.apiKey);
-          if (apiKey === void 0 || apiKey === "") {
-            throw gatewayError("auth", "no Gemini API key was found (set GEMINI_API_KEY or pass apiKey)", {
-              provider: PROVIDER
-            });
-          }
-          const url = streamEndpoint(model);
-          const body = buildRequestBody(model, conversation, options);
-          const response = await openStream(url, apiKey, body, options.signal);
-          const wire = response.body;
-          const tracker = { next: 0 };
-          for await (const event of sseEvents(wire, options.signal)) {
-            const payload = event.data;
-            if (payload === "" || payload === "[DONE]") {
-              continue;
-            }
-            let frame;
-            try {
-              frame = JSON.parse(payload);
-            } catch (cause) {
-              throw gatewayError("parse", "could not parse a Gemini stream frame", {
-                provider: PROVIDER,
-                cause
-              });
-            }
-            if (!isObject4(frame)) {
-              continue;
-            }
-            for (const emission of emitFromFrame(frame, tracker)) {
-              collected.push(emission);
-              yield emission;
-            }
-          }
-          const reply = foldReply(model.id, collected);
-          yield { kind: "done", reply };
-        } catch (cause) {
-          const error = cause instanceof Error && cause.name === "GatewayError" ? cause : gatewayError("transport", "the Gemini stream failed", { provider: PROVIDER, cause });
-          yield { kind: "error", error };
-        }
-      });
-    },
-    complete(model, conversation, options) {
-      return collectReply(this.stream(model, conversation, options));
-    }
-  };
-}
-
-// src/llmgateway/connectors/google-vertex.ts
-var PROVIDER2 = "google-vertex";
-var API_KIND = "google-vertex";
-var DEFAULT_LOCATION = "us-central1";
-var defaultBaseUrl = (location) => `https://${location}-aiplatform.googleapis.com`;
-function envValue(name) {
-  const raw = process.env[name];
-  if (raw === void 0) {
-    return void 0;
-  }
-  const trimmed = raw.trim();
-  return trimmed.length > 0 ? trimmed : void 0;
-}
-function firstEnv(names) {
-  for (const name of names) {
-    const value = envValue(name);
-    if (value !== void 0) {
-      return value;
-    }
-  }
-  return void 0;
-}
-function resolveTarget(model) {
-  const project = firstEnv(["GOOGLE_VERTEX_PROJECT", "GOOGLE_CLOUD_PROJECT"]);
-  if (project === void 0) {
-    throw gatewayError(
-      "auth",
-      "no Vertex project found; set GOOGLE_VERTEX_PROJECT or GOOGLE_CLOUD_PROJECT",
-      { provider: PROVIDER2 }
-    );
-  }
-  const location = firstEnv(["GOOGLE_VERTEX_LOCATION", "CLOUD_ML_REGION"]) ?? DEFAULT_LOCATION;
-  const host = (model.baseUrl ?? defaultBaseUrl(location)).replace(/\/+$/, "");
-  const url = `${host}/v1/projects/${encodeURIComponent(project)}/locations/${encodeURIComponent(location)}/publishers/google/models/${encodeURIComponent(model.id)}:streamGenerateContent?alt=sse`;
-  return { project, location, url };
-}
-function toFunctionCallingConfig(choice) {
-  switch (choice) {
-    case "auto":
-      return { functionCallingConfig: { mode: "AUTO" } };
-    case "required":
-      return { functionCallingConfig: { mode: "ANY" } };
-    case "none":
-      return { functionCallingConfig: { mode: "NONE" } };
-    default:
-      return void 0;
-  }
-}
-function thinkingBudget(level, maxOutput) {
-  if (level === void 0 || level === "off") {
-    return void 0;
-  }
-  const fraction = {
-    low: 0.2,
-    medium: 0.4,
-    high: 0.6,
-    max: 0.8
-  };
-  return Math.max(0, Math.floor(maxOutput * fraction[level]));
-}
-function buildBody3(model, c, opts) {
-  const body = {
-    contents: toGoogleContents(c)
-  };
-  const systemInstruction = toGoogleSystemInstruction(c);
-  if (systemInstruction !== void 0) {
-    body.systemInstruction = systemInstruction;
-  }
-  const tools = toGoogleTools(c.tools);
-  if (tools !== void 0) {
-    body.tools = tools;
-    const toolConfig = toFunctionCallingConfig(opts.toolChoice);
-    if (toolConfig !== void 0) {
-      body.toolConfig = toolConfig;
-    }
-  }
-  const generationConfig = {};
-  const maxTokens = opts.maxOutputTokens ?? model.maxOutputTokens;
-  if (maxTokens > 0) {
-    generationConfig.maxOutputTokens = maxTokens;
-  }
-  if (opts.temperature !== void 0) {
-    generationConfig.temperature = opts.temperature;
-  }
-  if (opts.topP !== void 0) {
-    generationConfig.topP = opts.topP;
-  }
-  if (model.reasoning) {
-    const budget = thinkingBudget(opts.thinking, maxTokens);
-    if (budget !== void 0) {
-      generationConfig.thinkingConfig = { thinkingBudget: budget };
-    }
-  }
-  if (Object.keys(generationConfig).length > 0) {
-    body.generationConfig = generationConfig;
-  }
-  return body;
-}
-function isObject5(v) {
-  return typeof v === "object" && v !== null;
-}
-function readString4(o, key) {
-  const v = o[key];
-  return typeof v === "string" ? v : void 0;
-}
-function readNumber4(o, key) {
-  const v = o[key];
-  return typeof v === "number" && Number.isFinite(v) ? v : void 0;
-}
-function readBool(o, key) {
-  return o[key] === true;
-}
-function mapFinishReason3(reason) {
-  switch (reason) {
-    case void 0:
-    case "":
-    case "FINISH_REASON_UNSPECIFIED":
-      return void 0;
-    case "STOP":
-      return "complete";
-    case "MAX_TOKENS":
-      return "max_output";
-    case "SAFETY":
-    case "RECITATION":
-    case "BLOCKLIST":
-    case "PROHIBITED_CONTENT":
-    case "SPII":
-      return "refusal";
-    default:
-      return "complete";
-  }
-}
-function readUsage3(chunk) {
-  const meta = chunk.usageMetadata;
-  if (!isObject5(meta)) {
-    return void 0;
-  }
-  const inputTokens = readNumber4(meta, "promptTokenCount") ?? 0;
-  const candidate = readNumber4(meta, "candidatesTokenCount") ?? 0;
-  const thoughts = readNumber4(meta, "thoughtsTokenCount") ?? 0;
-  const result = {
-    inputTokens,
-    outputTokens: candidate + thoughts
-  };
-  const cached = readNumber4(meta, "cachedContentTokenCount");
-  if (cached !== void 0) {
-    result.cacheReadTokens = cached;
-  }
-  return result;
-}
-function* emitFromChunk2(chunk, tracker) {
-  const usage = readUsage3(chunk);
-  if (usage !== void 0) {
-    yield { kind: "usage", usage };
-  }
-  const candidates = chunk.candidates;
-  if (!Array.isArray(candidates) || candidates.length === 0) {
-    return;
-  }
-  const candidate = candidates[0];
-  if (!isObject5(candidate)) {
-    return;
-  }
-  const content = candidate.content;
-  if (isObject5(content)) {
-    const parts = content.parts;
-    if (Array.isArray(parts)) {
-      for (const part of parts) {
-        yield* emitFromPart(part, tracker);
-      }
-    }
-  }
-  const finish = mapFinishReason3(readString4(candidate, "finishReason"));
-  if (finish !== void 0) {
-    yield { kind: "stop", stop: finish };
-  }
-}
-function* emitFromPart(part, tracker) {
-  if (!isObject5(part)) {
-    return;
-  }
-  const functionCall = part.functionCall;
-  if (isObject5(functionCall)) {
-    const name = readString4(functionCall, "name") ?? "";
-    const id = `vertex_call_${tracker.next}`;
-    tracker.next += 1;
-    yield { kind: "tool_call_start", id, name };
-    const args = functionCall.args;
-    const argsDelta = serializeArgs2(args);
-    if (argsDelta !== "") {
-      yield { kind: "tool_call_delta", id, argsDelta };
-    }
-    return;
-  }
-  const text = readString4(part, "text");
-  if (text !== void 0 && text !== "") {
-    if (readBool(part, "thought")) {
-      yield { kind: "thinking", delta: text };
-    } else {
-      yield { kind: "text", delta: text };
-    }
-  }
-}
-function serializeArgs2(args) {
-  if (args === void 0 || args === null) {
-    return "";
-  }
-  if (typeof args === "string") {
-    return args;
-  }
-  try {
-    return JSON.stringify(args);
-  } catch {
-    return "";
-  }
-}
-async function postStream(url, token, body, signal) {
-  let response;
-  try {
-    response = await fetch(url, {
-      method: "POST",
-      headers: {
-        "content-type": "application/json",
-        authorization: `Bearer ${token}`
-      },
-      body: JSON.stringify(body),
-      ...signal !== void 0 ? { signal } : {}
-    });
-  } catch (cause) {
-    if (signal?.aborted) {
-      throw gatewayError("aborted", "Vertex request was aborted before a response arrived", {
-        provider: PROVIDER2,
-        cause
-      });
-    }
-    throw gatewayError("transport", "network request to Vertex AI failed", {
-      provider: PROVIDER2,
-      cause
-    });
-  }
-  if (!response.ok) {
-    const detail = await readErrorBody3(response);
-    const kind = response.status === 401 || response.status === 403 ? "auth" : response.status === 429 ? "rate_limit" : "http";
-    throw gatewayError(kind, `Vertex AI returned HTTP ${response.status}${detail}`, {
-      provider: PROVIDER2,
-      status: response.status
-    });
-  }
-  if (response.body === null) {
-    throw gatewayError("transport", "Vertex AI response carried no body", {
-      provider: PROVIDER2,
-      status: response.status
-    });
-  }
-  return response;
-}
-async function readErrorBody3(response) {
-  try {
-    const text = await response.text();
-    return text === "" ? "" : `: ${text.slice(0, 500)}`;
-  } catch {
-    return "";
-  }
-}
-function creategooglevertexConnector(deps2) {
-  const { resolveSecret: resolveSecret2 } = deps2;
-  function stream2(model, conversation, options) {
-    return channelOf(async function* run() {
-      const collected = [];
-      try {
-        const token = await resolveSecret2(PROVIDER2, options.apiKey);
-        if (token === void 0 || token === "") {
-          throw gatewayError(
-            "auth",
-            "no Google access token available for Vertex AI; provide one via apiKey or the environment",
-            { provider: PROVIDER2 }
-          );
-        }
-        const target = resolveTarget(model);
-        const body = buildBody3(model, conversation, options);
-        const response = await postStream(target.url, token, body, options.signal);
-        const sseBody = response.body;
-        const tracker = { next: 0 };
-        for await (const event of sseEvents(sseBody, options.signal)) {
-          const payload = event.data;
-          if (payload === "" || payload === "[DONE]") {
-            continue;
-          }
-          let chunk;
-          try {
-            chunk = JSON.parse(payload);
-          } catch (cause) {
-            throw gatewayError("parse", "failed to parse a Vertex AI stream chunk", {
-              provider: PROVIDER2,
-              cause
-            });
-          }
-          if (!isObject5(chunk)) {
-            continue;
-          }
-          for (const emission of emitFromChunk2(chunk, tracker)) {
-            collected.push(emission);
-            yield emission;
-          }
-        }
-        yield { kind: "done", reply: foldReply(model.id, collected) };
-      } catch (cause) {
-        const error = cause instanceof Error && cause.name === "GatewayError" ? cause : gatewayError("transport", "Vertex AI stream failed", { provider: PROVIDER2, cause });
-        yield { kind: "error", error };
-      }
-    });
-  }
-  function complete2(model, conversation, options) {
-    return collectReply(stream2(model, conversation, options));
-  }
-  return {
-    id: "google-vertex",
-    api: API_KIND,
-    stream: stream2,
-    complete: complete2
-  };
-}
-
-// src/llmgateway/connectors/bedrock.ts
-var PROVIDER3 = "amazon";
-var DIALECT = "amazon-bedrock";
-var FALLBACK_REGION = "us-east-1";
-function discoverRegion() {
-  const env = (typeof process !== "undefined" ? process.env : void 0) ?? {};
-  const region = env.AWS_REGION ?? env.AWS_DEFAULT_REGION ?? env.AWS_BEDROCK_REGION;
-  const trimmed = region?.trim();
-  return trimmed !== void 0 && trimmed !== "" ? trimmed : void 0;
-}
-function converseStreamUrl(model, region) {
-  const base = model.baseUrl !== void 0 && model.baseUrl !== "" ? model.baseUrl.replace(/\/+$/, "") : `https://bedrock-runtime.${region}.amazonaws.com`;
-  return `${base}/model/${encodeURIComponent(model.id)}/converse-stream`;
-}
-function stringifyOutput(output) {
-  if (typeof output === "string") {
-    return output;
-  }
-  try {
-    return JSON.stringify(output);
-  } catch {
-    return String(output);
-  }
-}
-function toJsonInput(input) {
-  if (input !== null && typeof input === "object" && !Array.isArray(input)) {
-    return input;
-  }
-  if (typeof input === "string") {
-    try {
-      const parsed = JSON.parse(input);
-      if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
-        return parsed;
-      }
-    } catch {
-    }
-  }
-  return { value: input };
-}
-function toContentBlocks(block) {
-  switch (block.kind) {
-    case "text":
-      return [{ text: block.text }];
-    case "thinking":
-      return [
-        {
-          reasoningContent: {
-            reasoningText: block.signature !== void 0 ? { text: block.text, signature: block.signature } : { text: block.text }
-          }
-        }
-      ];
-    case "image": {
-      const slash = block.mediaType.indexOf("/");
-      const format = slash >= 0 ? block.mediaType.slice(slash + 1) : block.mediaType;
-      return [
-        {
-          image: {
-            format,
-            source: { bytes: block.dataBase64 }
-          }
-        }
-      ];
-    }
-    case "tool_call":
-      return [
-        {
-          toolUse: {
-            toolUseId: block.id,
-            name: block.name,
-            input: toJsonInput(block.input)
-          }
-        }
-      ];
-    case "tool_result":
-      return [
-        {
-          toolResult: {
-            toolUseId: block.callId,
-            content: [{ text: stringifyOutput(block.output) }],
-            ...block.isError === true ? { status: "error" } : {}
-          }
-        }
-      ];
-    case "command": {
-      const argv = block.args && block.args.length > 0 ? ` ${block.args.join(" ")}` : "";
-      return [{ text: `$ ${block.command}${argv}` }];
-    }
-  }
-}
-function converseRole(turn) {
-  return turn.role === "assistant" ? "assistant" : "user";
-}
-function toConverseMessages(conversation) {
-  const messages = [];
-  for (const turn of conversation.turns) {
-    const content = [];
-    for (const block of turn.blocks) {
-      for (const wire of toContentBlocks(block)) {
-        content.push(wire);
-      }
-    }
-    if (content.length > 0) {
-      messages.push({ role: converseRole(turn), content });
-    }
-  }
-  return messages;
-}
-function toConverseSystem(conversation) {
-  if (conversation.system === void 0 || conversation.system === "") {
-    return void 0;
-  }
-  return [{ text: conversation.system }];
-}
-function toConverseTools(tools) {
-  if (tools === void 0 || tools.length === 0) {
-    return void 0;
-  }
-  return tools.map((tool) => ({
-    toolSpec: {
-      name: tool.name,
-      description: tool.description,
-      inputSchema: { json: tool.parameters }
-    }
-  }));
-}
-function toConverseToolChoice(options) {
-  switch (options.toolChoice) {
-    case "auto":
-      return { auto: {} };
-    case "required":
-      return { any: {} };
-    case "none":
-    case void 0:
-      return void 0;
-  }
-}
-function toInferenceConfig(model, options) {
-  const config = {
-    maxTokens: options.maxOutputTokens ?? model.maxOutputTokens
-  };
-  if (options.temperature !== void 0) {
-    config.temperature = options.temperature;
-  }
-  if (options.topP !== void 0) {
-    config.topP = options.topP;
-  }
-  return config;
-}
-function buildConverseBody(model, conversation, options) {
-  const body = {
-    messages: toConverseMessages(conversation),
-    inferenceConfig: toInferenceConfig(model, options)
-  };
-  const system = toConverseSystem(conversation);
-  if (system !== void 0) {
-    body.system = system;
-  }
-  const tools = toConverseTools(conversation.tools);
-  if (tools !== void 0) {
-    const toolConfig = { tools };
-    const choice = toConverseToolChoice(options);
-    if (choice !== void 0) {
-      toolConfig.toolChoice = choice;
-    }
-    body.toolConfig = toolConfig;
-  }
-  return body;
-}
-async function requireSignedTransport(resolveSecret2, options) {
-  const credential = await resolveSecret2(PROVIDER3, options.apiKey);
-  const region = discoverRegion() ?? FALLBACK_REGION;
-  void credential;
-  void region;
-  throw gatewayError(
-    "unsupported",
-    "bedrock streaming requires SigV4 (todo)",
-    { provider: PROVIDER3 }
-  );
-}
-function createbedrockConnector(deps2) {
-  const { resolveSecret: resolveSecret2 } = deps2;
-  return {
-    id: "bedrock",
-    api: DIALECT,
-    stream(model, conversation, options) {
-      return channelOf(async function* () {
-        const region = discoverRegion() ?? FALLBACK_REGION;
-        const url = converseStreamUrl(model, region);
-        const body = buildConverseBody(model, conversation, options);
-        void url;
-        void body;
-        await requireSignedTransport(resolveSecret2, options);
-      });
-    },
-    complete(model, conversation, options) {
-      return collectReply(this.stream(model, conversation, options));
-    }
-  };
-}
-
-// src/llmgateway/connectors/azure-openai.ts
-var AZURE_API_VERSION = "2024-08-01-preview";
-function deploymentName(model) {
-  const id = model.id.trim();
-  if (id === "") {
-    throw gatewayError(
-      "unsupported",
-      "azure card is missing an id to use as the deployment name",
-      { provider: model.provider }
-    );
-  }
-  return id;
-}
-function endpointFor3(model) {
-  const base = model.baseUrl?.replace(/\/+$/, "");
-  if (base === void 0 || base === "") {
-    throw gatewayError(
-      "unsupported",
-      "azure card has no baseUrl; set it to the resource endpoint, e.g. https://<resource>.openai.azure.com",
-      { provider: model.provider }
-    );
-  }
-  const deployment = encodeURIComponent(deploymentName(model));
-  const query = new URLSearchParams({ "api-version": AZURE_API_VERSION });
-  return `${base}/openai/deployments/${deployment}/chat/completions?${query.toString()}`;
-}
-var AzureOpenAIConnector = class {
-  constructor(deps2) {
-    this.deps = deps2;
-  }
-  deps;
-  id = "azure-openai";
-  api = "azure-openai";
-  stream(model, conversation, options) {
-    const deps2 = this.deps;
-    return channelOf(async function* run() {
-      let cfg;
-      try {
-        cfg = await resolveConfig2(deps2, model, options);
-      } catch (cause) {
-        const error = cause instanceof Error && cause.name === "GatewayError" ? cause : gatewayError("auth", "could not prepare the Azure OpenAI request", {
-          provider: model.provider,
-          cause
-        });
-        yield { kind: "error", error };
-        return;
-      }
-      yield* streamOpenAICompatibleChat(cfg, model, conversation, options);
-    });
-  }
-  async complete(model, conversation, options) {
-    return collectReply(this.stream(model, conversation, options));
-  }
-};
-async function resolveConfig2(deps2, model, options) {
-  const url = endpointFor3(model);
-  const key = await deps2.resolveSecret(model.provider, options.apiKey);
-  if (key === void 0 || key === "") {
-    throw gatewayError(
-      "auth",
-      "no Azure OpenAI credential found \u2014 set AZURE_OPENAI_API_KEY (or AZURE_API_KEY), or pass options.apiKey",
-      { provider: model.provider }
-    );
-  }
-  return {
-    url,
-    // Azure authenticates with an api-key header, not an OpenAI bearer token.
-    headers: { "api-key": key }
-  };
-}
-function createazureopenaiConnector(deps2) {
-  return new AzureOpenAIConnector(deps2);
-}
-
-// src/llmgateway/connectors/nvidia.ts
-var DEFAULT_NVIDIA_BASE_URL = "https://integrate.api.nvidia.com/v1";
-function endpointFor4(model) {
-  const base = (model.baseUrl ?? DEFAULT_NVIDIA_BASE_URL).replace(/\/+$/, "");
-  return `${base}/chat/completions`;
-}
-function bodyOverridesFor(model) {
-  if (!model.reasoning) {
-    return void 0;
-  }
-  return { chat_template_kwargs: { thinking: true } };
-}
-var NvidiaConnector = class {
-  constructor(deps2) {
-    this.deps = deps2;
-  }
-  deps;
-  id = "nvidia";
-  api = "nvidia-openai-compatible";
-  stream(model, conversation, options) {
-    const deps2 = this.deps;
-    return channelOf(async function* run() {
-      let cfg;
-      try {
-        cfg = await assembleConfig(deps2, model, options);
-      } catch (cause) {
-        const error = cause instanceof Error && cause.name === "GatewayError" ? cause : gatewayError("auth", "unable to prepare the NVIDIA request", {
-          provider: model.provider,
-          cause
-        });
-        yield { kind: "error", error };
-        return;
-      }
-      yield* streamOpenAICompatibleChat(cfg, model, conversation, options);
-    });
-  }
-  async complete(model, conversation, options) {
-    return collectReply(this.stream(model, conversation, options));
-  }
-};
-async function assembleConfig(deps2, model, options) {
-  const key = await deps2.resolveSecret(model.provider, options.apiKey);
-  if (key === void 0 || key === "") {
-    throw gatewayError(
-      "auth",
-      "missing NVIDIA credential \u2014 set NVIDIA_API_KEY or pass options.apiKey",
-      { provider: model.provider }
-    );
-  }
-  const bodyExtra = bodyOverridesFor(model);
-  return {
-    url: endpointFor4(model),
-    headers: { authorization: `Bearer ${key}` },
-    ...bodyExtra ? { bodyExtra } : {}
-  };
-}
-function createnvidiaConnector(deps2) {
-  return new NvidiaConnector(deps2);
-}
-
-// src/llmgateway/connectors/kimi.ts
-var DEFAULT_MOONSHOT_BASE_URL = "https://api.moonshot.ai/v1";
-function endpointFor5(model) {
-  const base = (model.baseUrl ?? DEFAULT_MOONSHOT_BASE_URL).replace(/\/+$/, "");
-  return `${base}/chat/completions`;
-}
-var KimiConnector = class {
-  constructor(deps2) {
-    this.deps = deps2;
-  }
-  deps;
-  id = "kimi";
-  api = "kimi-openai-compatible";
-  stream(model, conversation, options) {
-    const deps2 = this.deps;
-    return channelOf(async function* run() {
-      let cfg;
-      try {
-        cfg = await resolveConfig3(deps2, model, options);
-      } catch (cause) {
-        const error = cause instanceof Error && cause.name === "GatewayError" ? cause : gatewayError("auth", "could not prepare the Kimi request", {
-          provider: model.provider,
-          cause
-        });
-        yield { kind: "error", error };
-        return;
-      }
-      yield* streamOpenAICompatibleChat(cfg, model, conversation, options);
-    });
-  }
-  async complete(model, conversation, options) {
-    return collectReply(this.stream(model, conversation, options));
-  }
-};
-async function resolveConfig3(deps2, model, options) {
-  const key = await deps2.resolveSecret(model.provider, options.apiKey);
-  if (key === void 0 || key === "") {
-    throw gatewayError(
-      "auth",
-      "no Kimi credential found \u2014 set MOONSHOT_API_KEY (or KIMI_API_KEY), or pass options.apiKey",
-      { provider: model.provider }
-    );
-  }
-  return {
-    url: endpointFor5(model),
-    headers: { authorization: `Bearer ${key}` }
-  };
-}
-function createkimiConnector(deps2) {
-  return new KimiConnector(deps2);
-}
-
-// src/llmgateway/connectors/ollama.ts
-var DEFAULT_BASE_URL3 = "http://localhost:11434";
-var PROVIDER4 = "ollama";
-function isObject6(value) {
-  return typeof value === "object" && value !== null;
-}
-function readString5(o, key) {
-  const v = o[key];
-  return typeof v === "string" ? v : void 0;
-}
-function readNumber5(o, key) {
-  const v = o[key];
-  return typeof v === "number" && Number.isFinite(v) ? v : void 0;
-}
-function buildOptions(model, opts) {
-  const options = {};
-  const numPredict = opts.maxOutputTokens ?? model.maxOutputTokens;
-  if (numPredict > 0) {
-    options.num_predict = numPredict;
-  }
-  if (opts.temperature !== void 0) {
-    options.temperature = opts.temperature;
-  }
-  if (opts.topP !== void 0) {
-    options.top_p = opts.topP;
-  }
-  return Object.keys(options).length > 0 ? options : void 0;
-}
-function buildRequestBody2(model, conversation, opts) {
-  const body = {
-    model: model.id,
-    messages: toOpenAIChatMessages(conversation),
-    stream: true
-  };
-  const tools = toOpenAITools(conversation.tools);
-  if (tools !== void 0) {
-    body.tools = tools;
-  }
-  const options = buildOptions(model, opts);
-  if (options !== void 0) {
-    body.options = options;
-  }
-  return body;
-}
-function chatEndpoint(model) {
-  const base = (model.baseUrl ?? DEFAULT_BASE_URL3).replace(/\/+$/u, "");
-  return `${base}/api/chat`;
-}
-function buildHeaders(secret) {
-  const headers = { "content-type": "application/json" };
-  if (secret !== void 0 && secret !== "") {
-    headers.authorization = `Bearer ${secret}`;
-  }
-  return headers;
-}
-async function openStream2(url, headers, body, signal) {
-  let response;
-  try {
-    response = await fetch(url, {
-      method: "POST",
-      headers,
-      body: JSON.stringify(body),
-      ...signal !== void 0 ? { signal } : {}
-    });
-  } catch (cause) {
-    if (signal?.aborted) {
-      throw gatewayError("aborted", "the Ollama request was aborted before a response arrived", {
-        provider: PROVIDER4,
-        cause
-      });
-    }
-    throw gatewayError("transport", "could not reach the Ollama daemon (is `ollama serve` running?)", {
-      provider: PROVIDER4,
-      cause
-    });
-  }
-  if (!response.ok) {
-    const detail = await readErrorDetail2(response);
-    const kind = response.status === 401 || response.status === 403 ? "auth" : response.status === 429 ? "rate_limit" : "http";
-    throw gatewayError(kind, `Ollama replied with HTTP ${response.status}${detail}`, {
-      provider: PROVIDER4,
-      status: response.status
-    });
-  }
-  if (response.body === null) {
-    throw gatewayError("transport", "the Ollama response carried no body to stream", {
-      provider: PROVIDER4,
-      status: response.status
-    });
-  }
-  return response;
-}
-async function readErrorDetail2(response) {
-  try {
-    const text = await response.text();
-    return text === "" ? "" : `: ${text.slice(0, 500)}`;
-  } catch {
-    return "";
-  }
-}
-function mapDoneReason(reason) {
-  switch (reason) {
-    case "stop":
-      return "complete";
-    case "length":
-      return "max_output";
-    case void 0:
-    case "":
-      return void 0;
-    default:
-      return "complete";
-  }
-}
-function readUsage4(line) {
-  const inputTokens = readNumber5(line, "prompt_eval_count");
-  const outputTokens = readNumber5(line, "eval_count");
-  if (inputTokens === void 0 && outputTokens === void 0) {
-    return void 0;
-  }
-  return {
-    inputTokens: inputTokens ?? 0,
-    outputTokens: outputTokens ?? 0
-  };
-}
-function serializeArgs3(args) {
-  if (typeof args === "string") {
-    return args;
-  }
-  try {
-    return JSON.stringify(args ?? {});
-  } catch {
-    return "{}";
-  }
-}
-function* emitToolCalls(toolCalls, tracker) {
-  for (const entry of toolCalls) {
-    if (!isObject6(entry)) {
-      continue;
-    }
-    const fn = entry.function;
-    if (!isObject6(fn)) {
-      continue;
-    }
-    const name = readString5(fn, "name") ?? "";
-    const id = `ollama_call_${tracker.next}`;
-    tracker.next += 1;
-    yield { kind: "tool_call_start", id, name };
-    const args = "arguments" in fn ? fn.arguments : {};
-    yield { kind: "tool_call_delta", id, argsDelta: serializeArgs3(args) };
-  }
-}
-function* emitFromLine(line, tracker) {
-  const message = line.message;
-  if (isObject6(message)) {
-    const content = readString5(message, "content");
-    if (content !== void 0 && content !== "") {
-      yield { kind: "text", delta: content };
-    }
-    const toolCalls = message.tool_calls;
-    if (Array.isArray(toolCalls)) {
-      yield* emitToolCalls(toolCalls, tracker);
-    }
-  }
-  if (line.done === true) {
-    const usage = readUsage4(line);
-    if (usage !== void 0) {
-      yield { kind: "usage", usage };
-    }
-    const stop = mapDoneReason(readString5(line, "done_reason"));
-    if (stop !== void 0) {
-      yield { kind: "stop", stop };
-    }
-  }
-}
-function createollamaConnector(deps2) {
-  const { resolveSecret: resolveSecret2 } = deps2;
-  return {
-    id: "ollama",
-    api: "ollama",
-    stream(model, conversation, options) {
-      return channelOf(async function* run() {
-        const collected = [];
-        try {
-          const secret = await resolveSecret2(PROVIDER4, options.apiKey);
-          const url = chatEndpoint(model);
-          const headers = buildHeaders(secret);
-          const body = buildRequestBody2(model, conversation, options);
-          const response = await openStream2(url, headers, body, options.signal);
-          const wire = response.body;
-          const tracker = { next: 0 };
-          for await (const value of ndjsonLines(wire, options.signal)) {
-            if (!isObject6(value)) {
-              continue;
-            }
-            for (const emission of emitFromLine(value, tracker)) {
-              collected.push(emission);
-              yield emission;
-            }
-            if (value.done === true) {
-              break;
-            }
-          }
-          const reply = foldReply(model.id, collected);
-          yield { kind: "done", reply };
-        } catch (cause) {
-          const error = cause instanceof Error && cause.name === "GatewayError" ? cause : gatewayError("transport", "the Ollama stream failed", { provider: PROVIDER4, cause });
-          yield { kind: "error", error };
-        }
-      });
-    },
-    complete(model, conversation, options) {
-      return collectReply(this.stream(model, conversation, options));
-    }
-  };
-}
-
-// src/llmgateway/connectors/mock.ts
-var ECHO_CALL_ID = "mock_call_0";
-var SCRIPTED_USAGE = {
-  inputTokens: 8,
-  outputTokens: 5
-};
-function scriptedDeltas() {
-  return [
-    { kind: "text", delta: "Hello" },
-    { kind: "text", delta: " world" },
-    { kind: "tool_call_start", id: ECHO_CALL_ID, name: "echo" },
-    { kind: "tool_call_delta", id: ECHO_CALL_ID, argsDelta: '{"msg":"hi"}' },
-    { kind: "usage", usage: { ...SCRIPTED_USAGE } },
-    { kind: "stop", stop: "tool_calls" }
-  ];
-}
-function finalDeltas() {
-  return [
-    { kind: "text", delta: "Hello world" },
-    { kind: "usage", usage: { ...SCRIPTED_USAGE } },
-    { kind: "stop", stop: "complete" }
-  ];
-}
-function hasToolResult(conversation) {
-  return conversation.turns.some((turn) => turn.blocks.some((block) => block.kind === "tool_result"));
-}
-function echoOffered(conversation) {
-  return (conversation.tools ?? []).some((tool) => tool.name === "echo");
-}
-function pickDeltas(conversation) {
-  return !hasToolResult(conversation) && echoOffered(conversation) ? scriptedDeltas() : finalDeltas();
-}
-var MockConnector = class {
-  id = "mock";
-  api = "mock";
-  // The resolver is accepted for factory symmetry with the live connectors; the
-  // mock dialect needs no credential, so it is intentionally not retained.
-  constructor(_deps) {
-  }
-  stream(model, conversation, options) {
-    const isAborted = () => options.signal?.aborted ?? false;
-    const deltas = pickDeltas(conversation);
-    return channelOf(async function* run() {
-      if (isAborted()) {
-        yield abortedDone(model.id);
-        return;
-      }
-      for (const delta of deltas) {
-        if (isAborted()) {
-          yield abortedDone(model.id);
-          return;
-        }
-        yield delta;
-      }
-      yield { kind: "done", reply: foldReply(model.id, deltas) };
-    });
-  }
-  async complete(model, conversation, options) {
-    return collectReply(this.stream(model, conversation, options));
-  }
-};
-function abortedDone(modelId) {
-  const reply = {
-    role: "assistant",
-    model: modelId,
-    blocks: [],
-    usage: { inputTokens: 0, outputTokens: 0 },
-    stop: "aborted"
-  };
-  return { kind: "done", reply };
-}
-function createmockConnector(deps2) {
-  return new MockConnector(deps2);
-}
-
-// src/llmgateway/connectors/index.ts
-var deps = { resolveSecret };
-var CONNECTOR_REGISTRY = {
-  "anthropic-messages": createanthropicConnector(deps),
-  "openai-completions": createopenaichatConnector(deps),
-  "openai-responses": createopenairesponsesConnector(deps),
-  "google-generative": creategoogleConnector(deps),
-  "google-vertex": creategooglevertexConnector(deps),
-  "amazon-bedrock": createbedrockConnector(deps),
-  "azure-openai": createazureopenaiConnector(deps),
-  "nvidia-openai-compatible": createnvidiaConnector(deps),
-  "kimi-openai-compatible": createkimiConnector(deps),
-  ollama: createollamaConnector(deps),
-  mock: createmockConnector(deps)
-};
-function connectorForApi(api) {
-  return CONNECTOR_REGISTRY[api];
-}
-
-// src/llmgateway/gateway.ts
-var NO_OPTIONS = {};
-function stream(modelId, conversation, options) {
-  const card = getCard(modelId);
-  if (card === void 0) {
-    throw gatewayError("unsupported", `unknown model: ${modelId}`);
-  }
-  return streamWithCard(card, conversation, options);
-}
-function streamWithCard(card, conversation, options) {
-  const connector = connectorForApi(card.api);
-  return connector.stream(card, conversation, options ?? NO_OPTIONS);
-}
-function complete(modelId, conversation, options) {
-  const card = getCard(modelId);
-  if (card === void 0) {
-    throw gatewayError("unsupported", `unknown model: ${modelId}`);
-  }
-  return completeWithCard(card, conversation, options);
-}
-function completeWithCard(card, conversation, options) {
-  const connector = connectorForApi(card.api);
-  return connector.complete(card, conversation, options ?? NO_OPTIONS);
-}
-export {
-  CONNECTOR_REGISTRY,
-  CardSelection,
-  GatewayError,
-  MODEL_CARDS,
-  complete,
-  completeWithCard,
-  connectorForApi,
-  estimateCost,
-  gatewayError,
-  getCard,
-  models,
-  stream,
-  streamWithCard
-};