@dbx-tools/model 0.9.32 → 0.9.36

package/lib/src/invoke.d.ts

@@ -41,6 +41,10 @@ export declare const OPEN_RESPONSES_PATH = "serving-endpoints/open-responses";
  * attaching a provider tool spec to whichever endpoint was resolved.
  */
 export declare const CHAT_COMPLETIONS_PATH = "serving-endpoints/chat/completions";
+/** Unity Gateway OpenAI Responses path used by Codex-compatible model services. */
+export declare const AI_GATEWAY_CODEX_RESPONSES_PATH = "ai-gateway/codex/v1/responses";
+/** Workspace Anthropic Messages path for native Claude requests. */
+export declare const ANTHROPIC_MESSAGES_PATH = "serving-endpoints/anthropic/v1/messages";
 /**
  * The OpenAI-compatible chat-completions invocations URL for an endpoint id.
  *
@@ -55,6 +59,10 @@ export declare function responsesUrl(host: string): string;
 export declare function openResponsesUrl(host: string): string;
 /** Workspace OpenAI Chat Completions URL (`POST`, model in the body). */
 export declare function chatCompletionsUrl(host: string): string;
+/** Unity Gateway Codex Responses URL (`POST`, model service in the body). */
+export declare function aiGatewayCodexResponsesUrl(host: string): string;
+/** Workspace Anthropic Messages URL (`POST`, model in the body). */
+export declare function anthropicMessagesUrl(host: string): string;
 /**
  * True when the endpoint is known to reject Chat Completions `/invocations`
  * and require the Responses API (Codex models today). Callers should route

package/lib/src/invoke.js

@@ -42,6 +42,10 @@ export const OPEN_RESPONSES_PATH = "serving-endpoints/open-responses";
  * attaching a provider tool spec to whichever endpoint was resolved.
  */
 export const CHAT_COMPLETIONS_PATH = "serving-endpoints/chat/completions";
