nexus-agents 2.155.1 → 2.157.0

package/dist/{chunk-N3Y6J2FL.js → chunk-RCSDD2QY.js}

@@ -1778,6 +1778,70 @@ function buildInTreeEntries() {
   return DEFAULT_MODEL_CAPABILITIES.models.map(toEntry);
 }
 
+// src/config/model-fuzzy-resolution.ts
+var MAX_FUZZY_ID_LENGTH = 256;
+var BREADTH_SOURCES = /* @__PURE__ */ new Set(["models-dev", "generated"]);
+var SOURCE_RANK = {
+  manifest: 0,
+  "in-tree": 1,
+  "models-dev": 2,
+  generated: 3,
+  derived: 4
+};
+function byTierPriority(a, b) {
+  return SOURCE_RANK[a.source] - SOURCE_RANK[b.source];
+}
+function versionKey(version) {
+  return normaliseModelId(version).replace(/\./g, "-");
+}
+function entryVersion(entry) {
+  return entry.version ?? resolveModelIdentitySync(entry.id).version;
+}
+function identityKeyFor(identity) {
+  if (identity.vendor === "unknown" || identity.family === "unknown") return void 0;
+  if (identity.version === void 0) return void 0;
+  return `${identity.vendor}|${identity.family}|${versionKey(identity.version)}`;
+}
+function buildIdentityIndex(entries) {
+  const index = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const version = entryVersion(entry);
+    if (version === void 0) continue;
+    const key = identityKeyFor({ vendor: entry.vendor, family: entry.family, version });
+    if (key === void 0) continue;
+    const bucket = index.get(key);
+    if (bucket === void 0) index.set(key, [entry]);
+    else bucket.push(entry);
+  }
+  return index;
+}
+function samePricing(a, b) {
+  return a.inputPer1M === b.inputPer1M && a.outputPer1M === b.outputPer1M;
+}
+function isEffectivelySameModel(a, b) {
+  if (normaliseModelId(a.id) === normaliseModelId(b.id)) return true;
+  if (a.pricing === void 0 || b.pricing === void 0) return false;
+  return samePricing(a.pricing, b.pricing) && a.contextWindow === b.contextWindow && a.maxOutputTokens === b.maxOutputTokens;
+}
+function dedupeEffectiveDuplicates(candidates) {
+  const kept = [];
+  for (const candidate of candidates) {
+    if (!kept.some((k) => isEffectivelySameModel(k, candidate))) kept.push(candidate);
+  }
+  return kept;
+}
+function uniqueCandidate(candidates) {
+  const distinct = dedupeEffectiveDuplicates(candidates);
+  return distinct.length === 1 ? distinct[0] : void 0;
+}
+function selectIdentityCandidate(candidates) {
+  if (candidates === void 0) return void 0;
+  const ranked = [...candidates].sort(byTierPriority);
+  const authoritative = ranked.filter((e) => !BREADTH_SOURCES.has(e.source));
+  if (authoritative.length > 0) return uniqueCandidate(authoritative);
+  return uniqueCandidate(ranked.filter((e) => BREADTH_SOURCES.has(e.source)));
+}
+
 // src/config/manifest-overlay.ts
 import { existsSync, readFileSync, statSync } from "fs";
 import { parse as parseYaml } from "yaml";
