@x12i/ai-tools 1.0.2

package/dist/chunk-TF4L2NEC.cjs

@@ -0,0 +1,729 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunk7Q742NI3cjs = require('./chunk-7Q742NI3.cjs');
+
+// src/cache/modelCache.ts
+var _nxcache = require('nx-cache');
+var cache = _nxcache.createNxCache.call(void 0, );
+var DEFAULT_MODEL_CACHE_TTL_MS = 60 * 60 * 1e3;
+function readCachedModels(appId, ttlMs = DEFAULT_MODEL_CACHE_TTL_MS) {
+  const res = cache.read("ai-models", { appId });
+  if (!res.found) return null;
+  const cachedAt = _optionalChain([res, 'access', _ => _.metadata, 'optionalAccess', _2 => _2.cachedAt]);
+  if (cachedAt) {
+    const age = Date.now() - new Date(cachedAt).getTime();
+    if (age > ttlMs) return null;
+  } else if (res.meta.isExpired) {
+    return null;
+  }
+  return res.value;
+}
+function writeCachedModels(appId, models, ttlMs = DEFAULT_MODEL_CACHE_TTL_MS) {
+  cache.write("ai-models", models, {
+    scope: { appId },
+    ttlMs,
+    metadata: { cachedAt: (/* @__PURE__ */ new Date()).toISOString(), count: models.size }
+  });
+}
+function invalidateModelsCache(appId) {
+  cache.resetKey("ai-models", { appId });
+}
+
+// src/catalog/aiModelsCatalogDescriptor.ts
+var AI_MODELS_CATALOG_ID = "ai-models";
+var AI_TOOLS_APP_ID = "ai-tools";
+var AI_MODELS_DESCRIPTOR = {
+  catalogId: AI_MODELS_CATALOG_ID,
+  label: "AI Models",
+  description: "Full mirror of OpenRouter Models API metadata and pricing, synced on a schedule.",
+  itemLabel: "Model",
+  sourceMode: "native",
+  status: "active",
+  visibility: "visible",
+  capabilities: {
+    canList: true,
+    canGet: true,
+    canCreate: false,
+    canEdit: false,
+    canDelete: false,
+    canExport: true,
+    canValidate: true
+  },
+  identity: {
+    itemIdStrategy: "natural",
+    itemIdField: "modelId",
+    titleField: "name",
+    subtitleField: "providerId",
+    statusField: "status",
+    updatedAtField: "syncedAt"
+  },
+  queryableFields: [
+    { key: "modelId", label: "Model ID", type: "string", indexed: true, filterable: true },
+    { key: "providerId", label: "Provider", type: "string", indexed: true, filterable: true },
+    { key: "name", label: "Name", type: "string", filterable: true },
+    { key: "canonicalSlug", label: "Canonical Slug", type: "string", indexed: true, filterable: true },
+    { key: "contextLength", label: "Context Length", type: "number", sortable: true },
+    {
+      key: "status",
+      label: "Status",
+      type: "enum",
+      indexed: true,
+      filterable: true,
+      enumValues: ["active", "deprecated", "unknown"]
+    },
+    {
+      key: "primaryOutputModality",
+      label: "Primary Output",
+      type: "string",
+      indexed: true,
+      filterable: true
+    },
+    { key: "supportsTools", label: "Tools", type: "boolean", indexed: true, filterable: true },
+    {
+      key: "supportsReasoning",
+      label: "Reasoning",
+      type: "boolean",
+      indexed: true,
+      filterable: true
+    },
+    { key: "supportsStreaming", label: "Streams", type: "boolean", filterable: true },
+    { key: "isModerated", label: "Moderated", type: "boolean", filterable: true },
+    { key: "syncedAt", label: "Synced At", type: "datetime", sortable: true }
+  ],
+  defaultSort: { field: "syncedAt", direction: "desc" }
+};
+
+// src/sync/openRouterRoutingEnv.ts
+var _env = require('@x12i/env');
+function providerIdToEnvKeyPrefix(providerId) {
+  return providerId.trim().toLowerCase().replace(/-/g, "_").toUpperCase();
+}
+function vendorApiKeyEnvName(providerId) {
+  return `${providerIdToEnvKeyPrefix(providerId)}_API_KEY`;
+}
+function loadOpenRouterRoutingEnv(env = process.env) {
+  const dotenv = _env.loadDotenv.call(void 0, );
+  const merged = {};
+  for (const [k, v] of Object.entries(dotenv)) {
+    if (v !== void 0) merged[k] = v;
+  }
+  for (const [k, v] of Object.entries(env)) {
+    if (v !== void 0) merged[k] = v;
+  }
+  const openRouterKey = _optionalChain([merged, 'access', _3 => _3.OPENROUTER_API_KEY, 'optionalAccess', _4 => _4.trim, 'call', _5 => _5()]);
+  const useRaw = _optionalChain([merged, 'access', _6 => _6.USE_OPENROUTER, 'optionalAccess', _7 => _7.trim, 'call', _8 => _8(), 'access', _9 => _9.toLowerCase, 'call', _10 => _10()]);
+  const useOpenRouterExplicit = useRaw === "true" || useRaw === "1";
+  return {
+    hasOpenRouterKey: Boolean(openRouterKey),
+    useOpenRouterExplicit,
+    getVendorApiKey(providerId) {
+      const name = vendorApiKeyEnvName(providerId);
+      const val = _optionalChain([merged, 'access', _11 => _11[name], 'optionalAccess', _12 => _12.trim, 'call', _13 => _13()]);
+      return val || void 0;
+    }
+  };
+}
+function shouldDefaultRouteViaOpenRouter(providerId, config) {
+  if (!config.hasOpenRouterKey) return false;
+  if (config.useOpenRouterExplicit) return true;
+  if (providerId && providerId !== "openrouter") {
+    return !config.getVendorApiKey(providerId);
+  }
+  return false;
+}
+
+// src/sync/modelNameResolver/constants.ts
+var DEFAULT_CONFIDENCE_THRESHOLD = 0.6;
+var PROVIDER_NORMALISATION_MAP = {
+  "open-router": "openrouter",
+  or: "openrouter",
+  oai: "openai",
+  "open-ai": "openai",
+  claude: "anthropic",
+  ant: "anthropic",
+  gemini: "google",
+  gcp: "google",
+  "google-ai": "google",
+  vertex: "google",
+  meta: "meta-llama",
+  llama: "meta-llama",
+  "mistral-ai": "mistral",
+  "cohere-ai": "cohere"
+};
+var LOCAL_PROVIDERS = /* @__PURE__ */ new Set([
+  "ollama",
+  "lmstudio",
+  "lm-studio",
+  "localai",
+  "local-ai",
+  "llamacpp",
+  "llama.cpp",
+  "llamafile",
+  "jan",
+  "koboldcpp"
+]);
+var PROVIDER_INFERENCE_MAP = [
+  { pattern: /^gpt-/, provider: "openai" },
+  { pattern: /^o1($|-)/, provider: "openai" },
+  { pattern: /^o3($|-)/, provider: "openai" },
+  { pattern: /^o4($|-)/, provider: "openai" },
+  { pattern: /^chatgpt-/, provider: "openai" },
+  { pattern: /^text-davinci/, provider: "openai" },
+  { pattern: /^dall-e/, provider: "openai" },
+  { pattern: /^whisper/, provider: "openai" },
+  { pattern: /^tts-/, provider: "openai" },
+  { pattern: /^claude-/, provider: "anthropic" },
+  { pattern: /^gemini-/, provider: "google" },
+  { pattern: /^palm-/, provider: "google" },
+  { pattern: /^bison/, provider: "google" },
+  { pattern: /^llama-?[23]/, provider: "meta-llama" },
+  { pattern: /^llama/, provider: "meta-llama" },
+  { pattern: /^codellama/, provider: "meta-llama" },
+  { pattern: /^mistral-/, provider: "mistral" },
+  { pattern: /^mixtral-/, provider: "mistral" },
+  { pattern: /^codestral/, provider: "mistral" },
+  { pattern: /^ministral/, provider: "mistral" },
+  { pattern: /^command-/, provider: "cohere" },
+  { pattern: /^c4ai-/, provider: "cohere" },
+  { pattern: /^deepseek-/, provider: "deepseek" },
+  { pattern: /^grok-/, provider: "x-ai" },
+  { pattern: /^qwen/, provider: "qwen" },
+  { pattern: /^yi-/, provider: "01-ai" },
+  { pattern: /^sonar/, provider: "perplexity" },
+  { pattern: /^pplx-/, provider: "perplexity" },
+  { pattern: /^titan-/, provider: "amazon" },
+  { pattern: /^nova-/, provider: "amazon" }
+];
+var SHORTHAND_MAP = {
+  gpt4: "openai/gpt-4",
+  gpt4o: "openai/gpt-4o",
+  "gpt-4-omni": "openai/gpt-4o",
+  gpt4omni: "openai/gpt-4o",
+  "gpt4-turbo": "openai/gpt-4-turbo",
+  gpt4turbo: "openai/gpt-4-turbo",
+  "gpt4-mini": "openai/gpt-4o-mini",
+  "gpt-4o-mini": "openai/gpt-4o-mini",
+  o1: "openai/o1",
+  "o1-mini": "openai/o1-mini",
+  o3: "openai/o3",
+  "o3-mini": "openai/o3-mini",
+  "o4-mini": "openai/o4-mini",
+  "3.5-turbo": "openai/gpt-3.5-turbo",
+  gpt35: "openai/gpt-3.5-turbo",
+  gpt3: "openai/gpt-3.5-turbo",
+  claude3: "anthropic/claude-3-5-sonnet-20241022",
+  "claude-3": "anthropic/claude-3-5-sonnet-20241022",
+  "claude3-sonnet": "anthropic/claude-3-5-sonnet-20241022",
+  "claude-sonnet": "anthropic/claude-3-5-sonnet-20241022",
+  "claude-haiku": "anthropic/claude-3-5-haiku-20241022",
+  "claude3-haiku": "anthropic/claude-3-5-haiku-20241022",
+  "claude-opus": "anthropic/claude-opus-4",
+  "claude3-opus": "anthropic/claude-3-opus-20240229",
+  claude4: "anthropic/claude-opus-4",
+  "claude4-sonnet": "anthropic/claude-sonnet-4",
+  "claude4-opus": "anthropic/claude-opus-4",
+  sonnet: "anthropic/claude-3-5-sonnet-20241022",
+  haiku: "anthropic/claude-3-5-haiku-20241022",
+  opus: "anthropic/claude-opus-4",
+  gemini: "google/gemini-pro",
+  "gemini-pro": "google/gemini-pro",
+  "gemini-flash": "google/gemini-flash-1.5",
+  gemini2: "google/gemini-2.0-flash-001",
+  "gemini-2": "google/gemini-2.0-flash-001",
+  llama3: "meta-llama/llama-3.1-8b-instruct",
+  "llama-3": "meta-llama/llama-3.1-8b-instruct",
+  llama2: "meta-llama/llama-2-13b-chat",
+  "llama-2": "meta-llama/llama-2-13b-chat",
+  mistral: "mistral/mistral-7b-instruct",
+  "mistral-large": "mistral/mistral-large-latest",
+  mixtral: "mistral/mixtral-8x7b-instruct",
+  deepseek: "deepseek/deepseek-chat",
+  "deepseek-r1": "deepseek/deepseek-r1"
+};
+
+// src/sync/modelNameResolver/normalize.ts
+function normalizeString(input) {
+  let s = input.trim();
+  s = s.replace(/\s+/g, " ").replace(/ /g, "-");
+  s = s.toLowerCase();
+  s = s.replace(/^\/+|\/+$/g, "");
+  s = s.replace(/\/+/g, "/");
+  if (s.startsWith('"') && s.endsWith('"') || s.startsWith("'") && s.endsWith("'")) {
+    s = s.slice(1, -1);
+  }
+  return s;
+}
+function normalizeProvider(provider) {
+  if (provider === void 0 || provider === "") return void 0;
+  const n = normalizeString(provider);
+  return _nullishCoalesce(PROVIDER_NORMALISATION_MAP[n], () => ( n));
+}
+function tokenise(s) {
+  return s.split(/[-_./]+/).filter(Boolean);
+}
+function modelSlug(modelId) {
+  const slash = modelId.indexOf("/");
+  return slash >= 0 ? modelId.slice(slash + 1) : modelId;
+}
+
+// src/sync/modelNameResolver/catalogIndexes.ts
+function buildCatalogIndexes(catalog) {
+  const aliasIndex = /* @__PURE__ */ new Map();
+  const slugIndex = /* @__PURE__ */ new Map();
+  const prefixCounts = /* @__PURE__ */ new Map();
+  for (const record of catalog.values()) {
+    for (const alias of record.aliases) {
+      aliasIndex.set(normalizeString(alias), record.modelId);
+    }
+    if (record.canonicalSlug) {
+      slugIndex.set(normalizeString(record.canonicalSlug), record.modelId);
+    }
+    const pid = record.providerId;
+    prefixCounts.set(pid, (_nullishCoalesce(prefixCounts.get(pid), () => ( 0))) + 1);
+  }
+  const providerPrefixesBySize = [...prefixCounts.entries()].sort((a, b) => b[1] - a[1]).map(([p]) => p);
+  return { aliasIndex, slugIndex, providerPrefixesBySize };
+}
+
+// src/sync/modelNameResolver/ModelNameResolver.ts
+var VERSION_STRIP_PATTERNS = [
+  { re: /-\d{4}-\d{2}-\d{2}$/, label: "date YYYY-MM-DD" },
+  { re: /-\d{8}$/, label: "date YYYYMMDD" },
+  { re: /-v\d+$/, label: "version -vN" },
+  { re: /-\d+\.\d+\.\d+$/, label: "semver" },
+  { re: /:\d+[a-z]?$/i, label: "colon version" },
+  { re: /-\d{4,}$/, label: "build number" },
+  { re: /@\d+$/, label: "epoch @NNNN" }
+];
+var ModelNameResolver = class {
+  
+  
+  
+  constructor(catalog, options = {}) {
+    this.catalog = catalog;
+    this.indexes = buildCatalogIndexes(catalog);
+    this.ctx = {
+      catalog,
+      indexes: this.indexes,
+      options: {
+        confidenceThreshold: _nullishCoalesce(options.confidenceThreshold, () => ( DEFAULT_CONFIDENCE_THRESHOLD)),
+        aliasRegistry: options.aliasRegistry,
+        additionalShorthands: _nullishCoalesce(options.additionalShorthands, () => ( {})),
+        additionalProviderPatterns: _nullishCoalesce(options.additionalProviderPatterns, () => ( [])),
+        additionalLocalProviders: _nullishCoalesce(options.additionalLocalProviders, () => ( [])),
+        routingEnv: _nullishCoalesce(options.routingEnv, () => ( loadOpenRouterRoutingEnv()))
+      }
+    };
+  }
+  resolve(input) {
+    const attempted = [];
+    const threshold = this.ctx.options.confidenceThreshold;
+    let provider = normalizeProvider(input.provider);
+    let model = normalizeString(input.model);
+    const normalisedInput = model;
+    if (this.ctx.options.aliasRegistry) {
+      attempted.push("alias-registry");
+      const entry = this.ctx.options.aliasRegistry.get(model);
+      if (entry) {
+        model = normalizeString(entry.modelId);
+        provider = _nullishCoalesce(normalizeProvider(entry.provider), () => ( provider));
+      }
+    }
+    if (this.ctx.options.aliasRegistry && provider) {
+      const aliasAsProvider = this.ctx.options.aliasRegistry.get(provider);
+      if (aliasAsProvider) {
+        attempted.push("alias-as-provider-correction");
+        model = normalizeString(aliasAsProvider.modelId);
+        provider = _nullishCoalesce(normalizeProvider(aliasAsProvider.provider), () => ( provider));
+      }
+    }
+    const localProviders = /* @__PURE__ */ new Set([
+      ...LOCAL_PROVIDERS,
+      ...this.ctx.options.additionalLocalProviders.map((p) => normalizeString(p))
+    ]);
+    if (provider && localProviders.has(provider)) {
+      attempted.push("local-provider-passthrough");
+      return this.success({
+        modelId: model,
+        record: null,
+        confidence: 0.99,
+        strategy: "local-provider-passthrough",
+        reason: `Local provider "${provider}" \u2014 model not looked up in catalog`,
+        resolvedVia: attempted,
+        normalisedInput,
+        provider,
+        originalProvider: input.provider
+      });
+    }
+    const preCorrection = [...attempted];
+    const { match, rejected } = this.runPipeline(model, provider, attempted, threshold, []);
+    if (match) {
+      const via = [
+        ...preCorrection.filter((s) => !match.resolvedVia.includes(s)),
+        ...match.resolvedVia
+      ];
+      return this.success({
+        modelId: match.modelId,
+        record: match.record,
+        confidence: match.confidence,
+        strategy: match.strategy,
+        reason: match.reason,
+        resolvedVia: via,
+        normalisedInput,
+        provider,
+        originalProvider: input.provider
+      });
+    }
+    const notFound = {
+      found: false,
+      modelId: null,
+      record: null,
+      attemptedStrategies: attempted,
+      reason: "No catalog entry matched after all strategies.",
+      bestRejectedCandidate: rejected
+    };
+    return notFound;
+  }
+  resolveMany(inputs) {
+    return inputs.map((i) => this.resolve(i));
+  }
+  resolveOrThrow(input) {
+    const result = this.resolve(input);
+    if (result.found) return result;
+    throw new (0, _chunk7Q742NI3cjs.ModelResolutionError)(input, result);
+  }
+  runPipeline(model, provider, attempted, threshold, resolvedVia, depth = 0) {
+    if (depth > 12) return { match: null };
+    const tryMatch = (strategy, fn) => {
+      if (!attempted.includes(strategy)) attempted.push(strategy);
+      const m = fn();
+      if (m && m.confidence >= threshold) {
+        return { ...m, resolvedVia: [...resolvedVia, strategy] };
+      }
+      return null;
+    };
+    let hit = tryMatch("exact-match", () => this.exactMatch(model));
+    if (hit) return { match: hit };
+    hit = tryMatch("catalog-alias-match", () => this.catalogAliasMatch(model));
+    if (hit) return { match: hit };
+    hit = tryMatch("canonical-slug-match", () => this.slugMatch(model));
+    if (hit) return { match: hit };
+    hit = tryMatch(
+      "provider-prefix-injection",
+      () => this.providerPrefixInjection(model, provider)
+    );
+    if (hit) return { match: hit };
+    hit = tryMatch("cross-provider-correction", () => this.crossProviderCorrection(model));
+    if (hit) return { match: hit };
+    const stripped = this.stripVersionSuffixes(model);
+    if (stripped && stripped !== model) {
+      if (!attempted.includes("version-suffix-strip")) attempted.push("version-suffix-strip");
+      const inner = this.runPipeline(
+        stripped,
+        provider,
+        attempted,
+        threshold,
+        [...resolvedVia, "version-suffix-strip"],
+        depth + 1
+      );
+      if (inner.match) {
+        return {
+          match: {
+            ...inner.match,
+            confidence: 0.85,
+            strategy: "version-suffix-strip",
+            reason: `Stripped version suffix from "${model}" \u2192 "${stripped}" then ${inner.match.reason}`,
+            resolvedVia: [...resolvedVia, "version-suffix-strip", ...inner.match.resolvedVia]
+          }
+        };
+      }
+    }
+    hit = tryMatch("date-suffix-strip", () => this.dateSuffixMatch(model));
+    if (hit) return { match: hit };
+    const shorthand = this.shorthandMap()[model];
+    if (shorthand) {
+      if (!attempted.includes("shorthand-expansion")) attempted.push("shorthand-expansion");
+      const inner = this.runPipeline(
+        normalizeString(shorthand),
+        provider,
+        attempted,
+        threshold,
+        [...resolvedVia, "shorthand-expansion"],
+        depth + 1
+      );
+      if (inner.match) {
+        return {
+          match: {
+            ...inner.match,
+            confidence: 0.8,
+            strategy: "shorthand-expansion",
+            reason: `Expanded shorthand "${model}" \u2192 "${shorthand}" then ${inner.match.reason}`,
+            resolvedVia: [...resolvedVia, "shorthand-expansion", ...inner.match.resolvedVia]
+          }
+        };
+      }
+    }
+    const partial = this.partialMatch(model, provider);
+    if (partial) {
+      if (!attempted.includes("partial-name-match")) attempted.push("partial-name-match");
+      if (partial.confidence >= threshold) {
+        return {
+          match: { ...partial, resolvedVia: [...resolvedVia, "partial-name-match"] }
+        };
+      }
+      return {
+        match: null,
+        rejected: {
+          modelId: partial.modelId,
+          confidence: partial.confidence,
+          reason: partial.reason
+        }
+      };
+    }
+    return { match: null };
+  }
+  exactMatch(model) {
+    const record = this.catalog.get(model);
+    if (!record) return null;
+    return {
+      modelId: model,
+      record,
+      confidence: 1,
+      strategy: "exact-match",
+      reason: `Exact catalog match for "${model}"`
+    };
+  }
+  catalogAliasMatch(model) {
+    const modelId = this.indexes.aliasIndex.get(model);
+    if (!modelId) return null;
+    const record = this.catalog.get(modelId);
+    if (!record) return null;
+    return {
+      modelId,
+      record,
+      confidence: 1,
+      strategy: "catalog-alias-match",
+      reason: `Catalog alias "${model}" \u2192 "${modelId}"`
+    };
+  }
+  slugMatch(model) {
+    const modelId = this.indexes.slugIndex.get(model);
+    if (!modelId) return null;
+    const record = this.catalog.get(modelId);
+    if (!record) return null;
+    return {
+      modelId,
+      record,
+      confidence: 0.95,
+      strategy: "canonical-slug-match",
+      reason: `Canonical slug match "${model}" \u2192 "${modelId}"`
+    };
+  }
+  inferProviderFromSlug(slug) {
+    const patterns = [
+      ...this.ctx.options.additionalProviderPatterns,
+      ...PROVIDER_INFERENCE_MAP
+    ];
+    for (const { pattern, provider } of patterns) {
+      if (pattern.test(slug)) return provider;
+    }
+    return void 0;
+  }
+  providerPrefixInjection(model, provider) {
+    if (model.includes("/")) return null;
+    const prefixes = [];
+    if (provider && provider !== "openrouter") {
+      prefixes.push(provider);
+    }
+    const inferred = this.inferProviderFromSlug(model);
+    if (inferred && !prefixes.includes(inferred)) prefixes.push(inferred);
+    for (const p of this.indexes.providerPrefixesBySize) {
+      if (!prefixes.includes(p)) prefixes.push(p);
+    }
+    for (const prefix of prefixes) {
+      const candidate = `${prefix}/${model}`;
+      let record = this.catalog.get(candidate);
+      let modelId = candidate;
+      if (!record) {
+        const latest = this.findLatestVersioned(candidate);
+        if (latest) {
+          record = latest.record;
+          modelId = latest.modelId;
+        }
+      }
+      if (record) {
+        const viaInference = inferred === prefix;
+        return {
+          modelId,
+          record,
+          confidence: 0.95,
+          strategy: "provider-prefix-injection",
+          reason: viaInference ? `Injected provider prefix "${prefix}/" inferred from model name pattern` : `Injected provider prefix "${prefix}/"`
+        };
+      }
+    }
+    return null;
+  }
+  crossProviderCorrection(model) {
+    if (!model.includes("/")) return null;
+    const [wrongPrefix, ...rest] = model.split("/");
+    const slug = rest.join("/");
+    const inferred = this.inferProviderFromSlug(slug);
+    if (!inferred || inferred === wrongPrefix) return null;
+    const candidate = `${inferred}/${slug}`;
+    let record = this.catalog.get(candidate);
+    let modelId = candidate;
+    if (!record) {
+      const latest = this.findLatestVersioned(candidate);
+      if (!latest) return null;
+      record = latest.record;
+      modelId = latest.modelId;
+    }
+    return {
+      modelId,
+      record,
+      confidence: 0.9,
+      strategy: "cross-provider-correction",
+      reason: `Corrected provider prefix from "${wrongPrefix}" to "${inferred}" based on model name pattern`
+    };
+  }
+  stripVersionSuffixes(model) {
+    for (const { re } of VERSION_STRIP_PATTERNS) {
+      if (re.test(model)) {
+        return model.replace(re, "");
+      }
+    }
+    return null;
+  }
+  dateSuffixMatch(model) {
+    if (model.includes("/")) {
+      const [prefix, slug] = model.split("/", 2);
+      const stripped = this.stripVersionSuffixes(slug);
+      if (stripped && stripped !== slug) {
+        const candidate = `${prefix}/${stripped}`;
+        const record = this.catalog.get(candidate);
+        if (record) {
+          return {
+            modelId: candidate,
+            record,
+            confidence: 0.85,
+            strategy: "date-suffix-strip",
+            reason: `Stripped date from slug "${slug}" \u2192 "${stripped}"`
+          };
+        }
+      }
+    }
+    const latest = this.findLatestVersioned(model);
+    if (latest) {
+      return {
+        modelId: latest.modelId,
+        record: latest.record,
+        confidence: 0.85,
+        strategy: "date-suffix-strip",
+        reason: `Matched "${model}" to versioned catalog entry "${latest.modelId}" (latest)`
+      };
+    }
+    return null;
+  }
+  findLatestVersioned(baseModelId) {
+    const candidates = [];
+    for (const [modelId, record] of this.catalog) {
+      if (modelId === baseModelId) continue;
+      if (modelId.startsWith(`${baseModelId}-`)) {
+        candidates.push({
+          modelId,
+          record,
+          suffix: modelId.slice(baseModelId.length + 1)
+        });
+      }
+    }
+    if (candidates.length === 0) return null;
+    candidates.sort((a, b) => b.suffix.localeCompare(a.suffix));
+    const best = candidates[0];
+    return { modelId: best.modelId, record: best.record };
+  }
+  shorthandMap() {
+    return { ...SHORTHAND_MAP, ...this.ctx.options.additionalShorthands };
+  }
+  partialMatch(model, provider) {
+    let best = null;
+    const inputTokens = tokenise(model);
+    if (inputTokens.length === 0) return null;
+    for (const record of this.catalog.values()) {
+      const recordTokens = /* @__PURE__ */ new Set([
+        ...tokenise(record.modelId),
+        ...tokenise(_nullishCoalesce(record.name, () => ( "")))
+      ]);
+      const intersection = inputTokens.filter((t) => recordTokens.has(t));
+      const overlapRatio = intersection.length / inputTokens.length;
+      let score = overlapRatio * 0.6;
+      if (record.modelId.includes(model)) score += 0.3;
+      const slug = modelSlug(record.modelId);
+      if (model.includes(slug)) score += 0.2;
+      if (provider && provider === record.providerId) score += 0.15;
+      const lenPenalty = Math.abs(model.length - slug.length) / Math.max(model.length, slug.length, 1) * 0.1;
+      score -= lenPenalty;
+      if (!best || score > best.score) {
+        best = { modelId: record.modelId, record, score };
+      }
+    }
+    if (!best || best.score < 0.65) return null;
+    return {
+      modelId: best.modelId,
+      record: best.record,
+      confidence: 0.65,
+      strategy: "partial-name-match",
+      reason: `Partial token match (score ${best.score.toFixed(2)})`
+    };
+  }
+  computeRoutedViaOpenRouter(modelId, record, provider, originalProvider) {
+    const norm = _nullishCoalesce(normalizeProvider(originalProvider), () => ( provider));
+    if (norm === "openrouter") return true;
+    if (norm && norm !== "openrouter") {
+      if (shouldDefaultRouteViaOpenRouter(norm, this.ctx.options.routingEnv)) return true;
+      return false;
+    }
+    const recordProvider = _optionalChain([record, 'optionalAccess', _14 => _14.providerId]);
+    if (recordProvider && shouldDefaultRouteViaOpenRouter(recordProvider, this.ctx.options.routingEnv)) {
+      return true;
+    }
+    if (_optionalChain([record, 'optionalAccess', _15 => _15.availableOnOpenRouter]) && modelId.includes("/")) return true;
+    return false;
+  }
+  success(args) {
+    return {
+      found: true,
+      modelId: args.modelId,
+      record: args.record,
+      routedViaOpenRouter: this.computeRoutedViaOpenRouter(
+        args.modelId,
+        args.record,
+        args.provider,
+        args.originalProvider
+      ),
+      confidence: args.confidence,
+      resolvedVia: args.resolvedVia,
+      resolvedReason: args.reason,
+      normalisedInput: args.normalisedInput
+    };
+  }
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.DEFAULT_MODEL_CACHE_TTL_MS = DEFAULT_MODEL_CACHE_TTL_MS; exports.readCachedModels = readCachedModels; exports.writeCachedModels = writeCachedModels; exports.invalidateModelsCache = invalidateModelsCache; exports.AI_MODELS_CATALOG_ID = AI_MODELS_CATALOG_ID; exports.AI_TOOLS_APP_ID = AI_TOOLS_APP_ID; exports.AI_MODELS_DESCRIPTOR = AI_MODELS_DESCRIPTOR; exports.providerIdToEnvKeyPrefix = providerIdToEnvKeyPrefix; exports.vendorApiKeyEnvName = vendorApiKeyEnvName; exports.loadOpenRouterRoutingEnv = loadOpenRouterRoutingEnv; exports.shouldDefaultRouteViaOpenRouter = shouldDefaultRouteViaOpenRouter; exports.normalizeString = normalizeString; exports.normalizeProvider = normalizeProvider; exports.buildCatalogIndexes = buildCatalogIndexes; exports.ModelNameResolver = ModelNameResolver;
+//# sourceMappingURL=chunk-TF4L2NEC.cjs.map