@dbx-tools/model 0.9.166 → 0.9.173

package/lib/src/generated/retired-models.json

@@ -1,11 +1,13 @@
 {
-    "generatedAt": 1791144427,
+    "generatedAt": 1793283170,
     "models": [
         "Anthropic Claude 3.7 Sonnet",
         "Anthropic Claude Sonnet 4",
         "DBRX",
         "DBRX Instruct",
+        "DeepSeek V4 Flash (0731)",
         "DeepSeek V4 Pro (0813)",
+        "DeepSeek V4.1 Flash",
         "Gemini 2.5 Flash",
         "Gemini 2.5 Pro",
         "Gemini 3 Pro",

package/lib/src/metadata-contract.d.ts

@@ -11,6 +11,10 @@ export declare const WEB_SEARCH_MODELS_URL = "https://docs.databricks.com/aws/en
 export declare const MODEL_RATE_LIMITS_URL = "https://docs.databricks.com/aws/en/machine-learning/foundation-model-apis/limits";
 /** Databricks documentation URL for reasoning-effort model policy. */
 export declare const QUERY_REASON_MODELS_URL = "https://docs.databricks.com/aws/en/machine-learning/model-serving/query-reason-models";
+/** models.dev provider catalogue URL. */
+export declare const MODELS_DEV_API_URL = "https://models.dev/api.json";
+/** modelparams.dev normalized model-parameter catalogue URL. */
+export declare const MODELPARAMS_DEV_MODELS_URL = "https://modelparams.dev/api/v1/models.json";
 /** Build-generated retired-model snapshot. */
 export interface RetiredModelsSnapshot {
     readonly generatedAt: number;
@@ -46,3 +50,26 @@ export interface ReasoningModelsSnapshot {
     readonly generatedAt: number;
     readonly catalogue: ReasoningModelCatalogue;
 }
+/** Portable capability sets normalized from models.dev. */
+export interface ModelsDevCapabilityCatalogue {
+    readonly imageInput: readonly string[];
+    readonly reasoning: readonly string[];
+    readonly tools: readonly string[];
+    readonly structuredOutput: readonly string[];
+    readonly temperatureSupported: readonly string[];
+    readonly temperatureUnsupported: readonly string[];
+}
+/** Build-generated models.dev capability and reasoning snapshot. */
+export interface ModelsDevSnapshot {
+    readonly generatedAt: number;
+    readonly capabilities: ModelsDevCapabilityCatalogue;
+}
+/** Reasoning support and discrete effort levels normalized from modelparams.dev. */
+export interface ModelParamsCatalogue extends ReasoningModelCatalogue {
+    readonly reasoning: readonly string[];
+}
+/** Build-generated modelparams.dev reasoning snapshot. */
+export interface ModelParamsSnapshot {
+    readonly generatedAt: number;
+    readonly catalogue: ModelParamsCatalogue;
+}

package/lib/src/metadata-contract.js

@@ -10,4 +10,8 @@ export const WEB_SEARCH_MODELS_URL = "https://docs.databricks.com/aws/en/machine
 export const MODEL_RATE_LIMITS_URL = "https://docs.databricks.com/aws/en/machine-learning/foundation-model-apis/limits";
 /** Databricks documentation URL for reasoning-effort model policy. */
 export const QUERY_REASON_MODELS_URL = "https://docs.databricks.com/aws/en/machine-learning/model-serving/query-reason-models";
-//# sourceMappingURL=data:application/json;base64,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
+/** models.dev provider catalogue URL. */
+export const MODELS_DEV_API_URL = "https://models.dev/api.json";
+/** modelparams.dev normalized model-parameter catalogue URL. */
+export const MODELPARAMS_DEV_MODELS_URL = "https://modelparams.dev/api/v1/models.json";
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/metadata.d.ts

@@ -1,13 +1,15 @@
 import type { ModelCapabilities, ModelMetadata, ModelRateLimits, ServingEndpointSummary } from "@dbx-tools/shared-model";
-import { type ModelCapabilityCatalogue } from "./metadata-contract.ts";
 import { type ReasoningLevel, type ReasoningModelCatalogue } from "./reasoning-translation.ts";
 interface MetadataIndex {
     readonly capabilities: {
-        readonly [Key in keyof ModelCapabilityCatalogue]: ReadonlySet<string>;
+        readonly [Key in keyof ModelCapabilities]: ReadonlySet<string>;
     };
     readonly rateLimits: ReadonlyMap<string, ModelRateLimits>;
     readonly reasoning: ReasoningModelCatalogue;
+    readonly reasoningDocs: ReasoningModelCatalogue;
+    readonly modelParamsReasoning: ReasoningModelCatalogue;
     readonly learnedReasoning: ReasoningModelCatalogue;
+    readonly temperatureUnsupported: ReadonlySet<string>;
 }
 /**
  * Hydrate or refresh documentation + learned caches into the process index.
@@ -32,20 +34,24 @@ export declare function rememberReasoningLevels(model: string, levels: readonly
  * Parse an upstream error body and persist the supported ladder for `model`.
  *
  * Accepts the same nested Databricks envelopes as {@link parseReasoningLevels}.
- * Returns the levels that were stored (or the current lookup when parse yields
- * nothing). The raw error body is never cached.
+ * Returns a published ladder without parsing or storing error-derived levels
+ * when one exists. Otherwise returns the levels that were stored, or the
+ * current fallback when parsing yields nothing. The raw error body is never
+ * cached.
  */
 export declare function learnReasoningLevelsFromError(model: string, body: unknown): Promise<ReasoningLevel[]>;
-/** Resolve documented model capabilities from a name or endpoint summary. */
+/** Resolve published model capabilities from a name or endpoint summary. */
 export declare function modelCapabilitiesFor(model: string | ServingEndpointSummary): ModelCapabilities;
+/** Resolve explicit Databricks temperature support, or undefined when unpublished. */
+export declare function modelTemperatureSupportFor(model: string | ServingEndpointSummary): boolean | undefined;
 /** Resolve published ITPM, OTPM, and QPH limits from a model identity. */
 export declare function modelRateLimitsFor(model: string | ServingEndpointSummary): ModelRateLimits | undefined;
 /**
- * Resolve reasoning levels: learned from errors, then documentation, then
- * family defaults.
+ * Resolve reasoning levels: Databricks documentation, modelparams.dev,
+ * learned errors, then family defaults.
  *
- * Does not parse error bodies; callers should use {@link parseReasoningLevels}
- * and then {@link rememberReasoningLevels}.
+ * Does not parse error bodies; callers handling an upstream error should use
+ * {@link learnReasoningLevelsFromError} so published levels keep precedence.
  */
 export declare function modelReasoningLevelsFor(model: string | ServingEndpointSummary): ReasoningLevel[];
 /** Resolve retirement, capability, and rate-limit metadata together. */
@@ -54,6 +60,8 @@ export declare function modelMetadataFor(model: string | ServingEndpointSummary)
 export declare function modelMetadataGeneratedAt(): Readonly<{
     retiredModels: number;
     capabilities: number;
+    modelsDev: number;
+    modelParams: number;
     rateLimits: number;
     reasoning: number;
 }>;

package/lib/src/metadata.js

@@ -1,27 +1,31 @@
 /**
- * Build-generated Databricks model retirement, capability, rate-limit, and
- * reasoning-effort metadata, plus a daily write-through cache for refreshed
- * docs and error-learned reasoning ladders.
+ * Build-generated Databricks and public model capability metadata, plus a
+ * daily write-through cache for refreshed sources and error-learned reasoning
+ * ladders.
  *
  * Committed snapshots seed every process. {@link refreshModelMetadata} pulls
- * documentation through the shared memory-first {@link createMetadataCache} and
- * rebuilds the in-memory index. Error-learned efforts use the same store via
- * {@link rememberReasoningLevels}. Known-good values are written behind to the
- * shared model project cache.
+ * Databricks documentation, models.dev, and modelparams.dev through the shared
+ * memory-first {@link createMetadataCache} and rebuilds the in-memory index.
+ * Error-learned efforts use the same store via {@link rememberReasoningLevels}.
+ * Known-good values are written behind to the shared model project cache.
  *
  * @module
  */
 import { memoize } from "@dbx-tools/shared-core";
-import { parseModelCapabilities, parseModelRateLimits, parseReasoningModels, parseRetiredModels, } from "./_metadata-generator.js";
+import { parseModelParams, parseModelCapabilities, parseModelRateLimits, parseModelsDev, parseReasoningModels, parseRetiredModels, } from "./_metadata-generator.js";
 import capabilitiesSnapshotJson from "./generated/model-capabilities.json" with { type: "json" };
+import modelParamsSnapshotJson from "./generated/modelparams-reasoning.json" with { type: "json" };
+import modelsDevSnapshotJson from "./generated/models-dev-capabilities.json" with { type: "json" };
 import rateLimitsSnapshotJson from "./generated/model-rate-limits.json" with { type: "json" };
 import reasoningSnapshotJson from "./generated/model-reasoning.json" with { type: "json" };
 import { createMetadataCache, mergePreferFreshList, mergePreferFreshRecord, } from "./metadata-cache.js";
-import { MODEL_RATE_LIMITS_URL, OPENAI_RESPONSES_MODELS_URL, QUERY_REASON_MODELS_URL, RETIRED_MODELS_URL, WEB_SEARCH_MODELS_URL, } from "./metadata-contract.js";
-import { inheritsNativeWebSearch, isFoundationModelIdentity, modelSearchQuery } from "./policy.js";
+import { MODELPARAMS_DEV_MODELS_URL, MODELS_DEV_API_URL, MODEL_RATE_LIMITS_URL, OPENAI_RESPONSES_MODELS_URL, QUERY_REASON_MODELS_URL, RETIRED_MODELS_URL, WEB_SEARCH_MODELS_URL, } from "./metadata-contract.js";
+import { inheritsNativeWebSearch, isFoundationModelIdentity, modelReasoningEfforts, modelSearchQuery, modelSupportsTools, } from "./policy.js";
 import { defaultReasoningLevels, documentedReasoningLevels, parseReasoning, parseReasoningLevels, uniqueReasoningLevels, } from "./reasoning-translation.js";
 import { COMMITTED_RETIRED_MODELS, modelStatusFor, replaceRetiredModelNames, RETIRED_MODELS_GENERATED_AT, } from "./retirement.js";
 const capabilitiesSnapshot = capabilitiesSnapshotJson;
+const modelParamsSnapshot = modelParamsSnapshotJson;
+const modelsDevSnapshot = modelsDevSnapshotJson;
 const rateLimitsSnapshot = rateLimitsSnapshotJson;
 const reasoningSnapshot = reasoningSnapshotJson;
 const USER_AGENT = "dbx-tools-model-metadata/1";
@@ -76,17 +80,48 @@ const reasoningDocsCache = createMetadataCache({
     load: async () => parseReasoningModels(await loadPage(QUERY_REASON_MODELS_URL), nowSeconds()).catalogue.models,
     merge: mergePreferFreshRecord,
 });
+const modelsDevCache = createMetadataCache({
+    key: "models-dev-capabilities",
+    fallback: modelsDevSnapshot.capabilities,
+    load: async () => {
+        const snapshot = parseModelsDev(await loadJson(MODELS_DEV_API_URL), nowSeconds());
+        return snapshot.capabilities;
+    },
+    merge: mergeModelsDevData,
+});
+const modelParamsCache = createMetadataCache({
+    key: "modelparams-reasoning",
+    fallback: modelParamsSnapshot.catalogue,
+    load: async () => parseModelParams(await loadJson(MODELPARAMS_DEV_MODELS_URL), nowSeconds()).catalogue,
+    merge: (input) => ({
+        reasoning: mergePreferFreshList({
+            fresh: input.fresh?.reasoning,
+            previous: input.previous?.reasoning,
+            fallback: input.fallback.reasoning,
+        }),
+        models: mergePreferFreshRecord({
+            fresh: input.fresh?.models,
+            previous: input.previous?.models,
+            fallback: input.fallback.models,
+        }),
+    }),
+});
 const learnedReasoningCache = createMetadataCache({
     key: "learned-reasoning",
     fallback: {},
     merge: mergePreferFreshRecord,
 });
 let liveIndex;
-const metadataIndex = memoize(() => liveIndex ?? buildIndexFromCommitted());
+const committedMetadataIndex = memoize(buildIndexFromCommitted);
+function metadataIndex() {
+    return liveIndex ?? committedMetadataIndex();
+}
 function buildIndexFromCommitted() {
     return buildIndex({
         retiredNames: COMMITTED_RETIRED_MODELS,
         capabilities: capabilitiesSnapshot.capabilities,
+        modelsDev: modelsDevSnapshot.capabilities,
+        modelParams: modelParamsSnapshot.catalogue,
         rateLimits: rateLimitsSnapshot.catalogue.models,
         reasoning: reasoningSnapshot.catalogue.models,
         learnedReasoning: {},
@@ -94,16 +129,34 @@ function buildIndexFromCommitted() {
 }
 function buildIndex(input) {
     replaceRetiredModelNames(input.retiredNames);
+    const reasoningDocs = freezeReasoningCatalogue(input.reasoning);
+    const modelParamsReasoning = freezeReasoningCatalogue(input.modelParams.models);
     return {
         capabilities: {
             responses: new Set(input.capabilities.responses),
-            imageInput: new Set(input.capabilities.imageInput),
+            imageInput: new Set([
+                ...input.capabilities.imageInput,
+                ...input.modelsDev.imageInput,
+            ]),
             applyPatch: new Set(input.capabilities.applyPatch),
             webSearch: new Set(input.capabilities.webSearch),
+            reasoning: new Set([
+                ...input.modelsDev.reasoning,
+                ...input.modelParams.reasoning,
+            ]),
+            tools: new Set(input.modelsDev.tools),
+            structuredOutput: new Set(input.modelsDev.structuredOutput),
+            temperature: new Set(input.modelsDev.temperatureSupported),
         },
         rateLimits: new Map(Object.entries(input.rateLimits)),
-        reasoning: freezeReasoningCatalogue(input.reasoning),
+        reasoning: Object.freeze({
+            ...modelParamsReasoning,
+            ...reasoningDocs,
+        }),
+        reasoningDocs,
+        modelParamsReasoning,
         learnedReasoning: freezeLearnedCatalogue(input.learnedReasoning),
+        temperatureUnsupported: new Set(input.modelsDev.temperatureUnsupported),
     };
 }
 function freezeReasoningCatalogue(models) {
@@ -128,9 +181,11 @@ export async function refreshModelMetadata() {
     if (refreshInflight)
         return refreshInflight;
     refreshInflight = (async () => {
-        const [retiredNames, capabilities, rateLimits, reasoning, learnedReasoning] = await Promise.all([
+        const [retiredNames, capabilities, modelsDev, modelParams, rateLimits, reasoning, learnedReasoning,] = await Promise.all([
             retiredCache.get(),
             capabilitiesCache.get(),
+            modelsDevCache.get(),
+            modelParamsCache.get(),
             rateLimitsCache.get(),
             reasoningDocsCache.get(),
             learnedReasoningCache.get(),
@@ -138,6 +193,8 @@ export async function refreshModelMetadata() {
         liveIndex = buildIndex({
             retiredNames,
             capabilities,
+            modelsDev,
+            modelParams,
             rateLimits,
             reasoning,
             learnedReasoning,
@@ -150,9 +207,11 @@ export async function refreshModelMetadata() {
 }
 /** Load shared cache entries without forcing a network refresh. */
 export async function hydrateModelMetadata() {
-    const [retiredNames, capabilities, rateLimits, reasoning, learnedReasoning] = await Promise.all([
+    const [retiredNames, capabilities, modelsDev, modelParams, rateLimits, reasoning, learnedReasoning,] = await Promise.all([
         peekOrFallback(retiredCache, COMMITTED_RETIRED_MODELS),
         peekOrFallback(capabilitiesCache, capabilitiesSnapshot.capabilities),
+        peekOrFallback(modelsDevCache, modelsDevSnapshot.capabilities),
+        peekOrFallback(modelParamsCache, modelParamsSnapshot.catalogue),
         peekOrFallback(rateLimitsCache, rateLimitsSnapshot.catalogue.models),
         peekOrFallback(reasoningDocsCache, reasoningSnapshot.catalogue.models),
         peekOrFallback(learnedReasoningCache, {}),
@@ -160,6 +219,8 @@ export async function hydrateModelMetadata() {
     liveIndex = buildIndex({
         retiredNames,
         capabilities,
+        modelsDev,
+        modelParams,
         rateLimits,
         reasoning,
         learnedReasoning,
@@ -208,13 +269,18 @@ export async function rememberReasoningLevels(model, levels) {
  * Parse an upstream error body and persist the supported ladder for `model`.
  *
  * Accepts the same nested Databricks envelopes as {@link parseReasoningLevels}.
- * Returns the levels that were stored (or the current lookup when parse yields
- * nothing). The raw error body is never cached.
+ * Returns a published ladder without parsing or storing error-derived levels
+ * when one exists. Otherwise returns the levels that were stored, or the
+ * current fallback when parsing yields nothing. The raw error body is never
+ * cached.
  */
 export async function learnReasoningLevelsFromError(model, body) {
+    const published = publishedReasoningLevelsFor(model, metadataIndex());
+    if (published)
+        return published;
     return rememberReasoningLevels(model, parseReasoningLevels(body));
 }
-/** Resolve documented model capabilities from a name or endpoint summary. */
+/** Resolve published model capabilities from a name or endpoint summary. */
 export function modelCapabilitiesFor(model) {
     const capabilities = metadataIndex().capabilities;
     const identities = modelIdentities(model, false);
@@ -227,8 +293,23 @@ export function modelCapabilitiesFor(model) {
         webSearch: keys.some((key) => capabilities.webSearch.has(key)) ||
             identities.some((identity) => isFoundationModelIdentity(identity) &&
                 inheritsNativeWebSearch(identity, capabilities.webSearch)),
+        reasoning: keys.some((key) => capabilities.reasoning.has(key)) ||
+            identities.some((identity) => modelReasoningEfforts(identity).length > 0),
+        tools: keys.some((key) => capabilities.tools.has(key)) || identities.some(modelSupportsTools),
+        structuredOutput: keys.some((key) => capabilities.structuredOutput.has(key)),
+        temperature: modelTemperatureSupportFor(model) === true,
     };
 }
+/** Resolve explicit Databricks temperature support, or undefined when unpublished. */
+export function modelTemperatureSupportFor(model) {
+    const index = metadataIndex();
+    const keys = modelIdentities(model).flatMap((identity) => modelKey(identity) ?? []);
+    if (keys.some((key) => index.temperatureUnsupported.has(key)))
+        return false;
+    if (keys.some((key) => index.capabilities.temperature.has(key)))
+        return true;
+    return undefined;
+}
 /** Resolve published ITPM, OTPM, and QPH limits from a model identity. */
 export function modelRateLimitsFor(model) {
     const limits = metadataIndex().rateLimits;
@@ -243,26 +324,38 @@ export function modelRateLimitsFor(model) {
     return undefined;
 }
 /**
- * Resolve reasoning levels: learned from errors, then documentation, then
- * family defaults.
+ * Resolve reasoning levels: Databricks documentation, modelparams.dev,
+ * learned errors, then family defaults.
  *
- * Does not parse error bodies; callers should use {@link parseReasoningLevels}
- * and then {@link rememberReasoningLevels}.
+ * Does not parse error bodies; callers handling an upstream error should use
+ * {@link learnReasoningLevelsFromError} so published levels keep precedence.
  */
 export function modelReasoningLevelsFor(model) {
     const index = metadataIndex();
+    const published = publishedReasoningLevelsFor(model, index);
+    if (published)
+        return published;
     for (const identity of modelIdentities(model)) {
         const learned = documentedReasoningLevels(identity, index.learnedReasoning);
         if (learned?.length)
             return learned;
     }
-    for (const identity of modelIdentities(model)) {
-        const documented = documentedReasoningLevels(identity, index.reasoning);
+    const primary = typeof model === "string" ? model : (model.modelServiceName ?? model.name);
+    return defaultReasoningLevels(primary);
+}
+function publishedReasoningLevelsFor(model, index) {
+    const identities = modelIdentities(model);
+    for (const identity of identities) {
+        const documented = documentedReasoningLevels(identity, index.reasoningDocs);
         if (documented?.length)
             return documented;
     }
-    const primary = typeof model === "string" ? model : (model.modelServiceName ?? model.name);
-    return defaultReasoningLevels(primary);
+    for (const identity of identities) {
+        const modelParams = documentedReasoningLevels(identity, index.modelParamsReasoning);
+        if (modelParams?.length)
+            return modelParams;
+    }
+    return undefined;
 }
 /** Resolve retirement, capability, and rate-limit metadata together. */
 export function modelMetadataFor(model) {
@@ -278,6 +371,8 @@ export function modelMetadataGeneratedAt() {
     return {
         retiredModels: RETIRED_MODELS_GENERATED_AT,
         capabilities: capabilitiesSnapshot.generatedAt,
+        modelsDev: modelsDevSnapshot.generatedAt,
+        modelParams: modelParamsSnapshot.generatedAt,
         rateLimits: rateLimitsSnapshot.generatedAt,
         reasoning: reasoningSnapshot.generatedAt,
     };
@@ -305,7 +400,32 @@ async function loadPage(url) {
     }
     return response.text();
 }
+async function loadJson(url) {
+    const response = await fetch(url, {
+        headers: { "user-agent": USER_AGENT },
+        signal: AbortSignal.timeout(15_000),
+    });
+    if (!response.ok) {
+        throw new Error(`Model metadata source returned HTTP ${response.status}: ${url}`);
+    }
+    return response.json();
+}
+function mergeModelsDevData(input) {
+    const capability = (key) => mergePreferFreshList({
+        fresh: input.fresh?.[key],
+        previous: input.previous?.[key],
+        fallback: input.fallback[key],
+    });
+    return {
+        imageInput: capability("imageInput"),
+        reasoning: capability("reasoning"),
+        tools: capability("tools"),
+        structuredOutput: capability("structuredOutput"),
+        temperatureSupported: capability("temperatureSupported"),
+        temperatureUnsupported: capability("temperatureUnsupported"),
+    };
+}
 function nowSeconds() {
     return Math.floor(Date.now() / 1000);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"metadata.js","sourceRoot":"","sources":["../../src/metadata.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Build-generated Databricks model retirement, capability, rate-limit, and\n * reasoning-effort metadata, plus a daily write-through cache for refreshed\n * docs and error-learned reasoning ladders.\n *\n * Committed snapshots seed every process. {@link refreshModelMetadata} pulls\n * documentation through the shared memory-first {@link createMetadataCache} and\n * rebuilds the in-memory index. Error-learned efforts use the same store via\n * {@link rememberReasoningLevels}. Known-good values are written behind to the\n * shared model project cache.\n *\n * @module\n */\nimport { memoize } from \"@dbx-tools/shared-core\";\nimport type {\n  ModelCapabilities,\n  ModelMetadata,\n  ModelRateLimits,\n  ServingEndpointSummary,\n} from \"@dbx-tools/shared-model\";\n\nimport {\n  parseModelCapabilities,\n  parseModelRateLimits,\n  parseReasoningModels,\n  parseRetiredModels,\n} from \"./_metadata-generator.ts\";\nimport capabilitiesSnapshotJson from \"./generated/model-capabilities.json\" with { type: \"json\" };\nimport rateLimitsSnapshotJson from \"./generated/model-rate-limits.json\" with { type: \"json\" };\nimport reasoningSnapshotJson from \"./generated/model-reasoning.json\" with { type: \"json\" };\nimport {\n  createMetadataCache,\n  mergePreferFreshList,\n  mergePreferFreshRecord,\n  type MetadataCache,\n} from \"./metadata-cache.ts\";\nimport {\n  MODEL_RATE_LIMITS_URL,\n  OPENAI_RESPONSES_MODELS_URL,\n  QUERY_REASON_MODELS_URL,\n  RETIRED_MODELS_URL,\n  WEB_SEARCH_MODELS_URL,\n  type ModelCapabilitiesSnapshot,\n  type ModelCapabilityCatalogue,\n  type ModelRateLimitsSnapshot,\n  type ReasoningModelsSnapshot,\n} from \"./metadata-contract.ts\";\nimport { inheritsNativeWebSearch, isFoundationModelIdentity, modelSearchQuery } from \"./policy.ts\";\nimport {\n  defaultReasoningLevels,\n  documentedReasoningLevels,\n  parseReasoning,\n  parseReasoningLevels,\n  type ReasoningLevel,\n  type ReasoningModelCatalogue,\n  uniqueReasoningLevels,\n} from \"./reasoning-translation.ts\";\nimport {\n  COMMITTED_RETIRED_MODELS,\n  modelStatusFor,\n  replaceRetiredModelNames,\n  RETIRED_MODELS_GENERATED_AT,\n} from \"./retirement.ts\";\n\nconst capabilitiesSnapshot = capabilitiesSnapshotJson as ModelCapabilitiesSnapshot;\nconst rateLimitsSnapshot = rateLimitsSnapshotJson as ModelRateLimitsSnapshot;\nconst reasoningSnapshot = reasoningSnapshotJson as ReasoningModelsSnapshot;\n\ninterface MetadataIndex {\n  readonly capabilities: {\n    readonly [Key in keyof ModelCapabilityCatalogue]: ReadonlySet<string>;\n  };\n  readonly rateLimits: ReadonlyMap<string, ModelRateLimits>;\n  readonly reasoning: ReasoningModelCatalogue;\n  readonly learnedReasoning: ReasoningModelCatalogue;\n}\n\ntype CapabilitySets = ModelCapabilityCatalogue;\n\nconst USER_AGENT = \"dbx-tools-model-metadata/1\";\n\nconst retiredCache = createMetadataCache<readonly string[]>({\n  key: \"retired-models\",\n  fallback: COMMITTED_RETIRED_MODELS,\n  load: async () => parseRetiredModels(await loadPage(RETIRED_MODELS_URL), nowSeconds()).models,\n  merge: mergePreferFreshList,\n});\n\nconst capabilitiesCache = createMetadataCache<CapabilitySets>({\n  key: \"model-capabilities\",\n  fallback: capabilitiesSnapshot.capabilities,\n  load: async () => {\n    const [responsesHtml, webSearchHtml] = await Promise.all([\n      loadPage(OPENAI_RESPONSES_MODELS_URL),\n      loadPage(WEB_SEARCH_MODELS_URL),\n    ]);\n    return parseModelCapabilities(responsesHtml, webSearchHtml, nowSeconds()).capabilities;\n  },\n  merge: (input) => ({\n    responses: mergePreferFreshList({\n      fresh: input.fresh?.responses,\n      previous: input.previous?.responses,\n      fallback: input.fallback.responses,\n    }),\n    imageInput: mergePreferFreshList({\n      fresh: input.fresh?.imageInput,\n      previous: input.previous?.imageInput,\n      fallback: input.fallback.imageInput,\n    }),\n    applyPatch: mergePreferFreshList({\n      fresh: input.fresh?.applyPatch,\n      previous: input.previous?.applyPatch,\n      fallback: input.fallback.applyPatch,\n    }),\n    webSearch: mergePreferFreshList({\n      fresh: input.fresh?.webSearch,\n      previous: input.previous?.webSearch,\n      fallback: input.fallback.webSearch,\n    }),\n  }),\n});\n\nconst rateLimitsCache = createMetadataCache<Readonly<Record<string, ModelRateLimits>>>({\n  key: \"model-rate-limits\",\n  fallback: rateLimitsSnapshot.catalogue.models,\n  load: async () =>\n    parseModelRateLimits(await loadPage(MODEL_RATE_LIMITS_URL), nowSeconds()).catalogue.models,\n  merge: mergePreferFreshRecord,\n});\n\nconst reasoningDocsCache = createMetadataCache<Readonly<Record<string, readonly string[]>>>({\n  key: \"model-reasoning\",\n  fallback: reasoningSnapshot.catalogue.models,\n  load: async () =>\n    parseReasoningModels(await loadPage(QUERY_REASON_MODELS_URL), nowSeconds()).catalogue.models,\n  merge: mergePreferFreshRecord,\n});\n\nconst learnedReasoningCache = createMetadataCache<\n  Readonly<Record<string, readonly ReasoningLevel[]>>\n>({\n  key: \"learned-reasoning\",\n  fallback: {},\n  merge: mergePreferFreshRecord,\n});\n\nlet liveIndex: MetadataIndex | undefined;\n\nconst metadataIndex = memoize<MetadataIndex>(() => liveIndex ?? buildIndexFromCommitted());\n\nfunction buildIndexFromCommitted(): MetadataIndex {\n  return buildIndex({\n    retiredNames: COMMITTED_RETIRED_MODELS,\n    capabilities: capabilitiesSnapshot.capabilities,\n    rateLimits: rateLimitsSnapshot.catalogue.models,\n    reasoning: reasoningSnapshot.catalogue.models,\n    learnedReasoning: {},\n  });\n}\n\nfunction buildIndex(input: {\n  readonly retiredNames: readonly string[];\n  readonly capabilities: CapabilitySets;\n  readonly rateLimits: Readonly<Record<string, ModelRateLimits>>;\n  readonly reasoning: Readonly<Record<string, readonly string[]>>;\n  readonly learnedReasoning: Readonly<Record<string, readonly ReasoningLevel[]>>;\n}): MetadataIndex {\n  replaceRetiredModelNames(input.retiredNames);\n  return {\n    capabilities: {\n      responses: new Set(input.capabilities.responses),\n      imageInput: new Set(input.capabilities.imageInput),\n      applyPatch: new Set(input.capabilities.applyPatch),\n      webSearch: new Set(input.capabilities.webSearch),\n    },\n    rateLimits: new Map(Object.entries(input.rateLimits)),\n    reasoning: freezeReasoningCatalogue(input.reasoning),\n    learnedReasoning: freezeLearnedCatalogue(input.learnedReasoning),\n  };\n}\n\nfunction freezeReasoningCatalogue(\n  models: Readonly<Record<string, readonly string[]>>,\n): ReasoningModelCatalogue {\n  return Object.freeze(\n    Object.fromEntries(\n      Object.entries(models).map(([key, levels]) => [\n        key,\n        Object.freeze(\n          uniqueReasoningLevels(levels.flatMap((level) => parseReasoning(level) ?? [])),\n        ),\n      ]),\n    ),\n  );\n}\n\nfunction freezeLearnedCatalogue(\n  models: Readonly<Record<string, readonly ReasoningLevel[]>>,\n): ReasoningModelCatalogue {\n  return Object.freeze(\n    Object.fromEntries(\n      Object.entries(models).map(([key, levels]) => [\n        key,\n        Object.freeze(uniqueReasoningLevels(levels)),\n      ]),\n    ),\n  );\n}\n\nlet refreshInflight: Promise<MetadataIndex> | undefined;\n\n/**\n * Hydrate or refresh documentation + learned caches into the process index.\n *\n * Safe to call on gateway startup. Concurrent callers share one refresh.\n */\nexport async function refreshModelMetadata(): Promise<MetadataIndex> {\n  if (refreshInflight) return refreshInflight;\n  refreshInflight = (async () => {\n    const [retiredNames, capabilities, rateLimits, reasoning, learnedReasoning] = await Promise.all(\n      [\n        retiredCache.get(),\n        capabilitiesCache.get(),\n        rateLimitsCache.get(),\n        reasoningDocsCache.get(),\n        learnedReasoningCache.get(),\n      ],\n    );\n    liveIndex = buildIndex({\n      retiredNames,\n      capabilities,\n      rateLimits,\n      reasoning,\n      learnedReasoning,\n    });\n    return liveIndex;\n  })().finally(() => {\n    refreshInflight = undefined;\n  });\n  return refreshInflight;\n}\n\n/** Load shared cache entries without forcing a network refresh. */\nexport async function hydrateModelMetadata(): Promise<MetadataIndex> {\n  const [retiredNames, capabilities, rateLimits, reasoning, learnedReasoning] = await Promise.all([\n    peekOrFallback(retiredCache, COMMITTED_RETIRED_MODELS),\n    peekOrFallback(capabilitiesCache, capabilitiesSnapshot.capabilities),\n    peekOrFallback(rateLimitsCache, rateLimitsSnapshot.catalogue.models),\n    peekOrFallback(reasoningDocsCache, reasoningSnapshot.catalogue.models),\n    peekOrFallback(learnedReasoningCache, {}),\n  ]);\n  liveIndex = buildIndex({\n    retiredNames,\n    capabilities,\n    rateLimits,\n    reasoning,\n    learnedReasoning,\n  });\n  return liveIndex;\n}\n\nasync function peekOrFallback<T>(cache: MetadataCache<T>, fallback: T): Promise<T> {\n  const peeked = await cache.peek();\n  if (peeked !== undefined) return peeked;\n  return cache.get().catch(() => fallback);\n}\n\n/** Return the committed reasoning-effort catalogue. Cached per process. */\nexport function reasoningModelCatalogue(): ReasoningModelCatalogue {\n  return metadataIndex().reasoning;\n}\n\n/** Return error-learned reasoning ladders from the shared model cache. */\nexport function learnedReasoningCatalogue(): ReasoningModelCatalogue {\n  return metadataIndex().learnedReasoning;\n}\n\n/**\n * Store levels learned from an upstream error and persist them write-through.\n *\n * Empty lists are ignored so a failed parse cannot wipe defaults. Error bodies\n * themselves are never stored - only the parsed ladder.\n */\nexport async function rememberReasoningLevels(\n  model: string,\n  levels: readonly ReasoningLevel[],\n): Promise<ReasoningLevel[]> {\n  const unique = uniqueReasoningLevels(levels);\n  if (unique.length === 0) return modelReasoningLevelsFor(model);\n  const key = modelKey(model);\n  if (!key) return modelReasoningLevelsFor(model);\n  const catalogue = await learnedReasoningCache.update((current) => ({\n    ...current,\n    [key]: unique,\n  }));\n  const current = metadataIndex();\n  liveIndex = {\n    ...current,\n    learnedReasoning: freezeLearnedCatalogue(catalogue),\n  };\n  return [...unique];\n}\n\n/**\n * Parse an upstream error body and persist the supported ladder for `model`.\n *\n * Accepts the same nested Databricks envelopes as {@link parseReasoningLevels}.\n * Returns the levels that were stored (or the current lookup when parse yields\n * nothing). The raw error body is never cached.\n */\nexport async function learnReasoningLevelsFromError(\n  model: string,\n  body: unknown,\n): Promise<ReasoningLevel[]> {\n  return rememberReasoningLevels(model, parseReasoningLevels(body));\n}\n\n/** Resolve documented model capabilities from a name or endpoint summary. */\nexport function modelCapabilitiesFor(model: string | ServingEndpointSummary): ModelCapabilities {\n  const capabilities = metadataIndex().capabilities;\n  const identities = modelIdentities(model, false);\n  const keys = identities.flatMap((identity) => modelKey(identity) ?? []);\n  return {\n    responses: keys.some((key) => capabilities.responses.has(key)),\n    imageInput: keys.some((key) => capabilities.imageInput.has(key)),\n    applyPatch: keys.some((key) => capabilities.applyPatch.has(key)),\n    // Version inheritance only applies to hosted foundation identities.\n    webSearch:\n      keys.some((key) => capabilities.webSearch.has(key)) ||\n      identities.some(\n        (identity) =>\n          isFoundationModelIdentity(identity) &&\n          inheritsNativeWebSearch(identity, capabilities.webSearch),\n      ),\n  };\n}\n\n/** Resolve published ITPM, OTPM, and QPH limits from a model identity. */\nexport function modelRateLimitsFor(\n  model: string | ServingEndpointSummary,\n): ModelRateLimits | undefined {\n  const limits = metadataIndex().rateLimits;\n  for (const identity of modelIdentities(model)) {\n    const key = modelKey(identity);\n    if (!key) continue;\n    const found = limits.get(key);\n    if (found) return found;\n  }\n  return undefined;\n}\n\n/**\n * Resolve reasoning levels: learned from errors, then documentation, then\n * family defaults.\n *\n * Does not parse error bodies; callers should use {@link parseReasoningLevels}\n * and then {@link rememberReasoningLevels}.\n */\nexport function modelReasoningLevelsFor(model: string | ServingEndpointSummary): ReasoningLevel[] {\n  const index = metadataIndex();\n  for (const identity of modelIdentities(model)) {\n    const learned = documentedReasoningLevels(identity, index.learnedReasoning);\n    if (learned?.length) return learned;\n  }\n  for (const identity of modelIdentities(model)) {\n    const documented = documentedReasoningLevels(identity, index.reasoning);\n    if (documented?.length) return documented;\n  }\n  const primary = typeof model === \"string\" ? model : (model.modelServiceName ?? model.name);\n  return defaultReasoningLevels(primary);\n}\n\n/** Resolve retirement, capability, and rate-limit metadata together. */\nexport function modelMetadataFor(model: string | ServingEndpointSummary): ModelMetadata {\n  const rateLimits = modelRateLimitsFor(model);\n  return {\n    status: modelStatusFor(model),\n    capabilities: modelCapabilitiesFor(model),\n    ...(rateLimits ? { rateLimits } : {}),\n  };\n}\n\n/** Return generation timestamps for the committed metadata snapshots. */\nexport function modelMetadataGeneratedAt(): Readonly<{\n  retiredModels: number;\n  capabilities: number;\n  rateLimits: number;\n  reasoning: number;\n}> {\n  return {\n    retiredModels: RETIRED_MODELS_GENERATED_AT,\n    capabilities: capabilitiesSnapshot.generatedAt,\n    rateLimits: rateLimitsSnapshot.generatedAt,\n    reasoning: reasoningSnapshot.generatedAt,\n  };\n}\n\nfunction modelIdentities(\n  model: string | ServingEndpointSummary,\n  includeDisplayName = true,\n): string[] {\n  if (typeof model === \"string\") return [model];\n  return [\n    model.name,\n    ...(includeDisplayName ? [model.displayName] : []),\n    model.modelServiceName,\n    ...Object.values(model.serviceNames ?? {}),\n  ].filter((value): value is string => Boolean(value));\n}\n\nfunction modelKey(value: string): string | undefined {\n  return modelSearchQuery(value)?.replaceAll(\" \", \"-\");\n}\n\nasync function loadPage(url: string): Promise<string> {\n  const response = await fetch(url, {\n    headers: { \"user-agent\": USER_AGENT },\n    signal: AbortSignal.timeout(15_000),\n  });\n  if (!response.ok) {\n    throw new Error(`Databricks documentation returned HTTP ${response.status}: ${url}`);\n  }\n  return response.text();\n}\n\nfunction nowSeconds(): number {\n  return Math.floor(Date.now() / 1000);\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"metadata.js","sourceRoot":"","sources":["../../src/metadata.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AAQjD,OAAO,EACL,gBAAgB,EAChB,sBAAsB,EACtB,oBAAoB,EACpB,cAAc,EACd,oBAAoB,EACpB,kBAAkB,GACnB,MAAM,0BAA0B,CAAC;AAClC,OAAO,wBAAwB,MAAM,qCAAqC,CAAC,OAAO,IAAI,EAAE,MAAM,EAAE,CAAC;AACjG,OAAO,uBAAuB,MAAM,wCAAwC,CAAC,OAAO,IAAI,EAAE,MAAM,EAAE,CAAC;AACnG,OAAO,qBAAqB,MAAM,0CAA0C,CAAC,OAAO,IAAI,EAAE,MAAM,EAAE,CAAC;AACnG,OAAO,sBAAsB,MAAM,oCAAoC,CAAC,OAAO,IAAI,EAAE,MAAM,EAAE,CAAC;AAC9F,OAAO,qBAAqB,MAAM,kCAAkC,CAAC,OAAO,IAAI,EAAE,MAAM,EAAE,CAAC;AAC3F,OAAO,EACL,mBAAmB,EACnB,oBAAoB,EACpB,sBAAsB,GAEvB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,0BAA0B,EAC1B,kBAAkB,EAClB,qBAAqB,EACrB,2BAA2B,EAC3B,uBAAuB,EACvB,kBAAkB,EAClB,qBAAqB,GAStB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACL,uBAAuB,EACvB,yBAAyB,EACzB,qBAAqB,EACrB,gBAAgB,EAChB,kBAAkB,GACnB,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,sBAAsB,EACtB,yBAAyB,EACzB,cAAc,EACd,oBAAoB,EAGpB,qBAAqB,GACtB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EACL,wBAAwB,EACxB,cAAc,EACd,wBAAwB,EACxB,2BAA2B,GAC5B,MAAM,iBAAiB,CAAC;AAEzB,MAAM,oBAAoB,GAAG,wBAAqD,CAAC;AACnF,MAAM,mBAAmB,GAAG,uBAA8C,CAAC;AAC3E,MAAM,iBAAiB,GAAG,qBAA0C,CAAC;AACrE,MAAM,kBAAkB,GAAG,sBAAiD,CAAC;AAC7E,MAAM,iBAAiB,GAAG,qBAAgD,CAAC;AAiB3E,MAAM,UAAU,GAAG,4BAA4B,CAAC;AAEhD,MAAM,YAAY,GAAG,mBAAmB,CAAoB;IAC1D,GAAG,EAAE,gBAAgB;IACrB,QAAQ,EAAE,wBAAwB;IAClC,IAAI,EAAE,KAAK,IAAI,EAAE,CAAC,kBAAkB,CAAC,MAAM,QAAQ,CAAC,kBAAkB,CAAC,EAAE,UAAU,EAAE,CAAC,CAAC,MAAM;IAC7F,KAAK,EAAE,oBAAoB;CAC5B,CAAC,CAAC;AAEH,MAAM,iBAAiB,GAAG,mBAAmB,CAAiB;IAC5D,GAAG,EAAE,oBAAoB;IACzB,QAAQ,EAAE,oBAAoB,CAAC,YAAY;IAC3C,IAAI,EAAE,KAAK,IAAI,EAAE;QACf,MAAM,CAAC,aAAa,EAAE,aAAa,CAAC,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC;YACvD,QAAQ,CAAC,2BAA2B,CAAC;YACrC,QAAQ,CAAC,qBAAqB,CAAC;SAChC,CAAC,CAAC;QACH,OAAO,sBAAsB,CAAC,aAAa,EAAE,aAAa,EAAE,UAAU,EAAE,CAAC,CAAC,YAAY,CAAC;IACzF,CAAC;IACD,KAAK,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QACjB,SAAS,EAAE,oBAAoB,CAAC;YAC9B,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,SAAS;YAC7B,QAAQ,EAAE,KAAK,CAAC,QAAQ,EAAE,SAAS;YACnC,QAAQ,EAAE,KAAK,CAAC,QAAQ,CAAC,SAAS;SACnC,CAAC;QACF,UAAU,EAAE,oBAAoB,CAAC;YAC/B,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,UAAU;YAC9B,QAAQ,EAAE,KAAK,CAAC,QAAQ,EAAE,UAAU;YACpC,QAAQ,EAAE,KAAK,CAAC,QAAQ,CAAC,UAAU;SACpC,CAAC;QACF,UAAU,EAAE,oBAAoB,CAAC;YAC/B,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,UAAU;YAC9B,QAAQ,EAAE,KAAK,CAAC,QAAQ,EAAE,UAAU;YACpC,QAAQ,EAAE,KAAK,CAAC,QAAQ,CAAC,UAAU;SACpC,CAAC;QACF,SAAS,EAAE,oBAAoB,CAAC;YAC9B,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,SAAS;YAC7B,QAAQ,EAAE,KAAK,CAAC,QAAQ,EAAE,SAAS;YACnC,QAAQ,EAAE,KAAK,CAAC,QAAQ,CAAC,SAAS;SACnC,CAAC;KACH,CAAC;CACH,CAAC,CAAC;AAEH,MAAM,eAAe,GAAG,mBAAmB,CAA4C;IACrF,GAAG,EAAE,mBAAmB;IACxB,QAAQ,EAAE,kBAAkB,CAAC,SAAS,CAAC,MAAM;IAC7C,IAAI,EAAE,KAAK,IAAI,EAAE,CACf,oBAAoB,CAAC,MAAM,QAAQ,CAAC,qBAAqB,CAAC,EAAE,UAAU,EAAE,CAAC,CAAC,SAAS,CAAC,MAAM;IAC5F,KAAK,EAAE,sBAAsB;CAC9B,CAAC,CAAC;AAEH,MAAM,kBAAkB,GAAG,mBAAmB,CAA8C;IAC1F,GAAG,EAAE,iBAAiB;IACtB,QAAQ,EAAE,iBAAiB,CAAC,SAAS,CAAC,MAAM;IAC5C,IAAI,EAAE,KAAK,IAAI,EAAE,CACf,oBAAoB,CAAC,MAAM,QAAQ,CAAC,uBAAuB,CAAC,EAAE,UAAU,EAAE,CAAC,CAAC,SAAS,CAAC,MAAM;IAC9F,KAAK,EAAE,sBAAsB;CAC9B,CAAC,CAAC;AAEH,MAAM,cAAc,GAAG,mBAAmB,CAAgB;IACxD,GAAG,EAAE,yBAAyB;IAC9B,QAAQ,EAAE,iBAAiB,CAAC,YAAY;IACxC,IAAI,EAAE,KAAK,IAAI,EAAE;QACf,MAAM,QAAQ,GAAG,cAAc,CAAC,MAAM,QAAQ,CAAC,kBAAkB,CAAC,EAAE,UAAU,EAAE,CAAC,CAAC;QAClF,OAAO,QAAQ,CAAC,YAAY,CAAC;IAC/B,CAAC;IACD,KAAK,EAAE,kBAAkB;CAC1B,CAAC,CAAC;AAEH,MAAM,gBAAgB,GAAG,mBAAmB,CAAuB;IACjE,GAAG,EAAE,uBAAuB;IAC5B,QAAQ,EAAE,mBAAmB,CAAC,SAAS;IACvC,IAAI,EAAE,KAAK,IAAI,EAAE,CACf,gBAAgB,CAAC,MAAM,QAAQ,CAAC,0BAA0B,CAAC,EAAE,UAAU,EAAE,CAAC,CAAC,SAAS;IACtF,KAAK,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QACjB,SAAS,EAAE,oBAAoB,CAAC;YAC9B,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,SAAS;YAC7B,QAAQ,EAAE,KAAK,CAAC,QAAQ,EAAE,SAAS;YACnC,QAAQ,EAAE,KAAK,CAAC,QAAQ,CAAC,SAAS;SACnC,CAAC;QACF,MAAM,EAAE,sBAAsB,CAAC;YAC7B,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,MAAM;YAC1B,QAAQ,EAAE,KAAK,CAAC,QAAQ,EAAE,MAAM;YAChC,QAAQ,EAAE,KAAK,CAAC,QAAQ,CAAC,MAAM;SAChC,CAAC;KACH,CAAC;CACH,CAAC,CAAC;AAEH,MAAM,qBAAqB,GAAG,mBAAmB,CAE/C;IACA,GAAG,EAAE,mBAAmB;IACxB,QAAQ,EAAE,EAAE;IACZ,KAAK,EAAE,sBAAsB;CAC9B,CAAC,CAAC;AAEH,IAAI,SAAoC,CAAC;AAEzC,MAAM,sBAAsB,GAAG,OAAO,CAAgB,uBAAuB,CAAC,CAAC;AAE/E,SAAS,aAAa;IACpB,OAAO,SAAS,IAAI,sBAAsB,EAAE,CAAC;AAC/C,CAAC;AAED,SAAS,uBAAuB;IAC9B,OAAO,UAAU,CAAC;QAChB,YAAY,EAAE,wBAAwB;QACtC,YAAY,EAAE,oBAAoB,CAAC,YAAY;QAC/C,SAAS,EAAE,iBAAiB,CAAC,YAAY;QACzC,WAAW,EAAE,mBAAmB,CAAC,SAAS;QAC1C,UAAU,EAAE,kBAAkB,CAAC,SAAS,CAAC,MAAM;QAC/C,SAAS,EAAE,iBAAiB,CAAC,SAAS,CAAC,MAAM;QAC7C,gBAAgB,EAAE,EAAE;KACrB,CAAC,CAAC;AACL,CAAC;AAED,SAAS,UAAU,CAAC,KAQnB;IACC,wBAAwB,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC;IAC7C,MAAM,aAAa,GAAG,wBAAwB,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;IAChE,MAAM,oBAAoB,GAAG,wBAAwB,CAAC,KAAK,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;IAChF,OAAO;QACL,YAAY,EAAE;YACZ,SAAS,EAAE,IAAI,GAAG,CAAC,KAAK,CAAC,YAAY,CAAC,SAAS,CAAC;YAChD,UAAU,EAAE,IAAI,GAAG,CAAC;gBAClB,GAAG,KAAK,CAAC,YAAY,CAAC,UAAU;gBAChC,GAAG,KAAK,CAAC,SAAS,CAAC,UAAU;aAC9B,CAAC;YACF,UAAU,EAAE,IAAI,GAAG,CAAC,KAAK,CAAC,YAAY,CAAC,UAAU,CAAC;YAClD,SAAS,EAAE,IAAI,GAAG,CAAC,KAAK,CAAC,YAAY,CAAC,SAAS,CAAC;YAChD,SAAS,EAAE,IAAI,GAAG,CAAC;gBACjB,GAAG,KAAK,CAAC,SAAS,CAAC,SAAS;gBAC5B,GAAG,KAAK,CAAC,WAAW,CAAC,SAAS;aAC/B,CAAC;YACF,KAAK,EAAE,IAAI,GAAG,CAAC,KAAK,CAAC,SAAS,CAAC,KAAK,CAAC;YACrC,gBAAgB,EAAE,IAAI,GAAG,CAAC,KAAK,CAAC,SAAS,CAAC,gBAAgB,CAAC;YAC3D,WAAW,EAAE,IAAI,GAAG,CAAC,KAAK,CAAC,SAAS,CAAC,oBAAoB,CAAC;SAC3D;QACD,UAAU,EAAE,IAAI,GAAG,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;QACrD,SAAS,EAAE,MAAM,CAAC,MAAM,CAAC;YACvB,GAAG,oBAAoB;YACvB,GAAG,aAAa;SACjB,CAAC;QACF,aAAa;QACb,oBAAoB;QACpB,gBAAgB,EAAE,sBAAsB,CAAC,KAAK,CAAC,gBAAgB,CAAC;QAChE,sBAAsB,EAAE,IAAI,GAAG,CAAC,KAAK,CAAC,SAAS,CAAC,sBAAsB,CAAC;KACxE,CAAC;AACJ,CAAC;AAED,SAAS,wBAAwB,CAC/B,MAAmD;IAEnD,OAAO,MAAM,CAAC,MAAM,CAClB,MAAM,CAAC,WAAW,CAChB,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,MAAM,CAAC,EAAE,EAAE,CAAC;QAC5C,GAAG;QACH,MAAM,CAAC,MAAM,CACX,qBAAqB,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,cAAc,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC,CAC9E;KACF,CAAC,CACH,CACF,CAAC;AACJ,CAAC;AAED,SAAS,sBAAsB,CAC7B,MAA2D;IAE3D,OAAO,MAAM,CAAC,MAAM,CAClB,MAAM,CAAC,WAAW,CAChB,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,MAAM,CAAC,EAAE,EAAE,CAAC;QAC5C,GAAG;QACH,MAAM,CAAC,MAAM,CAAC,qBAAqB,CAAC,MAAM,CAAC,CAAC;KAC7C,CAAC,CACH,CACF,CAAC;AACJ,CAAC;AAED,IAAI,eAAmD,CAAC;AAExD;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,oBAAoB;IACxC,IAAI,eAAe;QAAE,OAAO,eAAe,CAAC;IAC5C,eAAe,GAAG,CAAC,KAAK,IAAI,EAAE;QAC5B,MAAM,CACJ,YAAY,EACZ,YAAY,EACZ,SAAS,EACT,WAAW,EACX,UAAU,EACV,SAAS,EACT,gBAAgB,EACjB,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC;YACpB,YAAY,CAAC,GAAG,EAAE;YAClB,iBAAiB,CAAC,GAAG,EAAE;YACvB,cAAc,CAAC,GAAG,EAAE;YACpB,gBAAgB,CAAC,GAAG,EAAE;YACtB,eAAe,CAAC,GAAG,EAAE;YACrB,kBAAkB,CAAC,GAAG,EAAE;YACxB,qBAAqB,CAAC,GAAG,EAAE;SAC5B,CAAC,CAAC;QACH,SAAS,GAAG,UAAU,CAAC;YACrB,YAAY;YACZ,YAAY;YACZ,SAAS;YACT,WAAW;YACX,UAAU;YACV,SAAS;YACT,gBAAgB;SACjB,CAAC,CAAC;QACH,OAAO,SAAS,CAAC;IACnB,CAAC,CAAC,EAAE,CAAC,OAAO,CAAC,GAAG,EAAE;QAChB,eAAe,GAAG,SAAS,CAAC;IAC9B,CAAC,CAAC,CAAC;IACH,OAAO,eAAe,CAAC;AACzB,CAAC;AAED,mEAAmE;AACnE,MAAM,CAAC,KAAK,UAAU,oBAAoB;IACxC,MAAM,CACJ,YAAY,EACZ,YAAY,EACZ,SAAS,EACT,WAAW,EACX,UAAU,EACV,SAAS,EACT,gBAAgB,EACjB,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC;QACpB,cAAc,CAAC,YAAY,EAAE,wBAAwB,CAAC;QACtD,cAAc,CAAC,iBAAiB,EAAE,oBAAoB,CAAC,YAAY,CAAC;QACpE,cAAc,CAAC,cAAc,EAAE,iBAAiB,CAAC,YAAY,CAAC;QAC9D,cAAc,CAAC,gBAAgB,EAAE,mBAAmB,CAAC,SAAS,CAAC;QAC/D,cAAc,CAAC,eAAe,EAAE,kBAAkB,CAAC,SAAS,CAAC,MAAM,CAAC;QACpE,cAAc,CAAC,kBAAkB,EAAE,iBAAiB,CAAC,SAAS,CAAC,MAAM,CAAC;QACtE,cAAc,CAAC,qBAAqB,EAAE,EAAE,CAAC;KAC1C,CAAC,CAAC;IACH,SAAS,GAAG,UAAU,CAAC;QACrB,YAAY;QACZ,YAAY;QACZ,SAAS;QACT,WAAW;QACX,UAAU;QACV,SAAS;QACT,gBAAgB;KACjB,CAAC,CAAC;IACH,OAAO,SAAS,CAAC;AACnB,CAAC;AAED,KAAK,UAAU,cAAc,CAAI,KAAuB,EAAE,QAAW;IACnE,MAAM,MAAM,GAAG,MAAM,KAAK,CAAC,IAAI,EAAE,CAAC;IAClC,IAAI,MAAM,KAAK,SAAS;QAAE,OAAO,MAAM,CAAC;IACxC,OAAO,KAAK,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,QAAQ,CAAC,CAAC;AAC3C,CAAC;AAED,2EAA2E;AAC3E,MAAM,UAAU,uBAAuB;IACrC,OAAO,aAAa,EAAE,CAAC,SAAS,CAAC;AACnC,CAAC;AAED,0EAA0E;AAC1E,MAAM,UAAU,yBAAyB;IACvC,OAAO,aAAa,EAAE,CAAC,gBAAgB,CAAC;AAC1C,CAAC;AAED;;;;;GAKG;AACH,MAAM,CAAC,KAAK,UAAU,uBAAuB,CAC3C,KAAa,EACb,MAAiC;IAEjC,MAAM,MAAM,GAAG,qBAAqB,CAAC,MAAM,CAAC,CAAC;IAC7C,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,uBAAuB,CAAC,KAAK,CAAC,CAAC;IAC/D,MAAM,GAAG,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC;IAC5B,IAAI,CAAC,GAAG;QAAE,OAAO,uBAAuB,CAAC,KAAK,CAAC,CAAC;IAChD,MAAM,SAAS,GAAG,MAAM,qBAAqB,CAAC,MAAM,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;QACjE,GAAG,OAAO;QACV,CAAC,GAAG,CAAC,EAAE,MAAM;KACd,CAAC,CAAC,CAAC;IACJ,MAAM,OAAO,GAAG,aAAa,EAAE,CAAC;IAChC,SAAS,GAAG;QACV,GAAG,OAAO;QACV,gBAAgB,EAAE,sBAAsB,CAAC,SAAS,CAAC;KACpD,CAAC;IACF,OAAO,CAAC,GAAG,MAAM,CAAC,CAAC;AACrB,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,CAAC,KAAK,UAAU,6BAA6B,CACjD,KAAa,EACb,IAAa;IAEb,MAAM,SAAS,GAAG,2BAA2B,CAAC,KAAK,EAAE,aAAa,EAAE,CAAC,CAAC;IACtE,IAAI,SAAS;QAAE,OAAO,SAAS,CAAC;IAChC,OAAO,uBAAuB,CAAC,KAAK,EAAE,oBAAoB,CAAC,IAAI,CAAC,CAAC,CAAC;AACpE,CAAC;AAED,4EAA4E;AAC5E,MAAM,UAAU,oBAAoB,CAAC,KAAsC;IACzE,MAAM,YAAY,GAAG,aAAa,EAAE,CAAC,YAAY,CAAC;IAClD,MAAM,UAAU,GAAG,eAAe,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IACjD,MAAM,IAAI,GAAG,UAAU,CAAC,OAAO,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC;IACxE,OAAO;QACL,SAAS,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,YAAY,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAC9D,UAAU,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,YAAY,CAAC,UAAU,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAChE,UAAU,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,YAAY,CAAC,UAAU,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAChE,oEAAoE;QACpE,SAAS,EACP,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,YAAY,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;YACnD,UAAU,CAAC,IAAI,CACb,CAAC,QAAQ,EAAE,EAAE,CACX,yBAAyB,CAAC,QAAQ,CAAC;gBACnC,uBAAuB,CAAC,QAAQ,EAAE,YAAY,CAAC,SAAS,CAAC,CAC5D;QACH,SAAS,EACP,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,YAAY,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;YACnD,UAAU,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,qBAAqB,CAAC,QAAQ,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC;QAC3E,KAAK,EACH,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,YAAY,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,IAAI,UAAU,CAAC,IAAI,CAAC,kBAAkB,CAAC;QACxF,gBAAgB,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,YAAY,CAAC,gBAAgB,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAC5E,WAAW,EAAE,0BAA0B,CAAC,KAAK,CAAC,KAAK,IAAI;KACxD,CAAC;AACJ,CAAC;AAED,sFAAsF;AACtF,MAAM,UAAU,0BAA0B,CACxC,KAAsC;IAEtC,MAAM,KAAK,GAAG,aAAa,EAAE,CAAC;IAC9B,MAAM,IAAI,GAAG,eAAe,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC;IACpF,IAAI,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,KAAK,CAAC,sBAAsB,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAAE,OAAO,KAAK,CAAC;IAC5E,IAAI,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,KAAK,CAAC,YAAY,CAAC,WAAW,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAAE,OAAO,IAAI,CAAC;IAC7E,OAAO,SAAS,CAAC;AACnB,CAAC;AAED,0EAA0E;AAC1E,MAAM,UAAU,kBAAkB,CAChC,KAAsC;IAEtC,MAAM,MAAM,GAAG,aAAa,EAAE,CAAC,UAAU,CAAC;IAC1C,KAAK,MAAM,QAAQ,IAAI,eAAe,CAAC,KAAK,CAAC,EAAE,CAAC;QAC9C,MAAM,GAAG,GAAG,QAAQ,CAAC,QAAQ,CAAC,CAAC;QAC/B,IAAI,CAAC,GAAG;YAAE,SAAS;QACnB,MAAM,KAAK,GAAG,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAC9B,IAAI,KAAK;YAAE,OAAO,KAAK,CAAC;IAC1B,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,uBAAuB,CAAC,KAAsC;IAC5E,MAAM,KAAK,GAAG,aAAa,EAAE,CAAC;IAC9B,MAAM,SAAS,GAAG,2BAA2B,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IAC5D,IAAI,SAAS;QAAE,OAAO,SAAS,CAAC;IAChC,KAAK,MAAM,QAAQ,IAAI,eAAe,CAAC,KAAK,CAAC,EAAE,CAAC;QAC9C,MAAM,OAAO,GAAG,yBAAyB,CAAC,QAAQ,EAAE,KAAK,CAAC,gBAAgB,CAAC,CAAC;QAC5E,IAAI,OAAO,EAAE,MAAM;YAAE,OAAO,OAAO,CAAC;IACtC,CAAC;IACD,MAAM,OAAO,GAAG,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,gBAAgB,IAAI,KAAK,CAAC,IAAI,CAAC,CAAC;IAC3F,OAAO,sBAAsB,CAAC,OAAO,CAAC,CAAC;AACzC,CAAC;AAED,SAAS,2BAA2B,CAClC,KAAsC,EACtC,KAAoB;IAEpB,MAAM,UAAU,GAAG,eAAe,CAAC,KAAK,CAAC,CAAC;IAC1C,KAAK,MAAM,QAAQ,IAAI,UAAU,EAAE,CAAC;QAClC,MAAM,UAAU,GAAG,yBAAyB,CAAC,QAAQ,EAAE,KAAK,CAAC,aAAa,CAAC,CAAC;QAC5E,IAAI,UAAU,EAAE,MAAM;YAAE,OAAO,UAAU,CAAC;IAC5C,CAAC;IACD,KAAK,MAAM,QAAQ,IAAI,UAAU,EAAE,CAAC;QAClC,MAAM,WAAW,GAAG,yBAAyB,CAAC,QAAQ,EAAE,KAAK,CAAC,oBAAoB,CAAC,CAAC;QACpF,IAAI,WAAW,EAAE,MAAM;YAAE,OAAO,WAAW,CAAC;IAC9C,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC;AAED,wEAAwE;AACxE,MAAM,UAAU,gBAAgB,CAAC,KAAsC;IACrE,MAAM,UAAU,GAAG,kBAAkB,CAAC,KAAK,CAAC,CAAC;IAC7C,OAAO;QACL,MAAM,EAAE,cAAc,CAAC,KAAK,CAAC;QAC7B,YAAY,EAAE,oBAAoB,CAAC,KAAK,CAAC;QACzC,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KACtC,CAAC;AACJ,CAAC;AAED,yEAAyE;AACzE,MAAM,UAAU,wBAAwB;IAQtC,OAAO;QACL,aAAa,EAAE,2BAA2B;QAC1C,YAAY,EAAE,oBAAoB,CAAC,WAAW;QAC9C,SAAS,EAAE,iBAAiB,CAAC,WAAW;QACxC,WAAW,EAAE,mBAAmB,CAAC,WAAW;QAC5C,UAAU,EAAE,kBAAkB,CAAC,WAAW;QAC1C,SAAS,EAAE,iBAAiB,CAAC,WAAW;KACzC,CAAC;AACJ,CAAC;AAED,SAAS,eAAe,CACtB,KAAsC,EACtC,kBAAkB,GAAG,IAAI;IAEzB,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,CAAC,KAAK,CAAC,CAAC;IAC9C,OAAO;QACL,KAAK,CAAC,IAAI;QACV,GAAG,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;QAClD,KAAK,CAAC,gBAAgB;QACtB,GAAG,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,YAAY,IAAI,EAAE,CAAC;KAC3C,CAAC,MAAM,CAAC,CAAC,KAAK,EAAmB,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC;AACvD,CAAC;AAED,SAAS,QAAQ,CAAC,KAAa;IAC7B,OAAO,gBAAgB,CAAC,KAAK,CAAC,EAAE,UAAU,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;AACvD,CAAC;AAED,KAAK,UAAU,QAAQ,CAAC,GAAW;IACjC,MAAM,QAAQ,GAAG,MAAM,KAAK,CAAC,GAAG,EAAE;QAChC,OAAO,EAAE,EAAE,YAAY,EAAE,UAAU,EAAE;QACrC,MAAM,EAAE,WAAW,CAAC,OAAO,CAAC,MAAM,CAAC;KACpC,CAAC,CAAC;IACH,IAAI,CAAC,QAAQ,CAAC,EAAE,EAAE,CAAC;QACjB,MAAM,IAAI,KAAK,CAAC,0CAA0C,QAAQ,CAAC,MAAM,KAAK,GAAG,EAAE,CAAC,CAAC;IACvF,CAAC;IACD,OAAO,QAAQ,CAAC,IAAI,EAAE,CAAC;AACzB,CAAC;AAED,KAAK,UAAU,QAAQ,CAAC,GAAW;IACjC,MAAM,QAAQ,GAAG,MAAM,KAAK,CAAC,GAAG,EAAE;QAChC,OAAO,EAAE,EAAE,YAAY,EAAE,UAAU,EAAE;QACrC,MAAM,EAAE,WAAW,CAAC,OAAO,CAAC,MAAM,CAAC;KACpC,CAAC,CAAC;IACH,IAAI,CAAC,QAAQ,CAAC,EAAE,EAAE,CAAC;QACjB,MAAM,IAAI,KAAK,CAAC,uCAAuC,QAAQ,CAAC,MAAM,KAAK,GAAG,EAAE,CAAC,CAAC;IACpF,CAAC;IACD,OAAO,QAAQ,CAAC,IAAI,EAAE,CAAC;AACzB,CAAC;AAED,SAAS,kBAAkB,CAAC,KAI3B;IACC,MAAM,UAAU,GAAG,CAAC,GAAuC,EAAE,EAAE,CAC7D,oBAAoB,CAAC;QACnB,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,CAAC,GAAG,CAAC;QACzB,QAAQ,EAAE,KAAK,CAAC,QAAQ,EAAE,CAAC,GAAG,CAAC;QAC/B,QAAQ,EAAE,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC;KAC9B,CAAC,CAAC;IACL,OAAO;QACL,UAAU,EAAE,UAAU,CAAC,YAAY,CAAC;QACpC,SAAS,EAAE,UAAU,CAAC,WAAW,CAAC;QAClC,KAAK,EAAE,UAAU,CAAC,OAAO,CAAC;QAC1B,gBAAgB,EAAE,UAAU,CAAC,kBAAkB,CAAC;QAChD,oBAAoB,EAAE,UAAU,CAAC,sBAAsB,CAAC;QACxD,sBAAsB,EAAE,UAAU,CAAC,wBAAwB,CAAC;KAC7D,CAAC;AACJ,CAAC;AAED,SAAS,UAAU;IACjB,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,CAAC;AACvC,CAAC","sourcesContent":["/**\n * Build-generated Databricks and public model capability metadata, plus a\n * daily write-through cache for refreshed sources and error-learned reasoning\n * ladders.\n *\n * Committed snapshots seed every process. {@link refreshModelMetadata} pulls\n * Databricks documentation, models.dev, and modelparams.dev through the shared\n * memory-first {@link createMetadataCache} and rebuilds the in-memory index.\n * Error-learned efforts use the same store via {@link rememberReasoningLevels}.\n * Known-good values are written behind to the shared model project cache.\n *\n * @module\n */\nimport { memoize } from \"@dbx-tools/shared-core\";\nimport type {\n  ModelCapabilities,\n  ModelMetadata,\n  ModelRateLimits,\n  ServingEndpointSummary,\n} from \"@dbx-tools/shared-model\";\n\nimport {\n  parseModelParams,\n  parseModelCapabilities,\n  parseModelRateLimits,\n  parseModelsDev,\n  parseReasoningModels,\n  parseRetiredModels,\n} from \"./_metadata-generator.ts\";\nimport capabilitiesSnapshotJson from \"./generated/model-capabilities.json\" with { type: \"json\" };\nimport modelParamsSnapshotJson from \"./generated/modelparams-reasoning.json\" with { type: \"json\" };\nimport modelsDevSnapshotJson from \"./generated/models-dev-capabilities.json\" with { type: \"json\" };\nimport rateLimitsSnapshotJson from \"./generated/model-rate-limits.json\" with { type: \"json\" };\nimport reasoningSnapshotJson from \"./generated/model-reasoning.json\" with { type: \"json\" };\nimport {\n  createMetadataCache,\n  mergePreferFreshList,\n  mergePreferFreshRecord,\n  type MetadataCache,\n} from \"./metadata-cache.ts\";\nimport {\n  MODELPARAMS_DEV_MODELS_URL,\n  MODELS_DEV_API_URL,\n  MODEL_RATE_LIMITS_URL,\n  OPENAI_RESPONSES_MODELS_URL,\n  QUERY_REASON_MODELS_URL,\n  RETIRED_MODELS_URL,\n  WEB_SEARCH_MODELS_URL,\n  type ModelParamsCatalogue,\n  type ModelParamsSnapshot,\n  type ModelCapabilitiesSnapshot,\n  type ModelCapabilityCatalogue,\n  type ModelRateLimitsSnapshot,\n  type ModelsDevCapabilityCatalogue,\n  type ModelsDevSnapshot,\n  type ReasoningModelsSnapshot,\n} from \"./metadata-contract.ts\";\nimport {\n  inheritsNativeWebSearch,\n  isFoundationModelIdentity,\n  modelReasoningEfforts,\n  modelSearchQuery,\n  modelSupportsTools,\n} from \"./policy.ts\";\nimport {\n  defaultReasoningLevels,\n  documentedReasoningLevels,\n  parseReasoning,\n  parseReasoningLevels,\n  type ReasoningLevel,\n  type ReasoningModelCatalogue,\n  uniqueReasoningLevels,\n} from \"./reasoning-translation.ts\";\nimport {\n  COMMITTED_RETIRED_MODELS,\n  modelStatusFor,\n  replaceRetiredModelNames,\n  RETIRED_MODELS_GENERATED_AT,\n} from \"./retirement.ts\";\n\nconst capabilitiesSnapshot = capabilitiesSnapshotJson as ModelCapabilitiesSnapshot;\nconst modelParamsSnapshot = modelParamsSnapshotJson as ModelParamsSnapshot;\nconst modelsDevSnapshot = modelsDevSnapshotJson as ModelsDevSnapshot;\nconst rateLimitsSnapshot = rateLimitsSnapshotJson as ModelRateLimitsSnapshot;\nconst reasoningSnapshot = reasoningSnapshotJson as ReasoningModelsSnapshot;\n\ninterface MetadataIndex {\n  readonly capabilities: {\n    readonly [Key in keyof ModelCapabilities]: ReadonlySet<string>;\n  };\n  readonly rateLimits: ReadonlyMap<string, ModelRateLimits>;\n  readonly reasoning: ReasoningModelCatalogue;\n  readonly reasoningDocs: ReasoningModelCatalogue;\n  readonly modelParamsReasoning: ReasoningModelCatalogue;\n  readonly learnedReasoning: ReasoningModelCatalogue;\n  readonly temperatureUnsupported: ReadonlySet<string>;\n}\n\ntype CapabilitySets = ModelCapabilityCatalogue;\ntype ModelsDevData = ModelsDevCapabilityCatalogue;\n\nconst USER_AGENT = \"dbx-tools-model-metadata/1\";\n\nconst retiredCache = createMetadataCache<readonly string[]>({\n  key: \"retired-models\",\n  fallback: COMMITTED_RETIRED_MODELS,\n  load: async () => parseRetiredModels(await loadPage(RETIRED_MODELS_URL), nowSeconds()).models,\n  merge: mergePreferFreshList,\n});\n\nconst capabilitiesCache = createMetadataCache<CapabilitySets>({\n  key: \"model-capabilities\",\n  fallback: capabilitiesSnapshot.capabilities,\n  load: async () => {\n    const [responsesHtml, webSearchHtml] = await Promise.all([\n      loadPage(OPENAI_RESPONSES_MODELS_URL),\n      loadPage(WEB_SEARCH_MODELS_URL),\n    ]);\n    return parseModelCapabilities(responsesHtml, webSearchHtml, nowSeconds()).capabilities;\n  },\n  merge: (input) => ({\n    responses: mergePreferFreshList({\n      fresh: input.fresh?.responses,\n      previous: input.previous?.responses,\n      fallback: input.fallback.responses,\n    }),\n    imageInput: mergePreferFreshList({\n      fresh: input.fresh?.imageInput,\n      previous: input.previous?.imageInput,\n      fallback: input.fallback.imageInput,\n    }),\n    applyPatch: mergePreferFreshList({\n      fresh: input.fresh?.applyPatch,\n      previous: input.previous?.applyPatch,\n      fallback: input.fallback.applyPatch,\n    }),\n    webSearch: mergePreferFreshList({\n      fresh: input.fresh?.webSearch,\n      previous: input.previous?.webSearch,\n      fallback: input.fallback.webSearch,\n    }),\n  }),\n});\n\nconst rateLimitsCache = createMetadataCache<Readonly<Record<string, ModelRateLimits>>>({\n  key: \"model-rate-limits\",\n  fallback: rateLimitsSnapshot.catalogue.models,\n  load: async () =>\n    parseModelRateLimits(await loadPage(MODEL_RATE_LIMITS_URL), nowSeconds()).catalogue.models,\n  merge: mergePreferFreshRecord,\n});\n\nconst reasoningDocsCache = createMetadataCache<Readonly<Record<string, readonly string[]>>>({\n  key: \"model-reasoning\",\n  fallback: reasoningSnapshot.catalogue.models,\n  load: async () =>\n    parseReasoningModels(await loadPage(QUERY_REASON_MODELS_URL), nowSeconds()).catalogue.models,\n  merge: mergePreferFreshRecord,\n});\n\nconst modelsDevCache = createMetadataCache<ModelsDevData>({\n  key: \"models-dev-capabilities\",\n  fallback: modelsDevSnapshot.capabilities,\n  load: async () => {\n    const snapshot = parseModelsDev(await loadJson(MODELS_DEV_API_URL), nowSeconds());\n    return snapshot.capabilities;\n  },\n  merge: mergeModelsDevData,\n});\n\nconst modelParamsCache = createMetadataCache<ModelParamsCatalogue>({\n  key: \"modelparams-reasoning\",\n  fallback: modelParamsSnapshot.catalogue,\n  load: async () =>\n    parseModelParams(await loadJson(MODELPARAMS_DEV_MODELS_URL), nowSeconds()).catalogue,\n  merge: (input) => ({\n    reasoning: mergePreferFreshList({\n      fresh: input.fresh?.reasoning,\n      previous: input.previous?.reasoning,\n      fallback: input.fallback.reasoning,\n    }),\n    models: mergePreferFreshRecord({\n      fresh: input.fresh?.models,\n      previous: input.previous?.models,\n      fallback: input.fallback.models,\n    }),\n  }),\n});\n\nconst learnedReasoningCache = createMetadataCache<\n  Readonly<Record<string, readonly ReasoningLevel[]>>\n>({\n  key: \"learned-reasoning\",\n  fallback: {},\n  merge: mergePreferFreshRecord,\n});\n\nlet liveIndex: MetadataIndex | undefined;\n\nconst committedMetadataIndex = memoize<MetadataIndex>(buildIndexFromCommitted);\n\nfunction metadataIndex(): MetadataIndex {\n  return liveIndex ?? committedMetadataIndex();\n}\n\nfunction buildIndexFromCommitted(): MetadataIndex {\n  return buildIndex({\n    retiredNames: COMMITTED_RETIRED_MODELS,\n    capabilities: capabilitiesSnapshot.capabilities,\n    modelsDev: modelsDevSnapshot.capabilities,\n    modelParams: modelParamsSnapshot.catalogue,\n    rateLimits: rateLimitsSnapshot.catalogue.models,\n    reasoning: reasoningSnapshot.catalogue.models,\n    learnedReasoning: {},\n  });\n}\n\nfunction buildIndex(input: {\n  readonly retiredNames: readonly string[];\n  readonly capabilities: CapabilitySets;\n  readonly modelsDev: ModelsDevData;\n  readonly modelParams: ModelParamsCatalogue;\n  readonly rateLimits: Readonly<Record<string, ModelRateLimits>>;\n  readonly reasoning: Readonly<Record<string, readonly string[]>>;\n  readonly learnedReasoning: Readonly<Record<string, readonly ReasoningLevel[]>>;\n}): MetadataIndex {\n  replaceRetiredModelNames(input.retiredNames);\n  const reasoningDocs = freezeReasoningCatalogue(input.reasoning);\n  const modelParamsReasoning = freezeReasoningCatalogue(input.modelParams.models);\n  return {\n    capabilities: {\n      responses: new Set(input.capabilities.responses),\n      imageInput: new Set([\n        ...input.capabilities.imageInput,\n        ...input.modelsDev.imageInput,\n      ]),\n      applyPatch: new Set(input.capabilities.applyPatch),\n      webSearch: new Set(input.capabilities.webSearch),\n      reasoning: new Set([\n        ...input.modelsDev.reasoning,\n        ...input.modelParams.reasoning,\n      ]),\n      tools: new Set(input.modelsDev.tools),\n      structuredOutput: new Set(input.modelsDev.structuredOutput),\n      temperature: new Set(input.modelsDev.temperatureSupported),\n    },\n    rateLimits: new Map(Object.entries(input.rateLimits)),\n    reasoning: Object.freeze({\n      ...modelParamsReasoning,\n      ...reasoningDocs,\n    }),\n    reasoningDocs,\n    modelParamsReasoning,\n    learnedReasoning: freezeLearnedCatalogue(input.learnedReasoning),\n    temperatureUnsupported: new Set(input.modelsDev.temperatureUnsupported),\n  };\n}\n\nfunction freezeReasoningCatalogue(\n  models: Readonly<Record<string, readonly string[]>>,\n): ReasoningModelCatalogue {\n  return Object.freeze(\n    Object.fromEntries(\n      Object.entries(models).map(([key, levels]) => [\n        key,\n        Object.freeze(\n          uniqueReasoningLevels(levels.flatMap((level) => parseReasoning(level) ?? [])),\n        ),\n      ]),\n    ),\n  );\n}\n\nfunction freezeLearnedCatalogue(\n  models: Readonly<Record<string, readonly ReasoningLevel[]>>,\n): ReasoningModelCatalogue {\n  return Object.freeze(\n    Object.fromEntries(\n      Object.entries(models).map(([key, levels]) => [\n        key,\n        Object.freeze(uniqueReasoningLevels(levels)),\n      ]),\n    ),\n  );\n}\n\nlet refreshInflight: Promise<MetadataIndex> | undefined;\n\n/**\n * Hydrate or refresh documentation + learned caches into the process index.\n *\n * Safe to call on gateway startup. Concurrent callers share one refresh.\n */\nexport async function refreshModelMetadata(): Promise<MetadataIndex> {\n  if (refreshInflight) return refreshInflight;\n  refreshInflight = (async () => {\n    const [\n      retiredNames,\n      capabilities,\n      modelsDev,\n      modelParams,\n      rateLimits,\n      reasoning,\n      learnedReasoning,\n    ] = await Promise.all([\n      retiredCache.get(),\n      capabilitiesCache.get(),\n      modelsDevCache.get(),\n      modelParamsCache.get(),\n      rateLimitsCache.get(),\n      reasoningDocsCache.get(),\n      learnedReasoningCache.get(),\n    ]);\n    liveIndex = buildIndex({\n      retiredNames,\n      capabilities,\n      modelsDev,\n      modelParams,\n      rateLimits,\n      reasoning,\n      learnedReasoning,\n    });\n    return liveIndex;\n  })().finally(() => {\n    refreshInflight = undefined;\n  });\n  return refreshInflight;\n}\n\n/** Load shared cache entries without forcing a network refresh. */\nexport async function hydrateModelMetadata(): Promise<MetadataIndex> {\n  const [\n    retiredNames,\n    capabilities,\n    modelsDev,\n    modelParams,\n    rateLimits,\n    reasoning,\n    learnedReasoning,\n  ] = await Promise.all([\n    peekOrFallback(retiredCache, COMMITTED_RETIRED_MODELS),\n    peekOrFallback(capabilitiesCache, capabilitiesSnapshot.capabilities),\n    peekOrFallback(modelsDevCache, modelsDevSnapshot.capabilities),\n    peekOrFallback(modelParamsCache, modelParamsSnapshot.catalogue),\n    peekOrFallback(rateLimitsCache, rateLimitsSnapshot.catalogue.models),\n    peekOrFallback(reasoningDocsCache, reasoningSnapshot.catalogue.models),\n    peekOrFallback(learnedReasoningCache, {}),\n  ]);\n  liveIndex = buildIndex({\n    retiredNames,\n    capabilities,\n    modelsDev,\n    modelParams,\n    rateLimits,\n    reasoning,\n    learnedReasoning,\n  });\n  return liveIndex;\n}\n\nasync function peekOrFallback<T>(cache: MetadataCache<T>, fallback: T): Promise<T> {\n  const peeked = await cache.peek();\n  if (peeked !== undefined) return peeked;\n  return cache.get().catch(() => fallback);\n}\n\n/** Return the committed reasoning-effort catalogue. Cached per process. */\nexport function reasoningModelCatalogue(): ReasoningModelCatalogue {\n  return metadataIndex().reasoning;\n}\n\n/** Return error-learned reasoning ladders from the shared model cache. */\nexport function learnedReasoningCatalogue(): ReasoningModelCatalogue {\n  return metadataIndex().learnedReasoning;\n}\n\n/**\n * Store levels learned from an upstream error and persist them write-through.\n *\n * Empty lists are ignored so a failed parse cannot wipe defaults. Error bodies\n * themselves are never stored - only the parsed ladder.\n */\nexport async function rememberReasoningLevels(\n  model: string,\n  levels: readonly ReasoningLevel[],\n): Promise<ReasoningLevel[]> {\n  const unique = uniqueReasoningLevels(levels);\n  if (unique.length === 0) return modelReasoningLevelsFor(model);\n  const key = modelKey(model);\n  if (!key) return modelReasoningLevelsFor(model);\n  const catalogue = await learnedReasoningCache.update((current) => ({\n    ...current,\n    [key]: unique,\n  }));\n  const current = metadataIndex();\n  liveIndex = {\n    ...current,\n    learnedReasoning: freezeLearnedCatalogue(catalogue),\n  };\n  return [...unique];\n}\n\n/**\n * Parse an upstream error body and persist the supported ladder for `model`.\n *\n * Accepts the same nested Databricks envelopes as {@link parseReasoningLevels}.\n * Returns a published ladder without parsing or storing error-derived levels\n * when one exists. Otherwise returns the levels that were stored, or the\n * current fallback when parsing yields nothing. The raw error body is never\n * cached.\n */\nexport async function learnReasoningLevelsFromError(\n  model: string,\n  body: unknown,\n): Promise<ReasoningLevel[]> {\n  const published = publishedReasoningLevelsFor(model, metadataIndex());\n  if (published) return published;\n  return rememberReasoningLevels(model, parseReasoningLevels(body));\n}\n\n/** Resolve published model capabilities from a name or endpoint summary. */\nexport function modelCapabilitiesFor(model: string | ServingEndpointSummary): ModelCapabilities {\n  const capabilities = metadataIndex().capabilities;\n  const identities = modelIdentities(model, false);\n  const keys = identities.flatMap((identity) => modelKey(identity) ?? []);\n  return {\n    responses: keys.some((key) => capabilities.responses.has(key)),\n    imageInput: keys.some((key) => capabilities.imageInput.has(key)),\n    applyPatch: keys.some((key) => capabilities.applyPatch.has(key)),\n    // Version inheritance only applies to hosted foundation identities.\n    webSearch:\n      keys.some((key) => capabilities.webSearch.has(key)) ||\n      identities.some(\n        (identity) =>\n          isFoundationModelIdentity(identity) &&\n          inheritsNativeWebSearch(identity, capabilities.webSearch),\n      ),\n    reasoning:\n      keys.some((key) => capabilities.reasoning.has(key)) ||\n      identities.some((identity) => modelReasoningEfforts(identity).length > 0),\n    tools:\n      keys.some((key) => capabilities.tools.has(key)) || identities.some(modelSupportsTools),\n    structuredOutput: keys.some((key) => capabilities.structuredOutput.has(key)),\n    temperature: modelTemperatureSupportFor(model) === true,\n  };\n}\n\n/** Resolve explicit Databricks temperature support, or undefined when unpublished. */\nexport function modelTemperatureSupportFor(\n  model: string | ServingEndpointSummary,\n): boolean | undefined {\n  const index = metadataIndex();\n  const keys = modelIdentities(model).flatMap((identity) => modelKey(identity) ?? []);\n  if (keys.some((key) => index.temperatureUnsupported.has(key))) return false;\n  if (keys.some((key) => index.capabilities.temperature.has(key))) return true;\n  return undefined;\n}\n\n/** Resolve published ITPM, OTPM, and QPH limits from a model identity. */\nexport function modelRateLimitsFor(\n  model: string | ServingEndpointSummary,\n): ModelRateLimits | undefined {\n  const limits = metadataIndex().rateLimits;\n  for (const identity of modelIdentities(model)) {\n    const key = modelKey(identity);\n    if (!key) continue;\n    const found = limits.get(key);\n    if (found) return found;\n  }\n  return undefined;\n}\n\n/**\n * Resolve reasoning levels: Databricks documentation, modelparams.dev,\n * learned errors, then family defaults.\n *\n * Does not parse error bodies; callers handling an upstream error should use\n * {@link learnReasoningLevelsFromError} so published levels keep precedence.\n */\nexport function modelReasoningLevelsFor(model: string | ServingEndpointSummary): ReasoningLevel[] {\n  const index = metadataIndex();\n  const published = publishedReasoningLevelsFor(model, index);\n  if (published) return published;\n  for (const identity of modelIdentities(model)) {\n    const learned = documentedReasoningLevels(identity, index.learnedReasoning);\n    if (learned?.length) return learned;\n  }\n  const primary = typeof model === \"string\" ? model : (model.modelServiceName ?? model.name);\n  return defaultReasoningLevels(primary);\n}\n\nfunction publishedReasoningLevelsFor(\n  model: string | ServingEndpointSummary,\n  index: MetadataIndex,\n): ReasoningLevel[] | undefined {\n  const identities = modelIdentities(model);\n  for (const identity of identities) {\n    const documented = documentedReasoningLevels(identity, index.reasoningDocs);\n    if (documented?.length) return documented;\n  }\n  for (const identity of identities) {\n    const modelParams = documentedReasoningLevels(identity, index.modelParamsReasoning);\n    if (modelParams?.length) return modelParams;\n  }\n  return undefined;\n}\n\n/** Resolve retirement, capability, and rate-limit metadata together. */\nexport function modelMetadataFor(model: string | ServingEndpointSummary): ModelMetadata {\n  const rateLimits = modelRateLimitsFor(model);\n  return {\n    status: modelStatusFor(model),\n    capabilities: modelCapabilitiesFor(model),\n    ...(rateLimits ? { rateLimits } : {}),\n  };\n}\n\n/** Return generation timestamps for the committed metadata snapshots. */\nexport function modelMetadataGeneratedAt(): Readonly<{\n  retiredModels: number;\n  capabilities: number;\n  modelsDev: number;\n  modelParams: number;\n  rateLimits: number;\n  reasoning: number;\n}> {\n  return {\n    retiredModels: RETIRED_MODELS_GENERATED_AT,\n    capabilities: capabilitiesSnapshot.generatedAt,\n    modelsDev: modelsDevSnapshot.generatedAt,\n    modelParams: modelParamsSnapshot.generatedAt,\n    rateLimits: rateLimitsSnapshot.generatedAt,\n    reasoning: reasoningSnapshot.generatedAt,\n  };\n}\n\nfunction modelIdentities(\n  model: string | ServingEndpointSummary,\n  includeDisplayName = true,\n): string[] {\n  if (typeof model === \"string\") return [model];\n  return [\n    model.name,\n    ...(includeDisplayName ? [model.displayName] : []),\n    model.modelServiceName,\n    ...Object.values(model.serviceNames ?? {}),\n  ].filter((value): value is string => Boolean(value));\n}\n\nfunction modelKey(value: string): string | undefined {\n  return modelSearchQuery(value)?.replaceAll(\" \", \"-\");\n}\n\nasync function loadPage(url: string): Promise<string> {\n  const response = await fetch(url, {\n    headers: { \"user-agent\": USER_AGENT },\n    signal: AbortSignal.timeout(15_000),\n  });\n  if (!response.ok) {\n    throw new Error(`Databricks documentation returned HTTP ${response.status}: ${url}`);\n  }\n  return response.text();\n}\n\nasync function loadJson(url: string): Promise<unknown> {\n  const response = await fetch(url, {\n    headers: { \"user-agent\": USER_AGENT },\n    signal: AbortSignal.timeout(15_000),\n  });\n  if (!response.ok) {\n    throw new Error(`Model metadata source returned HTTP ${response.status}: ${url}`);\n  }\n  return response.json();\n}\n\nfunction mergeModelsDevData(input: {\n  readonly fresh: ModelsDevData | undefined;\n  readonly previous: ModelsDevData | undefined;\n  readonly fallback: ModelsDevData;\n}): ModelsDevData {\n  const capability = (key: keyof ModelsDevCapabilityCatalogue) =>\n    mergePreferFreshList({\n      fresh: input.fresh?.[key],\n      previous: input.previous?.[key],\n      fallback: input.fallback[key],\n    });\n  return {\n    imageInput: capability(\"imageInput\"),\n    reasoning: capability(\"reasoning\"),\n    tools: capability(\"tools\"),\n    structuredOutput: capability(\"structuredOutput\"),\n    temperatureSupported: capability(\"temperatureSupported\"),\n    temperatureUnsupported: capability(\"temperatureUnsupported\"),\n  };\n}\n\nfunction nowSeconds(): number {\n  return Math.floor(Date.now() / 1000);\n}\n"]}