llm-strings 1.1.2 → 1.3.0

package/dist/ai-sdk.cjs

@@ -0,0 +1,1177 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/ai-sdk.ts
+var ai_sdk_exports = {};
+__export(ai_sdk_exports, {
+  createAiSdkProviderOptions: () => createAiSdkProviderOptions
+});
+module.exports = __toCommonJS(ai_sdk_exports);
+
+// src/provider-core.ts
+function hasOwn(object, key) {
+  return Object.prototype.hasOwnProperty.call(object, key);
+}
+var HOST_ALIASES = {
+  openai: "api.openai.com",
+  azure: "models.inference.ai.azure.com",
+  anthropic: "api.anthropic.com",
+  google: "generativelanguage.googleapis.com",
+  "google-vertex": "aiplatform.googleapis.com",
+  aistudio: "generativelanguage.googleapis.com",
+  mistral: "api.mistral.ai",
+  cohere: "api.cohere.com",
+  bedrock: "bedrock-runtime.us-east-1.amazonaws.com",
+  openrouter: "openrouter.ai",
+  vercel: "gateway.ai.vercel.app",
+  alibaba: "dashscope-intl.aliyuncs.com",
+  alibabacloud: "dashscope-intl.aliyuncs.com",
+  dashscope: "dashscope-intl.aliyuncs.com",
+  groq: "api.groq.com",
+  fal: "fal.run",
+  fireworks: "api.fireworks.ai",
+  fireworksai: "api.fireworks.ai",
+  "black-forest-labs": "api.bfl.ai",
+  bfl: "api.bfl.ai",
+  deepseek: "api.deepseek.com",
+  moonshotai: "api.moonshot.ai",
+  moonshot: "api.moonshot.ai",
+  perplexity: "api.perplexity.ai",
+  venice: "api.venice.ai",
+  parasail: "api.parasail.io",
+  deepinfra: "api.deepinfra.com",
+  atlascloud: "api.atlascloud.ai",
+  novita: "api.novita.ai",
+  novitaai: "api.novita.ai",
+  grok: "api.x.ai",
+  xai: "api.x.ai",
+  together: "api.together.xyz",
+  togetherai: "api.together.xyz",
+  cerebras: "api.cerebras.ai",
+  replicate: "api.replicate.com",
+  prodia: "api.prodia.com",
+  luma: "api.lumalabs.ai",
+  bytedance: "ark.cn-beijing.volces.com",
+  kling: "api.klingai.com",
+  elevenlabs: "api.elevenlabs.io",
+  assemblyai: "api.assemblyai.com",
+  deepgram: "api.deepgram.com",
+  gladia: "api.gladia.io",
+  lmnt: "api.lmnt.com",
+  hume: "api.hume.ai",
+  revai: "api.rev.ai",
+  baseten: "api.baseten.co",
+  huggingface: "api-inference.huggingface.co",
+  wandb: "api.inference.wandb.ai",
+  weightsandbiases: "api.inference.wandb.ai",
+  baidu: "qianfan.baidubce.com",
+  qianfan: "qianfan.baidubce.com",
+  vertex: "aiplatform.googleapis.com",
+  xiaomi: "api.xiaomimimo.com",
+  minimax: "api.minimax.io"
+};
+var HOST_ALIAS_PROVIDERS = {
+  aistudio: "google",
+  vertex: "google-vertex",
+  grok: "xai",
+  bfl: "black-forest-labs",
+  moonshot: "moonshotai",
+  alibaba: "alibaba",
+  alibabacloud: "alibaba",
+  dashscope: "alibaba",
+  togetherai: "together",
+  fireworksai: "fireworks"
+};
+function readProcessEnv() {
+  return typeof process !== "undefined" && process.env ? process.env : {};
+}
+function normalizeHostValue(value) {
+  const trimmed = value.trim();
+  if (!trimmed) return trimmed;
+  try {
+    if (trimmed.includes("://")) {
+      return new URL(trimmed).host;
+    }
+  } catch {
+  }
+  return trimmed.replace(/^\/\//, "").split("/")[0] ?? trimmed;
+}
+function envHostOverride(alias, env) {
+  const upper = alias.toUpperCase();
+  const override = env[`LLM_STRINGS_${upper}_HOST`] ?? env[`LLM_STRINGS_HOST_${upper}`];
+  return override?.trim() ? override : void 0;
+}
+function resolveHostAlias(host, env = readProcessEnv()) {
+  const normalizedHost = host.toLowerCase();
+  if (!hasOwn(HOST_ALIASES, normalizedHost)) {
+    return { host };
+  }
+  const alias = normalizedHost;
+  const override = envHostOverride(alias, env);
+  return {
+    host: normalizeHostValue(override ?? HOST_ALIASES[alias]),
+    alias
+  };
+}
+function providerFromHostAlias(alias) {
+  const normalizedAlias = alias.toLowerCase();
+  if (hasOwn(PROVIDER_PARAMS, normalizedAlias)) {
+    return normalizedAlias;
+  }
+  if (hasOwn(HOST_ALIAS_PROVIDERS, normalizedAlias)) {
+    return HOST_ALIAS_PROVIDERS[normalizedAlias];
+  }
+  return void 0;
+}
+function detectProvider(host) {
+  host = host.toLowerCase();
+  if (host.includes("openrouter")) return "openrouter";
+  if (host.includes("gateway.ai.vercel")) return "vercel";
+  if (host.includes("amazonaws") || host.includes("bedrock")) return "bedrock";
+  if (host.includes("aiplatform.googleapis")) return "google-vertex";
+  if (host.includes("api.x.ai")) return "xai";
+  if (host.includes("groq")) return "groq";
+  if (host.includes("fal.run") || host.includes("fal.ai")) return "fal";
+  if (host.includes("deepinfra")) return "deepinfra";
+  if (host.includes("bfl.ai")) return "black-forest-labs";
+  if (host.includes("together")) return "together";
+  if (host.includes("fireworks")) return "fireworks";
+  if (host.includes("deepseek")) return "deepseek";
+  if (host.includes("moonshot")) return "moonshotai";
+  if (host.includes("perplexity")) return "perplexity";
+  if (host.includes("dashscope") || host.includes("aliyuncs")) return "alibaba";
+  if (host.includes("cerebras")) return "cerebras";
+  if (host.includes("replicate")) return "replicate";
+  if (host.includes("prodia")) return "prodia";
+  if (host.includes("lumalabs") || host.includes("luma")) return "luma";
+  if (host.includes("volces") || host.includes("bytedance")) return "bytedance";
+  if (host.includes("kling")) return "kling";
+  if (host.includes("elevenlabs")) return "elevenlabs";
+  if (host.includes("assemblyai")) return "assemblyai";
+  if (host.includes("deepgram")) return "deepgram";
+  if (host.includes("gladia")) return "gladia";
+  if (host.includes("lmnt")) return "lmnt";
+  if (host.includes("hume")) return "hume";
+  if (host.includes("rev.ai")) return "revai";
+  if (host.includes("baseten")) return "baseten";
+  if (host.includes("huggingface")) return "huggingface";
+  if (host.includes("azure")) return "azure";
+  if (host.includes("openai")) return "openai";
+  if (host.includes("anthropic") || host.includes("claude")) return "anthropic";
+  if (host.includes("googleapis") || host.includes("google")) return "google";
+  if (host.includes("mistral")) return "mistral";
+  if (host.includes("cohere")) return "cohere";
+  return void 0;
+}
+var ALIASES = {
+  // temperature
+  temp: "temperature",
+  // max_tokens
+  max: "max_tokens",
+  max_out: "max_tokens",
+  max_output: "max_tokens",
+  max_output_tokens: "max_tokens",
+  max_completion_tokens: "max_tokens",
+  maxOutputTokens: "max_tokens",
+  maxTokens: "max_tokens",
+  // top_p
+  topp: "top_p",
+  topP: "top_p",
+  nucleus: "top_p",
+  // top_k
+  topk: "top_k",
+  topK: "top_k",
+  // frequency_penalty
+  freq: "frequency_penalty",
+  freq_penalty: "frequency_penalty",
+  frequencyPenalty: "frequency_penalty",
+  repetition_penalty: "frequency_penalty",
+  // presence_penalty
+  pres: "presence_penalty",
+  pres_penalty: "presence_penalty",
+  presencePenalty: "presence_penalty",
+  // stop
+  stop_sequences: "stop",
+  stopSequences: "stop",
+  stop_sequence: "stop",
+  // seed
+  random_seed: "seed",
+  randomSeed: "seed",
+  // n (completions count)
+  candidateCount: "n",
+  candidate_count: "n",
+  num_completions: "n",
+  // effort / reasoning
+  reasoning_effort: "effort",
+  reasoning: "effort",
+  // cache
+  cache_control: "cache",
+  cacheControl: "cache",
+  cachePoint: "cache",
+  cache_point: "cache"
+};
+var OPENAI_COMPATIBLE_PARAMS = {
+  temperature: "temperature",
+  max_tokens: "max_tokens",
+  top_p: "top_p",
+  top_k: "top_k",
+  frequency_penalty: "frequency_penalty",
+  presence_penalty: "presence_penalty",
+  stop: "stop",
+  n: "n",
+  seed: "seed",
+  stream: "stream",
+  effort: "reasoning_effort"
+};
+var GOOGLE_COMPATIBLE_PARAMS = {
+  temperature: "temperature",
+  max_tokens: "maxOutputTokens",
+  top_p: "topP",
+  top_k: "topK",
+  frequency_penalty: "frequencyPenalty",
+  presence_penalty: "presencePenalty",
+  stop: "stopSequences",
+  n: "candidateCount",
+  stream: "stream",
+  seed: "seed",
+  responseMimeType: "responseMimeType",
+  responseSchema: "responseSchema"
+};
+var PROVIDER_PARAMS = {
+  openai: {
+    temperature: "temperature",
+    max_tokens: "max_tokens",
+    top_p: "top_p",
+    frequency_penalty: "frequency_penalty",
+    presence_penalty: "presence_penalty",
+    stop: "stop",
+    n: "n",
+    seed: "seed",
+    stream: "stream",
+    effort: "reasoning_effort"
+  },
+  azure: OPENAI_COMPATIBLE_PARAMS,
+  anthropic: {
+    temperature: "temperature",
+    max_tokens: "max_tokens",
+    top_p: "top_p",
+    top_k: "top_k",
+    stop: "stop_sequences",
+    stream: "stream",
+    effort: "effort",
+    cache: "cache_control",
+    cache_ttl: "cache_ttl"
+  },
+  google: {
+    temperature: "temperature",
+    max_tokens: "maxOutputTokens",
+    top_p: "topP",
+    top_k: "topK",
+    frequency_penalty: "frequencyPenalty",
+    presence_penalty: "presencePenalty",
+    stop: "stopSequences",
+    n: "candidateCount",
+    stream: "stream",
+    seed: "seed",
+    responseMimeType: "responseMimeType",
+    responseSchema: "responseSchema"
+  },
+  "google-vertex": GOOGLE_COMPATIBLE_PARAMS,
+  mistral: {
+    temperature: "temperature",
+    max_tokens: "max_tokens",
+    top_p: "top_p",
+    frequency_penalty: "frequency_penalty",
+    presence_penalty: "presence_penalty",
+    stop: "stop",
+    n: "n",
+    seed: "random_seed",
+    stream: "stream",
+    safe_prompt: "safe_prompt",
+    min_tokens: "min_tokens"
+  },
+  cohere: {
+    temperature: "temperature",
+    max_tokens: "max_tokens",
+    top_p: "p",
+    top_k: "k",
+    frequency_penalty: "frequency_penalty",
+    presence_penalty: "presence_penalty",
+    stop: "stop_sequences",
+    stream: "stream",
+    seed: "seed"
+  },
+  bedrock: {
+    // Bedrock Converse API uses camelCase
+    temperature: "temperature",
+    max_tokens: "maxTokens",
+    top_p: "topP",
+    top_k: "topK",
+    // Claude models via additionalModelRequestFields
+    stop: "stopSequences",
+    stream: "stream",
+    cache: "cache_control",
+    cache_ttl: "cache_ttl"
+  },
+  openrouter: {
+    // OpenAI-compatible API with extra routing params
+    temperature: "temperature",
+    max_tokens: "max_tokens",
+    top_p: "top_p",
+    top_k: "top_k",
+    frequency_penalty: "frequency_penalty",
+    presence_penalty: "presence_penalty",
+    stop: "stop",
+    n: "n",
+    seed: "seed",
+    stream: "stream",
+    effort: "reasoning_effort"
+  },
+  vercel: {
+    // OpenAI-compatible gateway
+    temperature: "temperature",
+    max_tokens: "max_tokens",
+    top_p: "top_p",
+    top_k: "top_k",
+    frequency_penalty: "frequency_penalty",
+    presence_penalty: "presence_penalty",
+    stop: "stop",
+    n: "n",
+    seed: "seed",
+    stream: "stream",
+    effort: "reasoning_effort"
+  },
+  xai: OPENAI_COMPATIBLE_PARAMS,
+  groq: OPENAI_COMPATIBLE_PARAMS,
+  fal: {},
+  deepinfra: OPENAI_COMPATIBLE_PARAMS,
+  "black-forest-labs": {},
+  together: OPENAI_COMPATIBLE_PARAMS,
+  fireworks: OPENAI_COMPATIBLE_PARAMS,
+  deepseek: OPENAI_COMPATIBLE_PARAMS,
+  moonshotai: OPENAI_COMPATIBLE_PARAMS,
+  perplexity: OPENAI_COMPATIBLE_PARAMS,
+  alibaba: OPENAI_COMPATIBLE_PARAMS,
+  cerebras: OPENAI_COMPATIBLE_PARAMS,
+  replicate: {},
+  prodia: {},
+  luma: {},
+  bytedance: {},
+  kling: {},
+  elevenlabs: {},
+  assemblyai: {},
+  deepgram: {},
+  gladia: {},
+  lmnt: {},
+  hume: {},
+  revai: {},
+  baseten: OPENAI_COMPATIBLE_PARAMS,
+  huggingface: OPENAI_COMPATIBLE_PARAMS
+};
+function isReasoningModel(model) {
+  const name = model.includes("/") ? model.split("/").pop() : model;
+  return /^o[134]/.test(name);
+}
+function canHostOpenAIModels(provider) {
+  return provider === "openai" || provider === "openrouter" || provider === "vercel";
+}
+function isGatewayProvider(provider) {
+  return provider === "openrouter" || provider === "vercel";
+}
+function detectGatewaySubProvider(model) {
+  const slash = model.indexOf("/");
+  if (slash < 1) return void 0;
+  const prefix = model.slice(0, slash);
+  const direct = [
+    "openai",
+    "anthropic",
+    "google",
+    "mistral",
+    "cohere"
+  ];
+  return direct.find((p) => p === prefix);
+}
+function detectBedrockModelFamily(model) {
+  const parts = model.split(".");
+  let prefix = parts[0];
+  if (["us", "eu", "apac", "global"].includes(prefix) && parts.length > 1) {
+    prefix = parts[1];
+  }
+  const families = [
+    "anthropic",
+    "meta",
+    "amazon",
+    "mistral",
+    "cohere",
+    "ai21"
+  ];
+  return families.find((f) => prefix === f);
+}
+function bedrockSupportsCaching(model) {
+  const family = detectBedrockModelFamily(model);
+  if (family === "anthropic") return true;
+  if (family === "amazon" && model.includes("nova")) return true;
+  return false;
+}
+var CACHE_VALUES = {
+  openai: void 0,
+  // OpenAI auto-caches; no explicit param
+  azure: void 0,
+  anthropic: "ephemeral",
+  google: void 0,
+  // Google uses explicit caching API, not a param
+  "google-vertex": void 0,
+  mistral: void 0,
+  cohere: void 0,
+  bedrock: "ephemeral",
+  // Supported for Claude models on Bedrock
+  openrouter: void 0,
+  // Depends on underlying provider
+  vercel: void 0,
+  // Depends on underlying provider
+  xai: void 0,
+  groq: void 0,
+  fal: void 0,
+  deepinfra: void 0,
+  "black-forest-labs": void 0,
+  together: void 0,
+  fireworks: void 0,
+  deepseek: void 0,
+  moonshotai: void 0,
+  perplexity: void 0,
+  alibaba: void 0,
+  cerebras: void 0,
+  replicate: void 0,
+  prodia: void 0,
+  luma: void 0,
+  bytedance: void 0,
+  kling: void 0,
+  elevenlabs: void 0,
+  assemblyai: void 0,
+  deepgram: void 0,
+  gladia: void 0,
+  lmnt: void 0,
+  hume: void 0,
+  revai: void 0,
+  baseten: void 0,
+  huggingface: void 0
+};
+var CACHE_TTLS = {
+  openai: void 0,
+  azure: void 0,
+  anthropic: ["5m", "1h"],
+  google: void 0,
+  "google-vertex": void 0,
+  mistral: void 0,
+  cohere: void 0,
+  bedrock: ["5m", "1h"],
+  // Claude on Bedrock uses same TTLs as direct Anthropic
+  openrouter: void 0,
+  vercel: void 0,
+  xai: void 0,
+  groq: void 0,
+  fal: void 0,
+  deepinfra: void 0,
+  "black-forest-labs": void 0,
+  together: void 0,
+  fireworks: void 0,
+  deepseek: void 0,
+  moonshotai: void 0,
+  perplexity: void 0,
+  alibaba: void 0,
+  cerebras: void 0,
+  replicate: void 0,
+  prodia: void 0,
+  luma: void 0,
+  bytedance: void 0,
+  kling: void 0,
+  elevenlabs: void 0,
+  assemblyai: void 0,
+  deepgram: void 0,
+  gladia: void 0,
+  lmnt: void 0,
+  hume: void 0,
+  revai: void 0,
+  baseten: void 0,
+  huggingface: void 0
+};
+var DURATION_RE = /^\d+[mh]$/;
+
+// src/normalize.ts
+function normalize(config, options = {}) {
+  const provider = (config.hostAlias ? providerFromHostAlias(config.hostAlias) : void 0) ?? detectProvider(config.host);
+  const subProvider = provider && isGatewayProvider(provider) ? detectGatewaySubProvider(config.model) : void 0;
+  const changes = [];
+  const params = {};
+  for (const [rawKey, value] of Object.entries(config.params)) {
+    let key = rawKey;
+    if (ALIASES[key]) {
+      const canonical = ALIASES[key];
+      if (options.verbose) {
+        changes.push({
+          from: key,
+          to: canonical,
+          value,
+          reason: `alias: "${key}" \u2192 "${canonical}"`
+        });
+      }
+      key = canonical;
+    }
+    if (key === "cache" && provider) {
+      let cacheValue = CACHE_VALUES[provider];
+      if (provider === "bedrock" && !bedrockSupportsCaching(config.model)) {
+        cacheValue = void 0;
+      }
+      if (!cacheValue) {
+        if (options.verbose) {
+          changes.push({
+            from: "cache",
+            to: "(dropped)",
+            value,
+            reason: `${provider} does not use a cache param for this model (caching is automatic or unsupported)`
+          });
+        }
+        continue;
+      }
+      const isBool = value === "true" || value === "1" || value === "yes";
+      const isDuration = DURATION_RE.test(value);
+      if (isBool || isDuration) {
+        const providerKey = PROVIDER_PARAMS[provider]?.["cache"] ?? "cache";
+        if (options.verbose) {
+          changes.push({
+            from: "cache",
+            to: providerKey,
+            value: cacheValue,
+            reason: `cache=${value} \u2192 ${providerKey}=${cacheValue} for ${provider}`
+          });
+        }
+        params[providerKey] = cacheValue;
+        if (isDuration && CACHE_TTLS[provider]) {
+          if (options.verbose) {
+            changes.push({
+              from: "cache",
+              to: "cache_ttl",
+              value,
+              reason: `cache=${value} \u2192 cache_ttl=${value} for ${provider}`
+            });
+          }
+          params["cache_ttl"] = value;
+        }
+        continue;
+      }
+    }
+    if (provider && PROVIDER_PARAMS[provider]) {
+      const providerKey = PROVIDER_PARAMS[provider][key];
+      if (providerKey && providerKey !== key) {
+        if (options.verbose) {
+          changes.push({
+            from: key,
+            to: providerKey,
+            value,
+            reason: `${provider} uses "${providerKey}" instead of "${key}"`
+          });
+        }
+        key = providerKey;
+      }
+    }
+    if (provider && canHostOpenAIModels(provider) && isReasoningModel(config.model) && key === "max_tokens") {
+      if (options.verbose) {
+        changes.push({
+          from: "max_tokens",
+          to: "max_completion_tokens",
+          value,
+          reason: "OpenAI reasoning models use max_completion_tokens instead of max_tokens"
+        });
+      }
+      key = "max_completion_tokens";
+    }
+    params[key] = value;
+  }
+  return {
+    config: { ...config, params },
+    provider,
+    subProvider,
+    changes
+  };
+}
+
+// src/parse.ts
+function parse(connectionString) {
+  const url = new URL(connectionString);
+  if (url.protocol !== "llm:") {
+    throw new Error(
+      `Invalid scheme: expected "llm://", got "${url.protocol}//"`
+    );
+  }
+  const { host, alias: hostAlias } = resolveHostAlias(url.host);
+  const model = url.pathname.replace(/^\//, "");
+  const label = url.username || void 0;
+  const apiKey = url.password || void 0;
+  const params = {};
+  for (const [key, value] of url.searchParams) {
+    params[key] = value;
+  }
+  return {
+    raw: connectionString,
+    host,
+    hostAlias,
+    model,
+    label,
+    apiKey,
+    params
+  };
+}
+
+// src/ai-sdk.ts
+var PROVIDER_OPTION_KEYS = {
+  openai: "openai",
+  azure: "azure",
+  anthropic: "anthropic",
+  google: "google",
+  "google-vertex": "vertex",
+  mistral: "mistral",
+  cohere: "cohere",
+  bedrock: "bedrock",
+  openrouter: "openrouter",
+  vercel: "gateway",
+  xai: "xai",
+  groq: "groq",
+  fal: "fal",
+  deepinfra: "deepinfra",
+  "black-forest-labs": "blackForestLabs",
+  together: "together",
+  fireworks: "fireworks",
+  deepseek: "deepseek",
+  moonshotai: "moonshotai",
+  perplexity: "perplexity",
+  alibaba: "alibaba",
+  cerebras: "cerebras",
+  replicate: "replicate",
+  prodia: "prodia",
+  luma: "luma",
+  bytedance: "bytedance",
+  kling: "kling",
+  elevenlabs: "elevenlabs",
+  assemblyai: "assemblyai",
+  deepgram: "deepgram",
+  gladia: "gladia",
+  lmnt: "lmnt",
+  hume: "hume",
+  revai: "revai",
+  baseten: "baseten",
+  huggingface: "huggingface"
+};
+var TRUE_VALUES = /* @__PURE__ */ new Set(["true", "1", "yes", "on"]);
+var FALSE_VALUES = /* @__PURE__ */ new Set(["false", "0", "no", "off"]);
+function providerOptionsKey(provider) {
+  return PROVIDER_OPTION_KEYS[provider];
+}
+function setProviderOption(options, provider, key, value) {
+  options[provider] ?? (options[provider] = {});
+  options[provider][key] = value;
+}
+function parseBoolean(value) {
+  const normalized = value.trim().toLowerCase();
+  if (TRUE_VALUES.has(normalized)) return true;
+  if (FALSE_VALUES.has(normalized)) return false;
+  return void 0;
+}
+function parseNumber(value) {
+  if (!value.trim()) return void 0;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+function parseJson(value) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return void 0;
+  }
+}
+function parseStringList(value) {
+  const json = parseJson(value);
+  if (Array.isArray(json)) {
+    return json.filter((item) => typeof item === "string");
+  }
+  return value.split(",").map((item) => item.trim()).filter(Boolean);
+}
+function typedValue(value) {
+  const booleanValue = parseBoolean(value);
+  if (booleanValue !== void 0) return booleanValue;
+  const numberValue = parseNumber(value);
+  if (numberValue !== void 0) return numberValue;
+  const jsonValue = parseJson(value);
+  if (jsonValue !== void 0) return jsonValue;
+  return value;
+}
+function mergeObjectOption(options, provider, key, value) {
+  const parsed = parseJson(value);
+  if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+    setProviderOption(options, provider, key, parsed);
+  }
+}
+function addOpenAiOption(options, key, value, target = "openai") {
+  const mappings = {
+    reasoning_effort: "reasoningEffort",
+    max_completion_tokens: "maxCompletionTokens",
+    parallel_tool_calls: "parallelToolCalls",
+    service_tier: "serviceTier",
+    strict_json_schema: "strictJsonSchema",
+    text_verbosity: "textVerbosity",
+    prompt_cache_key: "promptCacheKey",
+    prompt_cache_retention: "promptCacheRetention",
+    safety_identifier: "safetyIdentifier",
+    system_message_mode: "systemMessageMode",
+    force_reasoning: "forceReasoning",
+    reasoning_summary: "reasoningSummary",
+    previous_response_id: "previousResponseId",
+    max_tool_calls: "maxToolCalls",
+    allowed_tools: "allowedTools"
+  };
+  const directKeys = /* @__PURE__ */ new Set([
+    "conversation",
+    "instructions",
+    "logprobs",
+    "metadata",
+    "prediction",
+    "store",
+    "truncation",
+    "user"
+  ]);
+  if (!mappings[key] && !directKeys.has(key) && key !== "include") return;
+  const optionKey = mappings[key] ?? key;
+  if (key === "include") {
+    setProviderOption(options, target, optionKey, parseStringList(value));
+    return;
+  }
+  if (key === "metadata" || key === "prediction" || key === "allowed_tools") {
+    mergeObjectOption(options, target, optionKey, value);
+    return;
+  }
+  setProviderOption(options, target, optionKey, typedValue(value));
+}
+function addAnthropicOption(options, key, value) {
+  const target = "anthropic";
+  if (key === "cache_control" || key === "cacheControl") {
+    const ttl = options[target]?.cacheControl;
+    const ttlValue = ttl && typeof ttl === "object" && "ttl" in ttl ? ttl.ttl : void 0;
+    setProviderOption(options, target, "cacheControl", {
+      type: value === "ephemeral" ? "ephemeral" : value,
+      ...ttlValue ? { ttl: ttlValue } : {}
+    });
+    return;
+  }
+  if (key === "cache_ttl") {
+    const current = options[target]?.cacheControl;
+    setProviderOption(options, target, "cacheControl", {
+      ...current && typeof current === "object" ? current : {},
+      type: "ephemeral",
+      ttl: value
+    });
+    return;
+  }
+  if (key === "thinking") {
+    mergeObjectOption(options, target, "thinking", value);
+    return;
+  }
+  if (key === "thinking_budget" || key === "budget_tokens") {
+    const budgetTokens = parseNumber(value);
+    if (budgetTokens !== void 0) {
+      setProviderOption(options, target, "thinking", {
+        type: "enabled",
+        budgetTokens
+      });
+    }
+    return;
+  }
+  const mappings = {
+    send_reasoning: "sendReasoning",
+    structured_output_mode: "structuredOutputMode",
+    disable_parallel_tool_use: "disableParallelToolUse",
+    tool_streaming: "toolStreaming",
+    inference_geo: "inferenceGeo",
+    anthropic_beta: "anthropicBeta",
+    mcp_servers: "mcpServers",
+    task_budget: "taskBudget",
+    context_management: "contextManagement"
+  };
+  const directKeys = /* @__PURE__ */ new Set([
+    "effort",
+    "speed",
+    "sendReasoning",
+    "structuredOutputMode",
+    "disableParallelToolUse",
+    "toolStreaming",
+    "inferenceGeo",
+    "anthropicBeta",
+    "metadata",
+    "mcpServers",
+    "container",
+    "taskBudget",
+    "contextManagement"
+  ]);
+  if (!mappings[key] && !directKeys.has(key)) return;
+  const optionKey = mappings[key] ?? key;
+  if (key === "anthropic_beta") {
+    setProviderOption(options, target, optionKey, parseStringList(value));
+    return;
+  }
+  if (key === "metadata" || key === "mcp_servers" || key === "container" || key === "task_budget" || key === "context_management") {
+    mergeObjectOption(options, target, optionKey, value);
+    return;
+  }
+  setProviderOption(options, target, optionKey, typedValue(value));
+}
+function addGoogleOption(options, key, value, target = "google") {
+  if (key === "thinking_budget" || key === "thinking_level" || key === "include_thoughts") {
+    const current = options[target]?.thinkingConfig;
+    const thinkingConfig = current && typeof current === "object" && !Array.isArray(current) ? { ...current } : {};
+    if (key === "thinking_budget") {
+      const parsed = parseNumber(value);
+      if (parsed !== void 0) thinkingConfig.thinkingBudget = parsed;
+    }
+    if (key === "thinking_level") thinkingConfig.thinkingLevel = value;
+    if (key === "include_thoughts") {
+      const parsed = parseBoolean(value);
+      if (parsed !== void 0) thinkingConfig.includeThoughts = parsed;
+    }
+    setProviderOption(options, target, "thinkingConfig", thinkingConfig);
+    return;
+  }
+  const mappings = {
+    cached_content: "cachedContent",
+    structured_outputs: "structuredOutputs",
+    safety_settings: "safetySettings",
+    response_modalities: "responseModalities",
+    audio_timestamp: "audioTimestamp",
+    media_resolution: "mediaResolution",
+    image_config: "imageConfig",
+    retrieval_config: "retrievalConfig",
+    stream_function_call_arguments: "streamFunctionCallArguments",
+    service_tier: "serviceTier"
+  };
+  const directKeys = /* @__PURE__ */ new Set([
+    "cachedContent",
+    "structuredOutputs",
+    "safetySettings",
+    "threshold",
+    "audioTimestamp",
+    "labels",
+    "mediaResolution",
+    "imageConfig",
+    "retrievalConfig",
+    "responseModalities",
+    "streamFunctionCallArguments",
+    "serviceTier"
+  ]);
+  if (!mappings[key] && !directKeys.has(key)) return;
+  const optionKey = mappings[key] ?? key;
+  if (key === "response_modalities") {
+    setProviderOption(options, target, optionKey, parseStringList(value));
+    return;
+  }
+  if (key === "safety_settings" || key === "labels" || key === "image_config" || key === "retrieval_config") {
+    mergeObjectOption(options, target, optionKey, value);
+    return;
+  }
+  setProviderOption(options, target, optionKey, typedValue(value));
+}
+function addMistralOption(options, key, value) {
+  const target = "mistral";
+  const mappings = {
+    safe_prompt: "safePrompt",
+    document_image_limit: "documentImageLimit",
+    document_page_limit: "documentPageLimit",
+    structured_outputs: "structuredOutputs",
+    strict_json_schema: "strictJsonSchema",
+    parallel_tool_calls: "parallelToolCalls",
+    reasoning_effort: "reasoningEffort"
+  };
+  const directKeys = /* @__PURE__ */ new Set([
+    "safePrompt",
+    "documentImageLimit",
+    "documentPageLimit",
+    "structuredOutputs",
+    "strictJsonSchema",
+    "parallelToolCalls",
+    "reasoningEffort"
+  ]);
+  if (!mappings[key] && !directKeys.has(key)) return;
+  const optionKey = mappings[key] ?? key;
+  setProviderOption(options, target, optionKey, typedValue(value));
+}
+function addCohereOption(options, key, value) {
+  const target = "cohere";
+  if (key === "thinking") {
+    mergeObjectOption(options, target, "thinking", value);
+    return;
+  }
+  if (key === "thinking_token_budget" || key === "token_budget") {
+    const tokenBudget = parseNumber(value);
+    if (tokenBudget !== void 0) {
+      setProviderOption(options, target, "thinking", {
+        type: "enabled",
+        tokenBudget
+      });
+    }
+    return;
+  }
+  if (key === "thinking_type") {
+    const current = options[target]?.thinking;
+    setProviderOption(options, target, "thinking", {
+      ...current && typeof current === "object" ? current : {},
+      type: value
+    });
+  }
+}
+function addBedrockOption(options, key, value) {
+  const target = "bedrock";
+  if (key === "cache_control") {
+    setProviderOption(options, target, "cachePoint", {
+      type: value === "ephemeral" ? "default" : value
+    });
+    return;
+  }
+  if (key === "cache_ttl") {
+    const current = options[target]?.cachePoint;
+    setProviderOption(options, target, "cachePoint", {
+      ...current && typeof current === "object" ? current : {},
+      type: "default",
+      ttl: value
+    });
+    return;
+  }
+  if (key === "reasoning_config") {
+    mergeObjectOption(options, target, "reasoningConfig", value);
+    return;
+  }
+  if (key === "budget_tokens" || key === "reasoning_effort") {
+    const current = options[target]?.reasoningConfig;
+    const reasoningConfig = current && typeof current === "object" && !Array.isArray(current) ? { ...current } : {};
+    reasoningConfig.type = "enabled";
+    if (key === "budget_tokens") {
+      const budgetTokens = parseNumber(value);
+      if (budgetTokens !== void 0)
+        reasoningConfig.budgetTokens = budgetTokens;
+    }
+    if (key === "reasoning_effort") reasoningConfig.maxReasoningEffort = value;
+    setProviderOption(options, target, "reasoningConfig", reasoningConfig);
+    return;
+  }
+  const mappings = {
+    additional_model_request_fields: "additionalModelRequestFields",
+    anthropic_beta: "anthropicBeta",
+    service_tier: "serviceTier"
+  };
+  const directKeys = /* @__PURE__ */ new Set([
+    "additionalModelRequestFields",
+    "anthropicBeta",
+    "serviceTier"
+  ]);
+  if (!mappings[key] && !directKeys.has(key)) return;
+  const optionKey = mappings[key] ?? key;
+  if (key === "additional_model_request_fields") {
+    mergeObjectOption(options, target, optionKey, value);
+    return;
+  }
+  if (key === "anthropic_beta") {
+    setProviderOption(options, target, optionKey, parseStringList(value));
+    return;
+  }
+  setProviderOption(options, target, optionKey, typedValue(value));
+}
+function addGatewayOption(options, key, value) {
+  const target = "gateway";
+  const listKeys = /* @__PURE__ */ new Set(["only", "order", "tags", "models"]);
+  const objectKeys = /* @__PURE__ */ new Set(["byok", "provider_timeouts"]);
+  const mappings = {
+    zero_data_retention: "zeroDataRetention",
+    disallow_prompt_training: "disallowPromptTraining",
+    hipaa_compliant: "hipaaCompliant",
+    quota_entity_id: "quotaEntityId",
+    provider_timeouts: "providerTimeouts"
+  };
+  const directKeys = /* @__PURE__ */ new Set([
+    "sort",
+    "user",
+    "zeroDataRetention",
+    "disallowPromptTraining",
+    "hipaaCompliant",
+    "quotaEntityId",
+    "providerTimeouts"
+  ]);
+  if (!mappings[key] && !directKeys.has(key) && !listKeys.has(key) && !objectKeys.has(key)) {
+    return;
+  }
+  const optionKey = mappings[key] ?? key;
+  if (listKeys.has(key)) {
+    setProviderOption(options, target, optionKey, parseStringList(value));
+    return;
+  }
+  if (objectKeys.has(key)) {
+    mergeObjectOption(options, target, optionKey, value);
+    return;
+  }
+  setProviderOption(options, target, optionKey, typedValue(value));
+}
+function addOpenRouterOption(options, key, value) {
+  const target = "openrouter";
+  if (key === "models") {
+    setProviderOption(options, target, "models", parseStringList(value));
+    return;
+  }
+  if (key === "reasoning") {
+    mergeObjectOption(options, target, "reasoning", value);
+    return;
+  }
+  if (key === "reasoning_effort") {
+    const current = options[target]?.reasoning;
+    setProviderOption(options, target, "reasoning", {
+      ...current && typeof current === "object" ? current : {},
+      effort: value
+    });
+    return;
+  }
+  if (key === "reasoning_max_tokens" || key === "max_reasoning_tokens") {
+    const current = options[target]?.reasoning;
+    const maxTokens = parseNumber(value);
+    if (maxTokens !== void 0) {
+      setProviderOption(options, target, "reasoning", {
+        ...current && typeof current === "object" ? current : {},
+        max_tokens: maxTokens
+      });
+    }
+    return;
+  }
+  if (key === "reasoning_enabled" || key === "reasoning_exclude") {
+    const current = options[target]?.reasoning;
+    const parsed = parseBoolean(value);
+    if (parsed !== void 0) {
+      setProviderOption(options, target, "reasoning", {
+        ...current && typeof current === "object" ? current : {},
+        [key === "reasoning_enabled" ? "enabled" : "exclude"]: parsed
+      });
+    }
+    return;
+  }
+  if (key === "user") {
+    setProviderOption(options, target, "user", value);
+  }
+}
+function addFlexibleProviderOption(options, target, key, value) {
+  setProviderOption(options, target, key, typedValue(value));
+}
+function addProviderSpecificOption(options, provider, key, value, includeGatewayOptions) {
+  if (provider === "vercel") {
+    if (includeGatewayOptions) addGatewayOption(options, key, value);
+    return;
+  }
+  if (provider === "openai") addOpenAiOption(options, key, value);
+  if (provider === "azure") addOpenAiOption(options, key, value, "azure");
+  if (provider === "anthropic") addAnthropicOption(options, key, value);
+  if (provider === "google") addGoogleOption(options, key, value);
+  if (provider === "google-vertex")
+    addGoogleOption(options, key, value, "vertex");
+  if (provider === "mistral") addMistralOption(options, key, value);
+  if (provider === "cohere") addCohereOption(options, key, value);
+  if (provider === "bedrock") addBedrockOption(options, key, value);
+  if (provider === "openrouter") addOpenRouterOption(options, key, value);
+  if (provider === "xai") addOpenAiOption(options, key, value, "xai");
+  if (provider === "groq") addOpenAiOption(options, key, value, "groq");
+  if (provider === "fal") addFlexibleProviderOption(options, "fal", key, value);
+  if (provider === "deepinfra")
+    addOpenAiOption(options, key, value, "deepinfra");
+  if (provider === "black-forest-labs")
+    addFlexibleProviderOption(options, "blackForestLabs", key, value);
+  if (provider === "together") addOpenAiOption(options, key, value, "together");
+  if (provider === "fireworks")
+    addOpenAiOption(options, key, value, "fireworks");
+  if (provider === "deepseek") addOpenAiOption(options, key, value, "deepseek");
+  if (provider === "moonshotai")
+    addOpenAiOption(options, key, value, "moonshotai");
+  if (provider === "perplexity")
+    addOpenAiOption(options, key, value, "perplexity");
+  if (provider === "alibaba") addOpenAiOption(options, key, value, "alibaba");
+  if (provider === "cerebras") addOpenAiOption(options, key, value, "cerebras");
+  if (provider === "replicate")
+    addFlexibleProviderOption(options, "replicate", key, value);
+  if (provider === "prodia")
+    addFlexibleProviderOption(options, "prodia", key, value);
+  if (provider === "luma")
+    addFlexibleProviderOption(options, "luma", key, value);
+  if (provider === "bytedance")
+    addFlexibleProviderOption(options, "bytedance", key, value);
+  if (provider === "kling")
+    addFlexibleProviderOption(options, "kling", key, value);
+  if (provider === "elevenlabs")
+    addFlexibleProviderOption(options, "elevenlabs", key, value);
+  if (provider === "assemblyai")
+    addFlexibleProviderOption(options, "assemblyai", key, value);
+  if (provider === "deepgram")
+    addFlexibleProviderOption(options, "deepgram", key, value);
+  if (provider === "gladia")
+    addFlexibleProviderOption(options, "gladia", key, value);
+  if (provider === "lmnt")
+    addFlexibleProviderOption(options, "lmnt", key, value);
+  if (provider === "hume")
+    addFlexibleProviderOption(options, "hume", key, value);
+  if (provider === "revai")
+    addFlexibleProviderOption(options, "revai", key, value);
+  if (provider === "baseten") addOpenAiOption(options, key, value, "baseten");
+  if (provider === "huggingface")
+    addOpenAiOption(options, key, value, "huggingface");
+}
+function createAiSdkProviderOptions(configOrResult, options = {}) {
+  const normalized = typeof configOrResult === "string" ? normalize(parse(configOrResult), options) : "changes" in configOrResult && "subProvider" in configOrResult ? configOrResult : normalize(configOrResult, options);
+  const providerOptions = {};
+  if (!normalized.provider) {
+    return {
+      provider: normalized.provider,
+      subProvider: normalized.subProvider,
+      providerOptions
+    };
+  }
+  const includeGatewayOptions = options.includeGatewayOptions ?? normalized.provider === "vercel";
+  for (const [key, value] of Object.entries(normalized.config.params)) {
+    addProviderSpecificOption(
+      providerOptions,
+      normalized.provider,
+      key,
+      value,
+      includeGatewayOptions
+    );
+  }
+  if (normalized.provider !== "vercel" && !providerOptions[providerOptionsKey(normalized.provider)]) {
+    return {
+      provider: normalized.provider,
+      subProvider: normalized.subProvider,
+      providerOptions: {}
+    };
+  }
+  return {
+    provider: normalized.provider,
+    subProvider: normalized.subProvider,
+    providerOptions
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createAiSdkProviderOptions
+});
+//# sourceMappingURL=ai-sdk.cjs.map