llm-strings 1.4.0 → 1.5.1

package/dist/chunk-DPVT3FFP.js

@@ -1,116 +0,0 @@
-import {
-  ALIASES,
-  CACHE_TTLS,
-  CACHE_VALUES,
-  DURATION_RE,
-  PROVIDER_PARAMS,
-  bedrockSupportsCaching,
-  canHostOpenAIModels,
-  detectGatewaySubProvider,
-  detectProvider,
-  isGatewayProvider,
-  isReasoningModel,
-  providerFromHostAlias
-} from "./chunk-76EFNZCF.js";
-
-// 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
-  };
-}
-
-export {
-  normalize
-};

package/dist/chunk-OBLFZFNR.js

@@ -1,175 +0,0 @@
-import {
-  normalize
-} from "./chunk-DPVT3FFP.js";
-import {
-  parse
-} from "./chunk-5YTG2NRX.js";
-import {
-  PARAM_SPECS,
-  PROVIDER_PARAMS,
-  REASONING_MODEL_UNSUPPORTED,
-  bedrockSupportsCaching,
-  canHostOpenAIModels,
-  detectBedrockModelFamily,
-  isReasoningModel
-} from "./chunk-76EFNZCF.js";
-
-// 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;
-}
-
-export {
-  validate
-};