+/** Unity Gateway OpenAI Responses path used by Codex-compatible model services. */
+export const AI_GATEWAY_CODEX_RESPONSES_PATH = "ai-gateway/codex/v1/responses";
+/** Workspace Anthropic Messages path for native Claude requests. */
+export const ANTHROPIC_MESSAGES_PATH = "serving-endpoints/anthropic/v1/messages";
 /**
  * The OpenAI-compatible chat-completions invocations URL for an endpoint id.
  *
@@ -64,6 +68,14 @@ export function openResponsesUrl(host) {
 export function chatCompletionsUrl(host) {
     return new URL(CHAT_COMPLETIONS_PATH, host).toString();
 }
+/** Unity Gateway Codex Responses URL (`POST`, model service in the body). */
+export function aiGatewayCodexResponsesUrl(host) {
+    return new URL(AI_GATEWAY_CODEX_RESPONSES_PATH, host).toString();
+}
+/** Workspace Anthropic Messages URL (`POST`, model in the body). */
+export function anthropicMessagesUrl(host) {
+    return new URL(ANTHROPIC_MESSAGES_PATH, host).toString();
+}
 /**
  * True when the endpoint is known to reject Chat Completions `/invocations`
  * and require the Responses API (Codex models today). Callers should route
@@ -102,4 +114,4 @@ export async function authHeaders(client) {
     });
     return out;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"invoke.js","sourceRoot":"","sources":["../../src/invoke.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAAE,eAAe,IAAI,uBAAuB,EAAE,MAAM,aAAa,CAAC;AAEzE;;;;;GAKG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,aAAa,CAAC;AAEhD;;;GAGG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,6BAA6B,CAAC;AAE5D;;;GAGG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,kCAAkC,CAAC;AAEtE;;;;;GAKG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,oCAAoC,CAAC;AAE1E;;;;;;GAMG;AACH,MAAM,UAAU,cAAc,CAAC,IAAY,EAAE,QAAgB;IAC3D,OAAO,IAAI,GAAG,CACZ,qBAAqB,kBAAkB,CAAC,QAAQ,CAAC,IAAI,kBAAkB,EAAE,EACzE,IAAI,CACL,CAAC,QAAQ,EAAE,CAAC;AACf,CAAC;AAED,sEAAsE;AACtE,MAAM,UAAU,YAAY,CAAC,IAAY;IACvC,OAAO,IAAI,GAAG,CAAC,cAAc,EAAE,IAAI,CAAC,CAAC,QAAQ,EAAE,CAAC;AAClD,CAAC;AAED,oEAAoE;AACpE,MAAM,UAAU,gBAAgB,CAAC,IAAY;IAC3C,OAAO,IAAI,GAAG,CAAC,mBAAmB,EAAE,IAAI,CAAC,CAAC,QAAQ,EAAE,CAAC;AACvD,CAAC;AAED,yEAAyE;AACzE,MAAM,UAAU,kBAAkB,CAAC,IAAY;IAC7C,OAAO,IAAI,GAAG,CAAC,qBAAqB,EAAE,IAAI,CAAC,CAAC,QAAQ,EAAE,CAAC;AACzD,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,eAAe,CAAC,QAAgB;IAC9C,OAAO,uBAAuB,CAAC,QAAQ,CAAC,CAAC;AAC3C,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,oBAAoB,CAAC,IAAY,EAAE,QAAgB;IACjE,OAAO,cAAc,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC;AAChF,CAAC;AAED,+EAA+E;AAC/E,SAAS,cAAc,CAAC,QAAgB;IACtC,MAAM,CAAC,GAAG,QAAQ,CAAC,WAAW,EAAE,CAAC;IACjC,OAAO,CACL,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC;QACjB,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC;QACnB,4BAA4B,CAAC,IAAI,CAAC,CAAC,CAAC;QACpC,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,CACrB,CAAC;AACJ,CAAC;AAcD;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,WAAW,CAC/B,MAAgC;IAEhC,MAAM,OAAO,GAAG,IAAI,OAAO,EAAE,CAAC;IAC9B,MAAM,MAAM,CAAC,MAAM,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;IAC1C,MAAM,GAAG,GAA2B,EAAE,CAAC;IACvC,OAAO,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE;QAC7B,GAAG,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;IACnB,CAAC,CAAC,CAAC;IACH,OAAO,GAAG,CAAC;AACb,CAAC","sourcesContent":["/**\n * Calling a Model Serving endpoint directly over HTTP.\n *\n * The SDK's `servingEndpoints.query` covers the typed request shapes, but an\n * OpenAI-compatible caller (a proxy, a passthrough route, a streaming client)\n * needs to issue its own `fetch` against Databricks' OpenAI-shaped URLs with\n * an OpenAI body. That needs exactly two things the SDK doesn't hand out\n * directly: the URL ({@link invocationsUrl} / {@link responsesUrl} /\n * {@link openResponsesUrl}) and a currently-valid set of auth headers\n * ({@link authHeaders}).\n *\n * Auth is delegated entirely to the Databricks SDK: `config.authenticate`\n * re-runs the configured credential provider on every call and refreshes the\n * underlying OAuth / PAT token when it is close to expiry, so a caller never\n * manages token lifetimes itself - mint headers per request and each one is\n * signed with a valid bearer token.\n *\n * @module\n */\n\nimport { isResponsesOnly as isResponsesOnlyByPolicy } from \"./policy.ts\";\n\n/**\n * Path segment appended to a serving endpoint for OpenAI-compatible chat\n * requests. Databricks routes `/serving-endpoints/<name>/invocations` to the\n * endpoint's Chat Completions surface (`messages` in, `choices` out). Some\n * models (notably Codex) reject this path and require {@link responsesUrl}.\n */\nexport const INVOCATIONS_SUFFIX = \"invocations\";\n\n/**\n * Workspace-level OpenAI Responses API path. Body carries `model` (endpoint\n * id); used by GPT / Codex models that speak Responses natively.\n */\nexport const RESPONSES_PATH = \"serving-endpoints/responses\";\n\n/**\n * Workspace-level Open Responses API path - the cross-provider Responses\n * surface (Claude, Gemini, …) that OpenAI `/responses` does not cover.\n */\nexport const OPEN_RESPONSES_PATH = \"serving-endpoints/open-responses\";\n\n/**\n * Workspace-level OpenAI Chat Completions path. Body carries `model` (endpoint\n * id), unlike {@link invocationsUrl} which names the endpoint in the URL. Use\n * this when the caller has a model id rather than a per-endpoint route - e.g.\n * attaching a provider tool spec to whichever endpoint was resolved.\n */\nexport const CHAT_COMPLETIONS_PATH = \"serving-endpoints/chat/completions\";\n\n/**\n * The OpenAI-compatible chat-completions invocations URL for an endpoint id.\n *\n * @param host - Workspace host, e.g. `https://my-workspace.cloud.databricks.com/`.\n *   Pass the value resolved from `client.config.getHost()`.\n * @param endpoint - Endpoint id (already resolved; not fuzzy-matched here).\n */\nexport function invocationsUrl(host: string, endpoint: string): string {\n  return new URL(\n    `serving-endpoints/${encodeURIComponent(endpoint)}/${INVOCATIONS_SUFFIX}`,\n    host,\n  ).toString();\n}\n\n/** Workspace OpenAI Responses API URL (`POST`, model in the body). */\nexport function responsesUrl(host: string): string {\n  return new URL(RESPONSES_PATH, host).toString();\n}\n\n/** Workspace Open Responses API URL (`POST`, model in the body). */\nexport function openResponsesUrl(host: string): string {\n  return new URL(OPEN_RESPONSES_PATH, host).toString();\n}\n\n/** Workspace OpenAI Chat Completions URL (`POST`, model in the body). */\nexport function chatCompletionsUrl(host: string): string {\n  return new URL(CHAT_COMPLETIONS_PATH, host).toString();\n}\n\n/**\n * True when the endpoint is known to reject Chat Completions `/invocations`\n * and require the Responses API (Codex models today). Callers should route\n * those to {@link responsesUrl} instead of {@link invocationsUrl}.\n */\nexport function isResponsesOnly(endpoint: string): boolean {\n  return isResponsesOnlyByPolicy(endpoint);\n}\n\n/**\n * Pick the Databricks Responses upstream for an endpoint id: OpenAI-family\n * models use `/serving-endpoints/responses`; everything else uses the\n * cross-provider `/serving-endpoints/open-responses`.\n */\nexport function responsesUpstreamUrl(host: string, endpoint: string): string {\n  return isOpenAiFamily(endpoint) ? responsesUrl(host) : openResponsesUrl(host);\n}\n\n/** GPT / Codex / o-series style endpoint names that speak OpenAI Responses. */\nfunction isOpenAiFamily(endpoint: string): boolean {\n  const n = endpoint.toLowerCase();\n  return (\n    n.includes(\"gpt\") ||\n    n.includes(\"codex\") ||\n    /(^|[^a-z])o[1-9]([^a-z]|$)/.test(n) ||\n    n.includes(\"openai\")\n  );\n}\n\n/**\n * Minimal structural shape {@link authHeaders} needs. Declared narrowly rather\n * than as a full `WorkspaceClientLike` so a caller holding its own\n * `@databricks/sdk-experimental` `WorkspaceClient` satisfies it regardless of\n * which SDK version resolved in its tree.\n */\nexport interface AuthenticatingClientLike {\n  config: {\n    authenticate(headers: Headers): Promise<void>;\n  };\n}\n\n/**\n * Mint auth headers for one upstream request as a plain object, ready to spread\n * into a `fetch` init. Call it per request: the SDK refreshes the underlying\n * token when needed, so a long-lived process never has to track expiry itself.\n */\nexport async function authHeaders(\n  client: AuthenticatingClientLike,\n): Promise<Record<string, string>> {\n  const headers = new Headers();\n  await client.config.authenticate(headers);\n  const out: Record<string, string> = {};\n  headers.forEach((value, key) => {\n    out[key] = value;\n  });\n  return out;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"invoke.js","sourceRoot":"","sources":["../../src/invoke.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Calling a Model Serving endpoint directly over HTTP.\n *\n * The SDK's `servingEndpoints.query` covers the typed request shapes, but an\n * OpenAI-compatible caller (a proxy, a passthrough route, a streaming client)\n * needs to issue its own `fetch` against Databricks' OpenAI-shaped URLs with\n * an OpenAI body. That needs exactly two things the SDK doesn't hand out\n * directly: the URL ({@link invocationsUrl} / {@link responsesUrl} /\n * {@link openResponsesUrl}) and a currently-valid set of auth headers\n * ({@link authHeaders}).\n *\n * Auth is delegated entirely to the Databricks SDK: `config.authenticate`\n * re-runs the configured credential provider on every call and refreshes the\n * underlying OAuth / PAT token when it is close to expiry, so a caller never\n * manages token lifetimes itself - mint headers per request and each one is\n * signed with a valid bearer token.\n *\n * @module\n */\n\nimport { isResponsesOnly as isResponsesOnlyByPolicy } from \"./policy.ts\";\n\n/**\n * Path segment appended to a serving endpoint for OpenAI-compatible chat\n * requests. Databricks routes `/serving-endpoints/<name>/invocations` to the\n * endpoint's Chat Completions surface (`messages` in, `choices` out). Some\n * models (notably Codex) reject this path and require {@link responsesUrl}.\n */\nexport const INVOCATIONS_SUFFIX = \"invocations\";\n\n/**\n * Workspace-level OpenAI Responses API path. Body carries `model` (endpoint\n * id); used by GPT / Codex models that speak Responses natively.\n */\nexport const RESPONSES_PATH = \"serving-endpoints/responses\";\n\n/**\n * Workspace-level Open Responses API path - the cross-provider Responses\n * surface (Claude, Gemini, …) that OpenAI `/responses` does not cover.\n */\nexport const OPEN_RESPONSES_PATH = \"serving-endpoints/open-responses\";\n\n/**\n * Workspace-level OpenAI Chat Completions path. Body carries `model` (endpoint\n * id), unlike {@link invocationsUrl} which names the endpoint in the URL. Use\n * this when the caller has a model id rather than a per-endpoint route - e.g.\n * attaching a provider tool spec to whichever endpoint was resolved.\n */\nexport const CHAT_COMPLETIONS_PATH = \"serving-endpoints/chat/completions\";\n\n/** Unity Gateway OpenAI Responses path used by Codex-compatible model services. */\nexport const AI_GATEWAY_CODEX_RESPONSES_PATH = \"ai-gateway/codex/v1/responses\";\n\n/** Workspace Anthropic Messages path for native Claude requests. */\nexport const ANTHROPIC_MESSAGES_PATH = \"serving-endpoints/anthropic/v1/messages\";\n\n/**\n * The OpenAI-compatible chat-completions invocations URL for an endpoint id.\n *\n * @param host - Workspace host, e.g. `https://my-workspace.cloud.databricks.com/`.\n *   Pass the value resolved from `client.config.getHost()`.\n * @param endpoint - Endpoint id (already resolved; not fuzzy-matched here).\n */\nexport function invocationsUrl(host: string, endpoint: string): string {\n  return new URL(\n    `serving-endpoints/${encodeURIComponent(endpoint)}/${INVOCATIONS_SUFFIX}`,\n    host,\n  ).toString();\n}\n\n/** Workspace OpenAI Responses API URL (`POST`, model in the body). */\nexport function responsesUrl(host: string): string {\n  return new URL(RESPONSES_PATH, host).toString();\n}\n\n/** Workspace Open Responses API URL (`POST`, model in the body). */\nexport function openResponsesUrl(host: string): string {\n  return new URL(OPEN_RESPONSES_PATH, host).toString();\n}\n\n/** Workspace OpenAI Chat Completions URL (`POST`, model in the body). */\nexport function chatCompletionsUrl(host: string): string {\n  return new URL(CHAT_COMPLETIONS_PATH, host).toString();\n}\n\n/** Unity Gateway Codex Responses URL (`POST`, model service in the body). */\nexport function aiGatewayCodexResponsesUrl(host: string): string {\n  return new URL(AI_GATEWAY_CODEX_RESPONSES_PATH, host).toString();\n}\n\n/** Workspace Anthropic Messages URL (`POST`, model in the body). */\nexport function anthropicMessagesUrl(host: string): string {\n  return new URL(ANTHROPIC_MESSAGES_PATH, host).toString();\n}\n\n/**\n * True when the endpoint is known to reject Chat Completions `/invocations`\n * and require the Responses API (Codex models today). Callers should route\n * those to {@link responsesUrl} instead of {@link invocationsUrl}.\n */\nexport function isResponsesOnly(endpoint: string): boolean {\n  return isResponsesOnlyByPolicy(endpoint);\n}\n\n/**\n * Pick the Databricks Responses upstream for an endpoint id: OpenAI-family\n * models use `/serving-endpoints/responses`; everything else uses the\n * cross-provider `/serving-endpoints/open-responses`.\n */\nexport function responsesUpstreamUrl(host: string, endpoint: string): string {\n  return isOpenAiFamily(endpoint) ? responsesUrl(host) : openResponsesUrl(host);\n}\n\n/** GPT / Codex / o-series style endpoint names that speak OpenAI Responses. */\nfunction isOpenAiFamily(endpoint: string): boolean {\n  const n = endpoint.toLowerCase();\n  return (\n    n.includes(\"gpt\") ||\n    n.includes(\"codex\") ||\n    /(^|[^a-z])o[1-9]([^a-z]|$)/.test(n) ||\n    n.includes(\"openai\")\n  );\n}\n\n/**\n * Minimal structural shape {@link authHeaders} needs. Declared narrowly rather\n * than as a full `WorkspaceClientLike` so a caller holding its own\n * `@databricks/sdk-experimental` `WorkspaceClient` satisfies it regardless of\n * which SDK version resolved in its tree.\n */\nexport interface AuthenticatingClientLike {\n  config: {\n    authenticate(headers: Headers): Promise<void>;\n  };\n}\n\n/**\n * Mint auth headers for one upstream request as a plain object, ready to spread\n * into a `fetch` init. Call it per request: the SDK refreshes the underlying\n * token when needed, so a long-lived process never has to track expiry itself.\n */\nexport async function authHeaders(\n  client: AuthenticatingClientLike,\n): Promise<Record<string, string>> {\n  const headers = new Headers();\n  await client.config.authenticate(headers);\n  const out: Record<string, string> = {};\n  headers.forEach((value, key) => {\n    out[key] = value;\n  });\n  return out;\n}\n"]}

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

