llm-strings 1.4.0 → 1.5.0

package/dist/ai-sdk.cjs

@@ -139,44 +139,92 @@ function providerFromHostAlias(alias) {
   }
   return void 0;
 }
+function canonicalHostName(host) {
+  return normalizeHostValue(host).toLowerCase().split(":")[0] ?? host;
+}
+function hostMatches(host, ...domains) {
+  return domains.some((domain) => {
+    const normalizedDomain = domain.toLowerCase();
+    return host === normalizedDomain || host.endsWith(`.${normalizedDomain}`);
+  });
+}
+function hostHasLabel(host, ...labels) {
+  const hostLabels = host.split(".");
+  return labels.some((label) => hostLabels.includes(label.toLowerCase()));
+}
+function hostHasLabelPrefix(host, ...prefixes) {
+  const hostLabels = host.split(".");
+  return prefixes.some(
+    (prefix) => hostLabels.some((label) => label.startsWith(prefix.toLowerCase()))
+  );
+}
+var MODEL_FAMILY_DELIMITERS = /* @__PURE__ */ new Set(["-", "."]);
+function normalizeModelForMatching(model) {
+  return model.trim().toLowerCase();
+}
+function modelLeafName(model) {
+  const normalized = normalizeModelForMatching(model);
+  const slash = normalized.lastIndexOf("/");
+  return slash >= 0 ? normalized.slice(slash + 1) : normalized;
+}
+function modelMatchesFamily(model, family) {
+  const name = modelLeafName(model);
+  const normalizedFamily = normalizeModelForMatching(family);
+  if (!name || !normalizedFamily) return false;
+  if (name === normalizedFamily) return true;
+  const delimiter = name[normalizedFamily.length];
+  return name.startsWith(normalizedFamily) && delimiter !== void 0 && MODEL_FAMILY_DELIMITERS.has(delimiter);
+}
 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";
