llm-strings 1.1.2 → 1.2.0

package/dist/ai-sdk.cjs

@@ -0,0 +1,831 @@
+"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);
+}
+function providerFromHostAlias(alias) {
+  const normalizedAlias = alias.toLowerCase();
+  if (hasOwn(PROVIDER_PARAMS, normalizedAlias)) {
+    return 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("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 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"
+  },
+  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"
+  },
+  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"
+  }
+};
+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
+  anthropic: "ephemeral",
+  google: void 0,
+  // Google uses explicit caching API, not a param
+  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
+};
+var CACHE_TTLS = {
+  openai: void 0,
+  anthropic: ["5m", "1h"],
+  google: 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
+};
+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/ai-sdk.ts
+var PROVIDER_OPTION_KEYS = {
+  openai: "openai",
+  anthropic: "anthropic",
+  google: "google",
+  mistral: "mistral",
+  cohere: "cohere",
+  bedrock: "bedrock",
+  openrouter: "openrouter",
+  vercel: "gateway"
+};
+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) {
+  const 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) {
+  const 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 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 === "anthropic") addAnthropicOption(options, key, value);
+  if (provider === "google") addGoogleOption(options, key, value);
+  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);
+}
+function createAiSdkProviderOptions(configOrResult, options = {}) {
+  const normalized = "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