@@ -0,0 +1,84 @@
+/**
+ * Agnostic daily metadata cache on {@link https://www.npmjs.com/package/cacache | cacache}.
+ *
+ * Uses cacache's built-in memory memoization (`memoize: true` on put; gets read
+ * the in-memory layer by default) with content-addressed disk under
+ * `env-paths("dbx-tools").cache/model-gateway/<version>/`. Disk persistence is
+ * disabled inside a Databricks App ({@link environmentUtils.isDatabricksAppEnv});
+ * those processes keep a process-local Map only.
+ *
+ * Each cache owns a key, hard-coded fallback, optional network loader, and a
+ * merger that combines fresh / previous / fallback values. Freshness is the
+ * envelope `refreshedAt` window (default one day), not cacache's short LRU TTL.
+ *
+ * @module
+ */
+/** Envelope stored as JSON bytes in cacache for every key. */
+export interface MetadataCacheRecord<T> {
+    readonly refreshedAt: number;
+    readonly value: T;
+}
+/** Factory inputs for one named metadata cache. */
+export interface MetadataCacheOptions<T> {
+    /** Stable cacache key. */
+    readonly key: string;
+    /** Hard-coded / committed baseline used when store and load both miss. */
+    readonly fallback: T;
+    /**
+     * Refresh source. When omitted the cache only serves store + fallback and
+     * {@link MetadataCache.update} mutations (for example error-learned values).
+     */
+    readonly load?: () => Promise<T>;
+    /** Combine a fresh load, prior store value, and the hard-coded fallback. */
+    readonly merge: (input: MetadataCacheMergeInput<T>) => T;
+    /** Freshness window; defaults to {@link MODEL_METADATA_TTL_MS} (one day). */
+    readonly ttlMs?: number;
+    /** Package version segment in the cache path. Defaults to this package. */
+    readonly version?: string;
+    /** Override the cacache root directory (tests). */
+    readonly cacheDir?: string;
+    /**
+     * Force disk on/off. Defaults to off inside Databricks Apps, on otherwise.
+     */
+    readonly disk?: boolean;
+    /** Clock override for tests. */
+    readonly now?: () => number;
+}
+/** Arguments passed to a cache merger. */
+export interface MetadataCacheMergeInput<T> {
+    readonly fresh: T | undefined;
+    readonly previous: T | undefined;
+    readonly fallback: T;
+}
+/** One versioned metadata cache (cacache memory + optional disk). */
+export interface MetadataCache<T> {
+    /** Absolute cacache root for this package version (unused when disk is off). */
+    readonly path: string;
+    /** Whether cacache disk persistence is enabled for this instance. */
+    readonly diskEnabled: boolean;
+    /** Return a fresh-or-fallback value, refreshing when stale. */
+    get(): Promise<T>;
+    /** Read memory / disk without refreshing. */
+    peek(): Promise<T | undefined>;
+    /** Mutate the cached value and persist it. */
+    update(mutator: (current: T) => T): Promise<T>;
+    /** Force a refresh attempt even when the entry is still fresh. */
+    refresh(): Promise<T>;
+}
+/** Default cacache root for a package version under the dbx-tools cache dir. */
+export declare function defaultMetadataCacheDir(version: string): string;
+/** Whether metadata caches should persist to disk in this process. */
+export declare function metadataCacheDiskEnabled(environment?: NodeJS.ProcessEnv): boolean;
+/**
+ * Create one daily cache backed by cacache memoization, with optional disk.
+ */
+export declare function createMetadataCache<T>(options: MetadataCacheOptions<T>): MetadataCache<T>;
+/** Prefer a non-empty fresh array, else previous, else fallback. */
+export declare function mergePreferFreshList<T>(input: MetadataCacheMergeInput<readonly T[]>): T[];
+/**
+ * Shallow-merge record catalogues: fallback, then previous, then fresh keys.
+ * Fresh values win per key.
+ */
+export declare function mergePreferFreshRecord<T>(input: MetadataCacheMergeInput<Readonly<Record<string, T>>>): Record<string, T>;
+/** Test helper: wipe a cacache root and clear cacache memoization. */
+export declare function resetMetadataCacheDir(cacheDir: string): Promise<void>;