@@ -2249,6 +2313,13 @@ var ModelRegistry = class {
   byId = /* @__PURE__ */ new Map();
   byAlias = /* @__PURE__ */ new Map();
   // alias → canonical id
+  /**
+   * `vendor|family|version` → candidate entries, for the identity tier
+   * (#4164). Built ONCE, lazily on the first fuzzy lookup — the entry maps
+   * are immutable after construction, so it never goes stale. No caching of
+   * UNMATCHED ids happens anywhere (the index only holds loaded entries).
+   */
+  identityIndex;
   constructor(options = {}) {
     if (options.generatedEntries !== void 0) {
       this.loadEntries(options.generatedEntries);
@@ -2266,12 +2337,20 @@ var ModelRegistry = class {
   /**
    * Resolve a model id to its full metadata entry. Always returns —
    * unknown models get a derived entry with sensible defaults.
+   *
+   * On exact miss, the normalized/identity resolution tier (#4164) runs
+   * BEFORE derivation so decorated gateway ids (`Claude_Opus_4.8_hardened`)
+   * still pick up the canonical entry's pricing/metadata.
    */
   getEntry(modelId, hints) {
     const direct = this.lookupExact(modelId);
     if (direct !== void 0 && direct.source !== "models-dev" && direct.source !== "generated") {
       return direct;
     }
+    if (direct === void 0) {
+      const fuzzy = this.lookupFuzzy(modelId, hints);
+      if (fuzzy !== void 0) return fuzzy;
+    }
     const identity = resolveModelIdentitySync(modelId, augmentHints(hints, direct));
     const derived = deriveEntry(modelId, identity);
     if (direct !== void 0 && identity.vendor !== "unknown") {
@@ -2306,6 +2385,39 @@ var ModelRegistry = class {
     if (canonical !== void 0) return this.byId.get(canonical);
     return void 0;
   }
+  /**
+   * Normalized/identity resolution tier (#4164). Runs on exact miss only:
+   * (a) retry `lookupExact` with the `normaliseModelId`-normalized id so
+   *     aliases + alias-shadow (#3293) keep working;
+   * (b) identity-match {vendor, family, version} against the load-time
+   *     index — version required on both sides, tier-ordered uniqueness,
+   *     fail closed on ambiguity (see model-fuzzy-resolution.ts).
+   * Over-long ids skip the tier entirely (straight to derivation).
+   */
+  lookupFuzzy(modelId, hints) {
+    if (modelId.length > MAX_FUZZY_ID_LENGTH) return void 0;
+    const normalized = normaliseModelId(modelId);
+    const byNormalized = normalized === modelId ? void 0 : this.lookupExact(normalized);
+    if (byNormalized !== void 0) {
+      return this.resolveMatched(byNormalized, modelId, hints, "normalized");
+    }
+    const key = identityKeyFor(resolveModelIdentitySync(modelId, hints));
+    if (key === void 0) return void 0;
+    this.identityIndex ??= buildIdentityIndex(this.byId.values());
+    const matched = selectIdentityCandidate(this.identityIndex.get(key));
+    if (matched === void 0) return void 0;
+    return this.resolveMatched(matched, modelId, hints, "identity");
+  }
+  /**
+   * Build the entry returned for a fuzzy match: a fresh COPY that keeps the
+   * CALLER'S id and takes behaviour from derivation for that original id —
+   * the matched entry grants pricing/metadata only.
+   */
+  resolveMatched(matched, modelId, hints, matchedVia) {
+    const identity = resolveModelIdentitySync(modelId, augmentHints(hints, matched));
+    const derived = deriveEntry(modelId, identity);
+    return mergeMatchedWithDerived(matched, derived, matchedVia);
+  }
   loadEntries(entries) {
     for (const entry of entries) {
       this.byId.set(entry.id, entry);
@@ -2342,6 +2454,23 @@ function mergeSnapshotWithDerived(snapshot, derived) {
     source: "derived"
   };
 }
+function mergeMatchedWithDerived(matched, derived, matchedVia) {
+  const merged = {
+    ...mergeSnapshotWithDerived(matched, derived)
+  };
+  delete merged.aliases;
+  delete merged.cliName;
+  delete merged.cliAlias;
+  delete merged.cliModelName;
+  delete merged.unsupportedParameters;
+  delete merged.maxTokensParam;
+  delete merged.verifiedAt;
+  merged.id = derived.id;
+  if (derived.version !== void 0) merged.version = derived.version;
+  merged.matchedVia = matchedVia;
+  merged.resolvedFrom = matched.id;
+  return merged;
+}
 var globalRegistry;
 function getDefaultRegistry() {
   globalRegistry ??= buildDefaultRegistry();
@@ -2372,7 +2501,7 @@ function setDefaultRegistry(registry) {
 }
 async function reloadDefaultRegistry() {
   globalRegistry = buildDefaultRegistry();
-  const { resetGlobalRegistry } = await import("./unified-registry-SMGX7OMN.js");
+  const { resetGlobalRegistry } = await import("./unified-registry-MMQXU622.js");
   resetGlobalRegistry();
   return globalRegistry;
 }
@@ -13656,7 +13785,7 @@ var CompositeRouter = class _CompositeRouter {
    */
   async consultUnifiedContext(task) {
     try {
-      const { getContextForTask, inferTaskCategory } = await import("./context-retriever-FTLRG2N6.js");
+      const { getContextForTask, inferTaskCategory } = await import("./context-retriever-33SGXV33.js");
       const ctx = await getContextForTask({
         task: task.content,
         category: inferTaskCategory(task.content),
@@ -15159,4 +15288,4 @@ export {
   AgentCapability,
   OrchestratorError
 };
-//# sourceMappingURL=chunk-N3Y6J2FL.js.map
+//# sourceMappingURL=chunk-RCSDD2QY.js.map