@graphrefly/graphrefly 0.44.0 → 0.46.0

package/dist/chunk-4GYMCUDZ.js

@@ -0,0 +1,1085 @@
+import {
+  circuitBreaker
+} from "./chunk-RJOG4IJU.js";
+import {
+  dryRunAdapter,
+  fallbackAdapter,
+  withLayer
+} from "./chunk-CXANAIZU.js";
+import {
+  firstValueFrom
+} from "./chunk-O3MT7DYI.js";
+import {
+  parseSSEStream
+} from "./chunk-SOOKUYVM.js";
+
+// src/utils/ai/adapters/providers/anthropic.ts
+import { monotonicNs } from "@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/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 = 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, (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 = monotonicNs();
+      const resp = await sdk.messages.create(body, {
+        signal: invokeOpts?.signal
+      });
+      const latencyMs = Math.max(0, (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/google.ts
+import { monotonicNs as monotonicNs2 } from "@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 = monotonicNs2();
+      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, (monotonicNs2() - 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 = monotonicNs2();
+      const resp = await sdk.models.generateContent(params);
+      const latencyMs = Math.max(0, (monotonicNs2() - 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
+import { monotonicNs as monotonicNs3 } from "@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 = monotonicNs3();
+      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, (monotonicNs3() - 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 = monotonicNs3();
+      const resp = await sdk.chat.completions.create(body, { signal: invokeOpts?.signal });
+      const latencyMs = Math.max(0, (monotonicNs3() - 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
+import { fromAny } from "@graphrefly/pure-ts/extra";
+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(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;
+}
+function tier(name, adapter, opts) {
+  const out = { name, adapter };
+  if (opts?.breaker) out.breaker = opts.breaker;
+  if (opts?.filter) out.filter = opts.filter;
+  return out;
+}
+
+export {
+  anthropicAdapter,
+  googleAdapter,
+  openAICompatAdapter,
+  createAdapter,
+  AllTiersExhaustedError,
+  cascadingLlmAdapter,
+  tier
+};
+//# sourceMappingURL=chunk-4GYMCUDZ.js.map