noumen 0.6.0 → 0.8.0

package/dist/chunk-XZPAA5TO.js

@@ -0,0 +1,817 @@
+import {
+  ChatStreamError,
+  getMessageCacheBreakpointIndex
+} from "./chunk-OPFFLQZL.js";
+
+// src/providers/ai-sdk/errors.ts
+function isApiCallErrorLike(err) {
+  if (!err || typeof err !== "object") return false;
+  const name = err.name;
+  if (name !== "AI_APICallError" && name !== "APICallError") return false;
+  return typeof err.message === "string";
+}
+function mapApiCallError(err) {
+  if (err instanceof ChatStreamError) return err;
+  if (isApiCallErrorLike(err)) {
+    return new ChatStreamError(err.message, {
+      status: err.statusCode,
+      retryAfter: err.responseHeaders?.["retry-after"],
+      cause: err
+    });
+  }
+  const message = err instanceof Error ? err.message : String(err);
+  return new ChatStreamError(message, { cause: err });
+}
+
+// src/providers/ai-sdk/compat/schema.ts
+var PERMISSIVE_TYPES = [
+  "string",
+  "number",
+  "integer",
+  "boolean",
+  "object",
+  "null"
+];
+function fixTypelessProperties(schema) {
+  if (typeof schema !== "object" || schema === null) return schema;
+  const result = { ...schema };
+  if (result.properties && typeof result.properties === "object" && !Array.isArray(result.properties)) {
+    result.properties = Object.fromEntries(
+      Object.entries(result.properties).map(([key, value]) => {
+        if (typeof value !== "object" || value === null || Array.isArray(value)) {
+          return [key, value];
+        }
+        const propSchema = value;
+        const hasType = "type" in propSchema;
+        const hasRef = "$ref" in propSchema;
+        const hasAnyOf = "anyOf" in propSchema;
+        const hasOneOf = "oneOf" in propSchema;
+        const hasAllOf = "allOf" in propSchema;
+        if (!hasType && !hasRef && !hasAnyOf && !hasOneOf && !hasAllOf) {
+          const { items: _items, ...rest } = propSchema;
+          return [key, { ...rest, type: [...PERMISSIVE_TYPES] }];
+        }
+        return [key, fixTypelessProperties(propSchema)];
+      })
+    );
+  }
+  if (result.items) {
+    if (Array.isArray(result.items)) {
+      result.items = result.items.map(
+        (item) => fixTypelessProperties(item)
+      );
+    } else if (typeof result.items === "object") {
+      result.items = fixTypelessProperties(result.items);
+    }
+  }
+  return result;
+}
+
+// src/providers/ai-sdk/request.ts
+function translateRequest(params, opts) {
+  const { providerFamily } = opts;
+  const useAnthropicCache = providerFamily === "anthropic" && opts.cacheConfig?.enabled === true;
+  const prompt = buildPrompt(params, {
+    providerFamily,
+    cacheConfig: useAnthropicCache ? opts.cacheConfig : void 0,
+    skipCacheWrite: params.skipCacheWrite
+  });
+  const tools = buildTools(params.tools, {
+    providerFamily,
+    cacheConfig: useAnthropicCache ? opts.cacheConfig : void 0
+  });
+  const call = {
+    prompt,
+    maxOutputTokens: params.max_tokens
+  };
+  if (params.signal) call.abortSignal = params.signal;
+  if (tools && tools.length > 0) call.tools = tools;
+  const thinkingEnabled = params.thinking?.type === "enabled" && params.thinking.budgetTokens > 0;
+  if (providerFamily === "anthropic") {
+    if (!thinkingEnabled && params.temperature !== void 0) {
+      call.temperature = params.temperature;
+    }
+  } else if (params.temperature !== void 0) {
+    call.temperature = params.temperature;
+  }
+  if (params.outputFormat?.type === "json_schema") {
+    call.responseFormat = {
+      type: "json",
+      schema: params.outputFormat.schema,
+      name: params.outputFormat.name
+    };
+  } else if (params.outputFormat?.type === "json_object") {
+    call.responseFormat = { type: "json" };
+  }
+  const providerOptions = buildProviderOptions(params, providerFamily);
+  if (providerOptions) call.providerOptions = providerOptions;
+  return call;
+}
+function buildProviderOptions(params, family) {
+  const thinking = params.thinking;
+  const thinkingEnabled = thinking?.type === "enabled" && thinking.budgetTokens > 0;
+  switch (family) {
+    case "anthropic": {
+      if (!thinkingEnabled) {
+        return void 0;
+      }
+      const { budgetTokens } = thinking;
+      const maxOutput = params.max_tokens;
+      const clampedBudget = typeof maxOutput === "number" && maxOutput > 0 ? Math.min(budgetTokens, maxOutput - 1) : budgetTokens;
+      return {
+        anthropic: {
+          thinking: {
+            type: "enabled",
+            budgetTokens: clampedBudget
+          }
+        }
+      };
+    }
+    case "openai": {
+      const effort = params.reasoningEffort ?? (thinkingEnabled ? "high" : thinking?.type === "disabled" ? "minimal" : void 0);
+      if (!effort) return void 0;
+      return { openai: { reasoningEffort: effort } };
+    }
+    case "google": {
+      if (thinkingEnabled) {
+        const { budgetTokens } = thinking;
+        return { google: { thinkingConfig: { thinkingBudget: budgetTokens } } };
+      }
+      if (thinking?.type === "disabled") {
+        return { google: { thinkingConfig: { thinkingBudget: 0 } } };
+      }
+      return void 0;
+    }
+    default:
+      return void 0;
+  }
+}
+function buildPrompt(params, opts) {
+  const result = [];
+  const convo = params.messages.filter((m) => m.role !== "system");
+  const cacheEnabled = opts.cacheConfig?.enabled === true;
+  const cacheBreakpoint = cacheEnabled ? getMessageCacheBreakpointIndex(convo, opts.skipCacheWrite) : -1;
+  if (params.system) {
+    const sys = { role: "system", content: params.system };
+    if (cacheEnabled) {
+      sys.providerOptions = {
+        anthropic: { cacheControl: buildCacheControl(opts.cacheConfig) }
+      };
+    }
+    result.push(sys);
+  }
+  for (let i = 0; i < convo.length; i++) {
+    const msg = convo[i];
+    const addCache = cacheEnabled && i === cacheBreakpoint;
+    if (msg.role === "user") {
+      result.push(convertUserMessage(msg, addCache ? opts.cacheConfig : void 0));
+    } else if (msg.role === "assistant") {
+      result.push(
+        convertAssistantMessage(msg, {
+          addCache,
+          cacheConfig: opts.cacheConfig,
+          providerFamily: opts.providerFamily
+        })
+      );
+    } else if (msg.role === "tool") {
+      result.push(
+        convertToolMessage(msg, addCache ? opts.cacheConfig : void 0)
+      );
+    }
+  }
+  return result;
+}
+function convertUserMessage(msg, cacheConfig) {
+  const parts = Array.isArray(msg.content) ? contentPartsToAiSdk(msg.content) : [{ type: "text", text: msg.content }];
+  if (cacheConfig?.enabled && parts.length > 0) {
+    const last = parts[parts.length - 1];
+    last.providerOptions = {
+      ...last.providerOptions ?? {},
+      anthropic: { cacheControl: buildCacheControl(cacheConfig) }
+    };
+  }
+  return { role: "user", content: parts };
+}
+function convertAssistantMessage(msg, opts) {
+  const content = [];
+  if (msg.thinking_content && opts.providerFamily === "anthropic") {
+    const reasoning = {
+      type: "reasoning",
+      text: msg.thinking_content
+    };
+    if (msg.thinking_signature) {
+      reasoning.providerOptions = {
+        anthropic: { signature: msg.thinking_signature }
+      };
+    }
+    content.push(reasoning);
+  }
+  if (msg.redacted_thinking_data && opts.providerFamily === "anthropic") {
+    content.push({
+      type: "reasoning",
+      text: "",
+      providerOptions: {
+        anthropic: { redactedData: msg.redacted_thinking_data }
+      }
+    });
+  }
+  if (typeof msg.content === "string" && msg.content !== "") {
+    content.push({ type: "text", text: msg.content });
+  } else if (msg.content != null && typeof msg.content !== "string" && Array.isArray(msg.content)) {
+    for (const part of msg.content) {
+      if (part.type === "text") content.push({ type: "text", text: part.text });
+    }
+  }
+  if (msg.tool_calls) {
+    for (const tc of msg.tool_calls) {
+      let input = {};
+      if (tc.function.arguments) {
+        try {
+          input = JSON.parse(tc.function.arguments);
+        } catch {
+          input = {};
+        }
+      }
+      content.push({
+        type: "tool-call",
+        toolCallId: tc.id,
+        toolName: tc.function.name,
+        input
+      });
+    }
+  }
+  if (content.length === 0) {
+    content.push({ type: "text", text: "" });
+  }
+  if (opts.addCache && opts.cacheConfig?.enabled) {
+    for (let i = content.length - 1; i >= 0; i--) {
+      const block = content[i];
+      if (block.type === "reasoning") continue;
+      block.providerOptions = {
+        ...block.providerOptions ?? {},
+        anthropic: { cacheControl: buildCacheControl(opts.cacheConfig) }
+      };
+      break;
+    }
+  }
+  return { role: "assistant", content };
+}
+function convertToolMessage(msg, cacheConfig) {
+  const output = Array.isArray(msg.content) ? toolContentToOutput(msg.content, msg.isError) : msg.isError ? { type: "error-text", value: msg.content } : { type: "text", value: msg.content };
+  const part = {
+    type: "tool-result",
+    toolCallId: msg.tool_call_id,
+    toolName: "tool",
+    output
+  };
+  if (cacheConfig?.enabled) {
+    part.providerOptions = {
+      anthropic: { cacheControl: buildCacheControl(cacheConfig) }
+    };
+  }
+  return { role: "tool", content: [part] };
+}
+function contentPartsToAiSdk(parts) {
+  return parts.map((part) => {
+    if (part.type === "text") {
+      return { type: "text", text: part.text };
+    }
+    if (part.type === "image") {
+      return {
+        type: "file",
+        mediaType: part.media_type,
+        data: part.data
+      };
+    }
+    return {
+      type: "file",
+      mediaType: "image/*",
+      data: new URL(part.url)
+    };
+  });
+}
+function toolContentToOutput(parts, isError) {
+  const contentValue = parts.map((p) => {
+    if (p.type === "text") return { type: "text", text: p.text };
+    if (p.type === "image") {
+      return { type: "image-data", data: p.data, mediaType: p.media_type };
+    }
+    return { type: "image-url", url: p.url };
+  });
+  if (isError) {
+    const textOnly = contentValue.filter((v) => v.type === "text").map((v) => v.text).join("\n");
+    return { type: "error-text", value: textOnly };
+  }
+  return { type: "content", value: contentValue };
+}
+function buildTools(tools, opts) {
+  if (!tools || tools.length === 0) return void 0;
+  const cacheEnabled = opts.providerFamily === "anthropic" && opts.cacheConfig?.enabled === true;
+  return tools.map((t, idx) => {
+    const schema = fixTypelessProperties(
+      t.function.parameters
+    );
+    const tool = {
+      type: "function",
+      name: t.function.name,
+      description: t.function.description,
+      inputSchema: schema
+    };
+    if (cacheEnabled && idx === tools.length - 1) {
+      tool.providerOptions = {
+        anthropic: { cacheControl: buildCacheControl(opts.cacheConfig) }
+      };
+    }
+    return tool;
+  });
+}
+function buildCacheControl(config) {
+  const cc = { type: "ephemeral" };
+  if (config.ttl) cc.ttl = config.ttl;
+  if (config.scope) cc.scope = config.scope;
+  return cc;
+}
+
+// src/providers/ai-sdk/compat/json-repair.ts
+function sanitizeToolCallInput(input) {
+  try {
+    JSON.parse(input);
+    return input;
+  } catch {
+    return input.replace(/[\s]*<\|[^|]*\|>[\s]*/g, "").trim();
+  }
+}
+function tryRepairJson(input) {
+  let repaired = input.trim();
+  repaired = repaired.replace(
+    /([{,]\s*)([a-zA-Z_$][a-zA-Z0-9_$]*)"/g,
+    (match, prefix, name) => {
+      if (prefix.trimEnd().endsWith('"')) return match;
+      return `${prefix}"${name}"`;
+    }
+  );
+  repaired = repaired.replace(
+    /([{,]\s*)([a-zA-Z_$][a-zA-Z0-9_$]*)\s*:/g,
+    '$1"$2":'
+  );
+  repaired = repaired.replace(/'/g, '"');
+  repaired = repaired.replace(/,(\s*[}\]])/g, "$1");
+  repaired = repaired.replace(
+    /:\s*(\d{4}-\d{2}-\d{2}(?:T[\d:]+)?)\s*([,}])/g,
+    ': "$1"$2'
+  );
+  try {
+    return JSON.parse(repaired);
+  } catch {
+    return null;
+  }
+}
+function parseToolCallJson(input) {
+  if (!input) return void 0;
+  const sanitized = sanitizeToolCallInput(input);
+  if (!sanitized) return void 0;
+  try {
+    return JSON.parse(sanitized);
+  } catch {
+    return tryRepairJson(sanitized);
+  }
+}
+
+// src/providers/ai-sdk/stream.ts
+async function* translateStream(stream, model, signal) {
+  const reader = stream.getReader();
+  const state = createState();
+  try {
+    while (true) {
+      if (signal?.aborted) {
+        try {
+          await reader.cancel();
+        } catch {
+        }
+        throw new ChatStreamError("aborted", { cause: signal.reason });
+      }
+      const { done, value: part } = await reader.read();
+      if (done) break;
+      for (const chunk of processStreamPart(part, state, model)) {
+        yield chunk;
+      }
+      if (state.terminated) break;
+    }
+  } catch (err) {
+    if (err instanceof ChatStreamError) throw err;
+    throw mapApiCallError(err);
+  } finally {
+    try {
+      reader.releaseLock();
+    } catch {
+    }
+  }
+}
+function createState() {
+  return {
+    chunkIndex: 0,
+    toolIndexMap: /* @__PURE__ */ new Map(),
+    toolNames: /* @__PURE__ */ new Map(),
+    nextToolIndex: 0,
+    terminated: false
+  };
+}
+function processStreamPart(part, state, model) {
+  if (!part || typeof part !== "object") return [];
+  const chunkId = `chatcmpl-${state.chunkIndex++}`;
+  switch (part.type) {
+    case "text-delta": {
+      const delta = part.delta;
+      if (!delta) return [];
+      return [makeChunk(chunkId, model, { content: delta })];
+    }
+    case "reasoning-delta": {
+      const delta = part.delta;
+      if (!delta) return [];
+      return [makeChunk(chunkId, model, { thinking_content: delta })];
+    }
+    case "reasoning-end": {
+      const meta = part.providerMetadata;
+      const anthropicMeta = meta?.anthropic;
+      if (!anthropicMeta) return [];
+      const delta = {};
+      if (typeof anthropicMeta.signature === "string") {
+        delta.thinking_signature = anthropicMeta.signature;
+      }
+      if (typeof anthropicMeta.redactedData === "string") {
+        delta.redacted_thinking_data = anthropicMeta.redactedData;
+      }
+      if (Object.keys(delta).length === 0) return [];
+      return [makeChunk(chunkId, model, delta)];
+    }
+    case "tool-input-start": {
+      const p = part;
+      if (!p.id || !p.toolName) return [];
+      if (state.toolIndexMap.has(p.id)) return [];
+      const idx = state.nextToolIndex++;
+      state.toolIndexMap.set(p.id, idx);
+      state.toolNames.set(p.id, p.toolName);
+      return [
+        makeChunk(chunkId, model, {
+          tool_calls: [
+            {
+              index: idx,
+              id: p.id,
+              type: "function",
+              function: { name: p.toolName, arguments: "" }
+            }
+          ]
+        })
+      ];
+    }
+    case "tool-input-delta": {
+      const p = part;
+      if (!p.delta) return [];
+      let idx = state.toolIndexMap.get(p.id);
+      if (idx === void 0) {
+        idx = state.nextToolIndex++;
+        state.toolIndexMap.set(p.id, idx);
+      }
+      return [
+        makeChunk(chunkId, model, {
+          tool_calls: [
+            {
+              index: idx,
+              function: { arguments: p.delta }
+            }
+          ]
+        })
+      ];
+    }
+    case "tool-call": {
+      const p = part;
+      if (state.toolIndexMap.has(p.toolCallId)) {
+        return [];
+      }
+      const idx = state.nextToolIndex++;
+      state.toolIndexMap.set(p.toolCallId, idx);
+      state.toolNames.set(p.toolCallId, p.toolName);
+      const parsed = parseToolCallJson(p.input);
+      const argsString = parsed === null || parsed === void 0 ? p.input ?? "" : JSON.stringify(parsed);
+      return [
+        makeChunk(chunkId, model, {
+          tool_calls: [
+            {
+              index: idx,
+              id: p.toolCallId,
+              type: "function",
+              function: { name: p.toolName, arguments: argsString }
+            }
+          ]
+        })
+      ];
+    }
+    case "finish": {
+      state.terminated = true;
+      const p = part;
+      const finishReason = mapFinishReason(
+        p.finishReason,
+        state.toolIndexMap.size > 0
+      );
+      const usage = mapUsage(p.usage, p.providerMetadata);
+      return [
+        {
+          id: chunkId,
+          model,
+          choices: [
+            {
+              index: 0,
+              delta: {},
+              finish_reason: finishReason
+            }
+          ],
+          usage
+        }
+      ];
+    }
+    case "error": {
+      state.terminated = true;
+      throw mapApiCallError(part.error);
+    }
+    // No-op events we simply drop. These still advance chunkIndex for
+    // deterministic ids, matching mastra's approach.
+    case "stream-start":
+    case "response-metadata":
+    case "text-start":
+    case "text-end":
+    case "reasoning-start":
+    case "tool-input-end":
+    case "tool-result":
+    case "tool-approval-request":
+    case "file":
+    case "source":
+    case "raw":
+      return [];
+    default:
+      return [];
+  }
+}
+function mapFinishReason(reason, hasToolCalls) {
+  const unified = typeof reason === "object" && reason !== null && "unified" in reason ? reason.unified : reason ?? "other";
+  switch (unified) {
+    case "stop":
+      return hasToolCalls ? "tool_calls" : "stop";
+    case "length":
+      return "length";
+    case "content-filter":
+      return "content_filter";
+    case "tool-calls":
+      return "tool_calls";
+    case "error":
+      return "error";
+    case "other":
+    case "unknown":
+    default:
+      return hasToolCalls ? "tool_calls" : "stop";
+  }
+}
+function mapUsage(usage, providerMetadata) {
+  if (!usage) return void 0;
+  let prompt = 0;
+  let completion = 0;
+  let cacheRead;
+  let cacheCreation;
+  let thinking;
+  const nested = typeof usage.inputTokens === "object";
+  if (nested) {
+    const u = usage;
+    prompt = u.inputTokens.total ?? 0;
+    completion = u.outputTokens.total ?? 0;
+    cacheRead = u.inputTokens.cacheRead;
+    cacheCreation = u.inputTokens.cacheWrite;
+    thinking = u.outputTokens.reasoning;
+  } else {
+    const u = usage;
+    prompt = u.inputTokens ?? 0;
+    completion = u.outputTokens ?? 0;
+    thinking = u.reasoningTokens;
+    cacheRead = u.cachedInputTokens;
+  }
+  if (providerMetadata) {
+    const anth = providerMetadata.anthropic;
+    if (anth) {
+      if (cacheRead === void 0 && typeof anth.cacheReadInputTokens === "number") {
+        cacheRead = anth.cacheReadInputTokens;
+      }
+      if (cacheCreation === void 0 && typeof anth.cacheCreationInputTokens === "number") {
+        cacheCreation = anth.cacheCreationInputTokens;
+      }
+    }
+    const openai = providerMetadata.openai;
+    if (openai && cacheRead === void 0 && typeof openai.cachedPromptTokens === "number") {
+      cacheRead = openai.cachedPromptTokens;
+    }
+  }
+  return {
+    prompt_tokens: prompt,
+    completion_tokens: completion,
+    total_tokens: prompt + completion,
+    cache_read_tokens: cacheRead,
+    cache_creation_tokens: cacheCreation,
+    thinking_tokens: thinking
+  };
+}
+function makeChunk(id, model, delta) {
+  return {
+    id,
+    model,
+    choices: [
+      {
+        index: 0,
+        delta,
+        finish_reason: null
+      }
+    ]
+  };
+}
+
+// src/providers/ai-sdk/provider-family.ts
+function inferProviderFamily(providerString) {
+  const p = providerString.toLowerCase();
+  if (p.includes("anthropic")) return "anthropic";
+  if (p.startsWith("amazon-bedrock") || p.startsWith("bedrock")) {
+    return "anthropic";
+  }
+  if (p.startsWith("google.") || p === "google" || p.startsWith("google-generative-ai")) {
+    return "google";
+  }
+  if (p.startsWith("openai") || p.startsWith("openrouter") || p.startsWith("ollama") || p.endsWith(".chat") || p.endsWith(".responses")) {
+    return "openai";
+  }
+  return "unknown";
+}
+
+// src/providers/ai-sdk/provider.ts
+var AiSdkProvider = class {
+  defaultModel;
+  providerFamily;
+  model;
+  cacheConfig;
+  constructor(opts) {
+    this.model = opts.model;
+    this.defaultModel = opts.defaultModel ?? opts.model.modelId;
+    this.providerFamily = opts.providerFamily ?? inferProviderFamily(opts.model.provider);
+    this.cacheConfig = opts.cacheConfig;
+  }
+  async *chat(params) {
+    const call = translateRequest(params, {
+      providerFamily: this.providerFamily,
+      cacheConfig: this.cacheConfig
+    });
+    let result;
+    try {
+      result = await this.model.doStream(call);
+    } catch (err) {
+      throw mapApiCallError(err);
+    }
+    const modelId = params.model ?? this.defaultModel;
+    yield* translateStream(result.stream, modelId, params.signal);
+  }
+};
+
+// src/providers/resolve.ts
+var ENV_KEY_MAP = {
+  openai: "OPENAI_API_KEY",
+  anthropic: "ANTHROPIC_API_KEY",
+  gemini: "GEMINI_API_KEY",
+  openrouter: "OPENROUTER_API_KEY"
+};
+var DEFAULT_MODELS = {
+  openai: "gpt-5.4",
+  anthropic: "claude-opus-4.6",
+  gemini: "gemini-2.5-flash",
+  openrouter: "anthropic/claude-opus-4.6",
+  bedrock: "us.anthropic.claude-opus-4.6-v1:0",
+  vertex: "claude-opus-4.6",
+  ollama: "qwen2.5-coder:32b"
+};
+var SUPPORTED_PROVIDERS = Object.keys(DEFAULT_MODELS);
+function getProviderEnvKey(name) {
+  const envVar = ENV_KEY_MAP[name];
+  return envVar ? process.env[envVar] : void 0;
+}
+function cannotFindVendor(provider, pkg, err) {
+  const hint = err instanceof Error && err.message.includes("Cannot find") ? ` Install it with \`pnpm add ${pkg}\`.` : "";
+  throw new Error(
+    `noumen provider "${provider}" requires the "${pkg}" package.${hint}`,
+    { cause: err }
+  );
+}
+async function loadModule(provider, pkg) {
+  try {
+    return await import(pkg);
+  } catch (err) {
+    cannotFindVendor(provider, pkg, err);
+  }
+}
+async function resolveProvider(input, opts) {
+  if (typeof input !== "string") return input;
+  const name = input;
+  if (!SUPPORTED_PROVIDERS.includes(name)) {
+    throw new Error(
+      `Unknown provider "${name}". Supported: ${SUPPORTED_PROVIDERS.join(", ")}`
+    );
+  }
+  const apiKey = opts?.apiKey ?? getProviderEnvKey(name) ?? process.env.NOUMEN_API_KEY;
+  const modelId = opts?.model ?? DEFAULT_MODELS[name];
+  switch (name) {
+    case "openai": {
+      if (!apiKey) {
+        throw new Error("OpenAI requires an API key. Set OPENAI_API_KEY or pass apiKey.");
+      }
+      const mod = await loadModule(name, "@ai-sdk/openai");
+      const openai = mod.createOpenAI({ apiKey, baseURL: opts?.baseURL });
+      return new AiSdkProvider({ model: openai.chat(modelId) });
+    }
+    case "anthropic": {
+      if (!apiKey) {
+        throw new Error("Anthropic requires an API key. Set ANTHROPIC_API_KEY or pass apiKey.");
+      }
+      const mod = await loadModule(name, "@ai-sdk/anthropic");
+      const anthropic = mod.createAnthropic({ apiKey, baseURL: opts?.baseURL });
+      return new AiSdkProvider({
+        model: anthropic(modelId),
+        providerFamily: "anthropic",
+        cacheConfig: { enabled: true }
+      });
+    }
+    case "gemini": {
+      if (!apiKey) {
+        throw new Error("Gemini requires an API key. Set GEMINI_API_KEY or pass apiKey.");
+      }
+      const mod = await loadModule(name, "@ai-sdk/google");
+      const google = mod.createGoogleGenerativeAI({ apiKey, baseURL: opts?.baseURL });
+      return new AiSdkProvider({ model: google(modelId), providerFamily: "google" });
+    }
+    case "openrouter": {
+      if (!apiKey) {
+        throw new Error("OpenRouter requires an API key. Set OPENROUTER_API_KEY or pass apiKey.");
+      }
+      const mod = await loadModule(name, "@openrouter/ai-sdk-provider");
+      const openrouter = mod.createOpenRouter({ apiKey });
+      return new AiSdkProvider({ model: openrouter.chat(modelId) });
+    }
+    case "bedrock": {
+      const mod = await loadModule(name, "@ai-sdk/amazon-bedrock");
+      const bedrock = mod.createAmazonBedrock({
+        region: process.env.AWS_REGION,
+        baseURL: opts?.baseURL
+      });
+      return new AiSdkProvider({ model: bedrock(modelId), providerFamily: "anthropic" });
+    }
+    case "vertex": {
+      const mod = await loadModule(name, "@ai-sdk/google-vertex");
+      const vertex = mod.createVertex({
+        project: process.env.GCLOUD_PROJECT ?? process.env.GOOGLE_CLOUD_PROJECT,
+        location: process.env.GOOGLE_CLOUD_LOCATION ?? "us-central1",
+        baseURL: opts?.baseURL
+      });
+      const isClaude = modelId.toLowerCase().includes("claude");
+      const model = isClaude ? vertex.anthropic(modelId) : vertex(modelId);
+      return new AiSdkProvider({
+        model,
+        providerFamily: isClaude ? "anthropic" : "google"
+      });
+    }
+    case "ollama": {
+      const mod = await loadModule(name, "ollama-ai-provider-v2");
+      const base = opts?.baseURL ?? (process.env.OLLAMA_HOST ? `${process.env.OLLAMA_HOST.replace(/\/+$/, "")}/api` : void 0);
+      const ollama = mod.createOllama(base ? { baseURL: base } : {});
+      return new AiSdkProvider({ model: ollama(modelId) });
+    }
+    default:
+      throw new Error(`Unhandled provider: ${name}`);
+  }
+}
+async function detectProvider() {
+  if (process.env.ANTHROPIC_API_KEY) return "anthropic";
+  if (process.env.OPENAI_API_KEY) return "openai";
+  if (process.env.GEMINI_API_KEY) return "gemini";
+  if (process.env.OPENROUTER_API_KEY) return "openrouter";
+  if (process.env.AWS_ACCESS_KEY_ID || process.env.AWS_PROFILE) return "bedrock";
+  if (process.env.GOOGLE_APPLICATION_CREDENTIALS || process.env.GCLOUD_PROJECT) return "vertex";
+  if (process.env.OLLAMA_HOST) return "ollama";
+  try {
+    const host = process.env.OLLAMA_HOST ?? "http://localhost:11434";
+    const res = await fetch(`${host.replace(/\/+$/, "")}/api/tags`, {
+      signal: AbortSignal.timeout(500)
+    });
+    if (res.ok) return "ollama";
+  } catch {
+  }
+  return void 0;
+}
+
+export {
+  AiSdkProvider,
+  DEFAULT_MODELS,
+  SUPPORTED_PROVIDERS,
+  resolveProvider,
+  detectProvider
+};
+//# sourceMappingURL=chunk-XZPAA5TO.js.map