indusagi 0.13.7 → 0.13.8

package/dist/runtime.js

@@ -0,0 +1,4521 @@
+// 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
+    }
+  },
+  // ── MiniMax (Anthropic-compatible Messages API) ─────────────────────────
+  // Wire: same dialect as Claude (`anthropic-messages`) at api.minimax.io.
+  // Auth: MINIMAX_API_KEY. Ids match facade/models.generated.ts.
+  {
+    id: "MiniMax-M2",
+    provider: "minimax",
+    api: "anthropic-messages",
+    displayName: "MiniMax M2",
+    baseUrl: "https://api.minimax.io/anthropic",
+    contextWindow: 204800,
+    maxOutputTokens: 131072,
+    modalities: ["text"],
+    reasoning: true,
+    cost: {
+      inputPerMTok: 0.3,
+      outputPerMTok: 1.2
+    }
+  },
+  {
+    id: "MiniMax-M2.1",
+    provider: "minimax",
+    api: "anthropic-messages",
+    displayName: "MiniMax M2.1",
+    baseUrl: "https://api.minimax.io/anthropic",
+    contextWindow: 204800,
+    maxOutputTokens: 131072,
+    modalities: ["text"],
+    reasoning: true,
+    cost: {
+      inputPerMTok: 0.3,
+      outputPerMTok: 1.2
+    }
+  },
+  {
+    id: "MiniMax-M2.5",
+    provider: "minimax",
+    api: "anthropic-messages",
+    displayName: "MiniMax M2.5",
+    baseUrl: "https://api.minimax.io/anthropic",
+    contextWindow: 204800,
+    maxOutputTokens: 131072,
+    modalities: ["text"],
+    reasoning: true,
+    cost: {
+      inputPerMTok: 0.3,
+      outputPerMTok: 1.2
+    }
+  },
+  {
+    id: "MiniMax-M2.7",
+    provider: "minimax",
+    api: "anthropic-messages",
+    displayName: "MiniMax M2.7",
+    baseUrl: "https://api.minimax.io/anthropic",
+    contextWindow: 204800,
+    maxOutputTokens: 131072,
+    modalities: ["text"],
+    reasoning: true,
+    cost: {
+      inputPerMTok: 0.3,
+      outputPerMTok: 1.2
+    }
+  },
+  {
+    id: "MiniMax-M3",
+    provider: "minimax",
+    api: "anthropic-messages",
+    displayName: "MiniMax M3",
+    baseUrl: "https://api.minimax.io/anthropic",
+    contextWindow: 1048576,
+    maxOutputTokens: 512e3,
+    modalities: ["text", "image"],
+    reasoning: true,
+    cost: {
+      inputPerMTok: 0.6,
+      outputPerMTok: 2.4,
+      cacheReadPerMTok: 0.12
+    }
+  },
+  // ── 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
+function getCard(id) {
+  return MODEL_CARDS.find((card) => card.id === id);
+}
+
+// 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."
+  },
+  minimax: {
+    provider: "minimax",
+    scheme: "api-key",
+    envVars: ["MINIMAX_API_KEY"],
+    hint: "MiniMax global API key (api.minimax.io Anthropic-compatible)."
+  },
+  "minimax-cn": {
+    provider: "minimax-cn",
+    scheme: "api-key",
+    // Same key often works for both; CN-specific override first when set.
+    envVars: ["MINIMAX_CN_API_KEY", "MINIMAX_API_KEY"],
+    hint: "MiniMax China API key (api.minimaxi.com Anthropic-compatible)."
+  },
+  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, provider = "anthropic") {
+  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 ${provider} responded`, {
+        provider,
+        cause
+      });
+    }
+    throw gatewayError("transport", `network call to ${provider} failed`, { provider, 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, `${provider} returned HTTP ${response.status}${detail}`, {
+      provider,
+      status: response.status
+    });
+  }
+  if (response.body === null) {
+    throw gatewayError("transport", `${provider} response arrived with no body`, {
+      provider,
+      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(model, options) {
+    const provider = model.provider;
+    const key = await deps2.resolveSecret(provider, options.apiKey);
+    if (key === void 0 || key === "") {
+      const hint = provider === "minimax" || provider === "minimax-cn" ? "set MINIMAX_API_KEY (or MINIMAX_CN_API_KEY for CN) or pass options.apiKey" : "set ANTHROPIC_API_KEY or pass options.apiKey";
+      throw gatewayError("auth", `no API key found for provider "${provider}" (${hint})`, {
+        provider
+      });
+    }
+    return key;
+  }
+  function stream2(model, conversation, options) {
+    return channelOf(async function* run() {
+      const collected = [];
+      try {
+        const apiKey = await requireKey(model, options);
+        const body = toAnthropicRequest(conversation, model, options);
+        body.stream = true;
+        const response = await postMessages(
+          endpointFor(model),
+          apiKey,
+          body,
+          options.signal,
+          model.provider
+        );
+        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);
+}
+
+// src/runtime/contract/errors.ts
+function runError(kind, message, cause) {
+  return cause !== void 0 ? { kind, message, cause } : { kind, message };
+}
+
+// src/runtime/cadence/fold.ts
+var ZERO_USAGE = { inputTokens: 0, outputTokens: 0 };
+function addUsage(base, more) {
+  const cacheRead = (base.cacheReadTokens ?? 0) + (more.cacheReadTokens ?? 0);
+  const cacheWrite = (base.cacheWriteTokens ?? 0) + (more.cacheWriteTokens ?? 0);
+  return {
+    inputTokens: base.inputTokens + more.inputTokens,
+    outputTokens: base.outputTokens + more.outputTokens,
+    ...cacheRead > 0 ? { cacheReadTokens: cacheRead } : {},
+    ...cacheWrite > 0 ? { cacheWriteTokens: cacheWrite } : {}
+  };
+}
+function affectsBlocks(emission) {
+  switch (emission.kind) {
+    case "text":
+    case "thinking":
+    case "tool_call_start":
+    case "tool_call_delta":
+    case "done":
+      return true;
+    case "usage":
+    case "stop":
+    case "error":
+      return false;
+  }
+}
+function parseToolArgs(raw) {
+  const trimmed = raw.trim();
+  if (trimmed.length === 0) return {};
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    return { __unparsed: raw };
+  }
+}
+function foldBlocks(blocks, emission) {
+  if (!affectsBlocks(emission)) return blocks;
+  switch (emission.kind) {
+    case "text": {
+      const last = blocks[blocks.length - 1];
+      if (last && last.kind === "text") {
+        const merged = {
+          kind: "text",
+          text: last.text + emission.delta
+        };
+        return [...blocks.slice(0, -1), merged];
+      }
+      return [...blocks, { kind: "text", text: emission.delta }];
+    }
+    case "thinking": {
+      const last = blocks[blocks.length - 1];
+      if (last && last.kind === "thinking") {
+        const merged = {
+          kind: "thinking",
+          text: last.text + emission.delta,
+          ...last.signature !== void 0 ? { signature: last.signature } : {}
+        };
+        return [...blocks.slice(0, -1), merged];
+      }
+      return [...blocks, { kind: "thinking", text: emission.delta }];
+    }
+    case "tool_call_start": {
+      const opened = {
+        kind: "tool_call",
+        id: emission.id,
+        name: emission.name,
+        input: ""
+      };
+      return [...blocks, opened];
+    }
+    case "tool_call_delta": {
+      const idx = blocks.findIndex(
+        (b) => b.kind === "tool_call" && b.id === emission.id
+      );
+      if (idx === -1) {
+        const opened = {
+          kind: "tool_call",
+          id: emission.id,
+          name: "",
+          input: emission.argsDelta
+        };
+        return [...blocks, opened];
+      }
+      const prior = blocks[idx];
+      const priorRaw = typeof prior.input === "string" ? prior.input : "";
+      const grown = {
+        kind: "tool_call",
+        id: prior.id,
+        name: prior.name,
+        input: priorRaw + emission.argsDelta
+      };
+      const copy = blocks.slice();
+      copy[idx] = grown;
+      return copy;
+    }
+    case "done": {
+      return emission.reply.blocks;
+    }
+  }
+  return blocks;
+}
+function sealToolArgs(turn) {
+  let changed = false;
+  const blocks = turn.blocks.map((b) => {
+    if (b.kind === "tool_call" && typeof b.input === "string") {
+      changed = true;
+      const sealed = {
+        kind: "tool_call",
+        id: b.id,
+        name: b.name,
+        input: parseToolArgs(b.input)
+      };
+      return sealed;
+    }
+    return b;
+  });
+  if (!changed) return turn;
+  return { role: "assistant", blocks };
+}
+function foldTurn(turn, emission) {
+  const blocks = foldBlocks(turn.blocks, emission);
+  if (blocks === turn.blocks) return turn;
+  return { role: "assistant", blocks };
+}
+function toolCallsOf(turn) {
+  return turn.blocks.filter((b) => b.kind === "tool_call");
+}
+
+// src/runtime/cadence/reducer.ts
+function freshRunId() {
+  return crypto.randomUUID();
+}
+function initialSnapshot(sessionId, model, runId = freshRunId()) {
+  return {
+    runId,
+    sessionId,
+    phase: "idle",
+    messages: [],
+    pending: [],
+    usageTotal: ZERO_USAGE,
+    model
+  };
+}
+function publish(event) {
+  return { kind: "publish", event };
+}
+function announce(snapshot) {
+  return publish({ kind: "snapshot", snapshot });
+}
+function fault(state, error) {
+  const next = { ...state, phase: "faulted", error };
+  return {
+    state: next,
+    effects: [
+      { kind: "persist", snapshot: next },
+      publish({ kind: "faulted", error, snapshot: next })
+    ]
+  };
+}
+function lastAssistant(state) {
+  const last = state.messages[state.messages.length - 1];
+  return last && last.role === "assistant" ? last : void 0;
+}
+function withLastAssistant(state, turn) {
+  return [...state.messages.slice(0, -1), turn];
+}
+function cadence(config) {
+  const descriptors = config.tools?.descriptors() ?? [];
+  function conversationOf(messages) {
+    return {
+      ...config.system !== void 0 ? { system: config.system } : {},
+      turns: messages,
+      ...descriptors.length > 0 ? { tools: descriptors } : {}
+    };
+  }
+  function streamOptions() {
+    return {
+      ...config.thinking !== void 0 ? { thinking: config.thinking } : {},
+      ...config.maxOutputTokens !== void 0 ? { maxOutputTokens: config.maxOutputTokens } : {}
+    };
+  }
+  function invoke(state, messages) {
+    const { error: _cleared, ...rest } = state;
+    void _cleared;
+    const next = {
+      ...rest,
+      messages,
+      phase: "invoking",
+      pending: []
+    };
+    return {
+      state: next,
+      effects: [
+        {
+          kind: "invoke_model",
+          conversation: conversationOf(messages),
+          options: streamOptions()
+        },
+        announce(next)
+      ]
+    };
+  }
+  function onSubmit(state, input) {
+    const blank = { role: "assistant", blocks: [] };
+    const messages = [...state.messages, ...input, blank];
+    return invoke(state, messages);
+  }
+  function onEmission(state, signal) {
+    if (signal.kind !== "emission") return invalid(state, signal);
+    const emission = signal.emission;
+    if (emission.kind === "error") {
+      return fault(
+        state,
+        runError("model_failed", emission.error.message, emission.error)
+      );
+    }
+    if (emission.kind === "usage") {
+      const next2 = {
+        ...state,
+        phase: "streaming",
+        usageTotal: addUsage(state.usageTotal, emission.usage)
+      };
+      return { state: next2, effects: [] };
+    }
+    if (emission.kind === "stop") {
+      const next2 = { ...state, phase: "streaming" };
+      return { state: next2, effects: [] };
+    }
+    const open = lastAssistant(state);
+    const target = open ?? { role: "assistant", blocks: [] };
+    const folded = foldTurn(target, emission);
+    const usageTotal = emission.kind === "done" ? addUsage(state.usageTotal, emission.reply.usage) : state.usageTotal;
+    const messages = open ? withLastAssistant(state, folded) : [...state.messages, folded];
+    const next = {
+      ...state,
+      phase: "streaming",
+      usageTotal,
+      messages
+    };
+    const effects = [];
+    switch (emission.kind) {
+      case "text":
+        effects.push(publish({ kind: "text_delta", delta: emission.delta }));
+        break;
+      case "thinking":
+        effects.push(publish({ kind: "thinking_delta", delta: emission.delta }));
+        break;
+      case "tool_call_start":
+        effects.push(
+          publish({
+            kind: "tool_started",
+            id: emission.id,
+            name: emission.name
+          })
+        );
+        break;
+      case "tool_call_delta":
+      case "done":
+        break;
+    }
+    return { state: next, effects };
+  }
+  function onStreamEnd(state) {
+    const turn = lastAssistant(state);
+    if (!turn) {
+      return fault(
+        state,
+        runError("invalid_state", "stream_end with no open assistant turn")
+      );
+    }
+    const sealed = sealToolArgs(turn);
+    const messages = withLastAssistant(state, sealed);
+    const calls = toolCallsOf(sealed);
+    if (calls.length === 0) {
+      const settled2 = {
+        ...state,
+        phase: "settled",
+        messages,
+        pending: []
+      };
+      return {
+        state: settled2,
+        effects: [
+          { kind: "persist", snapshot: settled2 },
+          publish({ kind: "settled", snapshot: settled2 })
+        ]
+      };
+    }
+    const pending = calls.map((c) => ({
+      id: c.id,
+      name: c.name,
+      stage: "running"
+    }));
+    const dispatching = {
+      ...state,
+      phase: "dispatching",
+      messages,
+      pending
+    };
+    const effects = [announce(dispatching)];
+    for (const c of calls) {
+      const call = { id: c.id, name: c.name, input: c.input };
+      effects.push({ kind: "run_tool", call });
+    }
+    return { state: dispatching, effects };
+  }
+  function onToolSettled(state, id, result) {
+    const known = state.pending.find((p) => p.id === id);
+    if (!known) {
+      return fault(
+        state,
+        runError("invalid_state", `tool_settled for unknown call ${id}`)
+      );
+    }
+    const pending = state.pending.map(
+      (p) => p.id === id ? { ...p, stage: "done" } : p
+    );
+    const finished = publish({
+      kind: "tool_finished",
+      id,
+      name: known.name,
+      outcome: result
+    });
+    const block = {
+      kind: "tool_result",
+      callId: result.id,
+      output: result.output,
+      isError: result.isError
+    };
+    const messages = appendToolResult(state.messages, block);
+    const allDone = pending.every((p) => p.stage === "done");
+    if (!allDone) {
+      const waiting = { ...state, pending, messages };
+      return { state: waiting, effects: [finished, announce(waiting)] };
+    }
+    const cleared = { ...state, messages, pending: [] };
+    const invocation = invoke(cleared, messages);
+    return {
+      state: invocation.state,
+      effects: [finished, ...invocation.effects]
+    };
+  }
+  function onCompacted(state, summary) {
+    const keep = config.compaction?.keepRecent ?? 0;
+    const recent = keep > 0 ? state.messages.slice(-keep) : [];
+    const messages = [summary, ...recent];
+    return invoke(state, messages);
+  }
+  function invalid(state, signal) {
+    return fault(
+      state,
+      runError(
+        "invalid_state",
+        `signal '${signal.kind}' is not valid in phase '${state.phase}'`
+      )
+    );
+  }
+  return function step2(state, signal) {
+    if (state.phase === "faulted" || state.phase === "settled") {
+      if (signal.kind === "submit") return onSubmit(state, signal.input);
+      if (signal.kind === "compacted") return onCompacted(state, signal.summary);
+      if (signal.kind === "fault") return fault(state, signal.error);
+      return { state, effects: [] };
+    }
+    switch (signal.kind) {
+      case "abort":
+        return fault(state, runError("aborted", "run aborted by caller"));
+      case "fault":
+        return fault(state, signal.error);
+      case "submit":
+        return onSubmit(state, signal.input);
+      case "emission":
+        return onEmission(state, signal);
+      case "stream_end":
+        return onStreamEnd(state);
+      case "tool_settled":
+        return onToolSettled(state, signal.id, signal.result);
+      case "compacted":
+        return onCompacted(state, signal.summary);
+    }
+  };
+}
+function appendToolResult(messages, block) {
+  const last = messages[messages.length - 1];
+  if (last && last.role === "tool") {
+    const grown = { role: "tool", blocks: [...last.blocks, block] };
+    return [...messages.slice(0, -1), grown];
+  }
+  const opened = { role: "tool", blocks: [block] };
+  return [...messages, opened];
+}
+
+// src/runtime/turn/driver.ts
+function toRunError(thrown) {
+  if (thrown instanceof GatewayError) {
+    return runError("model_failed", thrown.message, thrown);
+  }
+  if (thrown instanceof Error) {
+    return runError("model_failed", thrown.message, thrown);
+  }
+  return runError("model_failed", "the model stream failed", thrown);
+}
+async function* driveTurn(channel) {
+  try {
+    for await (const emission of channel) {
+      yield { kind: "emission", emission };
+    }
+  } catch (thrown) {
+    yield { kind: "fault", error: toRunError(thrown) };
+    return;
+  }
+  yield { kind: "stream_end" };
+}
+
+// src/runtime/dispatch/scheduler.ts
+var DEFAULT_CONCURRENCY = 8;
+var SignalMailbox = class {
+  buffer = [];
+  wake = null;
+  closed = false;
+  /** Hand a finished signal to the consumer. */
+  deliver(signal) {
+    this.buffer.push(signal);
+    this.flush();
+  }
+  /** Mark the round complete so a parked consumer can terminate. */
+  close() {
+    this.closed = true;
+    this.flush();
+  }
+  /**
+   * Pull the next buffered signal, or `undefined` once the round is finished
+   * and the buffer is drained. Parks on a fresh promise while empty and open.
+   */
+  async next() {
+    for (; ; ) {
+      const ready = this.buffer.shift();
+      if (ready !== void 0) return ready;
+      if (this.closed) return void 0;
+      await new Promise((resolve) => {
+        this.wake = resolve;
+      });
+    }
+  }
+  /** Wake a parked consumer, if any. */
+  flush() {
+    const wake = this.wake;
+    if (wake) {
+      this.wake = null;
+      wake();
+    }
+  }
+};
+function settled(id, result) {
+  return { kind: "tool_settled", id, result };
+}
+function createScheduler(runner, concurrency = DEFAULT_CONCURRENCY) {
+  const limit = Math.max(1, Math.floor(concurrency));
+  const rounds = /* @__PURE__ */ new Set();
+  function abort(controller) {
+    rounds.delete(controller);
+    if (!controller.signal.aborted) controller.abort();
+  }
+  async function* run(calls, signal) {
+    const round = new AbortController();
+    rounds.add(round);
+    const onOuterAbort = () => abort(round);
+    if (signal.aborted) round.abort();
+    else signal.addEventListener("abort", onOuterAbort, { once: true });
+    const pending = calls.map((call) => ({
+      id: call.id,
+      name: call.name,
+      stage: "queued"
+    }));
+    const mailbox = new SignalMailbox();
+    const setStage = (id, stage) => {
+      const at = pending.findIndex((entry) => entry.id === id);
+      if (at !== -1) pending[at] = { ...pending[at], stage };
+    };
+    const drop = (id) => {
+      const at = pending.findIndex((entry) => entry.id === id);
+      if (at !== -1) pending.splice(at, 1);
+    };
+    let cursor = 0;
+    let active = 0;
+    const startNext = () => {
+      while (active < limit && cursor < calls.length && !round.signal.aborted) {
+        const call = calls[cursor++];
+        active++;
+        setStage(call.id, "running");
+        void runOne(call).finally(() => {
+          active--;
+          drop(call.id);
+          if (cursor >= calls.length && active === 0) mailbox.close();
+          else startNext();
+        });
+      }
+      if (round.signal.aborted && active === 0) mailbox.close();
+    };
+    const runOne = async (call) => {
+      const child = new AbortController();
+      const onRoundAbort = () => {
+        if (!child.signal.aborted) child.abort();
+      };
+      if (round.signal.aborted) child.abort();
+      else round.signal.addEventListener("abort", onRoundAbort, { once: true });
+      try {
+        const result = await runner.run(call, child.signal);
+        mailbox.deliver(settled(call.id, result));
+      } catch (cause) {
+        mailbox.deliver(
+          settled(call.id, {
+            id: call.id,
+            output: cause instanceof Error ? cause.message : cause,
+            isError: true
+          })
+        );
+      } finally {
+        round.signal.removeEventListener("abort", onRoundAbort);
+      }
+    };
+    if (calls.length === 0) mailbox.close();
+    else startNext();
+    try {
+      for (; ; ) {
+        const next = await mailbox.next();
+        if (next === void 0) return;
+        yield next;
+      }
+    } finally {
+      signal.removeEventListener("abort", onOuterAbort);
+      abort(round);
+    }
+  }
+  return {
+    run,
+    cancel() {
+      for (const controller of [...rounds]) abort(controller);
+    }
+  };
+}
+
+// src/runtime/memory/estimate.ts
+var CHARS_PER_TOKEN = 4;
+var TURN_OVERHEAD_TOKENS = 4;
+function blockCharCount(block) {
+  switch (block.kind) {
+    case "text":
+      return block.text.length;
+    case "thinking":
+      return block.text.length;
+    case "tool_call":
+      return block.name.length + serializedLength(block.input);
+    case "tool_result":
+      return serializedLength(block.output);
+    case "image":
+      return block.dataBase64.length;
+    default:
+      return 0;
+  }
+}
+function serializedLength(value) {
+  if (typeof value === "string") {
+    return value.length;
+  }
+  if (value === void 0 || value === null) {
+    return 0;
+  }
+  try {
+    return JSON.stringify(value).length;
+  } catch {
+    return String(value).length;
+  }
+}
+function estimateContextTokens(messages) {
+  let chars = 0;
+  for (const turn of messages) {
+    for (const block of turn.blocks) {
+      chars += blockCharCount(block);
+    }
+  }
+  const contentTokens = Math.ceil(chars / CHARS_PER_TOKEN);
+  return contentTokens + messages.length * TURN_OVERHEAD_TOKENS;
+}
+
+// src/runtime/memory/compactor.ts
+var DEFAULT_POLICY = {
+  triggerRatio: 0.8,
+  keepRecent: 8
+};
+var DISTILL_INSTRUCTION = [
+  "You are condensing the earlier portion of an ongoing agent conversation so it",
+  "can be dropped from the active window without losing what matters. Read the",
+  "transcript that follows and produce a single, self-contained briefing. Capture:",
+  "the user's overarching goal and any standing constraints; concrete decisions",
+  "already made and the reasoning behind them; facts discovered, files inspected,",
+  "and commands run, together with their salient results; the current state of the",
+  "work and what remains open. Preserve identifiers verbatim \u2014 file paths, function",
+  "and symbol names, error strings, command lines. Write in compact prose or tight",
+  "bullet points. Do not greet, do not editorialize, do not invent anything absent",
+  "from the transcript. The briefing replaces these turns entirely, so anything you",
+  "omit is forgotten."
+].join(" ");
+var SUMMARY_HEADING = "[condensed earlier context]";
+function shouldCompact(messages, model, cfg) {
+  const policy = cfg ?? DEFAULT_POLICY;
+  if (model.contextWindow <= 0) {
+    return false;
+  }
+  const estimate = estimateContextTokens(messages);
+  return estimate >= model.contextWindow * policy.triggerRatio;
+}
+function carriesToolResult(turn) {
+  return turn.blocks.some((block) => block.kind === "tool_result");
+}
+function findCutPoint(messages, keepRecent) {
+  const total = messages.length;
+  const keep = Math.max(0, Math.floor(keepRecent));
+  if (keep >= total) {
+    return 0;
+  }
+  let cut = total - keep;
+  while (cut < total && carriesToolResult(messages[cut])) {
+    cut += 1;
+  }
+  return cut;
+}
+function renderBlock(block) {
+  switch (block.kind) {
+    case "text":
+      return block.text;
+    case "thinking":
+      return block.text;
+    case "tool_call":
+      return `tool_call ${block.name}(${stringify(block.input)})`;
+    case "tool_result":
+      return `tool_result -> ${stringify(block.output)}`;
+    case "image":
+      return `[image ${block.mediaType}]`;
+    default:
+      return "";
+  }
+}
+function stringify(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function renderTurn(turn) {
+  const body = turn.blocks.map(renderBlock).filter((part) => part.length > 0).join("\n");
+  return `${turn.role}:
+${body}`;
+}
+async function collectText(channel) {
+  let streamed = "";
+  let final;
+  for await (const emission of channel) {
+    if (emission.kind === "text" && typeof emission.delta === "string") {
+      streamed += emission.delta;
+    } else if (emission.kind === "done" && emission.reply) {
+      final = emission.reply.blocks.filter((b) => b.kind === "text").map((b) => b.text).join("");
+    } else if (emission.kind === "error") {
+      throw new Error(emission.error?.message ?? "model channel errored during condensation");
+    }
+  }
+  const text = (final ?? streamed).trim();
+  return text;
+}
+async function summarize(messages, invoke) {
+  const transcript = messages.map(renderTurn).join("\n\n");
+  const conversation = {
+    system: DISTILL_INSTRUCTION,
+    turns: [
+      {
+        role: "user",
+        blocks: [{ kind: "text", text: transcript }]
+      }
+    ]
+  };
+  const channel = invoke(conversation, {});
+  const gist = await collectText(channel);
+  const summary = {
+    role: "user",
+    blocks: [{ kind: "text", text: `${SUMMARY_HEADING}
+${gist}` }]
+  };
+  return summary;
+}
+async function compact(messages, model, cfg, invoke) {
+  void model;
+  const policy = cfg ?? DEFAULT_POLICY;
+  const cut = findCutPoint(messages, policy.keepRecent);
+  if (cut <= 0) {
+    return messages;
+  }
+  const prefix = messages.slice(0, cut);
+  const tail = messages.slice(cut);
+  const summary = await summarize(prefix, invoke);
+  return [summary, ...tail];
+}
+
+// src/runtime/ledger/bus.ts
+var RunLedger = class {
+  /** The live set of handlers. Insertion order is preserved for delivery. */
+  handlers = /* @__PURE__ */ new Set();
+  /**
+   * Register a handler for every subsequent event.
+   *
+   * @returns a disposer that removes this handler. Calling it more than once is
+   * harmless. The same function reference may be subscribed only once; a
+   * duplicate subscription is a no-op that still returns a working disposer.
+   */
+  subscribe(handler) {
+    this.handlers.add(handler);
+    return () => {
+      this.handlers.delete(handler);
+    };
+  }
+  /**
+   * Deliver an event to every currently registered handler.
+   *
+   * Handlers are notified in registration order over a snapshot of the set, so
+   * mutations made during delivery apply to the next publish. A throwing
+   * handler is isolated: its error is swallowed so siblings still receive the
+   * event and the loop is never broken by a faulty subscriber.
+   */
+  publish(event) {
+    for (const handler of [...this.handlers]) {
+      try {
+        handler(event);
+      } catch {
+      }
+    }
+  }
+  /** Drop every handler. Useful when tearing a host down. */
+  clear() {
+    this.handlers.clear();
+  }
+  /** How many handlers are currently registered. */
+  get size() {
+    return this.handlers.size;
+  }
+};
+
+// src/runtime/store/hash.ts
+import { createHash } from "node:crypto";
+var HASH_WIDTH = 32;
+function hashNode(parent, turn, createdAt) {
+  const payload = JSON.stringify({
+    parent: parent ?? null,
+    turn,
+    createdAt
+  });
+  return createHash("sha256").update(payload).digest("hex").slice(0, HASH_WIDTH);
+}
+
+// src/runtime/store/dag.ts
+var SessionGraph = class _SessionGraph {
+  constructor(sessionId, clock = Date.now) {
+    this.sessionId = sessionId;
+    this.clock = clock;
+  }
+  sessionId;
+  nodes = /* @__PURE__ */ new Map();
+  head = null;
+  clock;
+  /**
+   * Rebuild a graph from previously persisted nodes plus its leaf pointer.
+   *
+   * Nodes may arrive in any order; parents are not required to precede children.
+   * The provided `leaf` becomes the head, or the loner node if exactly one
+   * exists and no leaf is named.
+   */
+  static hydrate(sessionId, nodes, leaf, clock = Date.now) {
+    const graph = new _SessionGraph(sessionId, clock);
+    for (const node of nodes) {
+      graph.nodes.set(node.id, node);
+    }
+    if (leaf !== null && graph.nodes.has(leaf)) {
+      graph.head = leaf;
+    } else if (nodes.length === 1) {
+      graph.head = nodes[0].id;
+    }
+    return graph;
+  }
+  /** The id of the node a fresh append will chain onto, or `null` if empty. */
+  get leaf() {
+    return this.head;
+  }
+  /** Total number of nodes across every branch. */
+  get size() {
+    return this.nodes.size;
+  }
+  /** Look up a node by its content hash. */
+  get(nodeId) {
+    return this.nodes.get(nodeId);
+  }
+  /** Every node in the graph, in insertion order. */
+  all() {
+    return [...this.nodes.values()];
+  }
+  /**
+   * Chain a new turn onto the current head and advance the head to it.
+   *
+   * Returns the freshly minted node. If the content hash collides with an
+   * existing node (identical lineage, turn, and timestamp), the head simply
+   * advances to that node without duplicating it.
+   */
+  append(turn) {
+    const parent = this.head;
+    const createdAt = this.clock();
+    const id = hashNode(parent, turn, createdAt);
+    const existing = this.nodes.get(id);
+    if (existing) {
+      this.head = id;
+      return existing;
+    }
+    const node = { id, parent, turn, createdAt };
+    this.nodes.set(id, node);
+    this.head = id;
+    return node;
+  }
+  /**
+   * Move the head to an existing node so the next append forks from there.
+   *
+   * Throws if `nodeId` is not part of this graph.
+   */
+  branchFrom(nodeId) {
+    const node = this.nodes.get(nodeId);
+    if (!node) {
+      throw new Error(`cannot branch from unknown node "${nodeId}"`);
+    }
+    this.head = nodeId;
+    return node;
+  }
+  /**
+   * Resolve the linear context ending at `leaf`, ordered root→leaf.
+   *
+   * Walks parent pointers from the leaf back to a root, then reverses. Throws if
+   * `leaf` is unknown or the chain references a missing parent.
+   */
+  pathTo(leaf) {
+    const turns = [];
+    let cursor = leaf;
+    while (cursor !== null) {
+      const node = this.nodes.get(cursor);
+      if (!node) {
+        throw new Error(`broken lineage: missing node "${cursor}"`);
+      }
+      turns.push(node.turn);
+      cursor = node.parent;
+    }
+    turns.reverse();
+    return turns;
+  }
+  /**
+   * Adopt `leaf` as the head and return its full root→leaf turn context.
+   *
+   * Convenience for re-entering a session at a chosen tip: combines {@link
+   * branchFrom} (positioning) with {@link pathTo} (context).
+   */
+  resume(leaf) {
+    this.branchFrom(leaf);
+    return this.pathTo(leaf);
+  }
+};
+
+// src/runtime/store/persist.ts
+import { mkdir, readdir, readFile, appendFile } from "node:fs/promises";
+import { join } from "node:path";
+var SESSION_EXT = ".jsonl";
+function upgradeRaw(raw, migrators) {
+  let current = raw;
+  for (const migrator of migrators) {
+    current = migrator.upgrade(current);
+  }
+  return current;
+}
+function asStoredRecord(value) {
+  if (typeof value !== "object" || value === null) {
+    return null;
+  }
+  const candidate = value;
+  if (candidate.type === "node" || candidate.type === "head") {
+    return value;
+  }
+  return null;
+}
+var SessionStore = class {
+  constructor(root, migrators = []) {
+    this.root = root;
+    this.migrators = migrators;
+  }
+  root;
+  migrators;
+  /** Absolute path of a session's JSONL file. */
+  fileFor(sessionId) {
+    return join(this.root, sessionId + SESSION_EXT);
+  }
+  /** Ensure the sessions root directory exists. */
+  async ensureRoot() {
+    await mkdir(this.root, { recursive: true });
+  }
+  /**
+   * Append one node to a session and advance its persisted head.
+   *
+   * Writes the node record followed by a head record pointing at it, so the last
+   * head marker in the file always names the live leaf.
+   */
+  async appendNode(sessionId, node) {
+    await this.ensureRoot();
+    const nodeRecord = { type: "node", node };
+    const headRecord = { type: "head", leaf: node.id };
+    const lines = JSON.stringify(nodeRecord) + "\n" + JSON.stringify(headRecord) + "\n";
+    await appendFile(this.fileFor(sessionId), lines, "utf8");
+  }
+  /**
+   * Load a session from disk into a {@link SessionGraph}.
+   *
+   * Replays every line, upgrades it through the migrator pipeline, collects the
+   * node records, and tracks the last head marker as the leaf. Blank lines are
+   * skipped. A missing session file yields an empty graph.
+   */
+  async loadSession(sessionId) {
+    let raw;
+    try {
+      raw = await readFile(this.fileFor(sessionId), "utf8");
+    } catch (cause) {
+      if (isNotFound(cause)) {
+        return new SessionGraph(sessionId);
+      }
+      throw cause;
+    }
+    const nodes = [];
+    let leaf = null;
+    for (const line of raw.split("\n")) {
+      const trimmed = line.trim();
+      if (trimmed.length === 0) {
+        continue;
+      }
+      const decoded = upgradeRaw(JSON.parse(trimmed), this.migrators);
+      const record = asStoredRecord(decoded);
+      if (!record) {
+        continue;
+      }
+      if (record.type === "node") {
+        nodes.push(record.node);
+      } else {
+        leaf = record.leaf;
+      }
+    }
+    return SessionGraph.hydrate(sessionId, nodes, leaf);
+  }
+  /**
+   * List the ids of every session present in the store.
+   *
+   * Returns an empty list if the root does not yet exist.
+   */
+  async listSessions() {
+    let entries;
+    try {
+      entries = await readdir(this.root);
+    } catch (cause) {
+      if (isNotFound(cause)) {
+        return [];
+      }
+      throw cause;
+    }
+    return entries.filter((name) => name.endsWith(SESSION_EXT)).map((name) => name.slice(0, -SESSION_EXT.length));
+  }
+};
+function isNotFound(cause) {
+  return typeof cause === "object" && cause !== null && cause.code === "ENOENT";
+}
+
+// src/runtime/conductor/agent.ts
+var DEFAULT_KEEP_RECENT_POLICY = {
+  triggerRatio: 0.8,
+  keepRecent: 8
+};
+function asTurns(input) {
+  if (typeof input === "string") {
+    return [{ role: "user", blocks: [{ kind: "text", text: input }] }];
+  }
+  return input;
+}
+function isTerminal(snapshot) {
+  return snapshot.phase === "settled" || snapshot.phase === "faulted";
+}
+var SignalQueue = class {
+  buffer = [];
+  wake = null;
+  /** Enqueue one signal and wake a parked consumer, if any. */
+  push(signal) {
+    this.buffer.push(signal);
+    const wake = this.wake;
+    if (wake) {
+      this.wake = null;
+      wake();
+    }
+  }
+  /** Pull the next signal, parking until one is available. */
+  async pull() {
+    for (; ; ) {
+      const ready = this.buffer.shift();
+      if (ready !== void 0) return ready;
+      await new Promise((resolve) => {
+        this.wake = resolve;
+      });
+    }
+  }
+  /** Whether at least one signal is buffered and ready. */
+  get hasPending() {
+    return this.buffer.length > 0;
+  }
+};
+function createAgent(config, deps2 = {}) {
+  const step2 = cadence(config);
+  const invokeModel = deps2.invokeModel ?? ((conversation, options) => stream(config.model, conversation, options));
+  const ledger = deps2.ledger instanceof RunLedger ? deps2.ledger : new RunLedger();
+  const runner = config.tools?.runner;
+  const scheduler = runner ? createScheduler(runner) : void 0;
+  const store = deps2.store instanceof SessionStore ? deps2.store : void 0;
+  const sessionId = crypto.randomUUID();
+  let snapshot = initialSnapshot(sessionId, config.model);
+  const queue = new SignalQueue();
+  let active = null;
+  let driving = null;
+  function onPublish(event) {
+    ledger.publish(event);
+  }
+  async function onInvokeModel(conversation, options) {
+    const card = getCard(config.model);
+    if (card && shouldCompact(snapshot.messages, card, config.compaction)) {
+      const redirected = await condenseIfShrinks(snapshot.messages);
+      if (redirected) return;
+    }
+    const controller = active;
+    const withSignal = controller ? { ...options, signal: controller.signal } : options;
+    let channel;
+    try {
+      channel = invokeModel(conversation, withSignal);
+    } catch (thrown) {
+      queue.push({
+        kind: "fault",
+        error: runError(
+          "model_failed",
+          thrown instanceof Error ? thrown.message : "model invocation failed",
+          thrown
+        )
+      });
+      return;
+    }
+    for await (const signal of driveTurn(channel)) {
+      if (controller?.signal.aborted) return;
+      queue.push(signal);
+    }
+  }
+  async function condenseIfShrinks(messages) {
+    const card = getCard(config.model);
+    if (!card) return false;
+    const keepRecent = (config.compaction ?? DEFAULT_KEEP_RECENT_POLICY).keepRecent;
+    if (findCutPoint(messages, keepRecent) <= 1) return false;
+    try {
+      const condensed = await compact(
+        messages,
+        card,
+        config.compaction,
+        invokeModel
+      );
+      const summary = condensed[0];
+      if (summary && condensed.length < messages.length) {
+        queue.push({ kind: "compacted", summary });
+        return true;
+      }
+      return false;
+    } catch (thrown) {
+      queue.push({
+        kind: "fault",
+        error: runError(
+          "compaction_failed",
+          thrown instanceof Error ? thrown.message : "history condensation failed",
+          thrown
+        )
+      });
+      return true;
+    }
+  }
+  async function onRunTools(calls) {
+    if (!scheduler) {
+      queue.push({
+        kind: "fault",
+        error: runError(
+          "tool_failed",
+          "a tool was requested but no tool runner is configured"
+        )
+      });
+      return;
+    }
+    const controller = active ?? new AbortController();
+    for await (const settled2 of scheduler.run(calls, controller.signal)) {
+      queue.push(settled2);
+    }
+  }
+  async function onCompact(messages) {
+    await condenseIfShrinks(messages);
+  }
+  async function onPersist(target) {
+    if (!store) return;
+    try {
+      const graph = await store.loadSession(target.sessionId);
+      await appendNewTurns(graph, target.sessionId, target.messages);
+    } catch {
+    }
+  }
+  async function appendNewTurns(graph, session, messages) {
+    for (const turn of messages) {
+      const before = graph.leaf;
+      const node = graph.append(turn);
+      if (node.id !== before) {
+        await store.appendNode(session, node);
+      }
+    }
+  }
+  function performAll(effects, inflight) {
+    const batch = [];
+    for (const effect of effects) {
+      switch (effect.kind) {
+        case "publish":
+          onPublish(effect.event);
+          break;
+        case "invoke_model":
+          track(onInvokeModel(effect.conversation, effect.options), inflight);
+          break;
+        case "run_tool":
+          batch.push(effect.call);
+          break;
+        case "compact":
+          track(onCompact(effect.messages), inflight);
+          break;
+        case "persist":
+          track(onPersist(effect.snapshot), inflight);
+          break;
+      }
+    }
+    if (batch.length > 0) {
+      track(onRunTools(batch), inflight);
+    }
+  }
+  function track(work, inflight) {
+    const tracked = work.finally(() => {
+      inflight.delete(tracked);
+    });
+    inflight.add(tracked);
+  }
+  async function drive(seed) {
+    const inflight = /* @__PURE__ */ new Set();
+    const maxTurns = config.maxTurns ?? 64;
+    let modelTurns = 0;
+    queue.push(seed);
+    for (; ; ) {
+      while (isTerminal(snapshot) && !queue.hasPending) {
+        if (inflight.size === 0) return snapshot;
+        await Promise.race([...inflight]);
+      }
+      const signal = await queue.pull();
+      const transition = step2(snapshot, signal);
+      snapshot = transition.state;
+      const invokes = transition.effects.reduce(
+        (n, e) => e.kind === "invoke_model" ? n + 1 : n,
+        0
+      );
+      if (invokes > 0 && modelTurns + invokes > maxTurns) {
+        queue.push({
+          kind: "fault",
+          error: runError(
+            "turn_budget",
+            `run exceeded its ${maxTurns}-turn budget`
+          )
+        });
+        performAll(
+          transition.effects.filter((e) => e.kind !== "invoke_model"),
+          inflight
+        );
+        continue;
+      }
+      modelTurns += invokes;
+      performAll(transition.effects, inflight);
+    }
+  }
+  function submit(input) {
+    const turns = asTurns(input);
+    if (driving) {
+      queue.push({ kind: "submit", input: turns });
+      return driving;
+    }
+    active = new AbortController();
+    const run = drive({ kind: "submit", input: turns }).finally(() => {
+      driving = null;
+      active = null;
+    });
+    driving = run;
+    return run;
+  }
+  function subscribe(handler) {
+    return ledger.subscribe(handler);
+  }
+  function abort() {
+    active?.abort();
+    if (scheduler) scheduler.cancel();
+    queue.push({ kind: "abort" });
+  }
+  function readSnapshot() {
+    return snapshot;
+  }
+  async function resume(targetSession) {
+    if (!store) {
+      throw runErrorThrowable(
+        "invalid_state",
+        "cannot resume without a configured session store"
+      );
+    }
+    const graph = await store.loadSession(targetSession);
+    const leaf = graph.leaf;
+    const history = leaf ? graph.pathTo(leaf) : [];
+    snapshot = {
+      ...initialSnapshot(targetSession, config.model, snapshot.runId),
+      messages: history
+    };
+  }
+  return {
+    submit,
+    subscribe,
+    abort,
+    snapshot: readSnapshot,
+    resume
+  };
+}
+function runErrorThrowable(kind, message) {
+  const err = new Error(message);
+  err.runError = runError(kind, message);
+  return err;
+}
+export {
+  cadence,
+  createAgent,
+  initialSnapshot,
+  runError,
+  cadence as step
+};