package/lib/src/metadata-cache.js

@@ -0,0 +1,226 @@
+/**
+ * Agnostic daily metadata cache on {@link https://www.npmjs.com/package/cacache | cacache}.
+ *
+ * Uses cacache's built-in memory memoization (`memoize: true` on put; gets read
+ * the in-memory layer by default) with content-addressed disk under
+ * `env-paths("dbx-tools").cache/model-gateway/<version>/`. Disk persistence is
+ * disabled inside a Databricks App ({@link environmentUtils.isDatabricksAppEnv});
+ * those processes keep a process-local Map only.
+ *
+ * Each cache owns a key, hard-coded fallback, optional network loader, and a
+ * merger that combines fresh / previous / fallback values. Freshness is the
+ * envelope `refreshedAt` window (default one day), not cacache's short LRU TTL.
+ *
+ * @module
+ */
+import { resolve } from "node:path";
+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 { MODEL_METADATA_TTL_MS } from "./_metadata-contract.js";
+const logger = log.logger("model/metadata-cache");
+const inflight = new Map();
+/** Default cacache root for a package version under the dbx-tools cache dir. */
+export function defaultMetadataCacheDir(version) {
+    const cacheDirectory = envPaths("dbx-tools", { suffix: "" }).cache;
+    return resolve(cacheDirectory, "model-gateway", version);
+}
+/** Whether metadata caches should persist to disk in this process. */
+export function metadataCacheDiskEnabled(environment = process.env) {
+    return !environmentUtils.isDatabricksAppEnv(environment);
+}
+/**
+ * Create one daily cache backed by cacache memoization, with optional disk.
+ */
+export function createMetadataCache(options) {
+    const ttlMs = options.ttlMs ?? MODEL_METADATA_TTL_MS;
+    const diskEnabled = options.disk ?? metadataCacheDiskEnabled();
+    const now = options.now ?? Date.now;
+    const pathPromise = resolveCacheDir(options);
+    let path = options.cacheDir;
+    const flightKey = (cachePath, suffix = "") => `${cachePath}::${options.key}${suffix}`;
+    /** Process-local store used when disk is off (Databricks Apps). */
+    const memoryOnly = new Map();
+    const resolveValue = (input) => options.merge(input);
+    const isFresh = (record) => Boolean(record && now() - record.refreshedAt < ttlMs);
+    const cachePath = async () => {
+        path ??= await pathPromise;
+        return path;
+    };
+    const readRecord = async () => {
+        if (!diskEnabled)
+            return memoryOnly.get(options.key);
+        const resolvedPath = await cachePath();
+        try {
+            // cacache reads its in-memory memo first unless memoize is false
+            const entry = await cacache.get(resolvedPath, options.key);
+            return decodeRecord(entry.data);
+        }
+        catch (error) {
+            if (isCacheMiss(error))
+                return undefined;
+            logger.warn("metadata cache cacache read failed", {
+                key: options.key,
+                path: resolvedPath,
+                error,
+            });
+            return undefined;
+        }
+    };
+    const writeRecord = async (record) => {
+        if (!diskEnabled) {
+            memoryOnly.set(options.key, record);
+            return;
+        }
+        const resolvedPath = await cachePath();
+        try {
+            await cacache.put(resolvedPath, options.key, `${JSON.stringify(record)}\n`, {
+                memoize: true,
+                metadata: { refreshedAt: record.refreshedAt },
+            });
+        }
+        catch (error) {
+            logger.warn("metadata cache cacache write failed", {
+                key: options.key,
+                path: resolvedPath,
+                error,
+            });
+        }
+    };
+    const persist = async (value, refreshedAt = now()) => {
+        await writeRecord({ refreshedAt, value });
+        return value;
+    };
+    const refresh = async (force) => {
+        const resolvedPath = await cachePath();
+        return coalesce(flightKey(resolvedPath), async () => {
+            const previous = await readRecord();
+            if (!force && isFresh(previous)) {
+                return resolveValue({
+                    fresh: undefined,
+                    previous: previous?.value,
+                    fallback: options.fallback,
+                });
+            }
+            let fresh;
+            if (options.load) {
+                try {
+                    fresh = await options.load();
+                }
+                catch (error) {
+                    logger.warn("metadata cache refresh failed; keeping last known good", {
+                        key: options.key,
+                        error,
+                        path: resolvedPath,
+                        diskEnabled,
+                    });
+                }
+            }
+            const value = resolveValue({
+                fresh,
+                previous: previous?.value,
+                fallback: options.fallback,
+            });
+            if (fresh !== undefined || !previous) {
+                await persist(value);
+            }
+            return value;
+        });
+    };
+    return {
+        get path() {
+            if (!path) {
+                throw new Error("metadata cache path is not resolved until the first cache read");
+            }
+            return path;
+        },
+        diskEnabled,
+        get: () => refresh(false),
+        peek: async () => (await readRecord())?.value,
+        refresh: () => refresh(true),
+        update: async (mutator) => {
+            const resolvedPath = await cachePath();
+            return coalesce(flightKey(resolvedPath, ":update"), async () => {
+                const previous = await readRecord();
+                const baseline = resolveValue({
+                    fresh: undefined,
+                    previous: previous?.value,
+                    fallback: options.fallback,
+                });
+                return persist(mutator(baseline));
+            });
+        },
+    };
+}
+async function resolveCacheDir(options) {
+    if (options.cacheDir)
+        return options.cacheDir;
+    const version = options.version ?? (await import("../index.js")).PACKAGE_VERSION;
+    return defaultMetadataCacheDir(version);
+}
+/** Prefer a non-empty fresh array, else previous, else fallback. */
+export function mergePreferFreshList(input) {
+    if (input.fresh && input.fresh.length > 0)
+        return [...input.fresh];
+    if (input.previous && input.previous.length > 0)
+        return [...input.previous];
+    return [...input.fallback];
+}
+/**
+ * Shallow-merge record catalogues: fallback, then previous, then fresh keys.
+ * Fresh values win per key.
+ */
+export function mergePreferFreshRecord(input) {
+    return {
+        ...input.fallback,
+        ...(input.previous ?? {}),
+        ...(input.fresh ?? {}),
+    };
+}
+/** Test helper: wipe a cacache root and clear cacache memoization. */
+export async function resetMetadataCacheDir(cacheDir) {
+    try {
+        await cacache.rm.all(cacheDir);
+    }
+    catch {
+        // empty / missing cache is fine
+    }
+    cacache.clearMemoized();
+    for (const key of [...inflight.keys()]) {
+        if (key.startsWith(`${cacheDir}::`))
+            inflight.delete(key);
+    }
+}
+function coalesce(key, work) {
+    const existing = inflight.get(key);
+    if (existing)
+        return existing;
+    const pending = work().finally(() => {
+        if (inflight.get(key) === pending)
+            inflight.delete(key);
+    });
+    inflight.set(key, pending);
+    return pending;
+}
+function decodeRecord(data) {
+    try {
+        const parsed = JSON.parse(data.toString("utf8"));
+        if (!parsed ||
+            typeof parsed !== "object" ||
+            typeof parsed.refreshedAt !== "number") {
+            return undefined;
+        }
+        return parsed;
+    }
+    catch {
+        return undefined;
+    }
+}
+function isCacheMiss(error) {
+    return Boolean(error &&
+        typeof error === "object" &&
+        "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\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 import(\"../index.ts\")).PACKAGE_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"]}

