llm-strings 1.0.0 → 1.1.0

package/dist/index.js

@@ -1,756 +1,30 @@
-// 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 = url.hostname;
-  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,
-    model,
-    label,
-    apiKey,
-    params
-  };
-}
-function build(config) {
-  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}${config.host}/${config.model}${qs}`;
-}
-
-// src/providers.ts
-function detectProvider(host) {
-  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 },
-    max_tokens: { type: "number", min: 1 },
-    top_p: { type: "number", min: 0, max: 1 },
-    frequency_penalty: { type: "number", min: -2, max: 2 },
-    presence_penalty: { type: "number", min: -2, max: 2 },
-    stop: { type: "string" },
-    n: { type: "number", min: 1 },
-    seed: { type: "number" },
-    stream: { type: "boolean" },
-    reasoning_effort: {
-      type: "string",
-      values: ["none", "minimal", "low", "medium", "high", "xhigh"]
-    }
-  },
-  anthropic: {
-    temperature: { type: "number", min: 0, max: 1 },
-    max_tokens: { type: "number", min: 1 },
-    top_p: { type: "number", min: 0, max: 1 },
-    top_k: { type: "number", min: 0 },
-    stop_sequences: { type: "string" },
-    stream: { type: "boolean" },
-    effort: { type: "string", values: ["low", "medium", "high", "max"] },
-    cache_control: { type: "string", values: ["ephemeral"] },
-    cache_ttl: { type: "string", values: ["5m", "1h"] }
-  },
-  google: {
-    temperature: { type: "number", min: 0, max: 2 },
-    maxOutputTokens: { type: "number", min: 1 },
-    topP: { type: "number", min: 0, max: 1 },
-    topK: { type: "number", min: 0 },
-    frequencyPenalty: { type: "number", min: -2, max: 2 },
-    presencePenalty: { type: "number", min: -2, max: 2 },
-    stopSequences: { type: "string" },
-    candidateCount: { type: "number", min: 1 },
-    stream: { type: "boolean" },
-    seed: { type: "number" },
-    responseMimeType: { type: "string" },
-    responseSchema: { type: "string" }
-  },
-  mistral: {
-    temperature: { type: "number", min: 0, max: 1 },
-    max_tokens: { type: "number", min: 1 },
-    top_p: { type: "number", min: 0, max: 1 },
-    frequency_penalty: { type: "number", min: -2, max: 2 },
-    presence_penalty: { type: "number", min: -2, max: 2 },
-    stop: { type: "string" },
-    n: { type: "number", min: 1 },
-    random_seed: { type: "number" },
-    stream: { type: "boolean" },
-    safe_prompt: { type: "boolean" },
-    min_tokens: { type: "number", min: 0 }
-  },
-  cohere: {
-    temperature: { type: "number", min: 0, max: 1 },
-    max_tokens: { type: "number", min: 1 },
-    p: { type: "number", min: 0, max: 1 },
-    k: { type: "number", min: 0, max: 500 },
-    frequency_penalty: { type: "number", min: 0, max: 1 },
-    presence_penalty: { type: "number", min: 0, max: 1 },
-    stop_sequences: { type: "string" },
-    stream: { type: "boolean" },
-    seed: { type: "number" }
-  },
-  bedrock: {
-    // Converse API inferenceConfig params
-    temperature: { type: "number", min: 0, max: 1 },
-    maxTokens: { type: "number", min: 1 },
-    topP: { type: "number", min: 0, max: 1 },
-    topK: { type: "number", min: 0 },
-    stopSequences: { type: "string" },
-    stream: { type: "boolean" },
-    cache_control: { type: "string", values: ["ephemeral"] },
-    cache_ttl: { type: "string", values: ["5m", "1h"] }
-  },
-  openrouter: {
-    // Loose validation — proxies to many providers with varying ranges
-    temperature: { type: "number", min: 0, max: 2 },
-    max_tokens: { type: "number", min: 1 },
-    top_p: { type: "number", min: 0, max: 1 },
-    top_k: { type: "number", min: 0 },
-    frequency_penalty: { type: "number", min: -2, max: 2 },
-    presence_penalty: { type: "number", min: -2, max: 2 },
-    stop: { type: "string" },
-    n: { type: "number", min: 1 },
-    seed: { type: "number" },
-    stream: { type: "boolean" },
-    reasoning_effort: {
-      type: "string",
-      values: ["none", "minimal", "low", "medium", "high", "xhigh"]
-    }
-  },
-  vercel: {
-    // Loose validation — proxies to many providers with varying ranges
-    temperature: { type: "number", min: 0, max: 2 },
-    max_tokens: { type: "number", min: 1 },
-    top_p: { type: "number", min: 0, max: 1 },
-    top_k: { type: "number", min: 0 },
-    frequency_penalty: { type: "number", min: -2, max: 2 },
-    presence_penalty: { type: "number", min: -2, max: 2 },
-    stop: { type: "string" },
-    n: { type: "number", min: 1 },
-    seed: { type: "number" },
-    stream: { type: "boolean" },
-    reasoning_effort: {
-      type: "string",
-      values: ["none", "minimal", "low", "medium", "high", "xhigh"]
-    }
-  }
-};
-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";
-}
-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 PROVIDER_META = [
-  { id: "openai", name: "OpenAI", host: "api.openai.com", color: "#10a37f" },
-  { id: "anthropic", name: "Anthropic", host: "api.anthropic.com", color: "#e8956a" },
-  { id: "google", name: "Google", host: "generativelanguage.googleapis.com", color: "#4285f4" },
-  { id: "mistral", name: "Mistral", host: "api.mistral.ai", color: "#ff7000" },
-  { id: "cohere", name: "Cohere", host: "api.cohere.com", color: "#39594d" },
-  { id: "bedrock", name: "Bedrock", host: "bedrock-runtime.us-east-1.amazonaws.com", color: "#ff9900" },
-  { id: "openrouter", name: "OpenRouter", host: "openrouter.ai", color: "#818cf8" },
-  { id: "vercel", name: "Vercel", host: "gateway.ai.vercel.app", color: "#ededed" }
-];
-var MODELS = {
-  openai: [
-    "gpt-5.2",
-    "gpt-5.2-pro",
-    "gpt-4.1",
-    "gpt-4.1-mini",
-    "gpt-4.1-nano",
-    "o3",
-    "o3-mini",
-    "o4-mini",
-    "o1-pro"
-  ],
-  anthropic: [
-    "claude-opus-4-6",
-    "claude-sonnet-4-6",
-    "claude-sonnet-4-5",
-    "claude-haiku-4-5"
-  ],
-  google: [
-    "gemini-3-pro-preview",
-    "gemini-3-flash-preview",
-    "gemini-2.5-pro",
-    "gemini-2.5-flash"
-  ],
-  mistral: [
-    "mistral-large-latest",
-    "mistral-medium-latest",
-    "mistral-small-latest",
-    "codestral-latest",
-    "magistral-medium-latest"
-  ],
-  cohere: [
-    "command-a-03-2025",
-    "command-r-plus-08-2024",
-    "command-r-08-2024",
-    "command-r7b-12-2024"
-  ],
-  bedrock: [
-    "anthropic.claude-opus-4-6-v1",
-    "anthropic.claude-sonnet-4-6-v1",
-    "anthropic.claude-haiku-4-5-v1",
-    "amazon.nova-pro-v1",
-    "amazon.nova-lite-v1",
-    "meta.llama3-70b-instruct-v1:0"
-  ],
-  openrouter: [
-    "openai/gpt-5.2",
-    "anthropic/claude-opus-4-6",
-    "google/gemini-2.5-pro",
-    "mistral/mistral-large-latest"
-  ],
-  vercel: [
-    "openai/gpt-5.2",
-    "anthropic/claude-opus-4-6",
-    "google/gemini-2.5-pro",
-    "google/gemini-3-pro-preview",
-    "google/gemini-3-flash-preview",
-    "mistral/mistral-large-latest",
-    "qwen/qwen2.5-pro"
-  ]
-};
-var CANONICAL_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", default: "", description: "Stop sequences" },
-    n: { type: "number", min: 1, default: 1, description: "Completions count" },
-    seed: { type: "number", default: "", description: "Random seed" },
-    stream: { type: "boolean", default: false, description: "Stream response" },
-    effort: { type: "enum", 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: { type: "string", default: "", description: "Stop sequences" },
-    stream: { type: "boolean", default: false, description: "Stream response" },
-    effort: { type: "enum", values: ["low", "medium", "high", "max"], default: "medium", description: "Thinking effort" },
-    cache: { type: "enum", values: ["ephemeral"], default: "ephemeral", description: "Cache control" },
-    cache_ttl: { type: "enum", values: ["5m", "1h"], default: "5m", description: "Cache TTL" }
-  },
-  google: {
-    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", default: "", description: "Stop sequences" },
-    n: { type: "number", min: 1, default: 1, description: "Candidate count" },
-    stream: { type: "boolean", default: false, description: "Stream response" },
-    seed: { type: "number", default: "", description: "Random seed" }
-  },
-  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", default: "", description: "Stop sequences" },
-    n: { type: "number", min: 1, default: 1, description: "Completions count" },
-    seed: { type: "number", default: "", 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" },
-    top_p: { type: "number", min: 0, max: 1, default: 1, description: "Nucleus sampling (p)" },
-    top_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: { type: "string", default: "", description: "Stop sequences" },
-    stream: { type: "boolean", default: false, description: "Stream response" },
-    seed: { type: "number", default: "", description: "Random seed" }
-  },
-  bedrock: {
-    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: { type: "string", default: "", description: "Stop sequences" },
-    stream: { type: "boolean", default: false, description: "Stream response" },
-    cache: { type: "enum", values: ["ephemeral"], default: "ephemeral", description: "Cache control" },
-    cache_ttl: { type: "enum", values: ["5m", "1h"], default: "5m", description: "Cache TTL" }
-  },
-  openrouter: {
-    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", default: "", description: "Stop sequences" },
-    n: { type: "number", min: 1, default: 1, description: "Completions count" },
-    seed: { type: "number", default: "", description: "Random seed" },
-    stream: { type: "boolean", default: false, description: "Stream response" },
-    effort: { type: "enum", values: ["none", "minimal", "low", "medium", "high", "xhigh"], default: "medium", description: "Reasoning effort" }
-  },
-  vercel: {
-    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", default: "", description: "Stop sequences" },
-    n: { type: "number", min: 1, default: 1, description: "Completions count" },
-    seed: { type: "number", default: "", description: "Random seed" },
-    stream: { type: "boolean", default: false, description: "Stream response" },
-    effort: { type: "enum", values: ["none", "minimal", "low", "medium", "high", "xhigh"], default: "medium", description: "Reasoning effort" }
-  }
-};
-
-// src/normalize.ts
-function normalize(config, options = {}) {
-  const provider = detectProvider(config.host);
-  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,
-    changes
-  };
-}
-
-// src/validate.ts
-function validate(connectionString, options = {}) {
-  const parsed = parse(connectionString);
-  const { config, provider } = 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 specs = PARAM_SPECS[provider];
-  const knownParams = 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 ${provider}.`,
-        severity: options.strict ? "error" : "warning"
-      });
-      continue;
-    }
-    const spec = specs[key];
-    if (!spec) continue;
-    if ((provider === "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;
-}
+import {
+  CANONICAL_PARAM_SPECS,
+  MODELS,
+  PROVIDER_META
+} from "./chunk-6P5GSSNW.js";
+import {
+  validate
+} from "./chunk-UYMVUTLV.js";
+import {
+  normalize
+} from "./chunk-MPIHGH6L.js";
+import {
+  build,
+  parse
+} from "./chunk-FCEV23OT.js";
+import {
+  ALIASES,
+  PARAM_SPECS,
+  PROVIDER_PARAMS,
+  REASONING_MODEL_UNSUPPORTED,
+  canHostOpenAIModels,
+  detectBedrockModelFamily,
+  detectGatewaySubProvider,
+  detectProvider,
+  isGatewayProvider,
+  isReasoningModel
+} from "./chunk-XID353H7.js";
 export {
   ALIASES,
   CANONICAL_PARAM_SPECS,
@@ -762,7 +36,9 @@ export {
   build,
   canHostOpenAIModels,
   detectBedrockModelFamily,
+  detectGatewaySubProvider,
   detectProvider,
+  isGatewayProvider,
   isReasoningModel,
   normalize,
   parse,