llm-strings 0.0.1

package/dist/index.cjs

@@ -0,0 +1,631 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ALIASES: () => ALIASES,
+  PROVIDER_PARAMS: () => PROVIDER_PARAMS,
+  build: () => build,
+  detectBedrockModelFamily: () => detectBedrockModelFamily,
+  detectProvider: () => detectProvider,
+  normalize: () => normalize,
+  parse: () => parse,
+  validate: () => validate
+});
+module.exports = __toCommonJS(index_exports);
+
+// 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]$/;
+
+// 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) {
+  const parsed = parse(connectionString);
+  const { config } = normalize(parsed);
+  const provider = detectProvider(config.host);
+  const issues = [];
+  if (!provider) {
+    issues.push({
+      param: "host",
+      value: config.host,
+      message: `Unknown provider for host "${config.host}". Validation skipped.`,
+      severity: "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: "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;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ALIASES,
+  PROVIDER_PARAMS,
+  build,
+  detectBedrockModelFamily,
+  detectProvider,
+  normalize,
+  parse,
+  validate
+});
+//# sourceMappingURL=index.cjs.map