mixdog 1.2.0 → 1.2.2

package/src/runtime/shared/llm/anthropic-effort.mjs

@@ -2,11 +2,13 @@
  * Anthropic "effort" (extended-thinking budget) request parameter handling.
  */
 import {
-  assertAnthropicManualBudgetSupported,
+  CLAUDE_GENERATION_FLOOR,
+  claudeGenerationAtLeast,
   emitsAnthropicProgressUpdates,
-  isAnthropicAdaptiveOnlyModel,
+  isAnthropicAdaptiveOnlyByGeneration,
   normalizeClaudeModelId as normalizeModelId,
 } from './anthropic-thinking-contract.mjs';
+import { getModelMetadataSync } from './model-catalog.mjs';
 
 const EFFORT_LEVELS = Object.freeze(['low', 'medium', 'high', 'xhigh', 'max']);
 const THINKING_DISPLAYS = new Set(['summarized', 'omitted', 'updates']);
@@ -32,12 +34,47 @@ const CONTROL_EFFORT_KEYS = new Set(['supported', 'enabled', 'default']);
 
 // ── Catalog-first capability index ───────────────────────────────────────
 // The provider catalog already carries what each model advertises
-// (capabilities.effort → reasoningOptions:[{type:'effort',values:[…]}]), so it
-// — not a hardcoded regex ladder — is the source of truth for what we put on
-// the wire. anthropic-model-resolve feeds this whenever the in-memory catalog
-// moves. The regex ladder below stays as the fallback for ids the catalog does
-// not know (offline start, api-key provider, first run before /v1/models).
-const _catalogEffortLevels = new Map();
+// (capabilities.effort → reasoningOptions:[{type:'effort',values:[…]}],
+// capabilities.thinking.types → thinkingTypes), so it — not an id ladder — is
+// the source of truth for what we put on the wire. Order for one model:
+//   1. the live-roster index below (anthropic-model-resolve feeds it whenever
+//      the in-memory catalog moves),
+//   2. the shared model catalog (cached roster / LiteLLM / models.dev),
+//   3. a release-generation floor (anthropic-thinking-contract) for an id no
+//      catalog describes — a new release inherits it, no per-id entry.
+const _catalogEntries = new Map();
+
+/** `{adaptive?:boolean, enabled?:boolean}` a live /v1/models row declares under
+ *  capabilities.thinking.types, or undefined when it declares neither. */
+export function thinkingTypesFromCapabilities(capabilities) {
+  const types = capabilities?.thinking?.types;
+  if (!types || typeof types !== 'object') return undefined;
+  const out = {};
+  for (const key of ['adaptive', 'enabled']) {
+    const declared = types[key];
+    const supported = typeof declared === 'boolean' ? declared : declared?.supported;
+    if (typeof supported === 'boolean') out[key] = supported;
+  }
+  return Object.keys(out).length ? out : undefined;
+}
+
+function _effortLevelsOf(reasoningOptions) {
+  const option = (Array.isArray(reasoningOptions) ? reasoningOptions : []).find(
+    (entry) =>
+      String(entry?.type || '')
+        .trim()
+        .toLowerCase() === 'effort'
+  );
+  return new Set(
+    (Array.isArray(option?.values) ? option.values : [])
+      .map((value) =>
+        String(value || '')
+          .trim()
+          .toLowerCase()
+      )
+      .filter((value) => value && !CONTROL_EFFORT_KEYS.has(value))
+  );
+}
 
 function _catalogKeys(model) {
   const id = normalizeModelId(model);
@@ -55,7 +92,7 @@ function _catalogKeys(model) {
  * lists carry no capability data and must not disable effort.
  */
 export function setModelEffortCapabilities(models) {
-  _catalogEffortLevels.clear();
+  _catalogEntries.clear();
   if (!Array.isArray(models)) return;
   for (const model of models) {
     if (!model?.id || !Array.isArray(model.reasoningOptions)) continue;
@@ -63,37 +100,82 @@ export function setModelEffortCapabilities(models) {
     // (custom-reasoning.mjs); a same-id custom model must never reshape the
     // first-party index.
     if (String(model.provider || '').startsWith('custom-')) continue;
-    const option = model.reasoningOptions.find(
-      (entry) =>
-        String(entry?.type || '')
-          .trim()
-          .toLowerCase() === 'effort'
-    );
-    const levels = new Set(
-      (Array.isArray(option?.values) ? option.values : [])
-        .map((value) =>
-          String(value || '')
-            .trim()
-            .toLowerCase()
-        )
-        .filter((value) => value && !CONTROL_EFFORT_KEYS.has(value))
-    );
+    const levels = _effortLevelsOf(model.reasoningOptions);
+    const manual = typeof model.thinkingTypes?.enabled === 'boolean' ? model.thinkingTypes.enabled : undefined;
+    const adaptive = typeof model.thinkingTypes?.adaptive === 'boolean' ? model.thinkingTypes.adaptive : undefined;
     for (const key of _catalogKeys(model.id)) {
-      const existing = _catalogEffortLevels.get(key);
+      const existing = _catalogEntries.get(key);
       // A bare alias shared by several records keeps the richer entry.
-      if (existing?.size && levels.size === 0) continue;
-      _catalogEffortLevels.set(key, levels);
+      if (existing?.levels.size && levels.size === 0) continue;
+      _catalogEntries.set(key, { levels, manual, adaptive });
     }
   }
 }
 
-/** Advertised levels for `model`, or null when the catalog has no record. */
-function _catalogLevels(model) {
+// Shared-catalog tier (cached roster rows, LiteLLM, models.dev) for an id the
+// live index does not hold. Only an actual effort ladder counts; silence
+// returns null so the generation floor decides.
+function _sharedCatalogEntry(model) {
+  const id = normalizeModelId(model);
+  if (!id) return null;
+  const levels = _effortLevelsOf(getModelMetadataSync(id, 'anthropic')?.reasoningOptions);
+  return levels.size ? { levels, manual: undefined, adaptive: undefined } : null;
+}
+
+/** `{levels: Set, manual?: boolean, adaptive?: boolean}` for `model`, or null when no catalog describes it. */
+function _catalogEntry(model) {
   for (const key of _catalogKeys(model)) {
-    const levels = _catalogEffortLevels.get(key);
-    if (levels) return levels;
+    const entry = _catalogEntries.get(key);
+    if (entry) return entry;
+  }
+  return _sharedCatalogEntry(model);
+}
+
+/** Advertised levels for `model`, or null when the catalog has no ladder for it. */
+function _catalogLevels(model) {
+  return _catalogEntry(model)?.levels ?? null;
+}
+
+/**
+ * True when the model's thinking contract rejects a manual
+ * `thinking:{type:"enabled",budget_tokens}` request: the catalog's declared
+ * thinking types decide, the release-generation floor covers an undescribed id.
+ */
+export function isAnthropicAdaptiveOnlyModel(model) {
+  const manual = _catalogEntry(model)?.manual;
+  return typeof manual === 'boolean' ? !manual : isAnthropicAdaptiveOnlyByGeneration(model);
+}
+
+// The thinking type is resolved apart from the effort ladder: a catalog can
+// advertise effort levels for a model that still takes the manual budget shape
+// (effort is not adaptive-thinking support). A declared `adaptive` flag decides;
+// otherwise the release-generation floor does, whatever ladder the catalog holds.
+function _usesAdaptiveThinking(model) {
+  if (isEnvTruthy(process.env.MIXDOG_ANTHROPIC_ALWAYS_ENABLE_EFFORT)) return true;
+  const adaptive = _catalogEntry(model)?.adaptive;
+  return typeof adaptive === 'boolean' ? adaptive : _floorSupportsEffort(model);
+}
+
+export function assertAnthropicManualBudgetSupported(model) {
+  if (isAnthropicAdaptiveOnlyModel(model)) {
+    throw new TypeError(`${model} does not support thinkingBudgetTokens; use effort with adaptive thinking instead.`);
   }
-  return null;
+}
+
+/**
+ * Effort levels the wire builder sends unchanged for `model` (reserved `max`
+ * excluded), from the same capability gates normalizeAnthropicEffortInput and
+ * applyAnthropicEffortToBody use: catalog record first, generation floor for
+ * an absent record. A model without effort support, or whose catalog record
+ * declares none, accepts none.
+ */
+export function anthropicEffortLevelsFor(model) {
+  // Only the adaptive path sends output_config effort; a manual-thinking model
+  // takes none, whatever ladder a catalog holds for it.
+  if (!modelSupportsEffort(model) || !_usesAdaptiveThinking(model)) return [];
+  const levels = ['low', 'medium', 'high'];
+  if (modelSupportsXhighEffort(model)) levels.push('xhigh');
+  return levels;
 }
 
 export const EFFORT_BETA_HEADER = 'effort-2025-11-24';
@@ -109,121 +191,41 @@ const _LOGGED_EFFORT_NORMALIZATION = new Set();
 const _LOGGED_UNKNOWN_EFFORT = new Set();
 const MAX_LOGGED_UNKNOWN_EFFORTS = 100;
 
-function parseClaudeVersion(model) {
-  const m = normalizeModelId(model);
-  const triple = m.match(/^claude-(haiku|sonnet|opus|fable)-(\d+)-(\d+)/);
-  if (triple) {
-    return { family: triple[1], major: Number(triple[2]), minor: Number(triple[3]) };
-  }
-  // Bare version ids carry family + major only (claude-opus-5). opus/haiku
-  // were missing here, so `claude-opus-5` parsed to null and fell through
-  // every capability check as an unknown shape.
-  const pair = m.match(/^claude-(sonnet|fable|opus|haiku)-(\d+)(?:$|[-@])/);
-  if (pair) {
-    return { family: pair[1], major: Number(pair[2]), minor: null };
-  }
-  // Legacy naming: version comes BEFORE the family (claude-3-7-sonnet,
-  // claude-3-5-sonnet, claude-3-opus). These are manual-thinking models —
-  // parse them so isLegacyAnthropicReasoningModel excludes them instead of
-  // letting modelSupportsEffort's `startsWith('claude-')` fallthrough grant
-  // them adaptive thinking + the effort beta (a hard 400).
-  const legacy = m.match(/^claude-(\d+)-(\d+)-(haiku|sonnet|opus)/);
-  if (legacy) {
-    return { family: legacy[3], major: Number(legacy[1]), minor: Number(legacy[2]) };
-  }
-  return null;
-}
-
-function isLegacyAnthropicReasoningModel(model) {
-  const parsed = parseClaudeVersion(model);
-  if (!parsed) return false;
-  if (parsed.family === 'haiku') return true;
-  if (parsed.family === 'fable') return false;
-  if (parsed.family === 'sonnet' || parsed.family === 'opus') {
-    if (parsed.major < 4) return true;
-    if (parsed.major === 4 && parsed.minor !== null && parsed.minor < 6) return true;
-    // Bare major, no minor (claude-opus-4 / claude-sonnet-4): adaptive
-    // effort only ships from 5 up, so 4.x aliases stay manual-thinking.
-    if (parsed.minor === null && parsed.major < 5) return true;
-    return false;
-  }
-  return false;
-}
-
-// @[MODEL LAUNCH]: extend allowlist when new Claude models ship with effort support.
 export function modelSupportsEffort(model) {
   if (isEnvTruthy(process.env.MIXDOG_ANTHROPIC_ALWAYS_ENABLE_EFFORT)) return true;
   const advertised = _catalogLevels(model);
   if (advertised) return advertised.size > 0;
-  return _regexSupportsEffort(model);
+  return _floorSupportsEffort(model);
 }
 
-// Fallback ladder for ids the catalog does not carry. Also used by
-// effortValuesForModel, which BUILDS the catalog records and therefore must
-// never consult the index it feeds.
-function _regexSupportsEffort(model) {
-  const m = normalizeModelId(model);
-  if (!m.includes('claude')) return false;
-  if (isLegacyAnthropicReasoningModel(model)) return false;
-  if (isAnthropicAdaptiveOnlyModel(model)) return true;
-  if (m.includes('opus-4-6') || m.includes('sonnet-4-6')) return true;
-  if (m.includes('sonnet-5') || m.includes('fable-5')) return true;
-  if (/^claude-mythos-5-1(?:-\d{8})?$/.test(m)) return true;
-  if (/^claude-opus-4-(6|7|8)(?:$|[-@])/.test(m)) return true;
-  if (/^claude-opus-5(?:$|[-@])/.test(m)) return true;
-  // Fallthrough for not-yet-enumerated modern models: only grant effort when
-  // parseClaudeVersion resolves a family with major>=4 (and not a manual-
-  // thinking legacy already excluded above). A bare `startsWith('claude-')`
-  // here would hand thinking:adaptive + the effort beta to legacy/unknown
-  // IDs (e.g. claude-3-7-sonnet) → hard 400. Unknown-shape IDs (no version
-  // parsed) fall through to false: no effort, no adaptive thinking.
-  const parsed = parseClaudeVersion(model);
-  if (
-    parsed &&
-    (parsed.family === 'sonnet' || parsed.family === 'opus' || parsed.family === 'fable') &&
-    parsed.major >= 4
-  ) {
-    return true;
-  }
-  return false;
+// Generation-floor fallbacks for ids the catalog does not describe. Also used
+// by effortValuesForModel, which BUILDS the catalog records and therefore must
+// never consult the index it feeds. Legacy manual-thinking generations
+// (claude-3-7-sonnet, claude-sonnet-4-5, claude-haiku-4-5) sit below the
+// floor; non-claude ids have no generation and get nothing.
+function _floorSupportsEffort(model) {
+  return claudeGenerationAtLeast(model, CLAUDE_GENERATION_FLOOR.adaptiveEffort);
 }
 
-// @[MODEL LAUNCH]: extend when new models support xhigh effort.
-// Per platform.claude.com/docs/en/build-with-claude/effort — xhigh is
-// supported by: Fable 5, Mythos 5, Opus 4.8, Opus 4.7, Sonnet 5.
-// NOT Opus 4.6 / Sonnet 4.6 (those support max but not xhigh).
 export function modelSupportsXhighEffort(model) {
   const advertised = _catalogLevels(model);
   if (advertised) return advertised.has('xhigh');
-  return _regexSupportsXhighEffort(model);
+  return _floorSupportsXhighEffort(model);
 }
 
-function _regexSupportsXhighEffort(model) {
-  const m = normalizeModelId(model);
-  if (/^claude-opus-4-(7|8)(?:$|[-@])/.test(m)) return true;
-  if (/^claude-opus-5(?:$|[-@])/.test(m)) return true;
-  if (/^claude-sonnet-5(?:$|[-@])/.test(m)) return true;
-  if (/^claude-fable-5(?:$|[-@])/.test(m)) return true;
-  if (/^claude-mythos-5(?:$|[-@])/.test(m)) return true;
-  if (/^claude-mythos-preview(?:$|[-@])/.test(m)) return true;
-  return false;
+function _floorSupportsXhighEffort(model) {
+  return claudeGenerationAtLeast(model, CLAUDE_GENERATION_FLOOR.xhighEffort);
 }
 
-// @[MODEL LAUNCH]: extend when new Opus models support max effort.
-// Max list = xhigh list PLUS Opus 4.6, Sonnet 4.6, Opus 4.5.
 export function modelSupportsMaxEffort(model) {
   const advertised = _catalogLevels(model);
-  // xhigh support implies max support (kept from the ladder below).
+  // xhigh support implies max support.
   if (advertised) return advertised.has('max') || advertised.has('xhigh');
-  return _regexSupportsMaxEffort(model);
+  return _floorSupportsMaxEffort(model);
 }
 
-function _regexSupportsMaxEffort(model) {
-  if (_regexSupportsXhighEffort(model)) return true;
-  const m = normalizeModelId(model);
-  if (/^claude-opus-4-(5|6)(?:$|[-@])/.test(m)) return true;
-  if (/^claude-sonnet-4-6(?:$|[-@])/.test(m)) return true;
-  return false;
+function _floorSupportsMaxEffort(model) {
+  return claudeGenerationAtLeast(model, CLAUDE_GENERATION_FLOOR.maxEffort);
 }
 
 function isEnvTruthy(value) {
@@ -276,7 +278,8 @@ export function normalizeAnthropicEffortInput(raw, model, logTag = 'anthropic')
 export function shouldIncludeEffortBeta(model, opts = {}) {
   const thinkingBudgetTokens = Number(opts.thinkingBudgetTokens);
   if (Number.isFinite(thinkingBudgetTokens) && thinkingBudgetTokens > 0) return false;
-  return modelSupportsEffort(model);
+  // Only requests that carry output_config effort (adaptive path) need the beta.
+  return modelSupportsEffort(model) && _usesAdaptiveThinking(model);
 }
 
 /**
@@ -300,7 +303,7 @@ export function applyAnthropicEffortToBody(
 
   const normalized = normalizeAnthropicEffortInput(opts.effort, model, logTag);
 
-  if (modelSupportsEffort(model)) {
+  if (modelSupportsEffort(model) && _usesAdaptiveThinking(model)) {
     if (normalized) {
       const existing = body.output_config && typeof body.output_config === 'object' ? body.output_config : {};
       body.output_config = { ...existing, effort: normalized };
@@ -372,10 +375,10 @@ export function effortValuesForModel(capabilities, modelId) {
   // the model supports effort but doesn't enumerate levels, so derive the
   // set from the known level ladder, gated by the top-tier model check.
   let levels = [...EFFORT_LEVELS];
-  if (!_regexSupportsMaxEffort(modelId)) {
+  if (!_floorSupportsMaxEffort(modelId)) {
     levels = levels.filter((level) => level !== 'max');
   }
-  if (!_regexSupportsXhighEffort(modelId)) {
+  if (!_floorSupportsXhighEffort(modelId)) {
     levels = levels.filter((level) => level !== 'xhigh');
   }
   return levels;

package/src/runtime/shared/llm/anthropic-thinking-contract.mjs

@@ -5,25 +5,61 @@ export function normalizeClaudeModelId(model) {
     .replace(/\./g, '-');
 }
 
-// One classification owns request shaping and manual-budget validation.
-export function isAnthropicAdaptiveOnlyModel(model) {
-  const id = normalizeClaudeModelId(model);
-  return (
-    /^claude-(?:fable|mythos)-5(?:-|$)/.test(id) ||
-    /^claude-(?:opus|sonnet)-5(?:-|$)/.test(id) ||
-    /^claude-opus-4-(?:7|8)(?:-|$)/.test(id)
-  );
+// Version token after the family (claude-opus-4-8, claude-nova-9-1-20270101)
+// or before it (claude-3-5-sonnet). Minor is one or two digits and never
+// followed by another digit, so a release date (claude-opus-4-20250514) is
+// not read as a minor version.
+const FAMILY_FIRST_VERSION = /^claude-[a-z][a-z0-9]*-(\d+)(?:-(\d{1,2})(?!\d))?(?:[-@]|$)/;
+const VERSION_FIRST_VERSION = /^claude-(\d+)(?:-(\d{1,2})(?!\d))?(?:[-@]|$)/;
+
+/**
+ * Release generation of a Claude id as major*100 + minor (4.8 → 408), derived
+ * from the version token alone — no family names. A claude-* id without a
+ * version token is a not-yet-numbered release and ranks as the newest
+ * (Infinity); a non-claude id has no generation (null). A route prefix before
+ * the claude token (anthropic/claude-…, us.anthropic.claude-…) is skipped.
+ */
+export function claudeGeneration(model) {
+  const normalized = normalizeClaudeModelId(model);
+  const at = normalized.indexOf('claude-');
+  if (at < 0) return null;
+  const id = normalized.slice(at);
+  const m = id.match(FAMILY_FIRST_VERSION) || id.match(VERSION_FIRST_VERSION);
+  return m ? Number(m[1]) * 100 + Number(m[2] || 0) : Infinity;
+}
+
+// Offline floors, used only for an id no catalog record describes. Each is the
+// first generation whose documented API contract has the capability; later
+// generations inherit it, so a new release needs no entry here.
+export const CLAUDE_GENERATION_FLOOR = Object.freeze({
+  // adaptive thinking + output_config.effort
+  adaptiveEffort: 406,
+  // thinking:{type:"enabled",budget_tokens} is rejected from here on
+  manualThinkingRejected: 407,
+  // effort tier "xhigh"
+  xhighEffort: 407,
+  // effort tier "max"
+  maxEffort: 405,
+});
+
+/** Generation at/above `floor`; ids with no generation (non-claude) never qualify. */
+export function claudeGenerationAtLeast(model, floor) {
+  const generation = claudeGeneration(model);
+  return generation !== null && generation >= floor;
+}
+
+// Offline classification for an id the catalog does not describe (catalog
+// lookup lives in anthropic-effort.mjs: isAnthropicAdaptiveOnlyModel).
+export function isAnthropicAdaptiveOnlyByGeneration(model) {
+  return claudeGenerationAtLeast(model, CLAUDE_GENERATION_FLOOR.manualThinkingRejected);
 }
 
 // Models that write their user-facing notes between tool calls (tool
 // preambles) as progress-update thinking blocks instead of text blocks.
+// Kept as an id list: no catalog field carries it, the display value rides a
+// beta-gated parameter that other models reject (a wrong "yes" is a 400), and
+// a wrong "no" only leaves preambles as text — so unknown ids stay off.
 export function emitsAnthropicProgressUpdates(model) {
   const id = normalizeClaudeModelId(model);
   return /^claude-(?:opus-5-5|sonnet-5-5|fable-5-1|mythos-5-1|fable-5)(?:-\d{8})?$/.test(id);
 }
-
-export function assertAnthropicManualBudgetSupported(model) {
-  if (isAnthropicAdaptiveOnlyModel(model)) {
-    throw new TypeError(`${model} does not support thinkingBudgetTokens; use effort with adaptive thinking instead.`);
-  }
-}

package/src/runtime/shared/llm/model-catalog.mjs

@@ -29,6 +29,7 @@ import {
 } from './provider-catalog-cache.mjs';
 import {
   modelsDevProviderId,
+  firstPartyModelsDevIds,
   providerCatalogEntry,
   providerMetadataCorrection,
   providerSeedRow,
@@ -60,35 +61,35 @@ const PRICING_CATALOG_RETRY_MS = 60_000;
 // name, so a provider-keyed lookup can find nothing and the route silently
 // prices at zero — indistinguishable from a genuinely free local model.
 
-// Which vendor actually served a relayed model, read off the model id. Only a
-// guess: its row fills capabilities and the effort ladder the route's own
-// sources left undeclared, and prices a model only when the provider-keyed
-// lookup found no rates, so a route with real catalog coverage is never
-// repriced by a name guess. Ids are matched on their leading family token
-// rather than a bare substring, so an unrelated model that merely mentions a
-// vendor is not adopted by it.
-const _RELAYED_MODEL_VENDORS = [
-  [/^claude[-.]/, 'anthropic'],
-  [/^(gpt|o[1-9]|codex)[-.]/, 'openai'],
-  [/^gemini[-.]/, 'google'],
-  [/^grok[-.]/, 'xai'],
-  [/^deepseek[-.]/, 'deepseek'],
-  [/^kimi[-.]/, 'moonshotai'],
-  [/^glm[-.]/, 'zai'],
-  [/^muse[-.]/, 'meta'],
-  [/^qwen(?:\d|[-.])/, 'alibaba'],
-  [/^minimax[-.]/, 'minimax'],
-  [/^mimo[-.]/, 'xiaomi'],
-  [/^longcat[-.]/, 'longcat'],
-];
-
-function _relayedModelVendor(id) {
-  const model = String(id || '').toLowerCase();
-  if (!model) return null;
-  for (const [pattern, vendor] of _RELAYED_MODEL_VENDORS) {
-    if (pattern.test(model)) return vendor;
+// Which vendor actually served a relayed model, read off the catalogs, in
+// order of provenance that does not depend on catalog entry order:
+//   1. the vendor LiteLLM lists the id under (fixed key order);
+//   2. registered first-party vendors that list it in models.dev (sorted);
+//   3. an unregistered models.dev provider, only when it is the sole such
+//      candidate — aggregators list many vendors' SKUs, so when several
+//      disagree there is no provenance and nothing is borrowed.
+// Only a guess: its row fills capabilities and the effort ladder the route's
+// own sources left undeclared, and prices a model only when the
+// provider-keyed lookup found no rates, so a route with real catalog coverage
+// is never repriced by it. A model no catalog lists has no vendor row to
+// lend, so there is nothing to guess and no id pattern is used.
+function _relayedModelVendors(id, catalog, modelsDevCatalog) {
+  // A vendor serves its own models: a relay or a user-defined provider listed
+  // in a catalog is never the vendor (and resolving it would guess again).
+  const isVendor = (vendor) =>
+    Boolean(vendor) && !String(vendor).startsWith('custom-') && !providerCatalogEntry(vendor)?.relay;
+  const vendors = new Set();
+  for (const key of [id, ..._CATALOG_SIMPLE_PREFIXES.map((prefix) => prefix + id)]) {
+    const vendor = modelsDevProviderId(catalog?.[key]?.litellm_provider);
+    if (isVendor(vendor)) vendors.add(vendor);
   }
-  return null;
+  const firstParty = new Set(firstPartyModelsDevIds());
+  for (const vendor of firstParty) if (modelsDevCatalog?.[vendor]?.models?.[id]) vendors.add(vendor);
+  const unregistered = Object.entries(modelsDevCatalog || {})
+    .filter(([vendor, entry]) => entry?.models?.[id] && !firstParty.has(vendor) && isVendor(vendor))
+    .map(([vendor]) => vendor);
+  if (unregistered.length === 1) vendors.add(unregistered[0]);
+  return vendors;
 }
 
 // Provider prefix variants used by the shared catalog resolver.
@@ -523,10 +524,15 @@ const effortEntry = (options) => (Array.isArray(options) ? options.find((o) => o
 // A vendor row is a first guess for a route it does not describe (relay,
 // same-vendor other endpoint, custom provider): it fills only the capabilities
 // and effort ladder the route's own sources left undeclared. Never limits.
-function withVendorGuess(meta, guess, { ladder = true } = {}) {
+// A relay serves the model through its own hosted tools, so the serving
+// vendor's web-search flag says nothing about the relay endpoint.
+function withVendorGuess(meta, guess, { ladder = true, relay = false } = {}) {
   if (!guess) return meta;
   const out = { ...(meta || _normalize({})) };
-  for (const key of GUESSED_FLAGS) out[key] ??= guess[key];
+  for (const key of GUESSED_FLAGS) {
+    if (relay && key === 'supportsWebSearch') continue;
+    out[key] ??= guess[key];
+  }
   const effort = effortEntry(guess.reasoningOptions);
   if (ladder && effort && out.supportsReasoning !== false && !effortEntry(out.reasoningOptions)) {
     out.reasoningOptions = [...(out.reasoningOptions || []), effort];
@@ -602,11 +608,16 @@ function catalogMetadata(id, mappedProvider, catalog, modelsDevCatalog) {
 
 // The row of the vendor serving a relayed or custom model id (no vendor: a
 // bare-id catalog lookup).
-function servingVendorMetadata(id, vendor, catalog, modelsDevCatalog) {
-  // Anthropic SKUs spell versions with hyphens (claude-opus-5-5); relays
-  // may list the same SKU with dots (claude-opus-5.5).
-  const vendorId = vendor === 'anthropic' ? id.replace(/(\d)\.(\d)/g, '$1-$2') : id;
-  return lookupModelMetadata(vendorId, vendor, catalog, modelsDevCatalog);
+function servingVendorMetadata(id, catalog, modelsDevCatalog) {
+  // Some vendors spell versions with hyphens (claude-opus-5-5) where relays
+  // list the same SKU with dots (claude-opus-5.5); the catalog decides which.
+  for (const candidate of new Set([id, id.replace(/(\d)\.(\d)/g, '$1-$2')])) {
+    for (const vendor of _relayedModelVendors(candidate, catalog, modelsDevCatalog)) {
+      const row = lookupModelMetadata(candidate, vendor, catalog, modelsDevCatalog);
+      if (row) return row;
+    }
+  }
+  return null;
 }
 
 // Both list enrichment and synchronous accounting use this exact resolver;
@@ -631,9 +642,9 @@ function lookupModelMetadata(originalId, provider, catalog, modelsDevCatalog, li
   const correction = source ? providerMetadataCorrection(provider, id) : null;
   if (meta && correction) meta = { ...meta, ...correction };
   let guess = null;
-  const relayVendor = source?.relay ? _relayedModelVendor(id) : null;
+  const relayGuess = source?.relay ? servingVendorMetadata(id, catalog, modelsDevCatalog) : null;
   if (custom) guess = customVendorMetadata(originalId, catalog, modelsDevCatalog);
-  else if (relayVendor) guess = servingVendorMetadata(id, relayVendor, catalog, modelsDevCatalog);
+  else if (relayGuess) guess = relayGuess;
   else if (source && !source.sameEndpoint) guess = mapped;
   if (source?.relay && !hasRates(meta) && hasRates(guess)) {
     meta = meta ? { ...meta, ...pricingFields(guess) } : pricingOnly(guess);
@@ -686,7 +697,10 @@ function lookupModelMetadata(originalId, provider, catalog, modelsDevCatalog, li
   const rosterLadders = [cached?.rawProviderModel, listedRow].filter(
     (row) => Array.isArray(row?.reasoningLevels) || Array.isArray(row?.reasoningOptions)
   );
-  meta = withVendorGuess(meta, guess, { ladder: !(source?.rosterLadderFinal && rosterLadders.length) });
+  meta = withVendorGuess(meta, guess, {
+    ladder: !(source?.rosterLadderFinal && rosterLadders.length),
+    relay: Boolean(relayGuess),
+  });
   return meta
     ? {
         ...meta,
@@ -706,8 +720,7 @@ function customVendorMetadata(originalId, catalog, modelsDevCatalog) {
   const listedId = String(originalId || '');
   for (const id of new Set([listedId, listedId.slice(listedId.lastIndexOf('/') + 1)])) {
     if (!id) continue;
-    const vendor = _relayedModelVendor(id) || modelsDevProviderId(catalog[id]?.litellm_provider);
-    const guess = servingVendorMetadata(id, vendor, catalog, modelsDevCatalog);
+    const guess = servingVendorMetadata(id, catalog, modelsDevCatalog);
     if (guess) return guess;
   }
   return null;
@@ -904,7 +917,6 @@ export function pricingCatalogRevisionSync() {
 }
 
 let lastAuditedRevision = null;
-let lastAudit = null;
 function auditCachedModelPricing() {
   const revision = pricingCatalogRevisionSync();
   const rows = Object.entries(cachedProviderModelListsSync()).flatMap(([provider, models]) =>
@@ -919,17 +931,6 @@ function auditCachedModelPricing() {
     );
   }
   lastAuditedRevision = revision;
-  lastAudit = { revision, rows, unpriced };
-  return lastAudit;
-}
-
-/** Catalog routes without a complete list price, from the latest audit (run on demand when none is cached). */
-export function unpricedModelsSync() {
-  return (lastAudit ?? auditCachedModelPricing()).unpriced.map(({ provider, model, missingRates }) => ({
-    provider,
-    model,
-    missingRates: [...missingRates],
-  }));
 }
 
 /**

package/src/runtime/shared/llm/openai-daybreak.mjs

@@ -13,17 +13,6 @@ export const DAYBREAK_OFF = 'off';
 export const DAYBREAK_BLUE_PROGRAM = 'daybreak_blue';
 const STANDARD_PROGRAM = 'standard';
 
-// Static fallback, used ONLY when a catalog row carries no access-program
-// list at all (an older cache or a catalog without the field). Any list the
-// catalog does send — empty included — decides on its own.
-const FALLBACK_DAYBREAK_BLUE_MODELS = new Set([
-  'gpt-6-sol',
-  'gpt-6-luna',
-  'gpt-5.6-sol',
-  'gpt-5.6-terra',
-  'gpt-5.6-luna',
-]);
-
 export const DAYBREAK_PARAMETER_OPTION = Object.freeze({
   id: DAYBREAK_PARAMETER_ID,
   label: 'Daybreak Blue',
@@ -43,13 +32,12 @@ export function catalogAccessPrograms(raw) {
 }
 
 /**
- * Whether a model (catalog record or bare id) accepts Blue: the catalog's
- * access-program list when it has one, else the static fallback.
+ * Whether a model accepts Blue: only when the catalog's access-program list
+ * for it names the program. A row with no list (or a bare id) is not offered
+ * the toggle; the server's catalog is the only source of this entitlement.
  */
 export function daybreakBlueSupported(model) {
-  if (Array.isArray(model?.accessPrograms)) return model.accessPrograms.includes(DAYBREAK_BLUE_PROGRAM);
-  const id = clean(typeof model === 'string' ? model : model?.id).toLowerCase();
-  return FALLBACK_DAYBREAK_BLUE_MODELS.has(id);
+  return Array.isArray(model?.accessPrograms) && model.accessPrograms.includes(DAYBREAK_BLUE_PROGRAM);
 }
 
 /**