package/lib/src/metadata.d.ts

@@ -1,33 +1,68 @@
-import type { ModelStatus, ServingEndpointSummary } from "@dbx-tools/shared-model/contracts";
-import { MODEL_METADATA_TTL_MS, MODEL_RATE_LIMITS_URL, OPENAI_RESPONSES_MODELS_URL, RETIRED_MODELS_URL, WEB_SEARCH_MODELS_URL, type ModelRateLimits } from "./_metadata-contract.ts";
-export { MODEL_METADATA_TTL_MS, MODEL_RATE_LIMITS_URL, OPENAI_RESPONSES_MODELS_URL, RETIRED_MODELS_URL, WEB_SEARCH_MODELS_URL, };
-export type { ModelCapabilitiesSnapshot, ModelCapabilityCatalogue, ModelRateLimitCatalogue, ModelRateLimits, ModelRateLimitsSnapshot, RetiredModelsSnapshot, } from "./_metadata-contract.ts";
-/** Documented capabilities resolved for one model identity. */
-export interface ModelCapabilities {
-    readonly responses: boolean;
-    readonly imageInput: boolean;
-    readonly applyPatch: boolean;
-    readonly webSearch: boolean;
-}
-/** Combined build-generated metadata resolved for one model identity. */
-export interface ModelMetadata {
-    readonly status: ModelStatus;
-    readonly capabilities: ModelCapabilities;
-    readonly rateLimits?: ModelRateLimits;
+import type { ModelCapabilities, ModelMetadata, ModelRateLimits, ModelStatus, 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>;
+    };
+    readonly rateLimits: ReadonlyMap<string, ModelRateLimits>;
+    readonly reasoning: ReasoningModelCatalogue;
+    readonly learnedReasoning: ReasoningModelCatalogue;
 }
