llm-strings 1.1.1 → 1.2.0

package/dist/index.cjs

@@ -1,18 +1,1038 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+"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);
 
-var _chunkRSUXM42Xcjs = require('./chunk-RSUXM42X.cjs');
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  HOST_ALIASES: () => HOST_ALIASES,
+  build: () => build,
+  normalize: () => normalize,
+  parse: () => parse,
+  resolveHostAlias: () => resolveHostAlias,
+  validate: () => validate
+});
+module.exports = __toCommonJS(index_exports);
 
+// src/provider-core.ts
+function hasOwn(object, key) {
+  return Object.prototype.hasOwnProperty.call(object, key);
+}
+var HOST_ALIASES = {
+  openai: "api.openai.com",
+  anthropic: "api.anthropic.com",
+  google: "generativelanguage.googleapis.com",
+  aistudio: "generativelanguage.googleapis.com",
+  mistral: "api.mistral.ai",
+  cohere: "api.cohere.com",
+  bedrock: "bedrock-runtime.us-east-1.amazonaws.com",
+  openrouter: "openrouter.ai",
+  vercel: "gateway.ai.vercel.app",
+  alibaba: "dashscope-intl.aliyuncs.com",
+  alibabacloud: "dashscope-intl.aliyuncs.com",
+  dashscope: "dashscope-intl.aliyuncs.com",
+  fireworks: "api.fireworks.ai",
+  fireworksai: "api.fireworks.ai",
+  venice: "api.venice.ai",
+  parasail: "api.parasail.io",
+  deepinfra: "api.deepinfra.com",
+  atlascloud: "api.atlascloud.ai",
+  novita: "api.novita.ai",
+  novitaai: "api.novita.ai",
+  grok: "api.x.ai",
+  xai: "api.x.ai",
+  wandb: "api.inference.wandb.ai",
+  weightsandbiases: "api.inference.wandb.ai",
+  baidu: "qianfan.baidubce.com",
+  qianfan: "qianfan.baidubce.com",
+  vertex: "aiplatform.googleapis.com",
+  xiaomi: "api.xiaomimimo.com",
+  minimax: "api.minimax.io"
+};
+function readProcessEnv() {
+  return typeof process !== "undefined" && process.env ? process.env : {};
+}
+function normalizeHostValue(value) {
+  const trimmed = value.trim();
+  if (!trimmed) return trimmed;
+  try {
+    if (trimmed.includes("://")) {
+      return new URL(trimmed).host;
+    }
+  } catch {
+  }
+  return trimmed.replace(/^\/\//, "").split("/")[0] ?? trimmed;
+}
+function envHostOverride(alias, env) {
+  const upper = alias.toUpperCase();
+  const override = env[`LLM_STRINGS_${upper}_HOST`] ?? env[`LLM_STRINGS_HOST_${upper}`];
+  return override?.trim() ? override : void 0;
+}
+function resolveHostAlias(host, env = readProcessEnv()) {
+  const normalizedHost = host.toLowerCase();
+  if (!hasOwn(HOST_ALIASES, normalizedHost)) {
+    return { host };
+  }
+  const alias = normalizedHost;
+  const override = envHostOverride(alias, env);
+  return {
+    host: normalizeHostValue(override ?? HOST_ALIASES[alias]),
+    alias
+  };
+}
+function providerFromHostAlias(alias) {
+  const normalizedAlias = alias.toLowerCase();
+  if (hasOwn(PROVIDER_PARAMS, normalizedAlias)) {
+    return normalizedAlias;
+  }
+  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"
+  }
+};
+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"
+    },
+    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: ["none", "minimal", "low", "medium", "high", "xhigh"],
+      default: "medium",
+      description: "Reasoning effort"
+    }
+  },
+  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: ["low", "medium", "high", "max"],
+      default: "medium",
+      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" }
+  },
+  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"
+    },
+    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: ["none", "minimal", "low", "medium", "high", "xhigh"],
+      default: "medium",
+      description: "Reasoning effort"
+    }
+  },
+  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"
+    },
+    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: ["none", "minimal", "low", "medium", "high", "xhigh"],
+      default: "medium",
+      description: "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);
+}
+var REASONING_MODEL_UNSUPPORTED = /* @__PURE__ */ new Set([
+  "temperature",
+  "top_p",
+  "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",
+    "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]$/;
 
-var _chunkMGWGNZDJcjs = require('./chunk-MGWGNZDJ.cjs');
+// src/parse.ts
+function parse(connectionString) {
+  const url = new URL(connectionString);
+  if (url.protocol !== "llm:") {
+    throw new Error(
+      `Invalid scheme: expected "llm://", got "${url.protocol}//"`
+    );
+  }
+  const { host, alias: hostAlias } = resolveHostAlias(url.host);
+  const model = url.pathname.replace(/^\//, "");
+  const label = url.username || void 0;
+  const apiKey = url.password || void 0;
+  const params = {};
+  for (const [key, value] of url.searchParams) {
+    params[key] = value;
+  }
+  return {
+    raw: connectionString,
+    host,
+    hostAlias,
+    model,
+    label,
+    apiKey,
+    params
+  };
+}
+function build(config) {
+  const { host } = resolveHostAlias(config.host);
+  const auth = config.label || config.apiKey ? `${config.label ?? ""}${config.apiKey ? `:${config.apiKey}` : ""}@` : "";
+  const query = new URLSearchParams(config.params).toString();
+  const qs = query ? `?${query}` : "";
+  return `llm://${auth}${host}/${config.model}${qs}`;
+}
 
+// 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
+  };
+}
 
-
-var _chunkN6NVBE43cjs = require('./chunk-N6NVBE43.cjs');
-require('./chunk-NSCBY4VD.cjs');
-
-
-
-
-
-exports.build = _chunkN6NVBE43cjs.build; exports.normalize = _chunkMGWGNZDJcjs.normalize; exports.parse = _chunkN6NVBE43cjs.parse; exports.validate = _chunkRSUXM42Xcjs.validate;
+// src/validate.ts
+function buildReverseParamMap(provider) {
+  const map = {};
+  for (const [canonical, specific] of Object.entries(
+    PROVIDER_PARAMS[provider]
+  )) {
+    map[specific] = canonical;
+  }
+  return map;
+}
+function lookupSubProviderSpec(gatewayParamName, gatewayReverseMap, subProvider) {
+  const canonical = gatewayReverseMap[gatewayParamName] ?? gatewayParamName;
+  const subProviderKey = PROVIDER_PARAMS[subProvider]?.[canonical];
+  if (!subProviderKey) return { spec: void 0, canonical };
+  return { spec: PARAM_SPECS[subProvider]?.[subProviderKey], canonical };
+}
+function buildSubProviderKnownParams(gateway, subProvider) {
+  const known = /* @__PURE__ */ new Set();
+  const subProviderCanonicals = new Set(
+    Object.keys(PROVIDER_PARAMS[subProvider])
+  );
+  for (const [canonical, gatewaySpecific] of Object.entries(
+    PROVIDER_PARAMS[gateway]
+  )) {
+    if (subProviderCanonicals.has(canonical)) {
+      known.add(gatewaySpecific);
+    }
+  }
+  return known;
+}
+function validate(connectionString, options = {}) {
+  const parsed = parse(connectionString);
+  const { config, provider, subProvider } = normalize(parsed);
+  const issues = [];
+  if (!provider) {
+    issues.push({
+      param: "host",
+      value: config.host,
+      message: `Unknown provider for host "${config.host}". Validation skipped.`,
+      severity: options.strict ? "error" : "warning"
+    });
+    return issues;
+  }
+  const effectiveProvider = subProvider ?? provider;
+  const specs = PARAM_SPECS[effectiveProvider];
+  const gatewayReverseMap = subProvider ? buildReverseParamMap(provider) : void 0;
+  const knownParams = subProvider ? buildSubProviderKnownParams(provider, subProvider) : new Set(Object.values(PROVIDER_PARAMS[provider]));
+  for (const [key, value] of Object.entries(config.params)) {
+    if (canHostOpenAIModels(provider) && isReasoningModel(config.model) && REASONING_MODEL_UNSUPPORTED.has(key)) {
+      issues.push({
+        param: key,
+        value,
+        message: `"${key}" is not supported by OpenAI reasoning model "${config.model}". Use "reasoning_effort" instead of temperature for controlling output.`,
+        severity: "error"
+      });
+      continue;
+    }
+    if (provider === "bedrock") {
+      const family = detectBedrockModelFamily(config.model);
+      if (key === "topK" && family && family !== "anthropic" && family !== "cohere" && family !== "mistral") {
+        issues.push({
+          param: key,
+          value,
+          message: `"topK" is not supported by ${family} models on Bedrock.`,
+          severity: "error"
+        });
+        continue;
+      }
+      if (key === "cache_control" && !bedrockSupportsCaching(config.model)) {
+        issues.push({
+          param: key,
+          value,
+          message: `Prompt caching is only supported for Anthropic Claude and Amazon Nova models on Bedrock, not ${family ?? "unknown"} models.`,
+          severity: "error"
+        });
+        continue;
+      }
+    }
+    if (!knownParams.has(key) && !specs[key]) {
+      issues.push({
+        param: key,
+        value,
+        message: `Unknown param "${key}" for ${effectiveProvider}.`,
+        severity: options.strict ? "error" : "warning"
+      });
+      continue;
+    }
+    let spec = specs[key];
+    if (subProvider && gatewayReverseMap && !spec) {
+      const result = lookupSubProviderSpec(key, gatewayReverseMap, subProvider);
+      spec = result.spec;
+    }
+    if (!spec) continue;
+    if ((effectiveProvider === "anthropic" || provider === "bedrock" && detectBedrockModelFamily(config.model) === "anthropic") && (key === "temperature" || key === "top_p" || key === "topP")) {
+      const otherKey = key === "temperature" ? provider === "bedrock" ? "topP" : "top_p" : "temperature";
+      if (key === "temperature" && config.params[otherKey] !== void 0) {
+        issues.push({
+          param: key,
+          value,
+          message: `Cannot specify both "temperature" and "${otherKey}" for Anthropic models.`,
+          severity: "error"
+        });
+      }
+    }
+    if (spec.type === "number") {
+      const num = Number(value);
+      if (isNaN(num)) {
+        issues.push({
+          param: key,
+          value,
+          message: `"${key}" should be a number, got "${value}".`,
+          severity: "error"
+        });
+        continue;
+      }
+      if (spec.min !== void 0 && num < spec.min) {
+        issues.push({
+          param: key,
+          value,
+          message: `"${key}" must be >= ${spec.min}, got ${num}.`,
+          severity: "error"
+        });
+      }
+      if (spec.max !== void 0 && num > spec.max) {
+        issues.push({
+          param: key,
+          value,
+          message: `"${key}" must be <= ${spec.max}, got ${num}.`,
+          severity: "error"
+        });
+      }
+    }
+    if (spec.type === "boolean") {
+      if (!["true", "false", "0", "1"].includes(value)) {
+        issues.push({
+          param: key,
+          value,
+          message: `"${key}" should be a boolean (true/false), got "${value}".`,
+          severity: "error"
+        });
+      }
+    }
+    if (spec.type === "string" && spec.values) {
+      if (!spec.values.includes(value)) {
+        issues.push({
+          param: key,
+          value,
+          message: `"${key}" must be one of [${spec.values.join(", ")}], got "${value}".`,
+          severity: "error"
+        });
+      }
+    }
+  }
+  return issues;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HOST_ALIASES,
+  build,
+  normalize,
+  parse,
+  resolveHostAlias,
+  validate
+});
 //# sourceMappingURL=index.cjs.map