llm-strings 1.4.0 → 1.5.0

package/dist/{chunk-76EFNZCF.js → chunk-PCJDQTOV.js}

@@ -113,44 +113,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 = {
@@ -193,7 +241,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",
@@ -203,6 +254,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",
@@ -213,6 +265,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",
@@ -231,6 +367,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",
@@ -307,6 +444,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",
@@ -315,12 +453,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",
@@ -333,7 +473,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,
@@ -343,9 +483,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: {},
@@ -358,6 +498,15 @@ 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",
@@ -372,6 +521,12 @@ var OPENAI_COMPATIBLE_PARAM_SPECS = {
     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,
@@ -405,11 +560,221 @@ var OPENAI_COMPATIBLE_PARAM_SPECS = {
   stream: { type: "boolean", default: false, description: "Stream response" },
   reasoning_effort: {
     type: "string",
-    values: ["none", "minimal", "low", "medium", "high", "xhigh"],
+    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",
@@ -478,6 +843,12 @@ var PARAM_SPECS = {
       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,
@@ -505,7 +876,7 @@ var PARAM_SPECS = {
     stream: { type: "boolean", default: false, description: "Stream response" },
     reasoning_effort: {
       type: "string",
-      values: ["none", "minimal", "low", "medium", "high", "xhigh"],
+      values: REASONING_EFFORT_VALUES,
       default: "medium",
       description: "Reasoning effort"
     }
@@ -542,8 +913,8 @@ var PARAM_SPECS = {
     stream: { type: "boolean", default: false, description: "Stream response" },
     effort: {
       type: "string",
-      values: ["low", "medium", "high", "max"],
-      default: "medium",
+      values: REASONING_EFFORT_VALUES,
+      default: "low",
       description: "Thinking effort"
     },
     cache_control: {
@@ -768,6 +1139,12 @@ var PARAM_SPECS = {
       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,
@@ -801,10 +1178,11 @@ var PARAM_SPECS = {
     stream: { type: "boolean", default: false, description: "Stream response" },
     reasoning_effort: {
       type: "string",
-      values: ["none", "minimal", "low", "medium", "high", "xhigh"],
+      values: REASONING_EFFORT_VALUES,
       default: "medium",
       description: "Reasoning effort"
-    }
+    },
+    ...OPENROUTER_ROUTING_PARAM_SPECS
   },
   vercel: {
     // Loose validation — proxies to many providers with varying ranges
@@ -821,6 +1199,12 @@ var PARAM_SPECS = {
       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,
@@ -854,14 +1238,70 @@ var PARAM_SPECS = {
     stream: { type: "boolean", default: false, description: "Stream response" },
     reasoning_effort: {
       type: "string",
-      values: ["none", "minimal", "low", "medium", "high", "xhigh"],
+      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: FAL_PARAM_SPECS,
   deepinfra: OPENAI_COMPATIBLE_PARAM_SPECS,
   "black-forest-labs": {},
   together: OPENAI_COMPATIBLE_PARAM_SPECS,
@@ -871,9 +1311,9 @@ var PARAM_SPECS = {
   perplexity: OPENAI_COMPATIBLE_PARAM_SPECS,
   alibaba: OPENAI_COMPATIBLE_PARAM_SPECS,
   cerebras: OPENAI_COMPATIBLE_PARAM_SPECS,
-  replicate: {},
-  prodia: {},
-  luma: {},
+  replicate: REPLICATE_PARAM_SPECS,
+  prodia: PRODIA_PARAM_SPECS,
+  luma: LUMA_PARAM_SPECS,
   bytedance: {},
   kling: {},
   elevenlabs: {},
@@ -887,11 +1327,13 @@ var 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";
@@ -899,29 +1341,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",
@@ -930,12 +1370,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 = {
@@ -1020,12 +1466,12 @@ var CACHE_TTLS = {
   baseten: void 0,
   huggingface: void 0
 };
-var DURATION_RE = /^\d+[mh]$/;
 
 export {
   HOST_ALIASES,
   resolveHostAlias,
   providerFromHostAlias,
+  modelMatchesFamily,
   detectProvider,
   ALIASES,
   PROVIDER_PARAMS,
@@ -1038,6 +1484,5 @@ export {
   detectBedrockModelFamily,
   bedrockSupportsCaching,
   CACHE_VALUES,
-  CACHE_TTLS,
-  DURATION_RE
+  CACHE_TTLS
 };