+  host = canonicalHostName(host);
+  if (hostMatches(host, "openrouter", "openrouter.ai")) return "openrouter";
+  if (hostMatches(host, "vercel", "gateway.ai.vercel.app", "gateway.ai.vercel.sh")) {
+    return "vercel";
+  }
+  if (hostMatches(host, "bedrock", "amazonaws.com") || hostHasLabelPrefix(host, "bedrock")) {
+    return "bedrock";
+  }
+  if (hostMatches(host, "aiplatform.googleapis.com")) return "google-vertex";
+  if (hostMatches(host, "xai", "x.ai", "api.x.ai")) return "xai";
+  if (hostMatches(host, "groq", "groq.com", "api.groq.com")) return "groq";
+  if (hostMatches(host, "fal", "fal.run", "fal.ai")) return "fal";
+  if (hostMatches(host, "deepinfra", "deepinfra.com")) return "deepinfra";
+  if (hostMatches(host, "bfl", "bfl.ai", "api.bfl.ai")) {
+    return "black-forest-labs";
+  }
+  if (hostMatches(host, "together", "together.xyz")) return "together";
+  if (hostMatches(host, "fireworks", "fireworks.ai")) return "fireworks";
+  if (hostMatches(host, "deepseek", "deepseek.com")) return "deepseek";
+  if (hostMatches(host, "moonshot", "moonshot.ai")) return "moonshotai";
+  if (hostMatches(host, "perplexity", "perplexity.ai")) return "perplexity";
+  if (hostMatches(host, "alibaba", "aliyuncs.com") || hostHasLabelPrefix(host, "dashscope")) {
+    return "alibaba";
+  }
+  if (hostMatches(host, "cerebras", "cerebras.ai")) return "cerebras";
+  if (hostMatches(host, "replicate", "replicate.com")) return "replicate";
+  if (hostMatches(host, "prodia", "prodia.com")) return "prodia";
+  if (hostMatches(host, "luma", "lumalabs.ai")) return "luma";
+  if (hostMatches(host, "bytedance", "volces.com") || hostHasLabel(host, "bytedance")) {
+    return "bytedance";
+  }
+  if (hostMatches(host, "kling", "klingai.com")) return "kling";
+  if (hostMatches(host, "elevenlabs", "elevenlabs.io")) return "elevenlabs";
+  if (hostMatches(host, "assemblyai", "assemblyai.com")) return "assemblyai";
+  if (hostMatches(host, "deepgram", "deepgram.com")) return "deepgram";
+  if (hostMatches(host, "gladia", "gladia.io")) return "gladia";
+  if (hostMatches(host, "lmnt", "lmnt.com")) return "lmnt";
+  if (hostMatches(host, "hume", "hume.ai")) return "hume";
+  if (hostMatches(host, "revai", "rev.ai")) return "revai";
+  if (hostMatches(host, "baseten", "baseten.co")) return "baseten";
+  if (hostMatches(host, "huggingface", "huggingface.co")) return "huggingface";
+  if (hostMatches(host, "azure", "azure.com")) return "azure";
+  if (hostMatches(host, "openai", "openai.com")) return "openai";
+  if (hostMatches(host, "anthropic", "anthropic.com", "claude.ai")) {
+    return "anthropic";
+  }
+  if (hostMatches(host, "google", "googleapis.com")) return "google";
+  if (hostMatches(host, "mistral", "mistral.ai")) return "mistral";
+  if (hostMatches(host, "cohere", "cohere.com")) return "cohere";
   return void 0;
 }
 var ALIASES = {
@@ -219,7 +267,10 @@ var ALIASES = {
   num_completions: "n",
   // effort / reasoning
   reasoning_effort: "effort",
+  reasoningEffort: "effort",
   reasoning: "effort",
+  thinking_effort: "effort",
+  thinkingEffort: "effort",
   // cache
   cache_control: "cache",
   cacheControl: "cache",
@@ -229,6 +280,7 @@ var ALIASES = {
 var OPENAI_COMPATIBLE_PARAMS = {
   temperature: "temperature",
   max_tokens: "max_tokens",
+  max_completion_tokens: "max_completion_tokens",
   top_p: "top_p",
   top_k: "top_k",
   frequency_penalty: "frequency_penalty",
@@ -239,6 +291,90 @@ var OPENAI_COMPATIBLE_PARAMS = {
   stream: "stream",
   effort: "reasoning_effort"
 };
+var COMMON_IMAGE_PARAMS = {
+  prompt: "prompt",
+  negative_prompt: "negative_prompt",
+  seed: "seed",
+  image_size: "image_size",
+  aspect_ratio: "aspect_ratio",
+  output_format: "output_format",
+  width: "width",
+  height: "height"
+};
+var FAL_PARAMS = {
+  ...COMMON_IMAGE_PARAMS,
+  num_images: "num_images",
+  enable_safety_checker: "enable_safety_checker",
+  enable_safety_checks: "enable_safety_checks",
+  enable_prompt_expansion: "enable_prompt_expansion",
+  expand_prompt: "expand_prompt"
+};
+var REPLICATE_PARAMS = {
+  ...COMMON_IMAGE_PARAMS,
+  input: "input",
+  version: "version",
+  num_outputs: "num_outputs",
+  num_inference_steps: "num_inference_steps",
+  guidance_scale: "guidance_scale",
+  stream: "stream",
+  webhook: "webhook",
+  webhook_events_filter: "webhook_events_filter"
+};
+var PRODIA_PARAMS = {
+  ...COMMON_IMAGE_PARAMS,
+  model: "model",
+  style_preset: "style_preset",
+  steps: "steps",
+  cfg_scale: "cfg_scale",
+  upscale: "upscale",
+  sampler: "sampler",
+  type: "type",
+  config: "config",
+  price: "price"
+};
+var LUMA_PARAMS = {
+  prompt: "prompt",
+  model: "model",
+  aspect_ratio: "aspect_ratio",
+  keyframes: "keyframes",
+  loop: "loop",
+  duration: "duration",
+  type: "type",
+  image_ref: "image_ref",
+  video: "video",
+  source: "source"
+};
+var OPENROUTER_ROUTING_PARAMS = {
+  provider: "provider",
+  order: "order",
+  "provider.order": "provider.order",
+  only: "only",
+  "provider.only": "provider.only",
+  ignore: "ignore",
+  "provider.ignore": "provider.ignore",
+  allow_fallbacks: "allow_fallbacks",
+  "provider.allow_fallbacks": "provider.allow_fallbacks",
+  require_parameters: "require_parameters",
+  "provider.require_parameters": "provider.require_parameters",
+  data_collection: "data_collection",
+  "provider.data_collection": "provider.data_collection",
+  zdr: "zdr",
+  "provider.zdr": "provider.zdr",
+  enforce_distillable_text: "enforce_distillable_text",
+  "provider.enforce_distillable_text": "provider.enforce_distillable_text",
+  quantizations: "quantizations",
+  "provider.quantizations": "provider.quantizations",
+  sort: "sort",
+  "provider.sort": "provider.sort",
+  preferred_min_throughput: "preferred_min_throughput",
+  "provider.preferred_min_throughput": "provider.preferred_min_throughput",
+  preferred_max_latency: "preferred_max_latency",
+  "provider.preferred_max_latency": "provider.preferred_max_latency",
+  max_price: "max_price",
+  "provider.max_price": "provider.max_price",
+  transforms: "transforms",
+  plugins: "plugins"
+};
 var GOOGLE_COMPATIBLE_PARAMS = {
   temperature: "temperature",
   max_tokens: "maxOutputTokens",
@@ -257,6 +393,7 @@ var PROVIDER_PARAMS = {
   openai: {
     temperature: "temperature",
     max_tokens: "max_tokens",
+    max_completion_tokens: "max_completion_tokens",
     top_p: "top_p",
     frequency_penalty: "frequency_penalty",
     presence_penalty: "presence_penalty",
@@ -333,6 +470,7 @@ var PROVIDER_PARAMS = {
     // OpenAI-compatible API with extra routing params
     temperature: "temperature",
     max_tokens: "max_tokens",
+    max_completion_tokens: "max_completion_tokens",
     top_p: "top_p",
     top_k: "top_k",
     frequency_penalty: "frequency_penalty",
@@ -341,12 +479,14 @@ var PROVIDER_PARAMS = {
     n: "n",
     seed: "seed",
     stream: "stream",
-    effort: "reasoning_effort"
+    effort: "reasoning_effort",
+    ...OPENROUTER_ROUTING_PARAMS
   },
   vercel: {
     // OpenAI-compatible gateway
     temperature: "temperature",
     max_tokens: "max_tokens",
+    max_completion_tokens: "max_completion_tokens",
     top_p: "top_p",
     top_k: "top_k",
     frequency_penalty: "frequency_penalty",
@@ -359,7 +499,7 @@ var PROVIDER_PARAMS = {
   },
   xai: OPENAI_COMPATIBLE_PARAMS,
   groq: OPENAI_COMPATIBLE_PARAMS,
-  fal: {},
+  fal: FAL_PARAMS,
   deepinfra: OPENAI_COMPATIBLE_PARAMS,
   "black-forest-labs": {},
   together: OPENAI_COMPATIBLE_PARAMS,
@@ -369,9 +509,9 @@ var PROVIDER_PARAMS = {
   perplexity: OPENAI_COMPATIBLE_PARAMS,
   alibaba: OPENAI_COMPATIBLE_PARAMS,
   cerebras: OPENAI_COMPATIBLE_PARAMS,
-  replicate: {},
-  prodia: {},
-  luma: {},
+  replicate: REPLICATE_PARAMS,
+  prodia: PRODIA_PARAMS,
+  luma: LUMA_PARAMS,
   bytedance: {},
   kling: {},
   elevenlabs: {},
@@ -384,12 +524,842 @@ var PROVIDER_PARAMS = {
   baseten: OPENAI_COMPATIBLE_PARAMS,
   huggingface: OPENAI_COMPATIBLE_PARAMS
 };
+var REASONING_EFFORT_VALUES = [
+  "none",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max"
+];
+var OPENAI_COMPATIBLE_PARAM_SPECS = {
+  temperature: {
+    type: "number",
+    min: 0,
+    max: 2,
+    default: 0.7,
+    description: "Controls randomness"
+  },
+  max_tokens: {
+    type: "number",
+    min: 1,
+    default: 4096,
+    description: "Maximum output tokens"
+  },
+  max_completion_tokens: {
+    type: "number",
+    min: 1,
+    default: 4096,
+    description: "Maximum completion tokens (reasoning models)"
+  },
+  top_p: {
+    type: "number",
+    min: 0,
+    max: 1,
+    default: 1,
+    description: "Nucleus sampling"
+  },
+  top_k: {
+    type: "number",
+    min: 0,
+    default: 40,
+    description: "Top-K sampling"
+  },
+  frequency_penalty: {
+    type: "number",
+    min: -2,
+    max: 2,
+    default: 0,
+    description: "Penalize frequent tokens"
+  },
+  presence_penalty: {
+    type: "number",
+    min: -2,
+    max: 2,
+    default: 0,
+    description: "Penalize repeated topics"
+  },
+  stop: { type: "string", description: "Stop sequences" },
+  n: { type: "number", min: 1, default: 1, description: "Completions count" },
+  seed: { type: "number", description: "Random seed" },
+  stream: { type: "boolean", default: false, description: "Stream response" },
+  reasoning_effort: {
+    type: "string",
+    values: REASONING_EFFORT_VALUES,
+    default: "medium",
+    description: "Reasoning effort"
+  }
+};
+var OPENROUTER_ROUTING_PARAM_SPECS = {
+  provider: { type: "string", description: "Provider routing preferences" },
+  order: { type: "string", description: "Provider order" },
+  "provider.order": { type: "string", description: "Provider order" },
+  only: { type: "string", description: "Provider allowlist" },
+  "provider.only": { type: "string", description: "Provider allowlist" },
+  ignore: { type: "string", description: "Provider blocklist" },
+  "provider.ignore": { type: "string", description: "Provider blocklist" },
+  allow_fallbacks: {
+    type: "boolean",
+    default: true,
+    description: "Allow fallback providers"
+  },
+  "provider.allow_fallbacks": {
+    type: "boolean",
+    default: true,
+    description: "Allow fallback providers"
+  },
+  require_parameters: {
+    type: "boolean",
+    default: false,
+    description: "Only route to providers that support all request params"
+  },
+  "provider.require_parameters": {
+    type: "boolean",
+    default: false,
+    description: "Only route to providers that support all request params"
+  },
+  data_collection: {
+    type: "string",
+    values: ["allow", "deny"],
+    default: "allow",
+    description: "Provider data collection policy"
+  },
+  "provider.data_collection": {
+    type: "string",
+    values: ["allow", "deny"],
+    default: "allow",
+    description: "Provider data collection policy"
+  },
+  zdr: {
+    type: "boolean",
+    description: "Require zero data retention providers"
+  },
+  "provider.zdr": {
+    type: "boolean",
+    description: "Require zero data retention providers"
+  },
+  enforce_distillable_text: {
+    type: "boolean",
+    description: "Require providers that allow text distillation"
+  },
+  "provider.enforce_distillable_text": {
+    type: "boolean",
+    description: "Require providers that allow text distillation"
+  },
+  quantizations: {
+    type: "string",
+    description: "Allowed provider quantization levels"
+  },
+  "provider.quantizations": {
+    type: "string",
+    description: "Allowed provider quantization levels"
+  },
+  sort: {
+    type: "string",
+    values: ["price", "throughput", "latency", "cost", "ttft", "tps"],
+    description: "Provider sort strategy"
+  },
+  "provider.sort": {
+    type: "string",
+    values: ["price", "throughput", "latency", "cost", "ttft", "tps"],
+    description: "Provider sort strategy"
+  },
+  preferred_min_throughput: {
+    type: "number",
+    min: 0,
+    description: "Preferred minimum provider throughput"
+  },
+  "provider.preferred_min_throughput": {
+    type: "number",
+    min: 0,
+    description: "Preferred minimum provider throughput"
+  },
+  preferred_max_latency: {
+    type: "number",
+    min: 0,
+    description: "Preferred maximum provider latency"
+  },
+  "provider.preferred_max_latency": {
+    type: "number",
+    min: 0,
+    description: "Preferred maximum provider latency"
+  },
+  max_price: {
+    type: "string",
+    description: "Maximum provider price filter"
+  },
+  "provider.max_price": {
+    type: "string",
+    description: "Maximum provider price filter"
+  },
+  transforms: {
+    type: "string",
+    description: "Legacy OpenRouter message transforms"
+  },
+  plugins: {
+    type: "string",
+    description: "OpenRouter request plugins"
+  }
+};
+var FAL_PARAM_SPECS = {
+  prompt: { type: "string", description: "Prompt" },
+  negative_prompt: { type: "string", description: "Negative prompt" },
+  seed: { type: "number", description: "Random seed" },
+  num_images: {
+    type: "number",
+    min: 1,
+    description: "Number of images to generate"
+  },
+  image_size: { type: "string", description: "Output image size" },
+  aspect_ratio: { type: "string", description: "Output aspect ratio" },
+  enable_safety_checker: {
+    type: "boolean",
+    description: "Enable safety checker"
+  },
+  enable_safety_checks: {
+    type: "boolean",
+    description: "Enable safety checker"
+  },
+  enable_prompt_expansion: {
+    type: "boolean",
+    description: "Enable prompt expansion"
+  },
+  expand_prompt: {
+    type: "boolean",
+    description: "Enable prompt expansion"
+  },
+  output_format: {
+    type: "string",
+    values: ["jpeg", "jpg", "png", "webp", "gif"],
+    description: "Output image format"
+  },
+  width: { type: "number", min: 1, description: "Image width" },
+  height: { type: "number", min: 1, description: "Image height" }
+};
+var REPLICATE_PARAM_SPECS = {
+  prompt: { type: "string", description: "Prompt" },
+  negative_prompt: { type: "string", description: "Negative prompt" },
+  input: { type: "string", description: "Model input object" },
+  version: { type: "string", description: "Model version" },
+  seed: { type: "number", description: "Random seed" },
+  num_outputs: {
+    type: "number",
+    min: 1,
+    description: "Number of outputs to generate"
+  },
+  num_inference_steps: {
+    type: "number",
+    min: 1,
+    description: "Number of inference steps"
+  },
+  guidance_scale: {
+    type: "number",
+    min: 0,
+    description: "Guidance scale"
+  },
+  image_size: { type: "string", description: "Output image size" },
+  aspect_ratio: { type: "string", description: "Output aspect ratio" },
+  output_format: { type: "string", description: "Output format" },
+  width: { type: "number", min: 1, description: "Image width" },
+  height: { type: "number", min: 1, description: "Image height" },
+  stream: { type: "boolean", description: "Request streaming output" },
+  webhook: { type: "string", description: "Webhook URL" },
+  webhook_events_filter: {
+    type: "string",
+    description: "Webhook events filter"
+  }
+};
+var PRODIA_PARAM_SPECS = {
+  model: { type: "string", description: "Model name" },
+  prompt: { type: "string", description: "Prompt" },
+  negative_prompt: { type: "string", description: "Negative prompt" },
+  style_preset: { type: "string", description: "Style preset" },
+  steps: { type: "number", min: 1, description: "Generation steps" },
+  cfg_scale: { type: "number", min: 0, description: "CFG scale" },
+  seed: { type: "number", description: "Random seed" },
+  upscale: { type: "boolean", description: "Enable 2x upscale" },
+  sampler: { type: "string", description: "Sampler" },
+  width: { type: "number", min: 1, max: 1024, description: "Image width" },
+  height: { type: "number", min: 1, max: 1024, description: "Image height" },
+  image_size: { type: "string", description: "Output image size" },
+  aspect_ratio: { type: "string", description: "Output aspect ratio" },
+  output_format: { type: "string", description: "Output format" },
+  type: { type: "string", description: "Prodia v2 job type" },
+  config: { type: "string", description: "Prodia v2 job config" },
+  price: { type: "boolean", description: "Include Prodia v2 job price" }
+};
+var LUMA_PARAM_SPECS = {
+  prompt: { type: "string", description: "Prompt" },
+  model: { type: "string", description: "Model name" },
+  aspect_ratio: { type: "string", description: "Output aspect ratio" },
+  keyframes: { type: "string", description: "Generation keyframes" },
+  loop: { type: "boolean", description: "Generate a looping video" },
+  duration: { type: "string", description: "Generation duration" },
+  type: { type: "string", description: "Generation type" },
+  image_ref: { type: "string", description: "Image reference" },
+  video: { type: "string", description: "Video options" },
+  source: { type: "string", description: "Source generation or media" }
+};
+var GOOGLE_COMPATIBLE_PARAM_SPECS = {
+  temperature: {
+    type: "number",
+    min: 0,
+    max: 2,
+    default: 0.7,
+    description: "Controls randomness"
+  },
+  maxOutputTokens: {
+    type: "number",
+    min: 1,
+    default: 4096,
+    description: "Maximum output tokens"
+  },
+  topP: {
+    type: "number",
+    min: 0,
+    max: 1,
+    default: 1,
+    description: "Nucleus sampling"
+  },
+  topK: {
+    type: "number",
+    min: 0,
+    default: 40,
+    description: "Top-K sampling"
+  },
+  frequencyPenalty: {
+    type: "number",
+    min: -2,
+    max: 2,
+    default: 0,
+    description: "Penalize frequent tokens"
+  },
+  presencePenalty: {
+    type: "number",
+    min: -2,
+    max: 2,
+    default: 0,
+    description: "Penalize repeated topics"
+  },
+  stopSequences: { type: "string", description: "Stop sequences" },
+  candidateCount: {
+    type: "number",
+    min: 1,
+    default: 1,
+    description: "Candidate count"
+  },
+  stream: { type: "boolean", default: false, description: "Stream response" },
+  seed: { type: "number", description: "Random seed" },
+  responseMimeType: { type: "string", description: "Response MIME type" },
+  responseSchema: { type: "string", description: "Response schema" }
+};
+var PARAM_SPECS = {
+  openai: {
+    temperature: {
+      type: "number",
+      min: 0,
+      max: 2,
+      default: 0.7,
+      description: "Controls randomness"
+    },
+    max_tokens: {
+      type: "number",
+      min: 1,
+      default: 4096,
+      description: "Maximum output tokens"
+    },
+    max_completion_tokens: {
+      type: "number",
+      min: 1,
+      default: 4096,
+      description: "Maximum completion tokens (reasoning models)"
+    },
+    top_p: {
+      type: "number",
+      min: 0,
+      max: 1,
+      default: 1,
+      description: "Nucleus sampling"
+    },
+    frequency_penalty: {
+      type: "number",
+      min: -2,
+      max: 2,
+      default: 0,
+      description: "Penalize frequent tokens"
+    },
+    presence_penalty: {
+      type: "number",
+      min: -2,
+      max: 2,
+      default: 0,
+      description: "Penalize repeated topics"
+    },
+    stop: { type: "string", description: "Stop sequences" },
+    n: { type: "number", min: 1, default: 1, description: "Completions count" },
+    seed: { type: "number", description: "Random seed" },
+    stream: { type: "boolean", default: false, description: "Stream response" },
+    reasoning_effort: {
+      type: "string",
+      values: REASONING_EFFORT_VALUES,
+      default: "medium",
+      description: "Reasoning effort"
+    }
+  },
+  azure: OPENAI_COMPATIBLE_PARAM_SPECS,
+  anthropic: {
+    temperature: {
+      type: "number",
+      min: 0,
+      max: 1,
+      default: 0.7,
+      description: "Controls randomness"
+    },
+    max_tokens: {
+      type: "number",
+      min: 1,
+      default: 4096,
+      description: "Maximum output tokens"
+    },
+    top_p: {
+      type: "number",
+      min: 0,
+      max: 1,
+      default: 1,
+      description: "Nucleus sampling"
+    },
+    top_k: {
+      type: "number",
+      min: 0,
+      default: 40,
+      description: "Top-K sampling"
+    },
+    stop_sequences: { type: "string", description: "Stop sequences" },
+    stream: { type: "boolean", default: false, description: "Stream response" },
+    effort: {
+      type: "string",
+      values: REASONING_EFFORT_VALUES,
+      default: "low",
+      description: "Thinking effort"
+    },
+    cache_control: {
+      type: "string",
+      values: ["ephemeral"],
+      default: "ephemeral",
+      description: "Cache control"
+    },
+    cache_ttl: {
+      type: "string",
+      values: ["5m", "1h"],
+      default: "5m",
+      description: "Cache TTL"
+    }
+  },
+  google: {
+    temperature: {
+      type: "number",
+      min: 0,
+      max: 2,
+      default: 0.7,
+      description: "Controls randomness"
+    },
+    maxOutputTokens: {
+      type: "number",
+      min: 1,
+      default: 4096,
+      description: "Maximum output tokens"
+    },
+    topP: {
+      type: "number",
+      min: 0,
+      max: 1,
+      default: 1,
+      description: "Nucleus sampling"
+    },
+    topK: {
+      type: "number",
+      min: 0,
+      default: 40,
+      description: "Top-K sampling"
+    },
+    frequencyPenalty: {
+      type: "number",
+      min: -2,
+      max: 2,
+      default: 0,
+      description: "Penalize frequent tokens"
+    },
+    presencePenalty: {
+      type: "number",
+      min: -2,
+      max: 2,
+      default: 0,
+      description: "Penalize repeated topics"
+    },
+    stopSequences: { type: "string", description: "Stop sequences" },
+    candidateCount: {
+      type: "number",
+      min: 1,
+      default: 1,
+      description: "Candidate count"
+    },
+    stream: { type: "boolean", default: false, description: "Stream response" },
+    seed: { type: "number", description: "Random seed" },
+    responseMimeType: { type: "string", description: "Response MIME type" },
+    responseSchema: { type: "string", description: "Response schema" }
+  },
+  "google-vertex": GOOGLE_COMPATIBLE_PARAM_SPECS,
+  mistral: {
+    temperature: {
+      type: "number",
+      min: 0,
+      max: 1,
+      default: 0.7,
+      description: "Controls randomness"
+    },
+    max_tokens: {
+      type: "number",
+      min: 1,
+      default: 4096,
+      description: "Maximum output tokens"
+    },
+    top_p: {
+      type: "number",
+      min: 0,
+      max: 1,
+      default: 1,
+      description: "Nucleus sampling"
+    },
+    frequency_penalty: {
+      type: "number",
+      min: -2,
+      max: 2,
+      default: 0,
+      description: "Penalize frequent tokens"
+    },
+    presence_penalty: {
+      type: "number",
+      min: -2,
+      max: 2,
+      default: 0,
+      description: "Penalize repeated topics"
+    },
+    stop: { type: "string", description: "Stop sequences" },
+    n: { type: "number", min: 1, default: 1, description: "Completions count" },
+    random_seed: { type: "number", description: "Random seed" },
+    stream: { type: "boolean", default: false, description: "Stream response" },
+    safe_prompt: {
+      type: "boolean",
+      default: false,
+      description: "Enable safe prompt"
+    },
+    min_tokens: {
+      type: "number",
+      min: 0,
+      default: 0,
+      description: "Minimum tokens"
+    }
+  },
+  cohere: {
+    temperature: {
+      type: "number",
+      min: 0,
+      max: 1,
+      default: 0.7,
+      description: "Controls randomness"
+    },
+    max_tokens: {
+      type: "number",
+      min: 1,
+      default: 4096,
+      description: "Maximum output tokens"
+    },
+    p: {
+      type: "number",
+      min: 0,
+      max: 1,
+      default: 1,
+      description: "Nucleus sampling (p)"
+    },
+    k: {
+      type: "number",
+      min: 0,
+      max: 500,
+      default: 40,
+      description: "Top-K sampling (k)"
+    },
+    frequency_penalty: {
+      type: "number",
+      min: 0,
+      max: 1,
+      default: 0,
+      description: "Penalize frequent tokens"
+    },
+    presence_penalty: {
+      type: "number",
+      min: 0,
+      max: 1,
+      default: 0,
+      description: "Penalize repeated topics"
+    },
+    stop_sequences: { type: "string", description: "Stop sequences" },
+    stream: { type: "boolean", default: false, description: "Stream response" },
+    seed: { type: "number", description: "Random seed" }
+  },
+  bedrock: {
+    // Converse API inferenceConfig params
+    temperature: {
+      type: "number",
+      min: 0,
+      max: 1,
+      default: 0.7,
+      description: "Controls randomness"
+    },
+    maxTokens: {
+      type: "number",
+      min: 1,
+      default: 4096,
+      description: "Maximum output tokens"
+    },
+    topP: {
+      type: "number",
+      min: 0,
+      max: 1,
+      default: 1,
+      description: "Nucleus sampling"
+    },
+    topK: {
+      type: "number",
+      min: 0,
+      default: 40,
+      description: "Top-K sampling"
+    },
+    stopSequences: { type: "string", description: "Stop sequences" },
+    stream: { type: "boolean", default: false, description: "Stream response" },
+    cache_control: {
+      type: "string",
+      values: ["ephemeral"],
+      default: "ephemeral",
+      description: "Cache control"
+    },
+    cache_ttl: {
+      type: "string",
+      values: ["5m", "1h"],
+      default: "5m",
+      description: "Cache TTL"
+    }
+  },
+  openrouter: {
+    // Loose validation — proxies to many providers with varying ranges
+    temperature: {
+      type: "number",
+      min: 0,
+      max: 2,
+      default: 0.7,
+      description: "Controls randomness"
+    },
+    max_tokens: {
+      type: "number",
+      min: 1,
+      default: 4096,
+      description: "Maximum output tokens"
+    },
+    max_completion_tokens: {
+      type: "number",
+      min: 1,
+      default: 4096,
+      description: "Maximum completion tokens (reasoning models)"
+    },
+    top_p: {
+      type: "number",
+      min: 0,
+      max: 1,
+      default: 1,
+      description: "Nucleus sampling"
+    },
+    top_k: {
+      type: "number",
+      min: 0,
+      default: 40,
+      description: "Top-K sampling"
+    },
+    frequency_penalty: {
+      type: "number",
+      min: -2,
+      max: 2,
+      default: 0,
+      description: "Penalize frequent tokens"
+    },
+    presence_penalty: {
+      type: "number",
+      min: -2,
+      max: 2,
+      default: 0,
+      description: "Penalize repeated topics"
+    },
+    stop: { type: "string", description: "Stop sequences" },
+    n: { type: "number", min: 1, default: 1, description: "Completions count" },
+    seed: { type: "number", description: "Random seed" },
+    stream: { type: "boolean", default: false, description: "Stream response" },
+    reasoning_effort: {
+      type: "string",
+      values: REASONING_EFFORT_VALUES,
+      default: "medium",
+      description: "Reasoning effort"
+    },
+    ...OPENROUTER_ROUTING_PARAM_SPECS
+  },
+  vercel: {
+    // Loose validation — proxies to many providers with varying ranges
+    temperature: {
+      type: "number",
+      min: 0,
+      max: 2,
+      default: 0.7,
+      description: "Controls randomness"
+    },
+    max_tokens: {
+      type: "number",
+      min: 1,
+      default: 4096,
+      description: "Maximum output tokens"
+    },
+    max_completion_tokens: {
+      type: "number",
+      min: 1,
+      default: 4096,
+      description: "Maximum completion tokens (reasoning models)"
+    },
+    top_p: {
+      type: "number",
+      min: 0,
+      max: 1,
+      default: 1,
+      description: "Nucleus sampling"
+    },
+    top_k: {
+      type: "number",
+      min: 0,
+      default: 40,
+      description: "Top-K sampling"
+    },
+    frequency_penalty: {
+      type: "number",
+      min: -2,
+      max: 2,
+      default: 0,
+      description: "Penalize frequent tokens"
+    },
+    presence_penalty: {
+      type: "number",
+      min: -2,
+      max: 2,
+      default: 0,
+      description: "Penalize repeated topics"
+    },
+    stop: { type: "string", description: "Stop sequences" },
+    n: { type: "number", min: 1, default: 1, description: "Completions count" },
+    seed: { type: "number", description: "Random seed" },
+    stream: { type: "boolean", default: false, description: "Stream response" },
+    reasoning_effort: {
+      type: "string",
+      values: REASONING_EFFORT_VALUES,
+      default: "medium",
+      description: "Reasoning effort"
+    },
+    order: { type: "string", description: "Gateway provider order" },
+    only: { type: "string", description: "Gateway provider allowlist" },
+    models: { type: "string", description: "Gateway fallback models" },
+    tags: { type: "string", description: "Gateway usage tags" },
+    sort: {
+      type: "string",
+      values: ["cost", "ttft", "tps"],
+      description: "Gateway provider sort strategy"
+    },
+    caching: {
+      type: "string",
+      values: ["auto"],
+      description: "Gateway automatic caching strategy"
+    },
+    user: { type: "string", description: "Gateway usage user identifier" },
+    byok: { type: "string", description: "Gateway BYOK credentials" },
+    zero_data_retention: {
+      type: "boolean",
+      description: "Gateway zero data retention routing"
+    },
+    zeroDataRetention: {
+      type: "boolean",
+      description: "Gateway zero data retention routing"
+    },
+    disallow_prompt_training: {
+      type: "boolean",
+      description: "Gateway prompt training opt-out routing"
+    },
+    disallowPromptTraining: {
+      type: "boolean",
+      description: "Gateway prompt training opt-out routing"
+    },
+    hipaa_compliant: {
+      type: "boolean",
+      description: "Gateway HIPAA-compliant routing"
+    },
+    hipaaCompliant: {
+      type: "boolean",
+      description: "Gateway HIPAA-compliant routing"
+    },
+    quota_entity_id: {
+      type: "string",
+      description: "Gateway quota entity identifier"
+    },
+    quotaEntityId: {
+      type: "string",
+      description: "Gateway quota entity identifier"
+    },
+    provider_timeouts: {
+      type: "string",
+      description: "Gateway provider timeouts"
+    },
+    providerTimeouts: {
+      type: "string",
+      description: "Gateway provider timeouts"
+    }
+  },
+  xai: OPENAI_COMPATIBLE_PARAM_SPECS,
+  groq: OPENAI_COMPATIBLE_PARAM_SPECS,
+  fal: FAL_PARAM_SPECS,
+  deepinfra: OPENAI_COMPATIBLE_PARAM_SPECS,
+  "black-forest-labs": {},
+  together: OPENAI_COMPATIBLE_PARAM_SPECS,
+  fireworks: OPENAI_COMPATIBLE_PARAM_SPECS,
+  deepseek: OPENAI_COMPATIBLE_PARAM_SPECS,
+  moonshotai: OPENAI_COMPATIBLE_PARAM_SPECS,
+  perplexity: OPENAI_COMPATIBLE_PARAM_SPECS,
+  alibaba: OPENAI_COMPATIBLE_PARAM_SPECS,
+  cerebras: OPENAI_COMPATIBLE_PARAM_SPECS,
+  replicate: REPLICATE_PARAM_SPECS,
+  prodia: PRODIA_PARAM_SPECS,
+  luma: LUMA_PARAM_SPECS,
+  bytedance: {},
+  kling: {},
+  elevenlabs: {},
+  assemblyai: {},
+  deepgram: {},
+  gladia: {},
+  lmnt: {},
+  hume: {},
+  revai: {},
+  baseten: OPENAI_COMPATIBLE_PARAM_SPECS,
+  huggingface: OPENAI_COMPATIBLE_PARAM_SPECS
+};
 function isReasoningModel(model) {
-  const name = model.includes("/") ? model.split("/").pop() : model;
-  return /^o[134]/.test(name);
+  const name = modelLeafName(model);
+  const oSeries = name.match(/^o\d+/)?.[0];
+  const gptSeries = name.match(/^gpt-[5-9]/)?.[0];
+  return (oSeries ? modelMatchesFamily(name, oSeries) : false) || (gptSeries ? modelMatchesFamily(name, gptSeries) : false);
 }
 function canHostOpenAIModels(provider) {
-  return provider === "openai" || provider === "openrouter" || provider === "vercel";
+  return provider === "openai" || provider === "azure" || provider === "openrouter" || provider === "vercel";
 }
 function isGatewayProvider(provider) {
   return provider === "openrouter" || provider === "vercel";
@@ -397,22 +1367,27 @@ function isGatewayProvider(provider) {
 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);
+  const prefix = normalizeModelForMatching(model.slice(0, slash));
+  const direct = {
+    openai: "openai",
+    anthropic: "anthropic",
+    google: "google",
+    vertex: "google",
+    "google-vertex": "google",
+    mistral: "mistral",
+    cohere: "cohere"
+  };
+  return direct[prefix];
 }
+var REASONING_MODEL_UNSUPPORTED = /* @__PURE__ */ new Set([
+  "temperature",
+  "top_p",
+  "top_k",
+  "frequency_penalty",
+  "presence_penalty",
+  "n"
+]);
 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",
@@ -421,12 +1396,18 @@ function detectBedrockModelFamily(model) {
     "cohere",
     "ai21"
   ];
-  return families.find((f) => prefix === f);
+  const parts = modelLeafName(model).split(".");
+  return families.find((family) => parts.includes(family));
 }
 function bedrockSupportsCaching(model) {
   const family = detectBedrockModelFamily(model);
   if (family === "anthropic") return true;
-  if (family === "amazon" && model.includes("nova")) return true;
+  if (family === "amazon") {
+    const parts = modelLeafName(model).split(".");
+    const amazonIndex = parts.indexOf("amazon");
+    const modelName = amazonIndex >= 0 ? parts[amazonIndex + 1] : void 0;
+    return modelName ? modelMatchesFamily(modelName, "nova") : false;
+  }
   return false;
 }
 var CACHE_VALUES = {
@@ -511,9 +1492,9 @@ var CACHE_TTLS = {
   baseten: void 0,
   huggingface: void 0
 };
-var DURATION_RE = /^\d+[mh]$/;
 
 // src/normalize.ts
+var DURATION_RE = /^\d+[mh]$/;
 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;
@@ -601,6 +1582,17 @@ function normalize(config, options = {}) {
       }
       key = "max_completion_tokens";
     }
+    if (provider && canHostOpenAIModels(provider) && isReasoningModel(config.model) && REASONING_MODEL_UNSUPPORTED.has(key)) {
+      if (options.verbose) {
+        changes.push({
+          from: key,
+          to: "(dropped)",
+          value,
+          reason: `${provider} reasoning model "${config.model}" does not support "${key}"`
+        });
+      }
+      continue;
+    }
     params[key] = value;
   }
   return {
@@ -1009,6 +2001,7 @@ function addGatewayOption(options, key, value) {
   };
   const directKeys = /* @__PURE__ */ new Set([
     "sort",
+    "caching",
     "user",
     "zeroDataRetention",
     "disallowPromptTraining",
@@ -1032,10 +2025,63 @@ function addGatewayOption(options, key, value) {
 }
 function addOpenRouterOption(options, key, value) {
   const target = "openrouter";
+  const providerKey = key.startsWith("provider.") ? key.slice(9) : key;
+  const providerListKeys = /* @__PURE__ */ new Set([
+    "order",
+    "only",
+    "ignore",
+    "quantizations"
+  ]);
+  const providerObjectKeys = /* @__PURE__ */ new Set([
+    "provider",
+    "sort",
+    "preferred_min_throughput",
+    "preferred_max_latency",
+    "max_price"
+  ]);
+  const providerScalarKeys = /* @__PURE__ */ new Set([
+    "allow_fallbacks",
+    "require_parameters",
+    "data_collection",
+    "zdr",
+    "enforce_distillable_text"
+  ]);
   if (key === "models") {
     setProviderOption(options, target, "models", parseStringList(value));
     return;
   }
+  if (key === "transforms") {
+    setProviderOption(options, target, "transforms", parseStringList(value));
+    return;
+  }
+  if (key === "plugins") {
+    const parsed = parseJson(value);
+    setProviderOption(
+      options,
+      target,
+      "plugins",
+      Array.isArray(parsed) ? parsed : parseStringList(value)
+    );
+    return;
+  }
+  if (key.startsWith("provider.") || providerListKeys.has(providerKey) || providerScalarKeys.has(providerKey) || providerObjectKeys.has(providerKey)) {
+    if (providerKey === "provider") {
+      mergeObjectOption(options, target, "provider", value);
+      return;
+    }
+    const current = options[target]?.provider;
+    const providerOptions = current && typeof current === "object" && !Array.isArray(current) ? { ...current } : {};
+    if (providerListKeys.has(providerKey)) {
+      providerOptions[providerKey] = parseStringList(value);
+    } else if (providerObjectKeys.has(providerKey)) {
+      const parsed = parseJson(value);
+      providerOptions[providerKey] = parsed !== void 0 ? parsed : typedValue(value);
+    } else {
+      providerOptions[providerKey] = typedValue(value);
+    }
+    setProviderOption(options, target, "provider", providerOptions);
+    return;
+  }
   if (key === "reasoning") {
     mergeObjectOption(options, target, "reasoning", value);
     return;
@@ -1077,65 +2123,49 @@ function addOpenRouterOption(options, key, value) {
 function addFlexibleProviderOption(options, target, key, value) {
   setProviderOption(options, target, key, typedValue(value));
 }
+var PROVIDER_OPTION_HANDLERS = {
+  openai: addOpenAiOption,
+  azure: (options, key, value) => addOpenAiOption(options, key, value, "azure"),
+  anthropic: addAnthropicOption,
+  google: addGoogleOption,
+  "google-vertex": (options, key, value) => addGoogleOption(options, key, value, "vertex"),
+  mistral: addMistralOption,
+  cohere: addCohereOption,
+  bedrock: addBedrockOption,
+  openrouter: addOpenRouterOption,
+  xai: (options, key, value) => addOpenAiOption(options, key, value, "xai"),
+  groq: (options, key, value) => addOpenAiOption(options, key, value, "groq"),
+  fal: (options, key, value) => addFlexibleProviderOption(options, "fal", key, value),
+  deepinfra: (options, key, value) => addOpenAiOption(options, key, value, "deepinfra"),
+  "black-forest-labs": (options, key, value) => addFlexibleProviderOption(options, "blackForestLabs", key, value),
+  together: (options, key, value) => addOpenAiOption(options, key, value, "together"),
+  fireworks: (options, key, value) => addOpenAiOption(options, key, value, "fireworks"),
+  deepseek: (options, key, value) => addOpenAiOption(options, key, value, "deepseek"),
+  moonshotai: (options, key, value) => addOpenAiOption(options, key, value, "moonshotai"),
+  perplexity: (options, key, value) => addOpenAiOption(options, key, value, "perplexity"),
+  alibaba: (options, key, value) => addOpenAiOption(options, key, value, "alibaba"),
+  cerebras: (options, key, value) => addOpenAiOption(options, key, value, "cerebras"),
+  replicate: (options, key, value) => addFlexibleProviderOption(options, "replicate", key, value),
+  prodia: (options, key, value) => addFlexibleProviderOption(options, "prodia", key, value),
+  luma: (options, key, value) => addFlexibleProviderOption(options, "luma", key, value),
+  bytedance: (options, key, value) => addFlexibleProviderOption(options, "bytedance", key, value),
+  kling: (options, key, value) => addFlexibleProviderOption(options, "kling", key, value),
+  elevenlabs: (options, key, value) => addFlexibleProviderOption(options, "elevenlabs", key, value),
+  assemblyai: (options, key, value) => addFlexibleProviderOption(options, "assemblyai", key, value),
+  deepgram: (options, key, value) => addFlexibleProviderOption(options, "deepgram", key, value),
+  gladia: (options, key, value) => addFlexibleProviderOption(options, "gladia", key, value),
+  lmnt: (options, key, value) => addFlexibleProviderOption(options, "lmnt", key, value),
+  hume: (options, key, value) => addFlexibleProviderOption(options, "hume", key, value),
+  revai: (options, key, value) => addFlexibleProviderOption(options, "revai", key, value),
+  baseten: (options, key, value) => addOpenAiOption(options, key, value, "baseten"),
+  huggingface: (options, key, value) => addOpenAiOption(options, key, value, "huggingface")
+};
 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");
+  PROVIDER_OPTION_HANDLERS[provider](options, key, value);
 }
 function createAiSdkProviderOptions(configOrResult, options = {}) {
   const normalized = typeof configOrResult === "string" ? normalize(parse(configOrResult), options) : "changes" in configOrResult && "subProvider" in configOrResult ? configOrResult : normalize(configOrResult, options);