+/**
+ * Hydrate or refresh documentation + learned caches into the process index.
+ *
+ * Safe to call on gateway startup. Concurrent callers share one refresh.
+ */
+export declare function refreshModelMetadata(): Promise<MetadataIndex>;
+/** Load cacache / memory entries without forcing a network refresh. */
+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[];
+/** Return the committed reasoning-effort catalogue. Cached per process. */
+export declare function reasoningModelCatalogue(): ReasoningModelCatalogue;
+/** Return error-learned reasoning ladders persisted in the metadata cache. */
+export declare function learnedReasoningCatalogue(): ReasoningModelCatalogue;
+/**
+ * Store levels learned from an upstream error and persist them write-through.
+ *
+ * Empty lists are ignored so a failed parse cannot wipe defaults. Error bodies
+ * themselves are never stored - only the parsed ladder.
+ */
+export declare function rememberReasoningLevels(model: string, levels: readonly ReasoningLevel[]): Promise<ReasoningLevel[]>;
+/**
+ * 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 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. */
 export declare function modelRateLimitsFor(model: string | ServingEndpointSummary): ModelRateLimits | undefined;
+/**
+ * Resolve reasoning levels: learned from errors, then documentation, then
+ * family defaults.
+ *
+ * Does not parse error bodies; callers should use {@link parseReasoningLevels}
+ * and then {@link rememberReasoningLevels}.
+ */
+export declare function modelReasoningLevelsFor(model: string | ServingEndpointSummary): ReasoningLevel[];
 /** Resolve retirement, capability, and rate-limit metadata together. */
 export declare function modelMetadataFor(model: string | ServingEndpointSummary): ModelMetadata;
-/** Return generation timestamps for the three committed metadata snapshots. */
+/** Return generation timestamps for the committed metadata snapshots. */
 export declare function modelMetadataGeneratedAt(): Readonly<{
     retiredModels: number;
     capabilities: number;
     rateLimits: number;
+    reasoning: number;
 }>;