@graphrefly/graphrefly 0.45.0 → 0.46.0

package/dist/utils/ai/browser.cjs

@@ -0,0 +1,2169 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/base/resilience/_internal.ts
+function clampNonNegative(value) {
+  return value < 0 ? 0 : value;
+}
+function isNode(x) {
+  return x != null && typeof x === "object" && "cache" in x && typeof x.subscribe === "function";
+}
+var import_core13;
+var init_internal = __esm({
+  "src/base/resilience/_internal.ts"() {
+    "use strict";
+    import_core13 = require("@graphrefly/pure-ts/core");
+  }
+});
+
+// src/base/resilience/backoff.ts
+var NS_PER_SEC;
+var init_backoff = __esm({
+  "src/base/resilience/backoff.ts"() {
+    "use strict";
+    NS_PER_SEC = 1e9;
+  }
+});
+
+// src/utils/ai/browser.ts
+var browser_exports = {};
+__export(browser_exports, {
+  chromeNanoAdapter: () => chromeNanoAdapter,
+  cloudFirstPreset: () => cloudFirstPreset,
+  localFirstPreset: () => localFirstPreset,
+  offlinePreset: () => offlinePreset,
+  webllmAdapter: () => webllmAdapter
+});
+module.exports = __toCommonJS(browser_exports);
+
+// src/utils/ai/adapters/providers/browser/chrome-nano.ts
+var import_core = require("@graphrefly/pure-ts/core");
+function makeAbortError() {
+  const err = new Error("aborted");
+  err.name = "AbortError";
+  return err;
+}
+function chromeNanoAdapter(opts = {}) {
+  const streamMode = opts.streamMode ?? "accumulated";
+  const nav = opts.navigatorOverride ?? globalThis.navigator;
+  const getAi = () => {
+    const ai = nav?.ai;
+    if (!ai?.languageModel)
+      throw new Error(
+        "chromeNanoAdapter: Chrome AI languageModel not available (requires Chrome 131+ with flag/OT)."
+      );
+    return ai;
+  };
+  const session = async (invokeOpts) => {
+    const ai = getAi();
+    return ai.languageModel.create({
+      systemPrompt: invokeOpts?.systemPrompt ?? opts.systemPrompt,
+      temperature: invokeOpts?.temperature ?? opts.temperature,
+      topK: opts.topK,
+      signal: invokeOpts?.signal
+    });
+  };
+  const flatten = (messages) => {
+    const parts = [];
+    for (const m of messages) {
+      if (m.role === "system") continue;
+      parts.push(`${m.role}: ${m.content}`);
+    }
+    return parts.join("\n\n");
+  };
+  const zeroUsage = () => ({ input: { regular: 0 }, output: { regular: 0 } });
+  return {
+    provider: "chrome-nano",
+    model: "chrome-nano",
+    async invoke(messages, invokeOpts) {
+      const sess = await session(invokeOpts);
+      try {
+        const prompt = flatten(messages);
+        const start = (0, import_core.monotonicNs)();
+        const content = await sess.prompt(prompt, { signal: invokeOpts?.signal });
+        const latencyMs = Math.max(0, ((0, import_core.monotonicNs)() - start) / 1e6);
+        return {
+          content,
+          usage: zeroUsage(),
+          finishReason: "stop",
+          latencyMs,
+          model: "chrome-nano",
+          provider: "chrome-nano"
+        };
+      } finally {
+        sess.destroy?.();
+      }
+    },
+    async *stream(messages, invokeOpts) {
+      const sess = await session(invokeOpts);
+      try {
+        const prompt = flatten(messages);
+        if (streamMode === "delta") {
+          for await (const chunk of sess.promptStreaming(prompt, {
+            signal: invokeOpts?.signal
+          })) {
+            if (invokeOpts?.signal?.aborted) throw makeAbortError();
+            if (chunk) yield { type: "token", delta: chunk };
+          }
+        } else {
+          let last = "";
+          for await (const chunk of sess.promptStreaming(prompt, {
+            signal: invokeOpts?.signal
+          })) {
+            if (invokeOpts?.signal?.aborted) throw makeAbortError();
+            const delta = chunk.startsWith(last) ? chunk.slice(last.length) : chunk;
+            last = chunk;
+            if (delta) yield { type: "token", delta };
+          }
+        }
+        yield { type: "usage", usage: zeroUsage() };
+        yield { type: "finish", reason: "stop" };
+      } finally {
+        sess.destroy?.();
+      }
+    }
+  };
+}
+
+// src/utils/ai/adapters/providers/browser/webllm.ts
+var import_core2 = require("@graphrefly/pure-ts/core");
+function makeAbortError2() {
+  const err = new Error("aborted");
+  err.name = "AbortError";
+  return err;
+}
+function webllmAdapter(opts) {
+  let engine = opts.engine;
+  const ensureEngine = async () => {
+    if (engine) return engine;
+    if (!isWebGpuAvailable(opts.navigatorOverride))
+      throw new Error("webllmAdapter: WebGPU not available in this environment");
+    const mod = await import("@mlc-ai/web-llm").catch(() => {
+      throw new Error(
+        "webllmAdapter: @mlc-ai/web-llm not installed. Add it as a peer dependency or pass opts.engine."
+      );
+    });
+    const factory = mod.CreateMLCEngine;
+    if (!factory) throw new Error("webllmAdapter: @mlc-ai/web-llm missing CreateMLCEngine export");
+    engine = await factory(opts.model, { initProgressCallback: opts.initProgressCallback });
+    return engine;
+  };
+  const flatten = (messages, invokeOpts) => {
+    const flat = [];
+    if (invokeOpts?.systemPrompt) flat.push({ role: "system", content: invokeOpts.systemPrompt });
+    for (const m of messages)
+      flat.push({ role: m.role === "tool" ? "user" : m.role, content: m.content });
+    return flat;
+  };
+  const mapUsage4 = (u) => ({
+    input: { regular: u?.prompt_tokens ?? 0 },
+    output: { regular: u?.completion_tokens ?? 0 },
+    raw: u
+  });
+  return {
+    provider: "webllm",
+    model: opts.model,
+    async invoke(messages, invokeOpts) {
+      const eng = await ensureEngine();
+      const start = (0, import_core2.monotonicNs)();
+      const resp = await eng.chat.completions.create(
+        {
+          model: invokeOpts?.model ?? opts.model,
+          messages: flatten(messages, invokeOpts),
+          max_tokens: invokeOpts?.maxTokens,
+          temperature: invokeOpts?.temperature
+        },
+        { signal: invokeOpts?.signal }
+      );
+      const latencyMs = Math.max(0, ((0, import_core2.monotonicNs)() - start) / 1e6);
+      const choice = resp.choices?.[0];
+      return {
+        content: choice?.message?.content ?? "",
+        usage: mapUsage4(resp.usage),
+        finishReason: choice?.finish_reason,
+        latencyMs,
+        model: opts.model,
+        provider: "webllm"
+      };
+    },
+    async *stream(messages, invokeOpts) {
+      const eng = await ensureEngine();
+      const asyncIter = await eng.chat.completions.create(
+        {
+          model: invokeOpts?.model ?? opts.model,
+          messages: flatten(messages, invokeOpts),
+          max_tokens: invokeOpts?.maxTokens,
+          temperature: invokeOpts?.temperature,
+          stream: true
+        },
+        { signal: invokeOpts?.signal }
+      );
+      let finalUsage;
+      let finishReason;
+      for await (const chunk of asyncIter) {
+        if (invokeOpts?.signal?.aborted) throw makeAbortError2();
+        const c = chunk.choices?.[0];
+        if (c?.delta?.content) yield { type: "token", delta: c.delta.content };
+        if (c?.finish_reason) finishReason = c.finish_reason;
+        if (chunk.usage) finalUsage = chunk.usage;
+      }
+      if (finalUsage) yield { type: "usage", usage: mapUsage4(finalUsage) };
+      yield { type: "finish", reason: finishReason ?? "stop" };
+    }
+  };
+}
+function isWebGpuAvailable(navOverride) {
+  const nav = navOverride ?? globalThis.navigator;
+  return !!(nav && "gpu" in nav && nav.gpu);
+}
+
+// src/utils/ai/adapters/providers/anthropic.ts
+var import_core4 = require("@graphrefly/pure-ts/core");
+
+// src/base/io/http-error.ts
+async function makeHttpError(resp, provider) {
+  let body;
+  try {
+    body = await resp.text();
+  } catch {
+    body = "";
+  }
+  const prefix = provider ?? "HTTP";
+  const err = new Error(
+    `${prefix} API ${resp.status}: ${resp.statusText}${body ? ` \u2014 ${body}` : ""}`
+  );
+  err.status = resp.status;
+  err.headers = resp.headers;
+  return err;
+}
+
+// src/base/io/sse.ts
+var import_core3 = require("@graphrefly/pure-ts/core");
+async function* parseSSEStream(source, opts) {
+  const parse = opts?.parse ?? ((raw) => raw);
+  const externalSignal = opts?.signal;
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let currentEvent = "message";
+  let currentData = [];
+  let currentId;
+  let currentRetry;
+  const queue = [];
+  const flushEvent = () => {
+    if (currentData.length === 0 && currentEvent === "message" && currentId === void 0) {
+      currentData = [];
+      return;
+    }
+    const raw = currentData.join("\n");
+    queue.push({
+      event: currentEvent,
+      data: parse(raw),
+      id: currentId,
+      retry: currentRetry
+    });
+    currentEvent = "message";
+    currentData = [];
+    currentId = void 0;
+    currentRetry = void 0;
+  };
+  const processLine = (line) => {
+    if (line === "") {
+      flushEvent();
+      return;
+    }
+    if (line.startsWith(":")) return;
+    const colon = line.indexOf(":");
+    const field = colon < 0 ? line : line.slice(0, colon);
+    let value = colon < 0 ? "" : line.slice(colon + 1);
+    if (value.startsWith(" ")) value = value.slice(1);
+    switch (field) {
+      case "event":
+        currentEvent = value;
+        break;
+      case "data":
+        currentData.push(value);
+        break;
+      case "id":
+        if (!value.includes("\0")) currentId = value;
+        break;
+      case "retry": {
+        const n = Number(value);
+        if (Number.isFinite(n)) currentRetry = n;
+        break;
+      }
+    }
+  };
+  const processChunk = (chunk, done) => {
+    buffer += decoder.decode(chunk, { stream: !done });
+    const parts = buffer.split(/\r?\n/);
+    buffer = parts.pop() ?? "";
+    for (const line of parts) processLine(line);
+  };
+  const resp = source;
+  const stream = source instanceof ReadableStream ? source : resp && typeof resp === "object" && resp.body instanceof ReadableStream ? resp.body : null;
+  let reader;
+  let iter;
+  let cleanupDone = false;
+  const cleanupReader = () => {
+    if (cleanupDone) return;
+    cleanupDone = true;
+    if (reader) {
+      void reader.cancel().catch(() => void 0);
+    }
+    if (iter && typeof iter.return === "function") {
+      void Promise.resolve(iter.return()).catch(() => void 0);
+    }
+  };
+  const onAbort = () => {
+    cleanupReader();
+  };
+  if (externalSignal) {
+    if (externalSignal.aborted) return;
+    externalSignal.addEventListener("abort", onAbort, { once: true });
+  }
+  try {
+    if (stream) {
+      reader = stream.getReader();
+      while (!externalSignal?.aborted) {
+        const { value, done } = await reader.read();
+        if (done) break;
+        processChunk(value, false);
+        while (queue.length > 0) {
+          const ev = queue.shift();
+          yield ev;
+        }
+      }
+      processChunk(new Uint8Array(), true);
+    } else {
+      const asyncIter = source;
+      iter = asyncIter[Symbol.asyncIterator]();
+      while (!externalSignal?.aborted) {
+        const step = await iter.next();
+        if (step.done) break;
+        processChunk(step.value, false);
+        while (queue.length > 0) {
+          const ev = queue.shift();
+          yield ev;
+        }
+      }
+      processChunk(new Uint8Array(), true);
+    }
+    if (buffer.trim()) {
+      for (const line of buffer.split(/\r?\n/)) processLine(line);
+      flushEvent();
+    }
+    while (queue.length > 0) {
+      const ev = queue.shift();
+      yield ev;
+    }
+  } finally {
+    if (externalSignal) {
+      externalSignal.removeEventListener("abort", onAbort);
+    }
+    cleanupReader();
+  }
+}
+
+// src/utils/ai/adapters/providers/anthropic.ts
+function anthropicAdapter(opts = {}) {
+  if (opts.sdk) return sdkBackedAnthropic(opts);
+  return fetchBackedAnthropic(opts);
+}
+function toAnthropicRequest(messages, invokeOpts, defaultModel, stream) {
+  const model = invokeOpts?.model ?? defaultModel;
+  if (!model)
+    throw new Error("anthropicAdapter: model must be set via options.model or invokeOpts.model");
+  const { system, chat } = partitionSystem(messages, invokeOpts?.systemPrompt);
+  const body = {
+    model,
+    messages: chat.map(toAnthropicMessage),
+    max_tokens: invokeOpts?.maxTokens ?? 4096
+  };
+  if (system) body.system = system;
+  if (invokeOpts?.temperature != null) body.temperature = invokeOpts.temperature;
+  if (invokeOpts?.tools && invokeOpts.tools.length > 0)
+    body.tools = invokeOpts.tools.map(toAnthropicTool);
+  if (invokeOpts?.maxReasoningTokens != null) {
+    body.thinking = { type: "enabled", budget_tokens: invokeOpts.maxReasoningTokens };
+  }
+  if (invokeOpts?.cacheHint) {
+  }
+  if (stream) body.stream = true;
+  if (invokeOpts?.providerExtras) Object.assign(body, invokeOpts.providerExtras);
+  return body;
+}
+function partitionSystem(messages, systemPrompt) {
+  const systemParts = [];
+  if (systemPrompt) systemParts.push(systemPrompt);
+  const chat = [];
+  for (const m of messages) {
+    if (m.role === "system") systemParts.push(m.content);
+    else chat.push(m);
+  }
+  return { system: systemParts.length > 0 ? systemParts.join("\n\n") : void 0, chat };
+}
+function toAnthropicMessage(m) {
+  if (m.role === "tool") {
+    return {
+      role: "user",
+      content: [
+        {
+          type: "tool_result",
+          tool_use_id: m.toolCallId,
+          content: m.content
+        }
+      ]
+    };
+  }
+  if (m.role === "assistant" && m.toolCalls && m.toolCalls.length > 0) {
+    const blocks = [];
+    if (m.content) blocks.push({ type: "text", text: m.content });
+    for (const tc of m.toolCalls) {
+      blocks.push({ type: "tool_use", id: tc.id, name: tc.name, input: tc.arguments });
+    }
+    return { role: "assistant", content: blocks };
+  }
+  return { role: m.role, content: m.content };
+}
+function toAnthropicTool(t) {
+  return {
+    name: t.name,
+    description: t.description,
+    input_schema: t.parameters
+  };
+}
+function mergeAnthropicUsage(prev, next) {
+  if (!prev) return { ...next };
+  const merged = { ...prev };
+  if (next.input_tokens != null) merged.input_tokens = next.input_tokens;
+  if (next.output_tokens != null) merged.output_tokens = next.output_tokens;
+  if (next.cache_read_input_tokens != null)
+    merged.cache_read_input_tokens = next.cache_read_input_tokens;
+  if (next.cache_creation_input_tokens != null)
+    merged.cache_creation_input_tokens = next.cache_creation_input_tokens;
+  if (next.cache_creation) {
+    merged.cache_creation = {
+      ...prev.cache_creation ?? {},
+      ...next.cache_creation
+    };
+  }
+  if (next.server_tool_use) {
+    merged.server_tool_use = {
+      ...prev.server_tool_use ?? {},
+      ...next.server_tool_use
+    };
+  }
+  return merged;
+}
+function mapUsage(u) {
+  const usage = {
+    input: { regular: u?.input_tokens ?? 0 },
+    output: { regular: u?.output_tokens ?? 0 },
+    raw: u
+  };
+  if (u?.cache_read_input_tokens) usage.input.cacheRead = u.cache_read_input_tokens;
+  if (u?.cache_creation) {
+    if (u.cache_creation.ephemeral_5m_input_tokens)
+      usage.input.cacheWrite5m = u.cache_creation.ephemeral_5m_input_tokens;
+    if (u.cache_creation.ephemeral_1h_input_tokens)
+      usage.input.cacheWrite1h = u.cache_creation.ephemeral_1h_input_tokens;
+  } else if (u?.cache_creation_input_tokens) {
+    usage.input.cacheWrite5m = u.cache_creation_input_tokens;
+  }
+  if (u?.server_tool_use?.web_search_requests) {
+    usage.auxiliary = { webSearchRequests: u.server_tool_use.web_search_requests };
+  }
+  return usage;
+}
+function toLLMResponse(msg, latencyMs) {
+  const textParts = [];
+  const toolCalls = [];
+  for (const block of msg.content) {
+    if (block.type === "text" && typeof block.text === "string") {
+      textParts.push(block.text);
+    } else if (block.type === "tool_use") {
+      const tb = block;
+      toolCalls.push({ id: tb.id, name: tb.name, arguments: tb.input ?? {} });
+    }
+  }
+  return {
+    content: textParts.join(""),
+    toolCalls: toolCalls.length > 0 ? toolCalls : void 0,
+    usage: mapUsage(msg.usage),
+    finishReason: msg.stop_reason,
+    latencyMs,
+    model: msg.model,
+    provider: "anthropic"
+  };
+}
+function fetchBackedAnthropic(opts) {
+  const apiKey = opts.apiKey ?? globalThis.process?.env?.ANTHROPIC_API_KEY;
+  if (!apiKey) {
+  }
+  const baseURL = opts.baseURL ?? "https://api.anthropic.com";
+  const anthropicVersion = opts.anthropicVersion ?? "2023-06-01";
+  const fetchImpl = opts.fetchImpl ?? fetch;
+  const commonHeaders = () => {
+    if (!apiKey)
+      throw new Error("anthropicAdapter: apiKey required for invoke/stream (or provide opts.sdk)");
+    return {
+      "x-api-key": apiKey,
+      "anthropic-version": anthropicVersion,
+      "content-type": "application/json",
+      ...opts.headers ?? {}
+    };
+  };
+  return {
+    provider: "anthropic",
+    model: opts.model,
+    async invoke(messages, invokeOpts) {
+      const body = toAnthropicRequest(messages, invokeOpts, opts.model, false);
+      const start = (0, import_core4.monotonicNs)();
+      const resp = await fetchImpl(`${baseURL}/v1/messages`, {
+        method: "POST",
+        headers: commonHeaders(),
+        body: JSON.stringify(body),
+        signal: invokeOpts?.signal
+      });
+      if (!resp.ok) throw await makeHttpError(resp, "Anthropic");
+      const json = await resp.json();
+      const latencyMs = Math.max(0, ((0, import_core4.monotonicNs)() - start) / 1e6);
+      return toLLMResponse(json, latencyMs);
+    },
+    async *stream(messages, invokeOpts) {
+      const body = toAnthropicRequest(messages, invokeOpts, opts.model, true);
+      const resp = await fetchImpl(`${baseURL}/v1/messages`, {
+        method: "POST",
+        headers: { ...commonHeaders(), accept: "text/event-stream" },
+        body: JSON.stringify(body),
+        signal: invokeOpts?.signal
+      });
+      if (!resp.ok) throw await makeHttpError(resp, "Anthropic");
+      if (!resp.body) throw new Error("anthropicAdapter: streaming response has no body");
+      let finalUsage;
+      let finishReason;
+      const toolCallsByIndex = /* @__PURE__ */ new Map();
+      for await (const event of parseSSEStream(resp.body, { signal: invokeOpts?.signal })) {
+        const data = event.data;
+        if (!data) continue;
+        let parsed;
+        try {
+          parsed = JSON.parse(data);
+        } catch {
+          continue;
+        }
+        switch (parsed.type) {
+          case "message_start": {
+            const ms = parsed;
+            finalUsage = mergeAnthropicUsage(finalUsage, ms.message.usage);
+            break;
+          }
+          case "content_block_start": {
+            const cb = parsed;
+            const b = cb.content_block;
+            if (b.type === "tool_use") {
+              toolCallsByIndex.set(cb.index, {
+                id: String(b.id ?? ""),
+                name: String(b.name ?? ""),
+                argBuf: ""
+              });
+              yield {
+                type: "tool-call-delta",
+                delta: { id: String(b.id ?? ""), name: String(b.name ?? "") }
+              };
+            }
+            break;
+          }
+          case "content_block_delta": {
+            const cbd = parsed;
+            const d = cbd.delta;
+            if (d.type === "text_delta" && typeof d.text === "string") {
+              yield { type: "token", delta: d.text };
+            } else if (d.type === "input_json_delta" && typeof d.partial_json === "string") {
+              const existing = toolCallsByIndex.get(cbd.index);
+              if (existing) existing.argBuf += d.partial_json;
+              yield {
+                type: "tool-call-delta",
+                delta: { argumentsDelta: d.partial_json }
+              };
+            } else if (d.type === "thinking_delta" && typeof d.thinking === "string") {
+              yield { type: "thinking", delta: d.thinking };
+            }
+            break;
+          }
+          case "message_delta": {
+            const md = parsed;
+            if (md.delta.stop_reason) finishReason = md.delta.stop_reason;
+            if (md.delta.usage) {
+              finalUsage = mergeAnthropicUsage(finalUsage, md.delta.usage);
+            }
+            break;
+          }
+          case "message_stop":
+            break;
+        }
+      }
+      if (finalUsage) yield { type: "usage", usage: mapUsage(finalUsage) };
+      yield { type: "finish", reason: finishReason ?? "stop" };
+    }
+  };
+}
+function sdkBackedAnthropic(opts) {
+  const sdk = opts.sdk;
+  if (!sdk) throw new Error("sdkBackedAnthropic: sdk instance required");
+  return {
+    provider: "anthropic",
+    model: opts.model,
+    async invoke(messages, invokeOpts) {
+      const body = toAnthropicRequest(messages, invokeOpts, opts.model, false);
+      const start = (0, import_core4.monotonicNs)();
+      const resp = await sdk.messages.create(body, {
+        signal: invokeOpts?.signal
+      });
+      const latencyMs = Math.max(0, ((0, import_core4.monotonicNs)() - start) / 1e6);
+      return toLLMResponse(resp, latencyMs);
+    },
+    async *stream(messages, invokeOpts) {
+      if (!sdk.messages.stream) {
+        throw new Error("sdkBackedAnthropic: SDK instance does not expose .messages.stream");
+      }
+      const body = toAnthropicRequest(messages, invokeOpts, opts.model, true);
+      let finalUsage;
+      let finishReason;
+      for await (const event of sdk.messages.stream(body, { signal: invokeOpts?.signal })) {
+        switch (event.type) {
+          case "message_start":
+            finalUsage = mergeAnthropicUsage(
+              finalUsage,
+              event.message.usage
+            );
+            break;
+          case "content_block_delta": {
+            const d = event.delta;
+            if (d?.type === "text_delta" && typeof d.text === "string") {
+              yield { type: "token", delta: d.text };
+            } else if (d?.type === "input_json_delta" && typeof d.partial_json === "string") {
+              yield { type: "tool-call-delta", delta: { argumentsDelta: d.partial_json } };
+            } else if (d?.type === "thinking_delta" && typeof d.thinking === "string") {
+              yield { type: "thinking", delta: d.thinking };
+            }
+            break;
+          }
+          case "message_delta": {
+            const md = event;
+            if (md.delta.stop_reason) finishReason = md.delta.stop_reason;
+            if (md.delta.usage) finalUsage = mergeAnthropicUsage(finalUsage, md.delta.usage);
+            break;
+          }
+        }
+      }
+      if (finalUsage) yield { type: "usage", usage: mapUsage(finalUsage) };
+      yield { type: "finish", reason: finishReason ?? "stop" };
+    }
+  };
+}
+
+// src/utils/ai/adapters/providers/dry-run.ts
+var import_core5 = require("@graphrefly/pure-ts/core");
+function makeAbortError3() {
+  const err = new Error("aborted");
+  err.name = "AbortError";
+  return err;
+}
+function sleep(ms, signal) {
+  if (ms <= 0) return Promise.resolve();
+  if (signal?.aborted) return Promise.reject(makeAbortError3());
+  return new Promise((resolve, reject) => {
+    const timer = new import_core5.ResettableTimer();
+    let onAbort;
+    const cleanup = () => {
+      timer.cancel();
+      if (signal && onAbort) signal.removeEventListener("abort", onAbort);
+    };
+    timer.start(ms, () => {
+      cleanup();
+      resolve();
+    });
+    if (signal) {
+      onAbort = () => {
+        cleanup();
+        reject(makeAbortError3());
+      };
+      signal.addEventListener("abort", onAbort, { once: true });
+    }
+  });
+}
+function dryRunAdapter(opts = {}) {
+  const provider = opts.provider ?? "dry-run";
+  const model = opts.model ?? "dry-run-v1";
+  const latencyMs = opts.latencyMs ?? 0;
+  const streamChunkSize = Math.max(1, opts.streamChunkSize ?? 16);
+  const respondFn = opts.respond ?? ((msgs) => {
+    const lastUser = [...msgs].reverse().find((m) => m.role === "user");
+    return lastUser ? `echo: ${lastUser.content}` : "dry-run: no user message";
+  });
+  const usageFn = opts.usage ?? ((msgs, content) => {
+    const totalInput = msgs.reduce((s, m) => s + m.content.length, 0);
+    return {
+      input: { regular: Math.ceil(totalInput / 4) },
+      output: { regular: Math.ceil(content.length / 4) }
+    };
+  });
+  return {
+    provider,
+    model,
+    async invoke(messages, invokeOpts) {
+      await sleep(latencyMs, invokeOpts?.signal);
+      if (invokeOpts?.signal?.aborted) throw makeAbortError3();
+      const content = respondFn(messages, invokeOpts);
+      const usage = usageFn(messages, content);
+      return {
+        content,
+        usage,
+        finishReason: "stop",
+        model: invokeOpts?.model ?? model,
+        provider,
+        tier: invokeOpts?.tier,
+        metadata: { dryRun: true }
+      };
+    },
+    async *stream(messages, invokeOpts) {
+      const content = respondFn(messages, invokeOpts);
+      const usage = usageFn(messages, content);
+      const chunkCount = Math.ceil(content.length / streamChunkSize) || 1;
+      const perChunkMs = latencyMs > 0 ? latencyMs / chunkCount : 0;
+      for (let i = 0; i < content.length; i += streamChunkSize) {
+        if (invokeOpts?.signal?.aborted) throw makeAbortError3();
+        await sleep(perChunkMs, invokeOpts?.signal);
+        yield { type: "token", delta: content.slice(i, i + streamChunkSize) };
+      }
+      yield { type: "usage", usage };
+      yield { type: "finish", reason: "stop" };
+    }
+  };
+}
+
+// src/utils/ai/adapters/providers/fallback.ts
+var import_core10 = require("@graphrefly/pure-ts/core");
+var import_extra5 = require("@graphrefly/pure-ts/extra");
+
+// src/utils/ai/adapters/middleware/replay-cache.ts
+var import_core9 = require("@graphrefly/pure-ts/core");
+var import_extra4 = require("@graphrefly/pure-ts/extra");
+
+// src/base/composition/single-from-any.ts
+var import_core7 = require("@graphrefly/pure-ts/core");
+var import_extra = require("@graphrefly/pure-ts/extra");
+
+// src/base/sources/settled.ts
+var import_core6 = require("@graphrefly/pure-ts/core");
+function firstValueFrom(source) {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    let shouldUnsub = false;
+    let unsub;
+    unsub = source.subscribe((msgs) => {
+      for (const m of msgs) {
+        if (settled) return;
+        if (m[0] === import_core6.DATA) {
+          settled = true;
+          resolve(m[1]);
+          if (unsub) {
+            unsub();
+            unsub = void 0;
+          } else shouldUnsub = true;
+          return;
+        }
+        if (m[0] === import_core6.ERROR) {
+          settled = true;
+          reject(m[1]);
+          if (unsub) {
+            unsub();
+            unsub = void 0;
+          } else shouldUnsub = true;
+          return;
+        }
+        if (m[0] === import_core6.COMPLETE) {
+          settled = true;
+          reject(new Error("completed without DATA"));
+          if (unsub) {
+            unsub();
+            unsub = void 0;
+          } else shouldUnsub = true;
+          return;
+        }
+      }
+    });
+    if (shouldUnsub) {
+      unsub?.();
+      unsub = void 0;
+    }
+  });
+}
+
+// src/base/composition/single-from-any.ts
+function singleFromAny(factory, opts = {}) {
+  const keyFn = opts.keyFn ?? ((k) => String(k));
+  const inFlight = /* @__PURE__ */ new Map();
+  return (key) => {
+    const k = keyFn(key);
+    const existing = inFlight.get(k);
+    if (existing) return existing;
+    const input = factory(key);
+    let rawPromise;
+    if (input != null && typeof input.then === "function") {
+      rawPromise = Promise.resolve(input);
+    } else if (input != null && typeof input === "object" && "subscribe" in input && "cache" in input) {
+      rawPromise = firstValueFrom(input);
+    } else if (input != null && typeof input === "object" && Symbol.asyncIterator in input) {
+      rawPromise = (async () => {
+        const iter = input[Symbol.asyncIterator]();
+        try {
+          const { value, done } = await iter.next();
+          if (done) throw new Error("singleFromAny: factory returned empty async iterable");
+          return value;
+        } finally {
+          await iter.return?.();
+        }
+      })();
+    } else if (input != null && typeof input === "object" && Symbol.iterator in input) {
+      rawPromise = (async () => {
+        const iter = input[Symbol.iterator]();
+        try {
+          const { value, done } = iter.next();
+          if (done) throw new Error("singleFromAny: factory returned empty iterable");
+          return value;
+        } finally {
+          iter.return?.();
+        }
+      })();
+    } else {
+      rawPromise = Promise.resolve(input);
+    }
+    let tracked;
+    const cleanup = () => {
+      if (inFlight.get(k) === tracked) inFlight.delete(k);
+    };
+    tracked = rawPromise.then(
+      (v) => {
+        cleanup();
+        return v;
+      },
+      (e) => {
+        cleanup();
+        throw e;
+      }
+    );
+    inFlight.set(k, tracked);
+    return tracked;
+  };
+}
+
+// src/utils/ai/adapters/_internal/content-addressed-cache.ts
+var import_extra2 = require("@graphrefly/pure-ts/extra");
+function contentAddressedCache(opts) {
+  const { storage, mode = "read-write", keyFn, keyPrefix = "llm-replay" } = opts;
+  const substrateMode = mode === "read-strict" ? "read" : mode;
+  const substrate = (0, import_extra2.contentAddressedStorage)({
+    storage,
+    keyPrefix,
+    mode: substrateMode,
+    keyContext: ({ messages, opts: invokeOpts }) => {
+      const { signal: _signal, keyContext: _keyContext, ...rest } = invokeOpts ?? {};
+      return { messages, opts: rest };
+    }
+  });
+  async function keyFor(messages, invokeOpts) {
+    if (keyFn) {
+      if (keyFn.length <= 1) {
+        const ctx = {
+          messages,
+          opts: invokeOpts,
+          context: invokeOpts?.keyContext
+        };
+        const raw2 = await keyFn(ctx);
+        return `${keyPrefix}:${raw2}`;
+      }
+      const raw = await keyFn(messages, invokeOpts);
+      return `${keyPrefix}:${raw}`;
+    }
+    return substrate.keyFor({ messages, opts: invokeOpts });
+  }
+  return {
+    keyFor,
+    async lookup(messages, invokeOpts) {
+      if (mode === "write") return void 0;
+      if (keyFn) {
+        const key = await keyFor(messages, invokeOpts);
+        const raw = await storage.load(key);
+        if (raw === void 0) return void 0;
+        return raw;
+      }
+      return substrate.lookup({ messages, opts: invokeOpts });
+    },
+    async store(messages, invokeOpts, value) {
+      if (mode === "read") return;
+      if (keyFn) {
+        const key = await keyFor(messages, invokeOpts);
+        await storage.save(key, value);
+        return;
+      }
+      await substrate.store({ messages, opts: invokeOpts }, value);
+    },
+    async forget(messages, invokeOpts) {
+      if (mode === "read" || mode === "write") return;
+      if (!storage.delete) return;
+      if (keyFn) {
+        const key = await keyFor(messages, invokeOpts);
+        await storage.delete(key);
+        return;
+      }
+      await substrate.forget({ messages, opts: invokeOpts });
+    }
+  };
+}
+
+// src/utils/ai/adapters/_internal/wrappers.ts
+var import_core8 = require("@graphrefly/pure-ts/core");
+var import_extra3 = require("@graphrefly/pure-ts/extra");
+function adapterWrapper(inner, impl, override) {
+  return {
+    provider: override?.provider ?? inner.provider,
+    model: override?.model ?? inner.model,
+    capabilities: override?.capabilities ?? inner.capabilities?.bind(inner),
+    invoke: impl.invoke,
+    stream: impl.stream
+  };
+}
+var MIDDLEWARE_LAYERS = /* @__PURE__ */ Symbol.for("graphrefly.adapter.middlewareLayers");
+function withLayer(adapter, layerName, inner) {
+  const innerLayers = inner ? readLayers(inner) : [];
+  const chain = [...innerLayers, layerName];
+  Object.defineProperty(adapter, MIDDLEWARE_LAYERS, {
+    value: Object.freeze(chain),
+    enumerable: false,
+    writable: false,
+    configurable: false
+  });
+  return adapter;
+}
+function readLayers(adapter) {
+  const v = adapter[MIDDLEWARE_LAYERS];
+  return Array.isArray(v) ? v : [];
+}
+
+// src/utils/ai/adapters/middleware/replay-cache.ts
+var ReplayCacheMissError = class extends Error {
+  constructor(key, method) {
+    super(`withReplayCache: no cached response for ${method} (key=${key}, mode=read-strict)`);
+    this.key = key;
+    this.method = method;
+  }
+  name = "ReplayCacheMissError";
+};
+function withReplayCache(inner, opts) {
+  const mode = opts.mode ?? "read-write";
+  const cacheStreaming = opts.cacheStreaming ?? false;
+  const captureStreamCadence = opts.captureStreamCadence ?? false;
+  const replaySpeed = opts.replaySpeed ?? 1;
+  const keyPrefix = opts.keyPrefix ?? "llm-replay";
+  const isReadOnly = mode === "read" || mode === "read-strict";
+  const cache = contentAddressedCache({
+    storage: opts.storage,
+    mode: mode === "write-only" ? "write" : mode,
+    keyFn: opts.keyFn,
+    keyPrefix
+  });
+  const sleepMs = (ms) => ms <= 0 ? Promise.resolve() : new Promise((resolve) => {
+    const t = new import_core9.ResettableTimer();
+    t.start(ms, () => resolve());
+  });
+  const upstreamInFlight = singleFromAny(
+    async ({ messages, invokeOpts }) => {
+      return await firstValueFrom((0, import_extra4.fromAny)(inner.invoke(messages, invokeOpts)));
+    },
+    { keyFn: ({ _precomputedKey }) => _precomputedKey }
+  );
+  const wrap = adapterWrapper(inner, {
+    async invoke(messages, invokeOpts) {
+      const key = await cache.keyFor(messages, invokeOpts);
+      const entry = await cache.lookup(messages, invokeOpts);
+      if (entry?.response) {
+        const cached = entry.response;
+        return { ...cached, metadata: { ...cached.metadata ?? {}, replayCache: "hit" } };
+      }
+      if (mode === "read-strict") throw new ReplayCacheMissError(key, "invoke");
+      const resp = await upstreamInFlight({ messages, invokeOpts, _precomputedKey: key });
+      if (!isReadOnly) {
+        await cache.store(messages, invokeOpts, { response: resp, storedAtNs: (0, import_core9.wallClockNs)() });
+      }
+      return resp;
+    },
+    async *stream(messages, invokeOpts) {
+      if (!cacheStreaming) {
+        for await (const delta of inner.stream(messages, invokeOpts)) yield delta;
+        return;
+      }
+      const key = await cache.keyFor(messages, invokeOpts);
+      const entry = await cache.lookup(messages, invokeOpts);
+      if (entry) {
+        const cached = entry.response;
+        if (entry.streamChunks && entry.streamCadenceMs) {
+          for (let i = 0; i < entry.streamChunks.length; i++) {
+            const delay = entry.streamCadenceMs[i] ?? 0;
+            const effective = replaySpeed > 0 ? delay / replaySpeed : 0;
+            if (effective > 0) await sleepMs(effective);
+            yield { type: "token", delta: entry.streamChunks[i]?.delta ?? "" };
+          }
+        } else if (cached.content) {
+          yield { type: "token", delta: cached.content };
+        }
+        if (cached.usage) yield { type: "usage", usage: cached.usage };
+        yield { type: "finish", reason: cached.finishReason ?? "stop" };
+        return;
+      }
+      if (mode === "read-strict") throw new ReplayCacheMissError(key, "stream");
+      let content = "";
+      let usage;
+      let finishReason;
+      const chunks = [];
+      const delaysMs = [];
+      let lastNs;
+      for await (const delta of inner.stream(messages, invokeOpts)) {
+        if (delta.type === "token") {
+          content += delta.delta;
+          if (captureStreamCadence) {
+            const now = (0, import_core9.monotonicNs)();
+            const gap = lastNs === void 0 ? 0 : (now - lastNs) / 1e6;
+            delaysMs.push(gap);
+            lastNs = now;
+            chunks.push({ delta: delta.delta });
+          }
+        }
+        if (delta.type === "usage") usage = delta.usage;
+        if (delta.type === "finish") finishReason = delta.reason;
+        yield delta;
+      }
+      if ((content || usage) && !isReadOnly) {
+        const resp = {
+          content,
+          usage: usage ?? { input: { regular: 0 }, output: { regular: 0 } },
+          finishReason,
+          model: inner.model ?? invokeOpts?.model ?? "",
+          provider: inner.provider
+        };
+        const entryToStore = {
+          response: resp,
+          storedAtNs: (0, import_core9.wallClockNs)(),
+          ...captureStreamCadence ? { streamChunks: chunks, streamCadenceMs: delaysMs } : {}
+        };
+        await cache.store(messages, invokeOpts, entryToStore);
+      }
+    }
+  });
+  withLayer(wrap, "withReplayCache", inner);
+  return wrap;
+}
+
+// src/utils/ai/adapters/providers/fallback.ts
+function degradedResponse(provider, model) {
+  return {
+    content: "[fallback: no cached response available for this request]",
+    usage: { input: { regular: 0 }, output: { regular: 0 } },
+    finishReason: "stop",
+    model,
+    provider,
+    metadata: { degraded: true, reason: "no-fixture" }
+  };
+}
+function normalizeRespondResult(raw, provider, model) {
+  if (typeof raw === "string") {
+    return {
+      content: raw,
+      usage: { input: { regular: 0 }, output: { regular: 0 } },
+      finishReason: "stop",
+      model,
+      provider,
+      metadata: { degraded: true, reason: "respond" }
+    };
+  }
+  return raw;
+}
+async function fixtureKey(fixture, keyPrefix) {
+  if ("key" in fixture) return fixture.key;
+  const canonical = (0, import_extra5.canonicalJson)({ messages: fixture.messages, opts: fixture.invokeOpts ?? {} });
+  const hex = await (0, import_core10.sha256Hex)(canonical);
+  return `${keyPrefix}:${hex}`;
+}
+function toCachedEntry(fixture) {
+  const base = {
+    response: fixture.response,
+    // Real timestamp so future TTL-aware tiers don't treat inline fixtures
+    // as Epoch-old and evict them on first pass. Matches the wall-clock
+    // write `withReplayCache` uses for disk-written entries.
+    storedAtNs: (0, import_core10.wallClockNs)()
+  };
+  if ("key" in fixture && fixture.stream) {
+    const tokenChunks = fixture.stream.chunks.filter(
+      (c) => c.type === "token"
+    );
+    return {
+      ...base,
+      streamChunks: tokenChunks.map((c) => ({ delta: c.delta })),
+      streamCadenceMs: fixture.stream.delaysMs ?? tokenChunks.map(() => 0)
+    };
+  }
+  return base;
+}
+function resolveFixtureStorage(opts, keyPrefix) {
+  const sources = [];
+  if (opts.fixtures != null) sources.push("fixtures");
+  if (opts.fixturesStorage != null) sources.push("fixturesStorage");
+  if (sources.length > 1) {
+    throw new TypeError(
+      `fallbackAdapter: \`fixtures\` and \`fixturesStorage\` are mutually exclusive; got both ${sources.join(" and ")}. Pick one source. For filesystem directories use the node subpath's \`fallbackAdapter\`.`
+    );
+  }
+  if (opts.fixtures) {
+    const tier = (0, import_extra5.memoryKv)();
+    const fixtures = opts.fixtures;
+    const seedReady = (async () => {
+      for (const fixture of fixtures) {
+        const key = await fixtureKey(fixture, keyPrefix);
+        await tier.save(key, toCachedEntry(fixture));
+      }
+    })();
+    seedReady.catch(() => {
+    });
+    return { tier, seedReady };
+  }
+  if (opts.fixturesStorage) return { tier: opts.fixturesStorage, seedReady: Promise.resolve() };
+  return { tier: void 0, seedReady: Promise.resolve() };
+}
+function fallbackAdapter(opts = {}) {
+  const provider = opts.provider ?? "fallback";
+  const model = opts.model ?? "fallback";
+  const onMiss = opts.onMiss ?? "respond";
+  const keyPrefix = opts.keyPrefix ?? "fallback";
+  const leaf = (() => {
+    if (opts.record) return opts.record.adapter;
+    if (onMiss === "throw") {
+      return dryRunAdapter({
+        provider,
+        model,
+        respond: () => "[unreachable: read-strict mode throws on miss]"
+      });
+    }
+    return {
+      provider,
+      model,
+      async invoke(messages, invokeOpts) {
+        const raw = opts.respond ? opts.respond(messages, invokeOpts) : degradedResponse(provider, model);
+        return normalizeRespondResult(raw, provider, model);
+      },
+      async *stream(messages, invokeOpts) {
+        const raw = opts.respond ? opts.respond(messages, invokeOpts) : degradedResponse(provider, model);
+        const r = normalizeRespondResult(raw, provider, model);
+        yield { type: "token", delta: r.content };
+        if (r.usage) yield { type: "usage", usage: r.usage };
+        yield { type: "finish", reason: r.finishReason ?? "stop" };
+      }
+    };
+  })();
+  let storage;
+  let seedReady = Promise.resolve();
+  if (opts.record) {
+    if (!opts.record.storage) {
+      throw new TypeError(
+        "fallbackAdapter: `record.storage` is required in record mode. For filesystem `record.dir` convenience, use the node subpath's `fallbackAdapter`."
+      );
+    }
+    storage = opts.record.storage;
+  } else {
+    const resolved = resolveFixtureStorage(opts, keyPrefix);
+    storage = resolved.tier ?? (0, import_extra5.memoryKv)();
+    seedReady = resolved.seedReady;
+  }
+  const mode = opts.record ? "read-write" : onMiss === "throw" ? "read-strict" : "read";
+  const cached = withReplayCache(leaf, {
+    storage,
+    mode,
+    keyPrefix,
+    cacheStreaming: true,
+    captureStreamCadence: true,
+    replaySpeed: opts.replaySpeed,
+    ...opts.keyFn ? { keyFn: opts.keyFn } : {}
+  });
+  return {
+    provider,
+    model,
+    capabilities: cached.capabilities?.bind(cached),
+    async invoke(messages, invokeOpts) {
+      await seedReady;
+      return cached.invoke(messages, invokeOpts);
+    },
+    async *stream(messages, invokeOpts) {
+      await seedReady;
+      for await (const delta of cached.stream(messages, invokeOpts)) yield delta;
+    }
+  };
+}
+
+// src/utils/ai/adapters/providers/google.ts
+var import_core11 = require("@graphrefly/pure-ts/core");
+function googleAdapter(opts = {}) {
+  if (opts.sdk) return sdkBackedGoogle(opts);
+  return fetchBackedGoogle(opts);
+}
+function toGeminiRequest(messages, invokeOpts) {
+  const systemParts = [];
+  const contents = [];
+  if (invokeOpts?.systemPrompt) systemParts.push(invokeOpts.systemPrompt);
+  for (const m of messages) {
+    if (m.role === "system") {
+      systemParts.push(m.content);
+      continue;
+    }
+    if (m.role === "tool") {
+      contents.push({
+        role: "user",
+        parts: [
+          {
+            functionResponse: {
+              name: m.name ?? m.toolCallId ?? "tool",
+              response: { result: m.content }
+            }
+          }
+        ]
+      });
+      continue;
+    }
+    if (m.role === "assistant" && m.toolCalls && m.toolCalls.length > 0) {
+      const parts = [];
+      if (m.content) parts.push({ text: m.content });
+      for (const tc of m.toolCalls) {
+        parts.push({ functionCall: { name: tc.name, args: tc.arguments } });
+      }
+      contents.push({ role: "model", parts });
+      continue;
+    }
+    contents.push({
+      role: m.role === "assistant" ? "model" : "user",
+      parts: [{ text: m.content }]
+    });
+  }
+  const body = { contents };
+  if (systemParts.length > 0) {
+    body.systemInstruction = { role: "system", parts: [{ text: systemParts.join("\n\n") }] };
+  }
+  const genConfig = {};
+  if (invokeOpts?.maxTokens != null) genConfig.maxOutputTokens = invokeOpts.maxTokens;
+  if (invokeOpts?.temperature != null) genConfig.temperature = invokeOpts.temperature;
+  if (invokeOpts?.maxReasoningTokens != null) {
+    genConfig.thinkingConfig = { thinkingBudget: invokeOpts.maxReasoningTokens };
+  }
+  if (Object.keys(genConfig).length > 0) body.generationConfig = genConfig;
+  if (invokeOpts?.tools && invokeOpts.tools.length > 0) {
+    body.tools = [{ functionDeclarations: invokeOpts.tools.map(toGeminiTool) }];
+  }
+  if (invokeOpts?.providerExtras) Object.assign(body, invokeOpts.providerExtras);
+  return body;
+}
+function toGeminiTool(t) {
+  return {
+    name: t.name,
+    description: t.description,
+    parameters: t.parameters
+  };
+}
+function toSdkParams(body, model, signal) {
+  const config = {};
+  const gen = body.generationConfig;
+  if (gen) {
+    if (typeof gen.maxOutputTokens === "number") config.maxOutputTokens = gen.maxOutputTokens;
+    if (typeof gen.temperature === "number") config.temperature = gen.temperature;
+    if (gen.thinkingConfig) config.thinkingConfig = gen.thinkingConfig;
+  }
+  if (body.systemInstruction) config.systemInstruction = body.systemInstruction;
+  if (body.tools) config.tools = body.tools;
+  for (const [k, v] of Object.entries(body)) {
+    if (k === "contents" || k === "generationConfig" || k === "systemInstruction" || k === "tools" || // Skip `abortSignal` so a caller-supplied entry in `providerExtras`
+    // can't briefly land in `config.abortSignal` before being
+    // overwritten — the canonical signal channel is the second
+    // `signal` argument (set on `config.abortSignal` below).
+    k === "abortSignal" || // Skip `model` so a stray `body.model` (not produced by
+    // `toGeminiRequest` today, but defensively guarded) doesn't
+    // duplicate the top-level `model` field on the SDK request.
+    k === "model") {
+      continue;
+    }
+    config[k] = v;
+  }
+  if (signal) config.abortSignal = signal;
+  return {
+    model,
+    contents: body.contents,
+    config: Object.keys(config).length > 0 ? config : void 0
+  };
+}
+function mapUsage2(u) {
+  const usage = {
+    input: { regular: 0 },
+    output: { regular: 0 },
+    raw: u
+  };
+  if (!u) return usage;
+  const promptTotal = u.promptTokenCount ?? 0;
+  const cached = u.cachedContentTokenCount ?? 0;
+  usage.input.regular = Math.max(0, promptTotal - cached);
+  if (cached > 0) usage.input.cacheRead = cached;
+  if (u.toolUsePromptTokenCount) usage.input.toolUse = u.toolUsePromptTokenCount;
+  if (u.promptTokensDetails) {
+    for (const d of u.promptTokensDetails) {
+      const modality = d.modality?.toLowerCase();
+      if (modality === "image") usage.input.image = (usage.input.image ?? 0) + d.tokenCount;
+      else if (modality === "audio") usage.input.audio = (usage.input.audio ?? 0) + d.tokenCount;
+      else if (modality === "video") usage.input.video = (usage.input.video ?? 0) + d.tokenCount;
+    }
+  }
+  usage.output.regular = u.candidatesTokenCount ?? 0;
+  if (u.thoughtsTokenCount) usage.output.reasoning = u.thoughtsTokenCount;
+  return usage;
+}
+function toLLMResponse2(json, latencyMs) {
+  const cand = json.candidates?.[0];
+  const parts = cand?.content?.parts ?? [];
+  const textParts = [];
+  const toolCalls = [];
+  let i = 0;
+  for (const p of parts) {
+    if (typeof p.text === "string") textParts.push(p.text);
+    if (p.functionCall) {
+      toolCalls.push({
+        id: `${p.functionCall.name}-${i++}`,
+        name: p.functionCall.name,
+        arguments: p.functionCall.args ?? {}
+      });
+    }
+  }
+  return {
+    content: textParts.join(""),
+    toolCalls: toolCalls.length > 0 ? toolCalls : void 0,
+    usage: mapUsage2(json.usageMetadata),
+    finishReason: cand?.finishReason,
+    latencyMs,
+    model: json.modelVersion,
+    provider: "google"
+  };
+}
+function resolveApiKey(opts) {
+  if (opts.apiKey) return opts.apiKey;
+  const env = globalThis.process?.env;
+  return env?.GOOGLE_API_KEY ?? env?.GEMINI_API_KEY;
+}
+function fetchBackedGoogle(opts) {
+  const baseURL = opts.baseURL ?? "https://generativelanguage.googleapis.com/v1beta";
+  const fetchImpl = opts.fetchImpl ?? fetch;
+  const pickModel = (invokeOpts) => {
+    const model = invokeOpts?.model ?? opts.model;
+    if (!model)
+      throw new Error("googleAdapter: model must be set via options.model or invokeOpts.model");
+    return model;
+  };
+  const keyParam = () => {
+    const key = resolveApiKey(opts);
+    if (!key) throw new Error("googleAdapter: apiKey required for invoke/stream");
+    return `key=${encodeURIComponent(key)}`;
+  };
+  return {
+    provider: "google",
+    model: opts.model,
+    async invoke(messages, invokeOpts) {
+      const model = pickModel(invokeOpts);
+      const body = toGeminiRequest(messages, invokeOpts);
+      const start = (0, import_core11.monotonicNs)();
+      const url = `${baseURL}/models/${encodeURIComponent(model)}:generateContent?${keyParam()}`;
+      const resp = await fetchImpl(url, {
+        method: "POST",
+        headers: { "content-type": "application/json", ...opts.headers ?? {} },
+        body: JSON.stringify(body),
+        signal: invokeOpts?.signal
+      });
+      if (!resp.ok) throw await makeHttpError(resp, "Google");
+      const json = await resp.json();
+      const latencyMs = Math.max(0, ((0, import_core11.monotonicNs)() - start) / 1e6);
+      return toLLMResponse2(json, latencyMs);
+    },
+    async *stream(messages, invokeOpts) {
+      const model = pickModel(invokeOpts);
+      const body = toGeminiRequest(messages, invokeOpts);
+      const url = `${baseURL}/models/${encodeURIComponent(model)}:streamGenerateContent?alt=sse&${keyParam()}`;
+      const resp = await fetchImpl(url, {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          accept: "text/event-stream",
+          ...opts.headers ?? {}
+        },
+        body: JSON.stringify(body),
+        signal: invokeOpts?.signal
+      });
+      if (!resp.ok) throw await makeHttpError(resp, "Google");
+      if (!resp.body) throw new Error("googleAdapter: streaming response has no body");
+      let finalUsage;
+      let finishReason;
+      for await (const event of parseSSEStream(resp.body, { signal: invokeOpts?.signal })) {
+        if (!event.data) continue;
+        let parsed;
+        try {
+          parsed = JSON.parse(event.data);
+        } catch {
+          continue;
+        }
+        const cand = parsed.candidates?.[0];
+        for (const p of cand?.content?.parts ?? []) {
+          if (typeof p.text === "string") {
+            if (p.thought) yield { type: "thinking", delta: p.text };
+            else yield { type: "token", delta: p.text };
+          }
+          if (p.functionCall) {
+            yield {
+              type: "tool-call-delta",
+              delta: {
+                name: p.functionCall.name,
+                argumentsDelta: JSON.stringify(p.functionCall.args ?? {})
+              }
+            };
+          }
+        }
+        if (cand?.finishReason) finishReason = cand.finishReason;
+        if (parsed.usageMetadata) finalUsage = parsed.usageMetadata;
+      }
+      if (finalUsage) yield { type: "usage", usage: mapUsage2(finalUsage) };
+      yield { type: "finish", reason: finishReason ?? "stop" };
+    }
+  };
+}
+function sdkBackedGoogle(opts) {
+  const sdk = opts.sdk;
+  if (!sdk) throw new Error("sdkBackedGoogle: sdk instance required");
+  return {
+    provider: "google",
+    model: opts.model,
+    async invoke(messages, invokeOpts) {
+      const body = toGeminiRequest(messages, invokeOpts);
+      const model = invokeOpts?.model ?? opts.model;
+      if (!model) throw new Error("googleAdapter: model required");
+      const params = toSdkParams(body, model, invokeOpts?.signal);
+      const start = (0, import_core11.monotonicNs)();
+      const resp = await sdk.models.generateContent(params);
+      const latencyMs = Math.max(0, ((0, import_core11.monotonicNs)() - start) / 1e6);
+      return toLLMResponse2(resp, latencyMs);
+    },
+    async *stream(messages, invokeOpts) {
+      if (!sdk.models.generateContentStream) {
+        throw new Error("sdkBackedGoogle: SDK instance does not expose generateContentStream");
+      }
+      const body = toGeminiRequest(messages, invokeOpts);
+      const model = invokeOpts?.model ?? opts.model;
+      if (!model) throw new Error("googleAdapter: model required");
+      const params = toSdkParams(body, model, invokeOpts?.signal);
+      let finalUsage;
+      let finishReason;
+      const stream = await sdk.models.generateContentStream(params);
+      for await (const chunk of stream) {
+        const cand = chunk.candidates?.[0];
+        for (const p of cand?.content?.parts ?? []) {
+          if (typeof p.text === "string") {
+            if (p.thought) yield { type: "thinking", delta: p.text };
+            else yield { type: "token", delta: p.text };
+          }
+          if (p.functionCall) {
+            yield {
+              type: "tool-call-delta",
+              delta: {
+                name: p.functionCall.name,
+                argumentsDelta: JSON.stringify(p.functionCall.args ?? {})
+              }
+            };
+          }
+        }
+        if (cand?.finishReason) finishReason = cand.finishReason;
+        if (chunk.usageMetadata) finalUsage = chunk.usageMetadata;
+      }
+      if (finalUsage) yield { type: "usage", usage: mapUsage2(finalUsage) };
+      yield { type: "finish", reason: finishReason ?? "stop" };
+    }
+  };
+}
+
+// src/utils/ai/adapters/providers/openai-compat.ts
+var import_core12 = require("@graphrefly/pure-ts/core");
+var PRESETS = {
+  openai: { baseURL: "https://api.openai.com/v1", apiKeyEnv: "OPENAI_API_KEY", provider: "openai" },
+  openrouter: {
+    baseURL: "https://openrouter.ai/api/v1",
+    apiKeyEnv: "OPENROUTER_API_KEY",
+    provider: "openrouter"
+  },
+  groq: { baseURL: "https://api.groq.com/openai/v1", apiKeyEnv: "GROQ_API_KEY", provider: "groq" },
+  ollama: { baseURL: "http://localhost:11434/v1", provider: "ollama" },
+  deepseek: {
+    baseURL: "https://api.deepseek.com/v1",
+    apiKeyEnv: "DEEPSEEK_API_KEY",
+    provider: "deepseek"
+  },
+  xai: { baseURL: "https://api.x.ai/v1", apiKeyEnv: "XAI_API_KEY", provider: "xai" }
+};
+function openAICompatAdapter(opts = {}) {
+  if (opts.sdk) return sdkBackedOpenAI(opts);
+  return fetchBackedOpenAI(opts);
+}
+function toOpenAIRequest(messages, invokeOpts, defaultModel, stream, bodyExtras) {
+  const model = invokeOpts?.model ?? defaultModel;
+  if (!model)
+    throw new Error("openAICompatAdapter: model must be set via options.model or invokeOpts.model");
+  const mapped = messages.map(toOpenAIMessage);
+  if (invokeOpts?.systemPrompt && !messages.some((m) => m.role === "system")) {
+    mapped.unshift({ role: "system", content: invokeOpts.systemPrompt });
+  }
+  const body = { model, messages: mapped };
+  if (invokeOpts?.maxTokens != null) body.max_tokens = invokeOpts.maxTokens;
+  if (invokeOpts?.temperature != null) body.temperature = invokeOpts.temperature;
+  if (invokeOpts?.tools && invokeOpts.tools.length > 0) {
+    body.tools = invokeOpts.tools.map(toOpenAITool);
+  }
+  if (invokeOpts?.maxReasoningTokens != null) {
+    body.reasoning = { max_tokens: invokeOpts.maxReasoningTokens };
+  }
+  if (stream) {
+    body.stream = true;
+    body.stream_options = { include_usage: true };
+  }
+  if (bodyExtras) Object.assign(body, bodyExtras);
+  if (invokeOpts?.providerExtras) Object.assign(body, invokeOpts.providerExtras);
+  return body;
+}
+function toOpenAIMessage(m) {
+  if (m.role === "tool") {
+    return { role: "tool", tool_call_id: m.toolCallId, content: m.content };
+  }
+  if (m.role === "assistant" && m.toolCalls && m.toolCalls.length > 0) {
+    return {
+      role: "assistant",
+      content: m.content || null,
+      tool_calls: m.toolCalls.map((tc) => ({
+        id: tc.id,
+        type: "function",
+        function: { name: tc.name, arguments: JSON.stringify(tc.arguments) }
+      }))
+    };
+  }
+  return { role: m.role, content: m.content };
+}
+function toOpenAITool(t) {
+  return {
+    type: "function",
+    function: {
+      name: t.name,
+      description: t.description,
+      parameters: t.parameters
+    }
+  };
+}
+function mapUsage3(u) {
+  const usage = {
+    input: { regular: 0 },
+    output: { regular: 0 },
+    raw: u
+  };
+  if (!u) return usage;
+  const inputTotal = u.prompt_tokens ?? 0;
+  let cacheRead = u.prompt_tokens_details?.cached_tokens ?? 0;
+  if (u.prompt_cache_hit_tokens != null) {
+    cacheRead = u.prompt_cache_hit_tokens;
+    usage.input.regular = u.prompt_cache_miss_tokens ?? Math.max(0, inputTotal - cacheRead);
+  } else {
+    usage.input.regular = Math.max(0, inputTotal - cacheRead);
+  }
+  if (cacheRead > 0) usage.input.cacheRead = cacheRead;
+  if (u.prompt_tokens_details?.audio_tokens)
+    usage.input.audio = u.prompt_tokens_details.audio_tokens;
+  const outputTotal = u.completion_tokens ?? 0;
+  const reasoning = u.completion_tokens_details?.reasoning_tokens ?? 0;
+  usage.output.regular = Math.max(0, outputTotal - reasoning);
+  if (reasoning > 0) usage.output.reasoning = reasoning;
+  if (u.completion_tokens_details?.audio_tokens)
+    usage.output.audio = u.completion_tokens_details.audio_tokens;
+  if (u.completion_tokens_details?.accepted_prediction_tokens) {
+    usage.output.predictionAccepted = u.completion_tokens_details.accepted_prediction_tokens;
+  }
+  if (u.completion_tokens_details?.rejected_prediction_tokens) {
+    usage.output.predictionRejected = u.completion_tokens_details.rejected_prediction_tokens;
+  }
+  return usage;
+}
+function toLLMResponse3(json, latencyMs, provider) {
+  const choice = json.choices[0];
+  const msg = choice?.message;
+  const content = msg?.content ?? "";
+  const toolCalls = (msg?.tool_calls ?? []).map((tc) => ({
+    id: tc.id,
+    name: tc.function.name,
+    arguments: safeJsonParse(tc.function.arguments)
+  }));
+  return {
+    content,
+    toolCalls: toolCalls.length > 0 ? toolCalls : void 0,
+    usage: mapUsage3(json.usage),
+    finishReason: choice?.finish_reason,
+    latencyMs,
+    model: json.model,
+    provider
+  };
+}
+function safeJsonParse(s) {
+  try {
+    const parsed = JSON.parse(s);
+    return typeof parsed === "object" && parsed != null ? parsed : { _raw: s };
+  } catch {
+    return { _raw: s };
+  }
+}
+function resolveConfig(opts) {
+  const preset = opts.preset ?? "openai";
+  const base = PRESETS[preset];
+  const baseURL = opts.baseURL ?? base.baseURL;
+  const provider = opts.provider ?? base.provider;
+  const envKey = base.apiKeyEnv;
+  const apiKey = opts.apiKey ?? (envKey ? globalThis.process?.env?.[envKey] : void 0);
+  return { provider, baseURL, apiKey };
+}
+function fetchBackedOpenAI(opts) {
+  const { provider, baseURL, apiKey } = resolveConfig(opts);
+  const fetchImpl = opts.fetchImpl ?? fetch;
+  const needsKey = provider !== "ollama";
+  const commonHeaders = () => {
+    const h = {
+      "content-type": "application/json",
+      ...opts.headers ?? {}
+    };
+    if (needsKey) {
+      if (!apiKey)
+        throw new Error(`openAICompatAdapter[${provider}]: apiKey required for invoke/stream`);
+      h.authorization = `Bearer ${apiKey}`;
+    }
+    return h;
+  };
+  return {
+    provider,
+    model: opts.model,
+    async invoke(messages, invokeOpts) {
+      const body = toOpenAIRequest(messages, invokeOpts, opts.model, false, opts.bodyExtras);
+      const start = (0, import_core12.monotonicNs)();
+      const resp = await fetchImpl(`${baseURL}/chat/completions`, {
+        method: "POST",
+        headers: commonHeaders(),
+        body: JSON.stringify(body),
+        signal: invokeOpts?.signal
+      });
+      if (!resp.ok) throw await makeHttpError(resp, provider);
+      const json = await resp.json();
+      const latencyMs = Math.max(0, ((0, import_core12.monotonicNs)() - start) / 1e6);
+      return toLLMResponse3(json, latencyMs, provider);
+    },
+    async *stream(messages, invokeOpts) {
+      const body = toOpenAIRequest(messages, invokeOpts, opts.model, true, opts.bodyExtras);
+      const resp = await fetchImpl(`${baseURL}/chat/completions`, {
+        method: "POST",
+        headers: { ...commonHeaders(), accept: "text/event-stream" },
+        body: JSON.stringify(body),
+        signal: invokeOpts?.signal
+      });
+      if (!resp.ok) throw await makeHttpError(resp, provider);
+      if (!resp.body)
+        throw new Error(`openAICompatAdapter[${provider}]: streaming response has no body`);
+      let finalUsage;
+      let finishReason;
+      for await (const event of parseSSEStream(resp.body, { signal: invokeOpts?.signal })) {
+        if (!event.data || event.data === "[DONE]") continue;
+        let parsed;
+        try {
+          parsed = JSON.parse(event.data);
+        } catch {
+          continue;
+        }
+        const choices = parsed.choices;
+        if (choices) {
+          const c = choices[0];
+          if (c?.delta?.content) yield { type: "token", delta: c.delta.content };
+          if (c?.delta?.reasoning_content) {
+            yield { type: "thinking", delta: c.delta.reasoning_content };
+          }
+          if (c?.delta?.tool_calls) {
+            for (const tc of c.delta.tool_calls) {
+              yield {
+                type: "tool-call-delta",
+                delta: {
+                  id: tc.id,
+                  name: tc.function?.name,
+                  argumentsDelta: tc.function?.arguments
+                }
+              };
+            }
+          }
+          if (c?.finish_reason) finishReason = c.finish_reason;
+        }
+        if (parsed.usage) {
+          finalUsage = parsed.usage;
+          yield { type: "usage", usage: mapUsage3(finalUsage) };
+        }
+      }
+      yield { type: "finish", reason: finishReason ?? "stop" };
+    }
+  };
+}
+function sdkBackedOpenAI(opts) {
+  const sdk = opts.sdk;
+  if (!sdk) throw new Error("sdkBackedOpenAI: sdk instance required");
+  const { provider } = resolveConfig(opts);
+  return {
+    provider,
+    model: opts.model,
+    async invoke(messages, invokeOpts) {
+      const body = toOpenAIRequest(messages, invokeOpts, opts.model, false, opts.bodyExtras);
+      const start = (0, import_core12.monotonicNs)();
+      const resp = await sdk.chat.completions.create(body, { signal: invokeOpts?.signal });
+      const latencyMs = Math.max(0, ((0, import_core12.monotonicNs)() - start) / 1e6);
+      return toLLMResponse3(resp, latencyMs, provider);
+    },
+    async *stream(messages, invokeOpts) {
+      const body = toOpenAIRequest(messages, invokeOpts, opts.model, true, opts.bodyExtras);
+      const stream = await sdk.chat.completions.create(body, {
+        signal: invokeOpts?.signal
+      });
+      let finalUsage;
+      let finishReason;
+      for await (const chunk of stream) {
+        const choices = chunk.choices;
+        if (choices) {
+          const c = choices[0];
+          if (c?.delta?.content) yield { type: "token", delta: c.delta.content };
+          if (c?.delta?.reasoning_content)
+            yield { type: "thinking", delta: c.delta.reasoning_content };
+          if (c?.delta?.tool_calls) {
+            for (const tc of c.delta.tool_calls) {
+              yield {
+                type: "tool-call-delta",
+                delta: {
+                  id: tc.id,
+                  name: tc.function?.name,
+                  argumentsDelta: tc.function?.arguments
+                }
+              };
+            }
+          }
+          if (c?.finish_reason) finishReason = c.finish_reason;
+        }
+        const u = chunk.usage;
+        if (u) {
+          finalUsage = u;
+          yield { type: "usage", usage: mapUsage3(u) };
+        }
+      }
+      if (!finalUsage) {
+      }
+      yield { type: "finish", reason: finishReason ?? "stop" };
+    }
+  };
+}
+
+// src/utils/ai/adapters/core/factory.ts
+function createAdapter(opts) {
+  switch (opts.provider) {
+    case "anthropic": {
+      const a = {
+        apiKey: opts.apiKey,
+        model: opts.model,
+        baseURL: opts.baseURL,
+        headers: opts.headers,
+        sdk: opts.sdk,
+        fetchImpl: opts.fetchImpl,
+        ...opts.extras
+      };
+      return anthropicAdapter(a);
+    }
+    case "google": {
+      const g = {
+        apiKey: opts.apiKey,
+        model: opts.model,
+        baseURL: opts.baseURL,
+        headers: opts.headers,
+        sdk: opts.sdk,
+        fetchImpl: opts.fetchImpl,
+        ...opts.extras
+      };
+      return googleAdapter(g);
+    }
+    case "dry-run": {
+      const d = {
+        model: opts.model,
+        ...opts.extras
+      };
+      return dryRunAdapter(d);
+    }
+    case "fallback": {
+      const f = {
+        provider: opts.provider,
+        model: opts.model,
+        ...opts.extras
+      };
+      return fallbackAdapter(f);
+    }
+    // OpenAI-compat presets
+    case "openai":
+    case "openrouter":
+    case "groq":
+    case "ollama":
+    case "deepseek":
+    case "xai": {
+      const c = {
+        preset: opts.provider,
+        apiKey: opts.apiKey,
+        model: opts.model,
+        baseURL: opts.baseURL,
+        headers: opts.headers,
+        bodyExtras: opts.bodyExtras,
+        sdk: opts.sdk,
+        fetchImpl: opts.fetchImpl,
+        ...opts.extras
+      };
+      return openAICompatAdapter(c);
+    }
+    default: {
+      const never = opts.provider;
+      throw new Error(`createAdapter: unknown provider: ${String(never)}`);
+    }
+  }
+}
+
+// src/utils/ai/adapters/routing/cascading.ts
+var import_extra6 = require("@graphrefly/pure-ts/extra");
+
+// src/utils/resilience/breaker.ts
+var import_core14 = require("@graphrefly/pure-ts/core");
+init_internal();
+init_backoff();
+function circuitBreaker(options) {
+  let threshold = 5;
+  let baseCooldownNs = 30 * NS_PER_SEC;
+  let cooldownStrategy = null;
+  let halfOpenMax = 1;
+  let now = import_core14.monotonicNs;
+  function applyOptions(o) {
+    threshold = Math.max(1, o?.failureThreshold ?? 5);
+    baseCooldownNs = clampNonNegative(o?.cooldownNs ?? 30 * NS_PER_SEC);
+    cooldownStrategy = o?.cooldown ?? null;
+    halfOpenMax = Math.max(1, o?.halfOpenMax ?? 1);
+    now = o?.now ?? import_core14.monotonicNs;
+  }
+  let _state = "closed";
+  let _failureCount = 0;
+  let _openCycle = 0;
+  let _lastOpenedAt = 0;
+  let _lastCooldownNs = baseCooldownNs;
+  let _halfOpenAttempts = 0;
+  let initialOpts;
+  let optsUnsub;
+  if (isNode(options)) {
+    const optsNode = options;
+    initialOpts = optsNode.cache;
+    applyOptions(initialOpts);
+    const lockedNow = initialOpts?.now;
+    const hadInitialCache = initialOpts !== void 0;
+    let firstEmit = hadInitialCache;
+    optsUnsub = optsNode.subscribe((msgs) => {
+      for (const m of msgs) {
+        if (m[0] !== import_core14.DATA) continue;
+        if (firstEmit) {
+          firstEmit = false;
+          continue;
+        }
+        const next = m[1];
+        if (next == null || typeof next !== "object") continue;
+        if (Object.keys(next).length === 0) continue;
+        if ("now" in next && next.now !== lockedNow) {
+          console.error(
+            "circuitBreaker: ignoring mid-flight `now` change \u2014 clock override is mode-locked at construction. Prior `now` preserved."
+          );
+          continue;
+        }
+        const merged = {
+          ...initialOpts ?? {},
+          ...next,
+          ...lockedNow !== void 0 ? { now: lockedNow } : {}
+        };
+        applyOptions(merged);
+        initialOpts = merged;
+      }
+    });
+  } else {
+    applyOptions(options);
+  }
+  _lastCooldownNs = baseCooldownNs;
+  function getCooldownNs() {
+    if (!cooldownStrategy) return baseCooldownNs;
+    const delayNs = cooldownStrategy(_openCycle);
+    return delayNs !== null ? delayNs : baseCooldownNs;
+  }
+  function transitionToOpen() {
+    _state = "open";
+    _lastCooldownNs = getCooldownNs();
+    _lastOpenedAt = now();
+    _halfOpenAttempts = 0;
+  }
+  const breaker = {
+    canExecute() {
+      if (_state === "closed") return true;
+      if (_state === "open") {
+        const elapsed = now() - _lastOpenedAt;
+        if (elapsed >= _lastCooldownNs) {
+          _state = "half-open";
+          _halfOpenAttempts = 1;
+          return true;
+        }
+        return false;
+      }
+      if (_halfOpenAttempts < halfOpenMax) {
+        _halfOpenAttempts++;
+        return true;
+      }
+      return false;
+    },
+    recordSuccess() {
+      if (_state === "half-open") {
+        _state = "closed";
+        _failureCount = 0;
+        _openCycle = 0;
+      } else if (_state === "closed") {
+        _failureCount = 0;
+      }
+    },
+    recordFailure(_error) {
+      if (_state === "half-open") {
+        _openCycle++;
+        transitionToOpen();
+        return;
+      }
+      if (_state === "closed") {
+        _failureCount++;
+        if (_failureCount >= threshold) {
+          transitionToOpen();
+        }
+      }
+    },
+    get state() {
+      return _state;
+    },
+    get failureCount() {
+      return _failureCount;
+    },
+    reset() {
+      _state = "closed";
+      _failureCount = 0;
+      _openCycle = 0;
+      _halfOpenAttempts = 0;
+    },
+    dispose() {
+      optsUnsub?.();
+    }
+    // Internal accessors used by withBreaker for the BreakerState
+    // companion (DS-13.5.B). Not part of the public CircuitBreaker
+    // interface but exposed for the bundle wiring.
+  };
+  breaker._stateSnapshot = () => ({
+    status: _state,
+    failureCount: _failureCount,
+    openCycle: _openCycle,
+    lastOpenedAtNs: _lastOpenedAt,
+    halfOpenAttempts: _halfOpenAttempts,
+    lastCooldownNs: _lastCooldownNs
+  });
+  return breaker;
+}
+
+// src/utils/ai/adapters/routing/cascading.ts
+var AllTiersExhaustedError = class extends Error {
+  name = "AllTiersExhaustedError";
+  skipped;
+  failed;
+  constructor(report) {
+    const parts = [];
+    if (report.failed.size > 0) parts.push(`failed=[${[...report.failed.keys()].join(",")}]`);
+    if (report.skipped.length > 0) {
+      parts.push(`skipped=[${report.skipped.map((s) => `${s.name}(${s.reason})`).join(",")}]`);
+    }
+    super(`All LLM adapter tiers exhausted: ${parts.join(" ")}`);
+    this.skipped = report.skipped;
+    this.failed = report.failed;
+  }
+};
+function cascadingLlmAdapter(tiers, opts = {}) {
+  if (tiers.length === 0) throw new RangeError("cascadingLlmAdapter: tiers must be non-empty");
+  const resolved = tiers.map((t) => ({
+    name: t.name,
+    adapter: t.adapter,
+    filter: t.filter,
+    breaker: t.breaker ? "canExecute" in t.breaker ? t.breaker : circuitBreaker(t.breaker) : void 0
+  }));
+  const streamRetryBeforeFirstChunk = opts.streamRetryBeforeFirstChunk ?? true;
+  const cascade = {
+    provider: "cascading",
+    model: void 0,
+    async invoke(messages, invokeOpts) {
+      const skipped = [];
+      const failed = /* @__PURE__ */ new Map();
+      for (let i = 0; i < resolved.length; i++) {
+        const t = resolved[i];
+        if (t.filter && !t.filter(messages, invokeOpts)) {
+          skipped.push({ name: t.name, reason: "filter" });
+          continue;
+        }
+        if (t.breaker && !t.breaker.canExecute()) {
+          skipped.push({ name: t.name, reason: "breaker" });
+          continue;
+        }
+        try {
+          const resp = await firstValueFrom((0, import_extra6.fromAny)(t.adapter.invoke(messages, invokeOpts)));
+          t.breaker?.recordSuccess();
+          return { ...resp, metadata: { ...resp.metadata ?? {}, tier: t.name } };
+        } catch (err) {
+          failed.set(t.name, err);
+          t.breaker?.recordFailure(err);
+          const next = resolved[i + 1];
+          if (next) opts.onFallback?.(t.name, next.name, err);
+        }
+      }
+      const report = { skipped, failed };
+      opts.onExhausted?.(report);
+      throw new AllTiersExhaustedError(report);
+    },
+    async *stream(messages, invokeOpts) {
+      const skipped = [];
+      const failed = /* @__PURE__ */ new Map();
+      for (let i = 0; i < resolved.length; i++) {
+        const t = resolved[i];
+        if (t.filter && !t.filter(messages, invokeOpts)) {
+          skipped.push({ name: t.name, reason: "filter" });
+          continue;
+        }
+        if (t.breaker && !t.breaker.canExecute()) {
+          skipped.push({ name: t.name, reason: "breaker" });
+          continue;
+        }
+        let yieldedAny = false;
+        try {
+          for await (const delta of t.adapter.stream(messages, invokeOpts)) {
+            yieldedAny = true;
+            yield delta;
+          }
+          t.breaker?.recordSuccess();
+          return;
+        } catch (err) {
+          failed.set(t.name, err);
+          t.breaker?.recordFailure(err);
+          if (yieldedAny || !streamRetryBeforeFirstChunk) {
+            throw err;
+          }
+          const next = resolved[i + 1];
+          if (next) opts.onFallback?.(t.name, next.name, err);
+        }
+      }
+      const report = { skipped, failed };
+      opts.onExhausted?.(report);
+      throw new AllTiersExhaustedError(report);
+    }
+  };
+  withLayer(cascade, `cascade[${resolved.map((t) => t.name).join(",")}]`);
+  return cascade;
+}
+
+// src/utils/ai/adapters/routing/browser-presets.ts
+function cloudFirstPreset(opts) {
+  const tiers = [{ name: "cloud", adapter: createAdapter(opts.cloud) }];
+  if (opts.webllmModel) {
+    tiers.push({ name: "webllm", adapter: webllmAdapter({ model: opts.webllmModel }) });
+  }
+  if (opts.chromeNano !== false) {
+    tiers.push({
+      name: "chrome-nano",
+      adapter: chromeNanoAdapter(),
+      filter: (_msgs, iOpts) => !iOpts?.tools || iOpts.tools.length === 0
+    });
+  }
+  return cascadingLlmAdapter(tiers, opts.cascade);
+}
+function localFirstPreset(opts) {
+  const tiers = [
+    {
+      name: "ollama",
+      adapter: createAdapter({
+        provider: "ollama",
+        model: opts.ollamaModel,
+        baseURL: opts.ollamaBaseURL
+      })
+    }
+  ];
+  if (opts.webllmModel) {
+    tiers.push({ name: "webllm", adapter: webllmAdapter({ model: opts.webllmModel }) });
+  }
+  if (opts.chromeNano !== false) {
+    tiers.push({
+      name: "chrome-nano",
+      adapter: chromeNanoAdapter(),
+      filter: (_msgs, iOpts) => !iOpts?.tools || iOpts.tools.length === 0
+    });
+  }
+  return cascadingLlmAdapter(tiers, opts.cascade);
+}
+function offlinePreset(opts) {
+  const tiers = [{ name: "webllm", adapter: webllmAdapter({ model: opts.webllmModel }) }];
+  if (opts.chromeNano !== false) {
+    tiers.push({
+      name: "chrome-nano",
+      adapter: chromeNanoAdapter(),
+      filter: (_msgs, iOpts) => !iOpts?.tools || iOpts.tools.length === 0
+    });
+  }
+  return cascadingLlmAdapter(tiers, opts.cascade);
+}
+//# sourceMappingURL=browser.cjs.map