@dbx-tools/model 0.9.40 → 0.9.43

package/lib/src/_retirement.js

@@ -0,0 +1,59 @@
+import retiredModelsSnapshotJson from "./generated/retired-models.json" with { type: "json" };
+const snapshot = retiredModelsSnapshotJson;
+const RETIRED_MODEL_PREFIXES = new Set([
+    "ai",
+    "anthropic",
+    "databricks",
+    "dbx",
+    "google",
+    "meta",
+    "openai",
+    "system",
+]);
+let names = Object.freeze([...snapshot.models]);
+let keys = retiredKeys(names);
+export const COMMITTED_RETIRED_MODELS = snapshot.models;
+export const RETIRED_MODELS_GENERATED_AT = snapshot.generatedAt;
+/** Replace retirement state after metadata cache hydration or refresh. */
+export function replaceRetiredModelNames(models) {
+    names = Object.freeze([...models]);
+    keys = retiredKeys(names);
+}
+/** Return the active retired-model names. */
+export function retiredModelNames() {
+    return names;
+}
+/** Resolve whether any supplied identity is listed as retired. */
+export function modelStatusFor(...models) {
+    const deprecated = models
+        .flatMap((model) => modelIdentities(model))
+        .some((identity) => {
+        const candidate = retiredModelKey(identity);
+        for (const key of keys) {
+            if (candidate === key || candidate.startsWith(`${key}-`))
+                return true;
+        }
+        return false;
+    });
+    return { deprecated };
+}
+function retiredKeys(models) {
+    return new Set(models.map(retiredModelKey).filter(Boolean));
+}
+function modelIdentities(model) {
+    if (typeof model === "string")
+        return [model];
+    return [
+        model.name,
+        model.displayName,
+        model.modelServiceName,
+        ...Object.values(model.serviceNames ?? {}),
+    ].filter((value) => Boolean(value));
+}
+function retiredModelKey(value) {
+    const tokens = value.toLowerCase().match(/[a-z0-9]+/g) ?? [];
+    while (tokens[0] && RETIRED_MODEL_PREFIXES.has(tokens[0]))
+        tokens.shift();
+    return tokens.join("-");
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/bindings.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Binding-safe facade for Databricks model discovery and routing.
+ *
+ * Generated language bindings should target this module instead of binding the
+ * full model package. It exposes plain TypeScript records while delegating all
+ * authentication, catalogue caching, fuzzy matching, policy, and URL selection
+ * to {@link createModelClient}.
+ *
+ * @module
+ */
+import type { ModelClass, ModelMetadata } from "@dbx-tools/shared-model/contracts";
+import { type ModelProtocol } from "./model-client.ts";
+/** Binding-friendly fuzzy model route request. */
+export interface ResolveModelRouteOptions {
+    readonly profile?: string;
+    readonly model?: string;
+    readonly fuzzy?: boolean;
+    readonly threshold?: number;
+    readonly requiresTools?: boolean;
+    readonly modelClass?: ModelClass;
+    readonly fallbacks?: readonly string[];
+    readonly liveOnly?: boolean;
+    readonly protocol?: ModelProtocol;
+    readonly refresh?: boolean;
+    readonly login?: boolean;
+}
+/** Binding-friendly model endpoint metadata used by Graphiti and other runtimes. */
+export interface ResolvedModelRoute {
+    readonly modelId: string;
+    readonly endpointName?: string;
+    readonly endpointTask?: string;
+    readonly endpointDimension?: number;
+    readonly source: "explicit" | "fuzzy-match" | "class" | "fallback";
+    readonly protocol: ModelProtocol;
+    readonly host: string;
+    readonly apiBase: string;
+    readonly url: string;
+    readonly headers: Readonly<Record<string, string>>;
+    readonly metadata: ModelMetadata;
+}
+/** Resolve one fuzzy model request through the canonical Node model client. */
+export declare function resolveModelRoute(options?: ResolveModelRouteOptions): Promise<ResolvedModelRoute>;

package/lib/src/bindings.js

@@ -0,0 +1,43 @@
+/**
+ * Binding-safe facade for Databricks model discovery and routing.
+ *
+ * Generated language bindings should target this module instead of binding the
+ * full model package. It exposes plain TypeScript records while delegating all
+ * authentication, catalogue caching, fuzzy matching, policy, and URL selection
+ * to {@link createModelClient}.
+ *
+ * @module
+ */
+import { createModelClient } from "./model-client.js";
+/** Resolve one fuzzy model request through the canonical Node model client. */
+export async function resolveModelRoute(options = {}) {
+    const client = await createModelClient({
+        ...(options.profile ? { auth: { profile: options.profile } } : {}),
+    });
+    const route = await client.route({
+        ...(options.model ? { explicit: options.model } : {}),
+        ...(options.fuzzy === undefined ? {} : { fuzzy: options.fuzzy }),
+        ...(options.threshold === undefined ? {} : { threshold: options.threshold }),
+        ...(options.requiresTools === undefined ? {} : { requiresTools: options.requiresTools }),
+        ...(options.modelClass ? { modelClass: options.modelClass } : {}),
+        ...(options.fallbacks ? { fallbacks: [...options.fallbacks] } : {}),
+        ...(options.liveOnly === undefined ? {} : { liveOnly: options.liveOnly }),
+        ...(options.protocol ? { protocol: options.protocol } : {}),
+        ...(options.refresh === undefined ? {} : { refresh: options.refresh }),
+        ...(options.login === undefined ? {} : { login: options.login }),
+    });
+    return {
+        modelId: route.modelId,
+        ...(route.endpoint?.name ? { endpointName: route.endpoint.name } : {}),
+        ...(route.endpoint?.task ? { endpointTask: route.endpoint.task } : {}),
+        ...(route.endpoint?.dimension ? { endpointDimension: route.endpoint.dimension } : {}),
+        source: route.source,
+        protocol: route.protocol,
+        host: route.host,
+        apiBase: route.apiBase,
+        url: route.url,
+        headers: { ...route.headers },
+        metadata: route.metadata,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/classify.d.ts

@@ -71,6 +71,11 @@ export declare function endpointCapabilities(endpoint: ServingEndpointSummary):
  * `4.8` - the bug a `major + minor/10` score would hit.
  */
 export declare function versionTuple(name: string): [number, number, number];
+/**
+ * Compare version tuples component-wise with missing parts as 0.
+ * Positive when `left` is newer.
+ */
+export declare function compareVersionTuples(left: readonly number[], right: readonly number[]): number;
 /**
  * Best-effort chat capability band for an endpoint we have no live
  * score for, keyed off provider family and the well-known variant words

package/lib/src/classify.js

@@ -96,15 +96,23 @@ export function versionTuple(name) {
         .map(Number);
     return [nums[0] ?? 0, nums[1] ?? 0, nums[2] ?? 0];
 }
-/** Compare two version tuples so the higher version sorts first (descending). */
-function compareVersionDesc(a, b) {
-    for (let i = 0; i < 3; i++) {
-        const diff = (b[i] ?? 0) - (a[i] ?? 0);
+/**
+ * Compare version tuples component-wise with missing parts as 0.
+ * Positive when `left` is newer.
+ */
+export function compareVersionTuples(left, right) {
+    const length = Math.max(left.length, right.length, 3);
+    for (let index = 0; index < length; index += 1) {
+        const diff = (left[index] ?? 0) - (right[index] ?? 0);
         if (diff !== 0)
             return diff;
     }
     return 0;
 }
+/** Compare two version tuples so the higher version sorts first (descending). */
+function compareVersionDesc(a, b) {
+    return compareVersionTuples(b, a);
+}
 /**
  * Monotonic version key for ordering siblings within a family/tier
  * (e.g. `opus-4-8` over `opus-4-7`). Encodes the {@link versionTuple}
@@ -280,4 +288,4 @@ export function classifyEndpoints(endpoints) {
         [ModelClass.Embedding]: embeddings,
     };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classify.js","sourceRoot":"","sources":["../../src/classify.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Model-class classification for Databricks Model Serving endpoints.\n *\n * Chat capability bands are derived from the live workspace catalogue\n * rather than a hand-maintained table. Databricks publishes\n * per-endpoint `quality` / `speed` / `cost` scores (the AI Playground\n * bars) on the serving list; {@link classifyEndpoints} buckets scored\n * chat models into the chat {@link ModelClass} bands by the *relative*\n * distribution of those scores (quantiles, not fixed cut-offs) so a\n * brand-new model that lands outside today's score range still slots in\n * next to its peers. Embedding endpoints (`task === \"llm/v1/embeddings\"`)\n * are bucketed into {@link ModelClass.Embedding} by task, independent of\n * any score.\n *\n * Unscored-but-recognizable chat endpoints are still placed by a small\n * family heuristic ({@link classifyByFamily}) so a workspace whose\n * models predate Foundation Model API scoring keeps working. The\n * offline fallback floor - the hard-coded model list reached for when\n * the live catalogue can't be read at all - is a server concern and\n * lives in `@dbx-tools/model`, not here: a browser client never talks\n * to Databricks directly, so it has nothing to fall back to.\n *\n * Pure (no Node-only imports), so a client can classify a `/models`\n * response without server dependencies.\n *\n * @module\n */\n\nimport {\n  type EndpointCapabilities,\n  type FamilyClass,\n  ModelClass as ModelClassValues,\n  type ModelClass as ModelClassType,\n  type ServingEndpointSummary,\n} from \"@dbx-tools/shared-model/contracts\";\n\ntype ModelClass = ModelClassType;\nconst ModelClass = ModelClassValues;\n\n/** Task hint Databricks stamps on chat completion endpoints. */\nconst CHAT_TASK = \"llm/v1/chat\";\n\n/** Task hint Databricks stamps on embedding endpoints. */\nconst EMBEDDING_TASK = \"llm/v1/embeddings\";\n\n/**\n * Provider families verified against Databricks Responses/Open Responses with\n * both a forced function call and a stateless `function_call_output` replay.\n *\n * Databricks' endpoint list/OpenAPI currently exposes no tools capability bit.\n * Keep this conservative: an unknown chat family is not agent-safe until it is\n * verified. Gemini is excluded because it emits a call but Open Responses\n * cannot replay the required thought signature; GPT-OSS rejects Responses\n * passthrough entirely.\n */\nexport function supportsToolsByFamily(name: string): boolean {\n  const n = name.toLowerCase();\n  if (n.includes(\"gemini\") || n.includes(\"gpt-oss\")) return false;\n  return (\n    n.includes(\"claude\") ||\n    n.includes(\"gpt\") ||\n    n.includes(\"qwen\") ||\n    n.includes(\"glm\") ||\n    n.includes(\"llama\")\n  );\n}\n\n/**\n * Derive an endpoint's capabilities from its Databricks task hint and its\n * classified {@link ModelClass}, so consumers filter on capability instead of\n * re-deriving it from raw `task` / `class` strings.\n *\n * Either signal alone is enough: the task hint is authoritative when present,\n * and the class covers endpoints Databricks left untasked but the classifier\n * recognized. Embedding wins over chat when both point at it, since the two are\n * not interchangeable.\n */\nexport function endpointCapabilities(endpoint: ServingEndpointSummary): EndpointCapabilities {\n  const embedding = endpoint.task === EMBEDDING_TASK || endpoint.class === ModelClass.Embedding;\n  // Every non-embedding class is a chat band, so \"classified but not embedding\"\n  // is the class-side test for chat capability.\n  const chat = !embedding && (endpoint.task === CHAT_TASK || endpoint.class !== undefined);\n  const tools = chat && (endpoint.supportsTools ?? supportsToolsByFamily(endpoint.name));\n  return { chat, embedding, tools };\n}\n\n/**\n * Numeric `[major, minor, patch]` version parsed from an endpoint\n * name, used to order siblings within a family/tier. Starts at the\n * first digit in the name, then reads successive separator-delimited,\n * digit-prefixed chunks as the three components (missing ones default\n * to `0`):\n *\n *   - `databricks-claude-opus-4-8`   -> `[4, 8, 0]`\n *   - `databricks-claude-opus-4-10`  -> `[4, 10, 0]` (sorts above 4-8)\n *   - `databricks-meta-llama-3-3-70b`-> `[3, 3, 70]`\n *   - `databricks-bge-large-en`      -> `[0, 0, 0]` (no digits)\n *\n * Component-wise comparison (not a decimal collapse) so `4.10` beats\n * `4.8` - the bug a `major + minor/10` score would hit.\n */\nexport function versionTuple(name: string): [number, number, number] {\n  const start = name.search(/\\d/);\n  if (start < 0) return [0, 0, 0];\n  const nums = name\n    .slice(start)\n    .split(/[^a-z0-9]+/i)\n    .map((chunk) => chunk.match(/^\\d+/)?.[0])\n    .filter((digits): digits is string => digits !== undefined)\n    .map(Number);\n  return [nums[0] ?? 0, nums[1] ?? 0, nums[2] ?? 0];\n}\n\n/** Compare two version tuples so the higher version sorts first (descending). */\nfunction compareVersionDesc(a: readonly number[], b: readonly number[]): number {\n  for (let i = 0; i < 3; i++) {\n    const diff = (b[i] ?? 0) - (a[i] ?? 0);\n    if (diff !== 0) return diff;\n  }\n  return 0;\n}\n\n/**\n * Monotonic version key for ordering siblings within a family/tier\n * (e.g. `opus-4-8` over `opus-4-7`). Encodes the {@link versionTuple}\n * as a single number so callers that need a scalar rank (the family\n * heuristic, the static fallback ordering) keep working; the encoding\n * preserves component order without the decimal-collapse bug.\n */\nfunction versionScore(name: string): number {\n  const [major, minor, patch] = versionTuple(name);\n  return major * 1_000_000 + minor * 1_000 + patch;\n}\n\n/**\n * Best-effort chat capability band for an endpoint we have no live\n * score for, keyed off provider family and the well-known variant words\n * in the name (`opus`/`sonnet`/`haiku`, `pro`/`mini`/`nano`,\n * `flash`/`flash-lite`, Llama parameter sizes, etc). Returns `null` for\n * names we don't recognize so unknown custom endpoints are never\n * auto-selected as a default. The accompanying `rank` orders siblings\n * within a class. Only ever returns a chat band - embedding endpoints\n * are classified by task, not name.\n */\nexport function classifyByFamily(name: string): FamilyClass | null {\n  const n = name.toLowerCase();\n  const at = (cls: ModelClass): FamilyClass => ({ class: cls, rank: versionScore(n) });\n\n  // Anthropic Claude\n  if (n.includes(\"opus\")) return at(ModelClass.ChatThinking);\n  if (n.includes(\"sonnet\")) return at(ModelClass.ChatBalanced);\n  if (n.includes(\"haiku\")) return at(ModelClass.ChatFast);\n\n  // OpenAI open-weights (check before the generic gpt branch)\n  if (n.includes(\"gpt-oss\")) {\n    return at(n.includes(\"120b\") ? ModelClass.ChatBalanced : ModelClass.ChatFast);\n  }\n  // OpenAI GPT family\n  if (n.includes(\"gpt\")) {\n    if (n.includes(\"pro\")) return at(ModelClass.ChatThinking);\n    if (n.includes(\"mini\") || n.includes(\"nano\")) return at(ModelClass.ChatFast);\n    return at(ModelClass.ChatBalanced);\n  }\n\n  // Google Gemini / Gemma\n  if (n.includes(\"gemini\")) {\n    if (n.includes(\"flash-lite\")) return at(ModelClass.ChatFast);\n    if (n.includes(\"pro\")) return at(ModelClass.ChatThinking);\n    return at(ModelClass.ChatBalanced);\n  }\n  if (n.includes(\"gemma\")) return at(ModelClass.ChatFast);\n\n  // Meta Llama\n  if (n.includes(\"llama\")) {\n    if (n.includes(\"maverick\") || n.includes(\"405b\")) return at(ModelClass.ChatThinking);\n    if (n.includes(\"70b\")) return at(ModelClass.ChatBalanced);\n    if (n.includes(\"8b\") || n.includes(\"1b\")) return at(ModelClass.ChatFast);\n    return at(ModelClass.ChatBalanced);\n  }\n\n  // Alibaba Qwen\n  if (n.includes(\"qwen\")) return at(ModelClass.ChatBalanced);\n\n  return null;\n}\n\n/** Linear-interpolated quantile of an ascending-sorted numeric array. */\nfunction quantile(sortedAsc: readonly number[], p: number): number {\n  if (sortedAsc.length === 0) return Number.NaN;\n  const idx = (sortedAsc.length - 1) * p;\n  const lo = Math.floor(idx);\n  const hi = Math.ceil(idx);\n  if (lo === hi) return sortedAsc[lo]!;\n  return sortedAsc[lo]! + (sortedAsc[hi]! - sortedAsc[lo]!) * (idx - lo);\n}\n\n/** Internal sortable wrapper carrying the ordering keys for a bucket entry. */\ninterface Ranked {\n  ep: ServingEndpointSummary;\n  /** Quality (scored) or family version (unscored) - higher first. */\n  sort: number;\n  /** Scored endpoints rank ahead of family-only guesses. */\n  scored: boolean;\n  tieCost: number;\n  tieSpeed: number;\n  /** Parsed name version, the final tie-breaker (newer sibling first). */\n  version: readonly number[];\n}\n\nfunction rankOrder(a: Ranked, b: Ranked): number {\n  if (a.scored !== b.scored) return a.scored ? -1 : 1;\n  if (b.sort !== a.sort) return b.sort - a.sort;\n  if (a.tieCost !== b.tieCost) return a.tieCost - b.tieCost;\n  if (b.tieSpeed !== a.tieSpeed) return b.tieSpeed - a.tieSpeed;\n  // Same scored-ness, quality, cost, and speed (e.g. several Claude\n  // Opus point releases): prefer the newer parsed version so\n  // `opus-4-8` beats `opus-4-7`.\n  return compareVersionDesc(a.version, b.version);\n}\n\n/**\n * Bucket live endpoints into {@link ModelClass}es, ranked best-first\n * within each chat band.\n *\n * Embedding endpoints (`task === \"llm/v1/embeddings\"`) go into\n * {@link ModelClass.Embedding} by task, in listing order (they carry no\n * capability score to rank on).\n *\n * Chat endpoints (`task === \"llm/v1/chat\"`) split into the three chat\n * bands. Scored endpoints (those carrying a `profile.quality`) drive\n * the banding: the observed quality distribution is split at its 1/3\n * and 2/3 quantiles, so the top third is {@link ModelClass.ChatThinking},\n * the bottom third {@link ModelClass.ChatFast}, and the middle\n * {@link ModelClass.ChatBalanced}. Because the thresholds come from the\n * data, the split adapts as Databricks adds or rescores models -\n * nothing is pinned to a fixed score band.\n *\n * Unscored chat endpoints are placed by {@link classifyByFamily} and\n * ranked after the scored ones in their band; unrecognized, unscored\n * endpoints (e.g. custom external models) are omitted entirely so they\n * are never picked as an automatic default.\n *\n * Within a chat band, scored models sort by `quality` desc, then `cost`\n * asc, then `speed` desc, then parsed name version desc; family-only\n * models sort by version rank then parsed version. The version\n * tie-break ({@link versionTuple}) is what separates point releases\n * that share a score profile (e.g. `opus-4-8` ahead of `opus-4-7`).\n */\nexport function classifyEndpoints(\n  endpoints: readonly ServingEndpointSummary[],\n): Record<ModelClass, ServingEndpointSummary[]> {\n  const chat = endpoints.filter((e) => e.task === CHAT_TASK);\n  const qualities = chat\n    .map((e) => e.profile?.quality)\n    .filter((q): q is number => Number.isFinite(q))\n    .sort((a, b) => a - b);\n  const low = quantile(qualities, 1 / 3);\n  const high = quantile(qualities, 2 / 3);\n\n  const buckets: Record<ModelClass, Ranked[]> = {\n    [ModelClass.ChatThinking]: [],\n    [ModelClass.ChatBalanced]: [],\n    [ModelClass.ChatFast]: [],\n    [ModelClass.Embedding]: [],\n  };\n\n  for (const ep of chat) {\n    const q = ep.profile?.quality;\n    if (Number.isFinite(q)) {\n      const quality = q as number;\n      const cls =\n        quality >= high\n          ? ModelClass.ChatThinking\n          : quality <= low\n            ? ModelClass.ChatFast\n            : ModelClass.ChatBalanced;\n      buckets[cls].push({\n        ep,\n        sort: quality,\n        scored: true,\n        tieCost: ep.profile?.cost ?? Number.POSITIVE_INFINITY,\n        tieSpeed: ep.profile?.speed ?? 0,\n        version: versionTuple(ep.name),\n      });\n      continue;\n    }\n    const family = classifyByFamily(ep.name);\n    if (!family) continue;\n    buckets[family.class].push({\n      ep,\n      sort: family.rank,\n      scored: false,\n      tieCost: Number.POSITIVE_INFINITY,\n      tieSpeed: 0,\n      version: versionTuple(ep.name),\n    });\n  }\n\n  // Embeddings are bucketed by task in listing order - no score to rank.\n  const embeddings = endpoints.filter((e) => e.task === EMBEDDING_TASK);\n\n  return {\n    [ModelClass.ChatThinking]: buckets[ModelClass.ChatThinking].sort(rankOrder).map((x) => x.ep),\n    [ModelClass.ChatBalanced]: buckets[ModelClass.ChatBalanced].sort(rankOrder).map((x) => x.ep),\n    [ModelClass.ChatFast]: buckets[ModelClass.ChatFast].sort(rankOrder).map((x) => x.ep),\n    [ModelClass.Embedding]: embeddings,\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classify.js","sourceRoot":"","sources":["../../src/classify.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Model-class classification for Databricks Model Serving endpoints.\n *\n * Chat capability bands are derived from the live workspace catalogue\n * rather than a hand-maintained table. Databricks publishes\n * per-endpoint `quality` / `speed` / `cost` scores (the AI Playground\n * bars) on the serving list; {@link classifyEndpoints} buckets scored\n * chat models into the chat {@link ModelClass} bands by the *relative*\n * distribution of those scores (quantiles, not fixed cut-offs) so a\n * brand-new model that lands outside today's score range still slots in\n * next to its peers. Embedding endpoints (`task === \"llm/v1/embeddings\"`)\n * are bucketed into {@link ModelClass.Embedding} by task, independent of\n * any score.\n *\n * Unscored-but-recognizable chat endpoints are still placed by a small\n * family heuristic ({@link classifyByFamily}) so a workspace whose\n * models predate Foundation Model API scoring keeps working. The\n * offline fallback floor - the hard-coded model list reached for when\n * the live catalogue can't be read at all - is a server concern and\n * lives in `@dbx-tools/model`, not here: a browser client never talks\n * to Databricks directly, so it has nothing to fall back to.\n *\n * Pure (no Node-only imports), so a client can classify a `/models`\n * response without server dependencies.\n *\n * @module\n */\n\nimport {\n  type EndpointCapabilities,\n  type FamilyClass,\n  ModelClass as ModelClassValues,\n  type ModelClass as ModelClassType,\n  type ServingEndpointSummary,\n} from \"@dbx-tools/shared-model/contracts\";\n\ntype ModelClass = ModelClassType;\nconst ModelClass = ModelClassValues;\n\n/** Task hint Databricks stamps on chat completion endpoints. */\nconst CHAT_TASK = \"llm/v1/chat\";\n\n/** Task hint Databricks stamps on embedding endpoints. */\nconst EMBEDDING_TASK = \"llm/v1/embeddings\";\n\n/**\n * Provider families verified against Databricks Responses/Open Responses with\n * both a forced function call and a stateless `function_call_output` replay.\n *\n * Databricks' endpoint list/OpenAPI currently exposes no tools capability bit.\n * Keep this conservative: an unknown chat family is not agent-safe until it is\n * verified. Gemini is excluded because it emits a call but Open Responses\n * cannot replay the required thought signature; GPT-OSS rejects Responses\n * passthrough entirely.\n */\nexport function supportsToolsByFamily(name: string): boolean {\n  const n = name.toLowerCase();\n  if (n.includes(\"gemini\") || n.includes(\"gpt-oss\")) return false;\n  return (\n    n.includes(\"claude\") ||\n    n.includes(\"gpt\") ||\n    n.includes(\"qwen\") ||\n    n.includes(\"glm\") ||\n    n.includes(\"llama\")\n  );\n}\n\n/**\n * Derive an endpoint's capabilities from its Databricks task hint and its\n * classified {@link ModelClass}, so consumers filter on capability instead of\n * re-deriving it from raw `task` / `class` strings.\n *\n * Either signal alone is enough: the task hint is authoritative when present,\n * and the class covers endpoints Databricks left untasked but the classifier\n * recognized. Embedding wins over chat when both point at it, since the two are\n * not interchangeable.\n */\nexport function endpointCapabilities(endpoint: ServingEndpointSummary): EndpointCapabilities {\n  const embedding = endpoint.task === EMBEDDING_TASK || endpoint.class === ModelClass.Embedding;\n  // Every non-embedding class is a chat band, so \"classified but not embedding\"\n  // is the class-side test for chat capability.\n  const chat = !embedding && (endpoint.task === CHAT_TASK || endpoint.class !== undefined);\n  const tools = chat && (endpoint.supportsTools ?? supportsToolsByFamily(endpoint.name));\n  return { chat, embedding, tools };\n}\n\n/**\n * Numeric `[major, minor, patch]` version parsed from an endpoint\n * name, used to order siblings within a family/tier. Starts at the\n * first digit in the name, then reads successive separator-delimited,\n * digit-prefixed chunks as the three components (missing ones default\n * to `0`):\n *\n *   - `databricks-claude-opus-4-8`   -> `[4, 8, 0]`\n *   - `databricks-claude-opus-4-10`  -> `[4, 10, 0]` (sorts above 4-8)\n *   - `databricks-meta-llama-3-3-70b`-> `[3, 3, 70]`\n *   - `databricks-bge-large-en`      -> `[0, 0, 0]` (no digits)\n *\n * Component-wise comparison (not a decimal collapse) so `4.10` beats\n * `4.8` - the bug a `major + minor/10` score would hit.\n */\nexport function versionTuple(name: string): [number, number, number] {\n  const start = name.search(/\\d/);\n  if (start < 0) return [0, 0, 0];\n  const nums = name\n    .slice(start)\n    .split(/[^a-z0-9]+/i)\n    .map((chunk) => chunk.match(/^\\d+/)?.[0])\n    .filter((digits): digits is string => digits !== undefined)\n    .map(Number);\n  return [nums[0] ?? 0, nums[1] ?? 0, nums[2] ?? 0];\n}\n\n/**\n * Compare version tuples component-wise with missing parts as 0.\n * Positive when `left` is newer.\n */\nexport function compareVersionTuples(left: readonly number[], right: readonly number[]): number {\n  const length = Math.max(left.length, right.length, 3);\n  for (let index = 0; index < length; index += 1) {\n    const diff = (left[index] ?? 0) - (right[index] ?? 0);\n    if (diff !== 0) return diff;\n  }\n  return 0;\n}\n\n/** Compare two version tuples so the higher version sorts first (descending). */\nfunction compareVersionDesc(a: readonly number[], b: readonly number[]): number {\n  return compareVersionTuples(b, a);\n}\n\n/**\n * Monotonic version key for ordering siblings within a family/tier\n * (e.g. `opus-4-8` over `opus-4-7`). Encodes the {@link versionTuple}\n * as a single number so callers that need a scalar rank (the family\n * heuristic, the static fallback ordering) keep working; the encoding\n * preserves component order without the decimal-collapse bug.\n */\nfunction versionScore(name: string): number {\n  const [major, minor, patch] = versionTuple(name);\n  return major * 1_000_000 + minor * 1_000 + patch;\n}\n\n/**\n * Best-effort chat capability band for an endpoint we have no live\n * score for, keyed off provider family and the well-known variant words\n * in the name (`opus`/`sonnet`/`haiku`, `pro`/`mini`/`nano`,\n * `flash`/`flash-lite`, Llama parameter sizes, etc). Returns `null` for\n * names we don't recognize so unknown custom endpoints are never\n * auto-selected as a default. The accompanying `rank` orders siblings\n * within a class. Only ever returns a chat band - embedding endpoints\n * are classified by task, not name.\n */\nexport function classifyByFamily(name: string): FamilyClass | null {\n  const n = name.toLowerCase();\n  const at = (cls: ModelClass): FamilyClass => ({ class: cls, rank: versionScore(n) });\n\n  // Anthropic Claude\n  if (n.includes(\"opus\")) return at(ModelClass.ChatThinking);\n  if (n.includes(\"sonnet\")) return at(ModelClass.ChatBalanced);\n  if (n.includes(\"haiku\")) return at(ModelClass.ChatFast);\n\n  // OpenAI open-weights (check before the generic gpt branch)\n  if (n.includes(\"gpt-oss\")) {\n    return at(n.includes(\"120b\") ? ModelClass.ChatBalanced : ModelClass.ChatFast);\n  }\n  // OpenAI GPT family\n  if (n.includes(\"gpt\")) {\n    if (n.includes(\"pro\")) return at(ModelClass.ChatThinking);\n    if (n.includes(\"mini\") || n.includes(\"nano\")) return at(ModelClass.ChatFast);\n    return at(ModelClass.ChatBalanced);\n  }\n\n  // Google Gemini / Gemma\n  if (n.includes(\"gemini\")) {\n    if (n.includes(\"flash-lite\")) return at(ModelClass.ChatFast);\n    if (n.includes(\"pro\")) return at(ModelClass.ChatThinking);\n    return at(ModelClass.ChatBalanced);\n  }\n  if (n.includes(\"gemma\")) return at(ModelClass.ChatFast);\n\n  // Meta Llama\n  if (n.includes(\"llama\")) {\n    if (n.includes(\"maverick\") || n.includes(\"405b\")) return at(ModelClass.ChatThinking);\n    if (n.includes(\"70b\")) return at(ModelClass.ChatBalanced);\n    if (n.includes(\"8b\") || n.includes(\"1b\")) return at(ModelClass.ChatFast);\n    return at(ModelClass.ChatBalanced);\n  }\n\n  // Alibaba Qwen\n  if (n.includes(\"qwen\")) return at(ModelClass.ChatBalanced);\n\n  return null;\n}\n\n/** Linear-interpolated quantile of an ascending-sorted numeric array. */\nfunction quantile(sortedAsc: readonly number[], p: number): number {\n  if (sortedAsc.length === 0) return Number.NaN;\n  const idx = (sortedAsc.length - 1) * p;\n  const lo = Math.floor(idx);\n  const hi = Math.ceil(idx);\n  if (lo === hi) return sortedAsc[lo]!;\n  return sortedAsc[lo]! + (sortedAsc[hi]! - sortedAsc[lo]!) * (idx - lo);\n}\n\n/** Internal sortable wrapper carrying the ordering keys for a bucket entry. */\ninterface Ranked {\n  ep: ServingEndpointSummary;\n  /** Quality (scored) or family version (unscored) - higher first. */\n  sort: number;\n  /** Scored endpoints rank ahead of family-only guesses. */\n  scored: boolean;\n  tieCost: number;\n  tieSpeed: number;\n  /** Parsed name version, the final tie-breaker (newer sibling first). */\n  version: readonly number[];\n}\n\nfunction rankOrder(a: Ranked, b: Ranked): number {\n  if (a.scored !== b.scored) return a.scored ? -1 : 1;\n  if (b.sort !== a.sort) return b.sort - a.sort;\n  if (a.tieCost !== b.tieCost) return a.tieCost - b.tieCost;\n  if (b.tieSpeed !== a.tieSpeed) return b.tieSpeed - a.tieSpeed;\n  // Same scored-ness, quality, cost, and speed (e.g. several Claude\n  // Opus point releases): prefer the newer parsed version so\n  // `opus-4-8` beats `opus-4-7`.\n  return compareVersionDesc(a.version, b.version);\n}\n\n/**\n * Bucket live endpoints into {@link ModelClass}es, ranked best-first\n * within each chat band.\n *\n * Embedding endpoints (`task === \"llm/v1/embeddings\"`) go into\n * {@link ModelClass.Embedding} by task, in listing order (they carry no\n * capability score to rank on).\n *\n * Chat endpoints (`task === \"llm/v1/chat\"`) split into the three chat\n * bands. Scored endpoints (those carrying a `profile.quality`) drive\n * the banding: the observed quality distribution is split at its 1/3\n * and 2/3 quantiles, so the top third is {@link ModelClass.ChatThinking},\n * the bottom third {@link ModelClass.ChatFast}, and the middle\n * {@link ModelClass.ChatBalanced}. Because the thresholds come from the\n * data, the split adapts as Databricks adds or rescores models -\n * nothing is pinned to a fixed score band.\n *\n * Unscored chat endpoints are placed by {@link classifyByFamily} and\n * ranked after the scored ones in their band; unrecognized, unscored\n * endpoints (e.g. custom external models) are omitted entirely so they\n * are never picked as an automatic default.\n *\n * Within a chat band, scored models sort by `quality` desc, then `cost`\n * asc, then `speed` desc, then parsed name version desc; family-only\n * models sort by version rank then parsed version. The version\n * tie-break ({@link versionTuple}) is what separates point releases\n * that share a score profile (e.g. `opus-4-8` ahead of `opus-4-7`).\n */\nexport function classifyEndpoints(\n  endpoints: readonly ServingEndpointSummary[],\n): Record<ModelClass, ServingEndpointSummary[]> {\n  const chat = endpoints.filter((e) => e.task === CHAT_TASK);\n  const qualities = chat\n    .map((e) => e.profile?.quality)\n    .filter((q): q is number => Number.isFinite(q))\n    .sort((a, b) => a - b);\n  const low = quantile(qualities, 1 / 3);\n  const high = quantile(qualities, 2 / 3);\n\n  const buckets: Record<ModelClass, Ranked[]> = {\n    [ModelClass.ChatThinking]: [],\n    [ModelClass.ChatBalanced]: [],\n    [ModelClass.ChatFast]: [],\n    [ModelClass.Embedding]: [],\n  };\n\n  for (const ep of chat) {\n    const q = ep.profile?.quality;\n    if (Number.isFinite(q)) {\n      const quality = q as number;\n      const cls =\n        quality >= high\n          ? ModelClass.ChatThinking\n          : quality <= low\n            ? ModelClass.ChatFast\n            : ModelClass.ChatBalanced;\n      buckets[cls].push({\n        ep,\n        sort: quality,\n        scored: true,\n        tieCost: ep.profile?.cost ?? Number.POSITIVE_INFINITY,\n        tieSpeed: ep.profile?.speed ?? 0,\n        version: versionTuple(ep.name),\n      });\n      continue;\n    }\n    const family = classifyByFamily(ep.name);\n    if (!family) continue;\n    buckets[family.class].push({\n      ep,\n      sort: family.rank,\n      scored: false,\n      tieCost: Number.POSITIVE_INFINITY,\n      tieSpeed: 0,\n      version: versionTuple(ep.name),\n    });\n  }\n\n  // Embeddings are bucketed by task in listing order - no score to rank.\n  const embeddings = endpoints.filter((e) => e.task === EMBEDDING_TASK);\n\n  return {\n    [ModelClass.ChatThinking]: buckets[ModelClass.ChatThinking].sort(rankOrder).map((x) => x.ep),\n    [ModelClass.ChatBalanced]: buckets[ModelClass.ChatBalanced].sort(rankOrder).map((x) => x.ep),\n    [ModelClass.ChatFast]: buckets[ModelClass.ChatFast].sort(rankOrder).map((x) => x.ep),\n    [ModelClass.Embedding]: embeddings,\n  };\n}\n"]}

package/lib/src/metadata-cache.js

@@ -18,16 +18,13 @@ import * as environmentUtils from "@dbx-tools/shared-core/environment-utils";
 import * as log from "@dbx-tools/shared-core/log";
 import cacache from "cacache";
 import envPaths from "env-paths";
+import packageManifest from "../package.json" with { type: "json" };
 import { MODEL_METADATA_TTL_MS } from "./_metadata-contract.js";
 const logger = log.logger("model/metadata-cache");
-let packageIdentityPromise;
-function packageIdentity() {
-    packageIdentityPromise ??= import("../index.js").then((mod) => ({
-        identifier: mod.PACKAGE_IDENTIFIER,
-        version: mod.PACKAGE_VERSION,
-    }));
-    return packageIdentityPromise;
-}
+const PACKAGE_IDENTITY = {
+    identifier: packageManifest.name,
+    version: packageManifest.version,
+};
 const inflight = new Map();
 /** Default cacache root for a package version under the dbx-tools cache dir. */
 export function defaultMetadataCacheDir(version) {
@@ -164,7 +161,7 @@ export function createMetadataCache(options) {
 async function resolveCacheDir(options) {
     if (options.cacheDir)
         return options.cacheDir;
-    const version = options.version ?? (await packageIdentity()).version;
+    const version = options.version ?? PACKAGE_IDENTITY.version;
     return defaultMetadataCacheDir(version);
 }
 /** Prefer a non-empty fresh array, else previous, else fallback. */
@@ -231,4 +228,4 @@ function isCacheMiss(error) {
         "code" in error &&
         error.code === "ENOENT");
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"metadata-cache.js","sourceRoot":"","sources":["../../src/metadata-cache.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Agnostic daily metadata cache on {@link https://www.npmjs.com/package/cacache | cacache}.\n *\n * Uses cacache's built-in memory memoization (`memoize: true` on put; gets read\n * the in-memory layer by default) with content-addressed disk under\n * `env-paths(\"dbx-tools\").cache/model-gateway/<version>/`. Disk persistence is\n * disabled inside a Databricks App ({@link environmentUtils.isDatabricksAppEnv});\n * those processes keep a process-local Map only.\n *\n * Each cache owns a key, hard-coded fallback, optional network loader, and a\n * merger that combines fresh / previous / fallback values. Freshness is the\n * envelope `refreshedAt` window (default one day), not cacache's short LRU TTL.\n *\n * @module\n */\n\nimport { resolve } from \"node:path\";\n\nimport * as environmentUtils from \"@dbx-tools/shared-core/environment-utils\";\nimport * as log from \"@dbx-tools/shared-core/log\";\nimport cacache from \"cacache\";\nimport envPaths from \"env-paths\";\n\nimport { MODEL_METADATA_TTL_MS } from \"./_metadata-contract.ts\";\n\nconst logger = log.logger(\"model/metadata-cache\");\n\ninterface PackageIdentity {\n  readonly identifier: string;\n  readonly version: string;\n}\n\nlet packageIdentityPromise: Promise<PackageIdentity> | undefined;\n\nfunction packageIdentity(): Promise<PackageIdentity> {\n  packageIdentityPromise ??= import(\"../index.ts\").then((mod) => ({\n    identifier: mod.PACKAGE_IDENTIFIER,\n    version: mod.PACKAGE_VERSION,\n  }));\n  return packageIdentityPromise;\n}\n\n/** Envelope stored as JSON bytes in cacache for every key. */\nexport interface MetadataCacheRecord<T> {\n  readonly refreshedAt: number;\n  readonly value: T;\n}\n\n/** Factory inputs for one named metadata cache. */\nexport interface MetadataCacheOptions<T> {\n  /** Stable cacache key. */\n  readonly key: string;\n  /** Hard-coded / committed baseline used when store and load both miss. */\n  readonly fallback: T;\n  /**\n   * Refresh source. When omitted the cache only serves store + fallback and\n   * {@link MetadataCache.update} mutations (for example error-learned values).\n   */\n  readonly load?: () => Promise<T>;\n  /** Combine a fresh load, prior store value, and the hard-coded fallback. */\n  readonly merge: (input: MetadataCacheMergeInput<T>) => T;\n  /** Freshness window; defaults to {@link MODEL_METADATA_TTL_MS} (one day). */\n  readonly ttlMs?: number;\n  /** Package version segment in the cache path. Defaults to this package. */\n  readonly version?: string;\n  /** Override the cacache root directory (tests). */\n  readonly cacheDir?: string;\n  /**\n   * Force disk on/off. Defaults to off inside Databricks Apps, on otherwise.\n   */\n  readonly disk?: boolean;\n  /** Clock override for tests. */\n  readonly now?: () => number;\n}\n\n/** Arguments passed to a cache merger. */\nexport interface MetadataCacheMergeInput<T> {\n  readonly fresh: T | undefined;\n  readonly previous: T | undefined;\n  readonly fallback: T;\n}\n\n/** One versioned metadata cache (cacache memory + optional disk). */\nexport interface MetadataCache<T> {\n  /** Absolute cacache root for this package version (unused when disk is off). */\n  readonly path: string;\n  /** Whether cacache disk persistence is enabled for this instance. */\n  readonly diskEnabled: boolean;\n  /** Return a fresh-or-fallback value, refreshing when stale. */\n  get(): Promise<T>;\n  /** Read memory / disk without refreshing. */\n  peek(): Promise<T | undefined>;\n  /** Mutate the cached value and persist it. */\n  update(mutator: (current: T) => T): Promise<T>;\n  /** Force a refresh attempt even when the entry is still fresh. */\n  refresh(): Promise<T>;\n}\n\nconst inflight = new Map<string, Promise<unknown>>();\n\n/** Default cacache root for a package version under the dbx-tools cache dir. */\nexport function defaultMetadataCacheDir(version: string): string {\n  const cacheDirectory = envPaths(\"dbx-tools\", { suffix: \"\" }).cache;\n  return resolve(cacheDirectory, \"model-gateway\", version);\n}\n\n/** Whether metadata caches should persist to disk in this process. */\nexport function metadataCacheDiskEnabled(environment: NodeJS.ProcessEnv = process.env): boolean {\n  return !environmentUtils.isDatabricksAppEnv(environment);\n}\n\n/**\n * Create one daily cache backed by cacache memoization, with optional disk.\n */\nexport function createMetadataCache<T>(options: MetadataCacheOptions<T>): MetadataCache<T> {\n  const ttlMs = options.ttlMs ?? MODEL_METADATA_TTL_MS;\n  const diskEnabled = options.disk ?? metadataCacheDiskEnabled();\n  const now = options.now ?? Date.now;\n  const pathPromise = resolveCacheDir(options);\n  let path = options.cacheDir;\n\n  const flightKey = (cachePath: string, suffix = \"\"): string =>\n    `${cachePath}::${options.key}${suffix}`;\n\n  /** Process-local store used when disk is off (Databricks Apps). */\n  const memoryOnly = new Map<string, MetadataCacheRecord<T>>();\n\n  const resolveValue = (input: MetadataCacheMergeInput<T>): T => options.merge(input);\n\n  const isFresh = (record: MetadataCacheRecord<T> | undefined): boolean =>\n    Boolean(record && now() - record.refreshedAt < ttlMs);\n\n  const cachePath = async (): Promise<string> => {\n    path ??= await pathPromise;\n    return path;\n  };\n\n  const readRecord = async (): Promise<MetadataCacheRecord<T> | undefined> => {\n    if (!diskEnabled) return memoryOnly.get(options.key);\n    const resolvedPath = await cachePath();\n    try {\n      // cacache reads its in-memory memo first unless memoize is false\n      const entry = await cacache.get(resolvedPath, options.key);\n      return decodeRecord<T>(entry.data);\n    } catch (error) {\n      if (isCacheMiss(error)) return undefined;\n      logger.warn(\"metadata cache cacache read failed\", {\n        key: options.key,\n        path: resolvedPath,\n        error,\n      });\n      return undefined;\n    }\n  };\n\n  const writeRecord = async (record: MetadataCacheRecord<T>): Promise<void> => {\n    if (!diskEnabled) {\n      memoryOnly.set(options.key, record);\n      return;\n    }\n    const resolvedPath = await cachePath();\n    try {\n      await cacache.put(resolvedPath, options.key, `${JSON.stringify(record)}\\n`, {\n        memoize: true,\n        metadata: { refreshedAt: record.refreshedAt },\n      });\n    } catch (error) {\n      logger.warn(\"metadata cache cacache write failed\", {\n        key: options.key,\n        path: resolvedPath,\n        error,\n      });\n    }\n  };\n\n  const persist = async (value: T, refreshedAt = now()): Promise<T> => {\n    await writeRecord({ refreshedAt, value });\n    return value;\n  };\n\n  const refresh = async (force: boolean): Promise<T> => {\n    const resolvedPath = await cachePath();\n    return coalesce(flightKey(resolvedPath), async () => {\n      const previous = await readRecord();\n      if (!force && isFresh(previous)) {\n        return resolveValue({\n          fresh: undefined,\n          previous: previous?.value,\n          fallback: options.fallback,\n        });\n      }\n\n      let fresh: T | undefined;\n      if (options.load) {\n        try {\n          fresh = await options.load();\n        } catch (error) {\n          logger.warn(\"metadata cache refresh failed; keeping last known good\", {\n            key: options.key,\n            error,\n            path: resolvedPath,\n            diskEnabled,\n          });\n        }\n      }\n\n      const value = resolveValue({\n        fresh,\n        previous: previous?.value,\n        fallback: options.fallback,\n      });\n      if (fresh !== undefined || !previous) {\n        await persist(value);\n      }\n      return value;\n    });\n  };\n\n  return {\n    get path() {\n      if (!path) {\n        throw new Error(\"metadata cache path is not resolved until the first cache read\");\n      }\n      return path;\n    },\n    diskEnabled,\n    get: () => refresh(false),\n    peek: async () => (await readRecord())?.value,\n    refresh: () => refresh(true),\n    update: async (mutator) => {\n      const resolvedPath = await cachePath();\n      return coalesce(flightKey(resolvedPath, \":update\"), async () => {\n        const previous = await readRecord();\n        const baseline = resolveValue({\n          fresh: undefined,\n          previous: previous?.value,\n          fallback: options.fallback,\n        });\n        return persist(mutator(baseline));\n      });\n    },\n  };\n}\n\nasync function resolveCacheDir(options: {\n  readonly cacheDir?: string;\n  readonly version?: string;\n}): Promise<string> {\n  if (options.cacheDir) return options.cacheDir;\n  const version = options.version ?? (await packageIdentity()).version;\n  return defaultMetadataCacheDir(version);\n}\n\n/** Prefer a non-empty fresh array, else previous, else fallback. */\nexport function mergePreferFreshList<T>(input: MetadataCacheMergeInput<readonly T[]>): T[] {\n  if (input.fresh && input.fresh.length > 0) return [...input.fresh];\n  if (input.previous && input.previous.length > 0) return [...input.previous];\n  return [...input.fallback];\n}\n\n/**\n * Shallow-merge record catalogues: fallback, then previous, then fresh keys.\n * Fresh values win per key.\n */\nexport function mergePreferFreshRecord<T>(\n  input: MetadataCacheMergeInput<Readonly<Record<string, T>>>,\n): Record<string, T> {\n  return {\n    ...input.fallback,\n    ...(input.previous ?? {}),\n    ...(input.fresh ?? {}),\n  };\n}\n\n/** Test helper: wipe a cacache root and clear cacache memoization. */\nexport async function resetMetadataCacheDir(cacheDir: string): Promise<void> {\n  try {\n    await cacache.rm.all(cacheDir);\n  } catch {\n    // empty / missing cache is fine\n  }\n  cacache.clearMemoized();\n  for (const key of [...inflight.keys()]) {\n    if (key.startsWith(`${cacheDir}::`)) inflight.delete(key);\n  }\n}\n\nfunction coalesce<T>(key: string, work: () => Promise<T>): Promise<T> {\n  const existing = inflight.get(key);\n  if (existing) return existing as Promise<T>;\n  const pending = work().finally(() => {\n    if (inflight.get(key) === pending) inflight.delete(key);\n  });\n  inflight.set(key, pending);\n  return pending;\n}\n\nfunction decodeRecord<T>(data: Buffer): MetadataCacheRecord<T> | undefined {\n  try {\n    const parsed = JSON.parse(data.toString(\"utf8\")) as unknown;\n    if (\n      !parsed ||\n      typeof parsed !== \"object\" ||\n      typeof (parsed as MetadataCacheRecord<T>).refreshedAt !== \"number\"\n    ) {\n      return undefined;\n    }\n    return parsed as MetadataCacheRecord<T>;\n  } catch {\n    return undefined;\n  }\n}\n\nfunction isCacheMiss(error: unknown): boolean {\n  return Boolean(\n    error &&\n    typeof error === \"object\" &&\n    \"code\" in error &&\n    (error as { code?: string }).code === \"ENOENT\",\n  );\n}\n\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"metadata-cache.js","sourceRoot":"","sources":["../../src/metadata-cache.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,OAAO,KAAK,gBAAgB,MAAM,0CAA0C,CAAC;AAC7E,OAAO,KAAK,GAAG,MAAM,4BAA4B,CAAC;AAClD,OAAO,OAAO,MAAM,SAAS,CAAC;AAC9B,OAAO,QAAQ,MAAM,WAAW,CAAC;AAEjC,OAAO,eAAe,MAAM,iBAAiB,CAAC,OAAO,IAAI,EAAE,MAAM,EAAE,CAAC;AACpE,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAEhE,MAAM,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,sBAAsB,CAAC,CAAC;AAOlD,MAAM,gBAAgB,GAAoB;IACxC,UAAU,EAAE,eAAe,CAAC,IAAI;IAChC,OAAO,EAAE,eAAe,CAAC,OAAO;CACjC,CAAC;AA0DF,MAAM,QAAQ,GAAG,IAAI,GAAG,EAA4B,CAAC;AAErD,gFAAgF;AAChF,MAAM,UAAU,uBAAuB,CAAC,OAAe;IACrD,MAAM,cAAc,GAAG,QAAQ,CAAC,WAAW,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC;IACnE,OAAO,OAAO,CAAC,cAAc,EAAE,eAAe,EAAE,OAAO,CAAC,CAAC;AAC3D,CAAC;AAED,sEAAsE;AACtE,MAAM,UAAU,wBAAwB,CAAC,cAAiC,OAAO,CAAC,GAAG;IACnF,OAAO,CAAC,gBAAgB,CAAC,kBAAkB,CAAC,WAAW,CAAC,CAAC;AAC3D,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,mBAAmB,CAAI,OAAgC;IACrE,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,IAAI,qBAAqB,CAAC;IACrD,MAAM,WAAW,GAAG,OAAO,CAAC,IAAI,IAAI,wBAAwB,EAAE,CAAC;IAC/D,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,IAAI,IAAI,CAAC,GAAG,CAAC;IACpC,MAAM,WAAW,GAAG,eAAe,CAAC,OAAO,CAAC,CAAC;IAC7C,IAAI,IAAI,GAAG,OAAO,CAAC,QAAQ,CAAC;IAE5B,MAAM,SAAS,GAAG,CAAC,SAAiB,EAAE,MAAM,GAAG,EAAE,EAAU,EAAE,CAC3D,GAAG,SAAS,KAAK,OAAO,CAAC,GAAG,GAAG,MAAM,EAAE,CAAC;IAE1C,mEAAmE;IACnE,MAAM,UAAU,GAAG,IAAI,GAAG,EAAkC,CAAC;IAE7D,MAAM,YAAY,GAAG,CAAC,KAAiC,EAAK,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAEpF,MAAM,OAAO,GAAG,CAAC,MAA0C,EAAW,EAAE,CACtE,OAAO,CAAC,MAAM,IAAI,GAAG,EAAE,GAAG,MAAM,CAAC,WAAW,GAAG,KAAK,CAAC,CAAC;IAExD,MAAM,SAAS,GAAG,KAAK,IAAqB,EAAE;QAC5C,IAAI,KAAK,MAAM,WAAW,CAAC;QAC3B,OAAO,IAAI,CAAC;IACd,CAAC,CAAC;IAEF,MAAM,UAAU,GAAG,KAAK,IAAiD,EAAE;QACzE,IAAI,CAAC,WAAW;YAAE,OAAO,UAAU,CAAC,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QACrD,MAAM,YAAY,GAAG,MAAM,SAAS,EAAE,CAAC;QACvC,IAAI,CAAC;YACH,iEAAiE;YACjE,MAAM,KAAK,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,YAAY,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC;YAC3D,OAAO,YAAY,CAAI,KAAK,CAAC,IAAI,CAAC,CAAC;QACrC,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,WAAW,CAAC,KAAK,CAAC;gBAAE,OAAO,SAAS,CAAC;YACzC,MAAM,CAAC,IAAI,CAAC,oCAAoC,EAAE;gBAChD,GAAG,EAAE,OAAO,CAAC,GAAG;gBAChB,IAAI,EAAE,YAAY;gBAClB,KAAK;aACN,CAAC,CAAC;YACH,OAAO,SAAS,CAAC;QACnB,CAAC;IACH,CAAC,CAAC;IAEF,MAAM,WAAW,GAAG,KAAK,EAAE,MAA8B,EAAiB,EAAE;QAC1E,IAAI,CAAC,WAAW,EAAE,CAAC;YACjB,UAAU,CAAC,GAAG,CAAC,OAAO,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;YACpC,OAAO;QACT,CAAC;QACD,MAAM,YAAY,GAAG,MAAM,SAAS,EAAE,CAAC;QACvC,IAAI,CAAC;YACH,MAAM,OAAO,CAAC,GAAG,CAAC,YAAY,EAAE,OAAO,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,EAAE;gBAC1E,OAAO,EAAE,IAAI;gBACb,QAAQ,EAAE,EAAE,WAAW,EAAE,MAAM,CAAC,WAAW,EAAE;aAC9C,CAAC,CAAC;QACL,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,CAAC,IAAI,CAAC,qCAAqC,EAAE;gBACjD,GAAG,EAAE,OAAO,CAAC,GAAG;gBAChB,IAAI,EAAE,YAAY;gBAClB,KAAK;aACN,CAAC,CAAC;QACL,CAAC;IACH,CAAC,CAAC;IAEF,MAAM,OAAO,GAAG,KAAK,EAAE,KAAQ,EAAE,WAAW,GAAG,GAAG,EAAE,EAAc,EAAE;QAClE,MAAM,WAAW,CAAC,EAAE,WAAW,EAAE,KAAK,EAAE,CAAC,CAAC;QAC1C,OAAO,KAAK,CAAC;IACf,CAAC,CAAC;IAEF,MAAM,OAAO,GAAG,KAAK,EAAE,KAAc,EAAc,EAAE;QACnD,MAAM,YAAY,GAAG,MAAM,SAAS,EAAE,CAAC;QACvC,OAAO,QAAQ,CAAC,SAAS,CAAC,YAAY,CAAC,EAAE,KAAK,IAAI,EAAE;YAClD,MAAM,QAAQ,GAAG,MAAM,UAAU,EAAE,CAAC;YACpC,IAAI,CAAC,KAAK,IAAI,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC;gBAChC,OAAO,YAAY,CAAC;oBAClB,KAAK,EAAE,SAAS;oBAChB,QAAQ,EAAE,QAAQ,EAAE,KAAK;oBACzB,QAAQ,EAAE,OAAO,CAAC,QAAQ;iBAC3B,CAAC,CAAC;YACL,CAAC;YAED,IAAI,KAAoB,CAAC;YACzB,IAAI,OAAO,CAAC,IAAI,EAAE,CAAC;gBACjB,IAAI,CAAC;oBACH,KAAK,GAAG,MAAM,OAAO,CAAC,IAAI,EAAE,CAAC;gBAC/B,CAAC;gBAAC,OAAO,KAAK,EAAE,CAAC;oBACf,MAAM,CAAC,IAAI,CAAC,wDAAwD,EAAE;wBACpE,GAAG,EAAE,OAAO,CAAC,GAAG;wBAChB,KAAK;wBACL,IAAI,EAAE,YAAY;wBAClB,WAAW;qBACZ,CAAC,CAAC;gBACL,CAAC;YACH,CAAC;YAED,MAAM,KAAK,GAAG,YAAY,CAAC;gBACzB,KAAK;gBACL,QAAQ,EAAE,QAAQ,EAAE,KAAK;gBACzB,QAAQ,EAAE,OAAO,CAAC,QAAQ;aAC3B,CAAC,CAAC;YACH,IAAI,KAAK,KAAK,SAAS,IAAI,CAAC,QAAQ,EAAE,CAAC;gBACrC,MAAM,OAAO,CAAC,KAAK,CAAC,CAAC;YACvB,CAAC;YACD,OAAO,KAAK,CAAC;QACf,CAAC,CAAC,CAAC;IACL,CAAC,CAAC;IAEF,OAAO;QACL,IAAI,IAAI;YACN,IAAI,CAAC,IAAI,EAAE,CAAC;gBACV,MAAM,IAAI,KAAK,CAAC,gEAAgE,CAAC,CAAC;YACpF,CAAC;YACD,OAAO,IAAI,CAAC;QACd,CAAC;QACD,WAAW;QACX,GAAG,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC;QACzB,IAAI,EAAE,KAAK,IAAI,EAAE,CAAC,CAAC,MAAM,UAAU,EAAE,CAAC,EAAE,KAAK;QAC7C,OAAO,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC;QAC5B,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,EAAE;YACxB,MAAM,YAAY,GAAG,MAAM,SAAS,EAAE,CAAC;YACvC,OAAO,QAAQ,CAAC,SAAS,CAAC,YAAY,EAAE,SAAS,CAAC,EAAE,KAAK,IAAI,EAAE;gBAC7D,MAAM,QAAQ,GAAG,MAAM,UAAU,EAAE,CAAC;gBACpC,MAAM,QAAQ,GAAG,YAAY,CAAC;oBAC5B,KAAK,EAAE,SAAS;oBAChB,QAAQ,EAAE,QAAQ,EAAE,KAAK;oBACzB,QAAQ,EAAE,OAAO,CAAC,QAAQ;iBAC3B,CAAC,CAAC;gBACH,OAAO,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC;YACpC,CAAC,CAAC,CAAC;QACL,CAAC;KACF,CAAC;AACJ,CAAC;AAED,KAAK,UAAU,eAAe,CAAC,OAG9B;IACC,IAAI,OAAO,CAAC,QAAQ;QAAE,OAAO,OAAO,CAAC,QAAQ,CAAC;IAC9C,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,IAAI,gBAAgB,CAAC,OAAO,CAAC;IAC5D,OAAO,uBAAuB,CAAC,OAAO,CAAC,CAAC;AAC1C,CAAC;AAED,oEAAoE;AACpE,MAAM,UAAU,oBAAoB,CAAI,KAA4C;IAClF,IAAI,KAAK,CAAC,KAAK,IAAI,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC;QAAE,OAAO,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC;IACnE,IAAI,KAAK,CAAC,QAAQ,IAAI,KAAK,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC;QAAE,OAAO,CAAC,GAAG,KAAK,CAAC,QAAQ,CAAC,CAAC;IAC5E,OAAO,CAAC,GAAG,KAAK,CAAC,QAAQ,CAAC,CAAC;AAC7B,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,sBAAsB,CACpC,KAA2D;IAE3D,OAAO;QACL,GAAG,KAAK,CAAC,QAAQ;QACjB,GAAG,CAAC,KAAK,CAAC,QAAQ,IAAI,EAAE,CAAC;QACzB,GAAG,CAAC,KAAK,CAAC,KAAK,IAAI,EAAE,CAAC;KACvB,CAAC;AACJ,CAAC;AAED,sEAAsE;AACtE,MAAM,CAAC,KAAK,UAAU,qBAAqB,CAAC,QAAgB;IAC1D,IAAI,CAAC;QACH,MAAM,OAAO,CAAC,EAAE,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IACjC,CAAC;IAAC,MAAM,CAAC;QACP,gCAAgC;IAClC,CAAC;IACD,OAAO,CAAC,aAAa,EAAE,CAAC;IACxB,KAAK,MAAM,GAAG,IAAI,CAAC,GAAG,QAAQ,CAAC,IAAI,EAAE,CAAC,EAAE,CAAC;QACvC,IAAI,GAAG,CAAC,UAAU,CAAC,GAAG,QAAQ,IAAI,CAAC;YAAE,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;IAC5D,CAAC;AACH,CAAC;AAED,SAAS,QAAQ,CAAI,GAAW,EAAE,IAAsB;IACtD,MAAM,QAAQ,GAAG,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACnC,IAAI,QAAQ;QAAE,OAAO,QAAsB,CAAC;IAC5C,MAAM,OAAO,GAAG,IAAI,EAAE,CAAC,OAAO,CAAC,GAAG,EAAE;QAClC,IAAI,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,KAAK,OAAO;YAAE,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;IAC1D,CAAC,CAAC,CAAC;IACH,QAAQ,CAAC,GAAG,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;IAC3B,OAAO,OAAO,CAAC;AACjB,CAAC;AAED,SAAS,YAAY,CAAI,IAAY;IACnC,IAAI,CAAC;QACH,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAY,CAAC;QAC5D,IACE,CAAC,MAAM;YACP,OAAO,MAAM,KAAK,QAAQ;YAC1B,OAAQ,MAAiC,CAAC,WAAW,KAAK,QAAQ,EAClE,CAAC;YACD,OAAO,SAAS,CAAC;QACnB,CAAC;QACD,OAAO,MAAgC,CAAC;IAC1C,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,SAAS,CAAC;IACnB,CAAC;AACH,CAAC;AAED,SAAS,WAAW,CAAC,KAAc;IACjC,OAAO,OAAO,CACZ,KAAK;QACL,OAAO,KAAK,KAAK,QAAQ;QACzB,MAAM,IAAI,KAAK;QACd,KAA2B,CAAC,IAAI,KAAK,QAAQ,CAC/C,CAAC;AACJ,CAAC","sourcesContent":["/**\n * Agnostic daily metadata cache on {@link https://www.npmjs.com/package/cacache | cacache}.\n *\n * Uses cacache's built-in memory memoization (`memoize: true` on put; gets read\n * the in-memory layer by default) with content-addressed disk under\n * `env-paths(\"dbx-tools\").cache/model-gateway/<version>/`. Disk persistence is\n * disabled inside a Databricks App ({@link environmentUtils.isDatabricksAppEnv});\n * those processes keep a process-local Map only.\n *\n * Each cache owns a key, hard-coded fallback, optional network loader, and a\n * merger that combines fresh / previous / fallback values. Freshness is the\n * envelope `refreshedAt` window (default one day), not cacache's short LRU TTL.\n *\n * @module\n */\n\nimport { resolve } from \"node:path\";\n\nimport * as environmentUtils from \"@dbx-tools/shared-core/environment-utils\";\nimport * as log from \"@dbx-tools/shared-core/log\";\nimport cacache from \"cacache\";\nimport envPaths from \"env-paths\";\n\nimport packageManifest from \"../package.json\" with { type: \"json\" };\nimport { MODEL_METADATA_TTL_MS } from \"./_metadata-contract.ts\";\n\nconst logger = log.logger(\"model/metadata-cache\");\n\ninterface PackageIdentity {\n  readonly identifier: string;\n  readonly version: string;\n}\n\nconst PACKAGE_IDENTITY: PackageIdentity = {\n  identifier: packageManifest.name,\n  version: packageManifest.version,\n};\n\n/** Envelope stored as JSON bytes in cacache for every key. */\nexport interface MetadataCacheRecord<T> {\n  readonly refreshedAt: number;\n  readonly value: T;\n}\n\n/** Factory inputs for one named metadata cache. */\nexport interface MetadataCacheOptions<T> {\n  /** Stable cacache key. */\n  readonly key: string;\n  /** Hard-coded / committed baseline used when store and load both miss. */\n  readonly fallback: T;\n  /**\n   * Refresh source. When omitted the cache only serves store + fallback and\n   * {@link MetadataCache.update} mutations (for example error-learned values).\n   */\n  readonly load?: () => Promise<T>;\n  /** Combine a fresh load, prior store value, and the hard-coded fallback. */\n  readonly merge: (input: MetadataCacheMergeInput<T>) => T;\n  /** Freshness window; defaults to {@link MODEL_METADATA_TTL_MS} (one day). */\n  readonly ttlMs?: number;\n  /** Package version segment in the cache path. Defaults to this package. */\n  readonly version?: string;\n  /** Override the cacache root directory (tests). */\n  readonly cacheDir?: string;\n  /**\n   * Force disk on/off. Defaults to off inside Databricks Apps, on otherwise.\n   */\n  readonly disk?: boolean;\n  /** Clock override for tests. */\n  readonly now?: () => number;\n}\n\n/** Arguments passed to a cache merger. */\nexport interface MetadataCacheMergeInput<T> {\n  readonly fresh: T | undefined;\n  readonly previous: T | undefined;\n  readonly fallback: T;\n}\n\n/** One versioned metadata cache (cacache memory + optional disk). */\nexport interface MetadataCache<T> {\n  /** Absolute cacache root for this package version (unused when disk is off). */\n  readonly path: string;\n  /** Whether cacache disk persistence is enabled for this instance. */\n  readonly diskEnabled: boolean;\n  /** Return a fresh-or-fallback value, refreshing when stale. */\n  get(): Promise<T>;\n  /** Read memory / disk without refreshing. */\n  peek(): Promise<T | undefined>;\n  /** Mutate the cached value and persist it. */\n  update(mutator: (current: T) => T): Promise<T>;\n  /** Force a refresh attempt even when the entry is still fresh. */\n  refresh(): Promise<T>;\n}\n\nconst inflight = new Map<string, Promise<unknown>>();\n\n/** Default cacache root for a package version under the dbx-tools cache dir. */\nexport function defaultMetadataCacheDir(version: string): string {\n  const cacheDirectory = envPaths(\"dbx-tools\", { suffix: \"\" }).cache;\n  return resolve(cacheDirectory, \"model-gateway\", version);\n}\n\n/** Whether metadata caches should persist to disk in this process. */\nexport function metadataCacheDiskEnabled(environment: NodeJS.ProcessEnv = process.env): boolean {\n  return !environmentUtils.isDatabricksAppEnv(environment);\n}\n\n/**\n * Create one daily cache backed by cacache memoization, with optional disk.\n */\nexport function createMetadataCache<T>(options: MetadataCacheOptions<T>): MetadataCache<T> {\n  const ttlMs = options.ttlMs ?? MODEL_METADATA_TTL_MS;\n  const diskEnabled = options.disk ?? metadataCacheDiskEnabled();\n  const now = options.now ?? Date.now;\n  const pathPromise = resolveCacheDir(options);\n  let path = options.cacheDir;\n\n  const flightKey = (cachePath: string, suffix = \"\"): string =>\n    `${cachePath}::${options.key}${suffix}`;\n\n  /** Process-local store used when disk is off (Databricks Apps). */\n  const memoryOnly = new Map<string, MetadataCacheRecord<T>>();\n\n  const resolveValue = (input: MetadataCacheMergeInput<T>): T => options.merge(input);\n\n  const isFresh = (record: MetadataCacheRecord<T> | undefined): boolean =>\n    Boolean(record && now() - record.refreshedAt < ttlMs);\n\n  const cachePath = async (): Promise<string> => {\n    path ??= await pathPromise;\n    return path;\n  };\n\n  const readRecord = async (): Promise<MetadataCacheRecord<T> | undefined> => {\n    if (!diskEnabled) return memoryOnly.get(options.key);\n    const resolvedPath = await cachePath();\n    try {\n      // cacache reads its in-memory memo first unless memoize is false\n      const entry = await cacache.get(resolvedPath, options.key);\n      return decodeRecord<T>(entry.data);\n    } catch (error) {\n      if (isCacheMiss(error)) return undefined;\n      logger.warn(\"metadata cache cacache read failed\", {\n        key: options.key,\n        path: resolvedPath,\n        error,\n      });\n      return undefined;\n    }\n  };\n\n  const writeRecord = async (record: MetadataCacheRecord<T>): Promise<void> => {\n    if (!diskEnabled) {\n      memoryOnly.set(options.key, record);\n      return;\n    }\n    const resolvedPath = await cachePath();\n    try {\n      await cacache.put(resolvedPath, options.key, `${JSON.stringify(record)}\\n`, {\n        memoize: true,\n        metadata: { refreshedAt: record.refreshedAt },\n      });\n    } catch (error) {\n      logger.warn(\"metadata cache cacache write failed\", {\n        key: options.key,\n        path: resolvedPath,\n        error,\n      });\n    }\n  };\n\n  const persist = async (value: T, refreshedAt = now()): Promise<T> => {\n    await writeRecord({ refreshedAt, value });\n    return value;\n  };\n\n  const refresh = async (force: boolean): Promise<T> => {\n    const resolvedPath = await cachePath();\n    return coalesce(flightKey(resolvedPath), async () => {\n      const previous = await readRecord();\n      if (!force && isFresh(previous)) {\n        return resolveValue({\n          fresh: undefined,\n          previous: previous?.value,\n          fallback: options.fallback,\n        });\n      }\n\n      let fresh: T | undefined;\n      if (options.load) {\n        try {\n          fresh = await options.load();\n        } catch (error) {\n          logger.warn(\"metadata cache refresh failed; keeping last known good\", {\n            key: options.key,\n            error,\n            path: resolvedPath,\n            diskEnabled,\n          });\n        }\n      }\n\n      const value = resolveValue({\n        fresh,\n        previous: previous?.value,\n        fallback: options.fallback,\n      });\n      if (fresh !== undefined || !previous) {\n        await persist(value);\n      }\n      return value;\n    });\n  };\n\n  return {\n    get path() {\n      if (!path) {\n        throw new Error(\"metadata cache path is not resolved until the first cache read\");\n      }\n      return path;\n    },\n    diskEnabled,\n    get: () => refresh(false),\n    peek: async () => (await readRecord())?.value,\n    refresh: () => refresh(true),\n    update: async (mutator) => {\n      const resolvedPath = await cachePath();\n      return coalesce(flightKey(resolvedPath, \":update\"), async () => {\n        const previous = await readRecord();\n        const baseline = resolveValue({\n          fresh: undefined,\n          previous: previous?.value,\n          fallback: options.fallback,\n        });\n        return persist(mutator(baseline));\n      });\n    },\n  };\n}\n\nasync function resolveCacheDir(options: {\n  readonly cacheDir?: string;\n  readonly version?: string;\n}): Promise<string> {\n  if (options.cacheDir) return options.cacheDir;\n  const version = options.version ?? PACKAGE_IDENTITY.version;\n  return defaultMetadataCacheDir(version);\n}\n\n/** Prefer a non-empty fresh array, else previous, else fallback. */\nexport function mergePreferFreshList<T>(input: MetadataCacheMergeInput<readonly T[]>): T[] {\n  if (input.fresh && input.fresh.length > 0) return [...input.fresh];\n  if (input.previous && input.previous.length > 0) return [...input.previous];\n  return [...input.fallback];\n}\n\n/**\n * Shallow-merge record catalogues: fallback, then previous, then fresh keys.\n * Fresh values win per key.\n */\nexport function mergePreferFreshRecord<T>(\n  input: MetadataCacheMergeInput<Readonly<Record<string, T>>>,\n): Record<string, T> {\n  return {\n    ...input.fallback,\n    ...(input.previous ?? {}),\n    ...(input.fresh ?? {}),\n  };\n}\n\n/** Test helper: wipe a cacache root and clear cacache memoization. */\nexport async function resetMetadataCacheDir(cacheDir: string): Promise<void> {\n  try {\n    await cacache.rm.all(cacheDir);\n  } catch {\n    // empty / missing cache is fine\n  }\n  cacache.clearMemoized();\n  for (const key of [...inflight.keys()]) {\n    if (key.startsWith(`${cacheDir}::`)) inflight.delete(key);\n  }\n}\n\nfunction coalesce<T>(key: string, work: () => Promise<T>): Promise<T> {\n  const existing = inflight.get(key);\n  if (existing) return existing as Promise<T>;\n  const pending = work().finally(() => {\n    if (inflight.get(key) === pending) inflight.delete(key);\n  });\n  inflight.set(key, pending);\n  return pending;\n}\n\nfunction decodeRecord<T>(data: Buffer): MetadataCacheRecord<T> | undefined {\n  try {\n    const parsed = JSON.parse(data.toString(\"utf8\")) as unknown;\n    if (\n      !parsed ||\n      typeof parsed !== \"object\" ||\n      typeof (parsed as MetadataCacheRecord<T>).refreshedAt !== \"number\"\n    ) {\n      return undefined;\n    }\n    return parsed as MetadataCacheRecord<T>;\n  } catch {\n    return undefined;\n  }\n}\n\nfunction isCacheMiss(error: unknown): boolean {\n  return Boolean(\n    error &&\n    typeof error === \"object\" &&\n    \"code\" in error &&\n    (error as { code?: string }).code === \"ENOENT\",\n  );\n}\n"]}

package/lib/src/metadata.d.ts

@@ -1,10 +1,8 @@
-import type { ModelCapabilities, ModelMetadata, ModelRateLimits, ModelStatus, ServingEndpointSummary } from "@dbx-tools/shared-model/contracts";
+import type { ModelCapabilities, ModelMetadata, ModelRateLimits, ServingEndpointSummary } from "@dbx-tools/shared-model/contracts";
 import { MODEL_METADATA_TTL_MS, MODEL_RATE_LIMITS_URL, OPENAI_RESPONSES_MODELS_URL, QUERY_REASON_MODELS_URL, RETIRED_MODELS_URL, WEB_SEARCH_MODELS_URL, type ModelCapabilityCatalogue } from "./_metadata-contract.ts";
 import { type ReasoningLevel, type ReasoningModelCatalogue } from "./reasoning-translation.ts";
 export { MODEL_METADATA_TTL_MS, MODEL_RATE_LIMITS_URL, OPENAI_RESPONSES_MODELS_URL, QUERY_REASON_MODELS_URL, RETIRED_MODELS_URL, WEB_SEARCH_MODELS_URL, };
 interface MetadataIndex {
-    readonly retiredNames: readonly string[];
-    readonly retiredKeys: ReadonlySet<string>;
     readonly capabilities: {
         readonly [Key in keyof ModelCapabilityCatalogue]: ReadonlySet<string>;
     };
@@ -22,8 +20,7 @@ export declare function refreshModelMetadata(): Promise<MetadataIndex>;
 export declare function hydrateModelMetadata(): Promise<MetadataIndex>;
 /** Absolute cacache root used by the documentation / learned caches. */
 export declare function modelMetadataCachePath(): string;
-/** Return the committed retired-model names. The array is cached and immutable. */
-export declare function retiredModelNames(): readonly string[];
+export { modelStatusFor, retiredModelNames } from "./_retirement.ts";
 /** Return the committed reasoning-effort catalogue. Cached per process. */
 export declare function reasoningModelCatalogue(): ReasoningModelCatalogue;
 /** Return error-learned reasoning ladders persisted in the metadata cache. */
@@ -43,8 +40,6 @@ export declare function rememberReasoningLevels(model: string, levels: readonly
  * nothing). The raw error body is never written to disk.
  */
 export declare function learnReasoningLevelsFromError(model: string, body: unknown): Promise<ReasoningLevel[]>;
-/** Resolve whether any supplied identity is listed in the retirement snapshot. */
-export declare function modelStatusFor(...models: readonly (string | ServingEndpointSummary)[]): ModelStatus;
 /** Resolve documented model capabilities from a name or endpoint summary. */
 export declare function modelCapabilitiesFor(model: string | ServingEndpointSummary): ModelCapabilities;
 /** Resolve published ITPM, OTPM, and QPH limits from a model identity. */