@dbx-tools/model 0.9.118 → 0.9.120

package/README.md

@@ -193,10 +193,12 @@ const raw = await modelCatalog.listServingEndpointsUncached(client);
 await modelCatalog.clearServingEndpointsCache(host);
 ```
 
-`listServingEndpoints()` uses AppKit's `CacheManager`, enriches endpoints with
-classification and embedding dimensions, and keys the cache by workspace host.
-`listServingEndpointsUncached()` is useful for simple scripts that only need the
-SDK response and do not want a cache dependency.
+`listServingEndpoints()` uses the shared memory-first model project cache, enriches
+endpoints with classification and embedding dimensions, and isolates entries by
+workspace host and trusted credential identity. If a refresh fails, it can return
+the last known-good value retained on disk. `listServingEndpointsUncached()` is
+useful for simple scripts that only need the SDK response and do not want a cache
+dependency.
 
 ## Fuzzy Resolve Endpoint Names
 
@@ -221,10 +223,10 @@ const resolved = await resolve.rankModelIdLive((force) => loadCatalogue(force),
 `rankModelIdLive()` matches the catalogue you already hold and, on a miss,
 reloads once with `force` before giving up, so a model deployed after your cache
 warmed still resolves without a restart. You supply the loader, so the caching
-policy stays yours: `listServingEndpoints` and its `CacheManager`, a plain field
-in a long-lived CLI, or a test double. `rankModelId()` is the pure form over a
-single snapshot; unlike `serving.resolveModelId` it breaks equal match scores by
-class and then version, so `"opus"` prefers `opus-5` over `opus-4-7`.
+policy stays yours: `listServingEndpoints` and its shared project cache, a plain
+field in a long-lived CLI, or a test double. `rankModelId()` is the pure form over
+a single snapshot; unlike `serving.resolveModelId` it breaks equal match scores
+by class and then version, so `"opus"` prefers `opus-5` over `opus-4-7`.
 
 ## Call An Endpoint Directly
 

package/index.ts

@@ -3,7 +3,7 @@
 // Hand edits are overwritten on the next watch; this file is read-only.
 
 export const PACKAGE_IDENTIFIER = "@dbx-tools/model";
-export const PACKAGE_VERSION = "0.9.118";
+export const PACKAGE_VERSION = "0.9.120";
 export * as bindings from "./src/bindings.ts";
 export * as classes from "./src/classes.ts";
 export * as classify from "./src/classify.ts";
@@ -21,7 +21,7 @@ export { FALLBACK_MODEL_IDS } from "./src/fallback.ts";
 export { INVOCATIONS_SUFFIX, SERVING_ENDPOINTS_PATH, RESPONSES_PATH, OPEN_RESPONSES_PATH, CHAT_COMPLETIONS_PATH, AI_GATEWAY_CODEX_RESPONSES_PATH, ANTHROPIC_BASE_PATH, ANTHROPIC_MESSAGES_PATH } from "./src/invoke.ts";
 export type { AuthenticatingClientLike } from "./src/invoke.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 } from "./src/metadata.ts";
-export type { MetadataCacheRecord, MetadataCacheOptions, MetadataCacheMergeInput, MetadataCache } from "./src/metadata-cache.ts";
+export type { MetadataCacheOptions, MetadataCacheMergeInput, MetadataCache } from "./src/metadata-cache.ts";
 export { DEFAULT_MODEL_CACHE_TTL_MS, DEFAULT_FUZZY_THRESHOLD } from "./src/model-catalog.ts";
 export type { WorkspaceClientLike, ListServingEndpointsOptions } from "./src/model-catalog.ts";
 export { DEFAULT_MODEL_CLIENT_CACHE_TTL_MS } from "./src/model-client.ts";

package/lib/index.d.ts

@@ -1,5 +1,5 @@
 export declare const PACKAGE_IDENTIFIER = "@dbx-tools/model";
-export declare const PACKAGE_VERSION = "0.9.118";
+export declare const PACKAGE_VERSION = "0.9.120";
 export * as bindings from "./src/bindings.ts";
 export * as classes from "./src/classes.ts";
 export * as classify from "./src/classify.ts";
@@ -17,7 +17,7 @@ export { FALLBACK_MODEL_IDS } from "./src/fallback.ts";
 export { INVOCATIONS_SUFFIX, SERVING_ENDPOINTS_PATH, RESPONSES_PATH, OPEN_RESPONSES_PATH, CHAT_COMPLETIONS_PATH, AI_GATEWAY_CODEX_RESPONSES_PATH, ANTHROPIC_BASE_PATH, ANTHROPIC_MESSAGES_PATH } from "./src/invoke.ts";
 export type { AuthenticatingClientLike } from "./src/invoke.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 } from "./src/metadata.ts";
-export type { MetadataCacheRecord, MetadataCacheOptions, MetadataCacheMergeInput, MetadataCache } from "./src/metadata-cache.ts";
+export type { MetadataCacheOptions, MetadataCacheMergeInput, MetadataCache } from "./src/metadata-cache.ts";
 export { DEFAULT_MODEL_CACHE_TTL_MS, DEFAULT_FUZZY_THRESHOLD } from "./src/model-catalog.ts";
 export type { WorkspaceClientLike, ListServingEndpointsOptions } from "./src/model-catalog.ts";
 export { DEFAULT_MODEL_CLIENT_CACHE_TTL_MS } from "./src/model-client.ts";

package/lib/index.js

@@ -2,7 +2,7 @@
 // Regenerated from the exporting modules in ./src.
 // Hand edits are overwritten on the next watch; this file is read-only.
 export const PACKAGE_IDENTIFIER = "@dbx-tools/model";
-export const PACKAGE_VERSION = "0.9.118";
+export const PACKAGE_VERSION = "0.9.120";
 export * as bindings from "./src/bindings.js";
 export * as classes from "./src/classes.js";
 export * as classify from "./src/classify.js";
@@ -24,4 +24,4 @@ export { DEFAULT_MODEL_CLIENT_CACHE_TTL_MS } from "./src/model-client.js";
 export { ModelFamily } from "./src/policy.js";
 export { REASONING_LEVELS } from "./src/reasoning-translation.js";
 export * from "./exports.js";
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/_cache.d.ts

@@ -0,0 +1,4 @@
+/** Memory-first cache for endpoint catalogues, isolated for full invalidation. */
+export declare const modelCatalogueCache: import("cacheable").Cacheable;
+/** One memory-first project cache shared by every model metadata key. */
+export declare const modelMetadataCache: import("cacheable").Cacheable;

package/lib/src/_cache.js

@@ -0,0 +1,12 @@
+import { projectCache } from "@dbx-tools/cache/cache";
+/** Memory-first cache for endpoint catalogues, isolated for full invalidation. */
+export const modelCatalogueCache = projectCache("model-catalog", {
+    maxEntries: 256,
+    useClone: false,
+});
+/** One memory-first project cache shared by every model metadata key. */
+export const modelMetadataCache = projectCache("model-metadata", {
+    maxEntries: 256,
+    useClone: false,
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiX2NhY2hlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL19jYWNoZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFFdEQsa0ZBQWtGO0FBQ2xGLE1BQU0sQ0FBQyxNQUFNLG1CQUFtQixHQUFHLFlBQVksQ0FBQyxlQUFlLEVBQUU7SUFDL0QsVUFBVSxFQUFFLEdBQUc7SUFDZixRQUFRLEVBQUUsS0FBSztDQUNoQixDQUFDLENBQUM7QUFFSCx5RUFBeUU7QUFDekUsTUFBTSxDQUFDLE1BQU0sa0JBQWtCLEdBQUcsWUFBWSxDQUFDLGdCQUFnQixFQUFFO0lBQy9ELFVBQVUsRUFBRSxHQUFHO0lBQ2YsUUFBUSxFQUFFLEtBQUs7Q0FDaEIsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgcHJvamVjdENhY2hlIH0gZnJvbSBcIkBkYngtdG9vbHMvY2FjaGUvY2FjaGVcIjtcblxuLyoqIE1lbW9yeS1maXJzdCBjYWNoZSBmb3IgZW5kcG9pbnQgY2F0YWxvZ3VlcywgaXNvbGF0ZWQgZm9yIGZ1bGwgaW52YWxpZGF0aW9uLiAqL1xuZXhwb3J0IGNvbnN0IG1vZGVsQ2F0YWxvZ3VlQ2FjaGUgPSBwcm9qZWN0Q2FjaGUoXCJtb2RlbC1jYXRhbG9nXCIsIHtcbiAgbWF4RW50cmllczogMjU2LFxuICB1c2VDbG9uZTogZmFsc2UsXG59KTtcblxuLyoqIE9uZSBtZW1vcnktZmlyc3QgcHJvamVjdCBjYWNoZSBzaGFyZWQgYnkgZXZlcnkgbW9kZWwgbWV0YWRhdGEga2V5LiAqL1xuZXhwb3J0IGNvbnN0IG1vZGVsTWV0YWRhdGFDYWNoZSA9IHByb2plY3RDYWNoZShcIm1vZGVsLW1ldGFkYXRhXCIsIHtcbiAgbWF4RW50cmllczogMjU2LFxuICB1c2VDbG9uZTogZmFsc2UsXG59KTtcbiJdfQ==

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

@@ -1,48 +1,21 @@
 /**
- * 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.
+ * Daily model metadata cache built on the shared memory-first cache package.
  *
  * @module
  */
-/** Envelope stored as JSON bytes in cacache for every key. */
-export interface MetadataCacheRecord<T> {
-    readonly refreshedAt: number;
-    readonly value: T;
-}
+import { createCache } from "@dbx-tools/cache/cache";
 /** Factory inputs for one named metadata cache. */
 export interface MetadataCacheOptions<T> {
-    /** Stable cacache key. */
+    /** Stable cache 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).
-     */
+    /** Optional refresh source. */
     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). */
+    /** Freshness window; defaults to 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> {
@@ -50,35 +23,20 @@ export interface MetadataCacheMergeInput<T> {
     readonly previous: T | undefined;
     readonly fallback: T;
 }
-/** One versioned metadata cache (cacache memory + optional disk). */
+/** One namespaced view over the shared metadata cache. */
 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. */
+    /** Read process memory 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>;
+/** Create one namespaced view over the shared model metadata cache. */
+export declare function createMetadataCache<T>(options: MetadataCacheOptions<T>, cache?: ReturnType<typeof createCache>): 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.
- */
+/** Shallow-merge record catalogues: fallback, then previous, then fresh keys. */
 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

@@ -1,169 +1,64 @@
 /**
- * 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.
+ * Daily model metadata cache built on the shared memory-first cache package.
  *
  * @module
  */
-import { resolve } from "node:path";
-import * as environmentUtils from "@dbx-tools/shared-core/environment-utils";
+import { getOrSet } from "@dbx-tools/cache/cache";
+import * as errorUtils from "@dbx-tools/shared-core/error-utils";
 import * as log from "@dbx-tools/shared-core/log";
-import cacache from "cacache";
-import envPaths from "env-paths";
-import packageManifest from "../package.json" with { type: "json" };
+import { modelMetadataCache } from "./_cache.js";
 import { MODEL_METADATA_TTL_MS } from "./_metadata-contract.js";
 const logger = log.logger("model/metadata-cache");
-const PACKAGE_IDENTITY = {
-    identifier: packageManifest.name,
-    version: packageManifest.version,
-};
-const inflight = new Map();
-/** Default cacache root for a package version under the dbx-tools cache dir. */
-export function defaultMetadataCacheDir(version) {
-    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) {
+/** Create one namespaced view over the shared model metadata cache. */
+export function createMetadataCache(options, cache = modelMetadataCache) {
     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 });
+    const valueKey = `model-metadata:value:${options.key}`;
+    const refreshKey = `model-metadata:refresh:${options.key}`;
+    const read = () => cache.get(valueKey);
+    const persist = async (value) => {
+        await cache.set(valueKey, value);
         return value;
     };
+    const resolveValue = (fresh, previous) => options.merge({ fresh, previous, fallback: options.fallback });
     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,
-                });
-            }
+        if (force)
+            await cache.delete(refreshKey);
+        let staleRefreshFailed = false;
+        await getOrSet(cache, refreshKey, async () => {
+            const previous = await read();
             let fresh;
             if (options.load) {
                 try {
                     fresh = await options.load();
                 }
                 catch (error) {
-                    logger.warn("metadata cache refresh failed; keeping last known good", {
+                    logger.warn("metadata cache refresh failed; using cached or committed value", {
                         key: options.key,
-                        error,
-                        path: resolvedPath,
-                        diskEnabled,
+                        error: errorUtils.toError(error),
                     });
+                    staleRefreshFailed = previous !== undefined;
                 }
             }
-            const value = resolveValue({
-                fresh,
-                previous: previous?.value,
-                fallback: options.fallback,
-            });
-            if (fresh !== undefined || !previous) {
-                await persist(value);
-            }
-            return value;
-        });
+            const resolved = resolveValue(fresh, previous);
+            if (fresh !== undefined || previous === undefined)
+                await persist(resolved);
+            return true;
+        }, { ttl: ttlMs, throwErrors: true });
+        if (staleRefreshFailed)
+            await cache.delete(refreshKey);
+        return resolveValue(undefined, await read());
     };
     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,
+        peek: read,
         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));
-            });
+            const value = await persist(mutator(resolveValue(undefined, await read())));
+            await cache.set(refreshKey, true, { ttl: ttlMs });
+            return value;
         },
     };
 }
-async function resolveCacheDir(options) {
-    if (options.cacheDir)
-        return options.cacheDir;
-    const version = options.version ?? PACKAGE_IDENTITY.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)
@@ -172,10 +67,7 @@ export function mergePreferFreshList(input) {
         return [...input.previous];
     return [...input.fallback];
 }
-/**
- * Shallow-merge record catalogues: fallback, then previous, then fresh keys.
- * Fresh values win per key.
- */
+/** Shallow-merge record catalogues: fallback, then previous, then fresh keys. */
 export function mergePreferFreshRecord(input) {
     return {
         ...input.fallback,
@@ -183,49 +75,4 @@ export function mergePreferFreshRecord(input) {
         ...(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 packageManifest from \"../package.json\" with { type: \"json\" };\nimport { MODEL_METADATA_TTL_MS } from \"./_metadata-contract.ts\";\n\nconst logger = log.logger(\"model/metadata-cache\");\n\ninterface PackageIdentity {\n  readonly identifier: string;\n  readonly version: string;\n}\n\nconst PACKAGE_IDENTITY: PackageIdentity = {\n  identifier: packageManifest.name,\n  version: packageManifest.version,\n};\n\n/** Envelope stored as JSON bytes in cacache for every key. */\nexport interface MetadataCacheRecord<T> {\n  readonly refreshedAt: number;\n  readonly value: T;\n}\n\n/** Factory inputs for one named metadata cache. */\nexport interface MetadataCacheOptions<T> {\n  /** Stable cacache key. */\n  readonly key: string;\n  /** Hard-coded / committed baseline used when store and load both miss. */\n  readonly fallback: T;\n  /**\n   * Refresh source. When omitted the cache only serves store + fallback and\n   * {@link MetadataCache.update} mutations (for example error-learned values).\n   */\n  readonly load?: () => Promise<T>;\n  /** Combine a fresh load, prior store value, and the hard-coded fallback. */\n  readonly merge: (input: MetadataCacheMergeInput<T>) => T;\n  /** Freshness window; defaults to {@link MODEL_METADATA_TTL_MS} (one day). */\n  readonly ttlMs?: number;\n  /** Package version segment in the cache path. Defaults to this package. */\n  readonly version?: string;\n  /** Override the cacache root directory (tests). */\n  readonly cacheDir?: string;\n  /**\n   * Force disk on/off. Defaults to off inside Databricks Apps, on otherwise.\n   */\n  readonly disk?: boolean;\n  /** Clock override for tests. */\n  readonly now?: () => number;\n}\n\n/** Arguments passed to a cache merger. */\nexport interface MetadataCacheMergeInput<T> {\n  readonly fresh: T | undefined;\n  readonly previous: T | undefined;\n  readonly fallback: T;\n}\n\n/** One versioned metadata cache (cacache memory + optional disk). */\nexport interface MetadataCache<T> {\n  /** Absolute cacache root for this package version (unused when disk is off). */\n  readonly path: string;\n  /** Whether cacache disk persistence is enabled for this instance. */\n  readonly diskEnabled: boolean;\n  /** Return a fresh-or-fallback value, refreshing when stale. */\n  get(): Promise<T>;\n  /** Read memory / disk without refreshing. */\n  peek(): Promise<T | undefined>;\n  /** Mutate the cached value and persist it. */\n  update(mutator: (current: T) => T): Promise<T>;\n  /** Force a refresh attempt even when the entry is still fresh. */\n  refresh(): Promise<T>;\n}\n\nconst inflight = new Map<string, Promise<unknown>>();\n\n/** Default cacache root for a package version under the dbx-tools cache dir. */\nexport function defaultMetadataCacheDir(version: string): string {\n  const cacheDirectory = envPaths(\"dbx-tools\", { suffix: \"\" }).cache;\n  return resolve(cacheDirectory, \"model-gateway\", version);\n}\n\n/** Whether metadata caches should persist to disk in this process. */\nexport function metadataCacheDiskEnabled(environment: NodeJS.ProcessEnv = process.env): boolean {\n  return !environmentUtils.isDatabricksAppEnv(environment);\n}\n\n/**\n * Create one daily cache backed by cacache memoization, with optional disk.\n */\nexport function createMetadataCache<T>(options: MetadataCacheOptions<T>): MetadataCache<T> {\n  const ttlMs = options.ttlMs ?? MODEL_METADATA_TTL_MS;\n  const diskEnabled = options.disk ?? metadataCacheDiskEnabled();\n  const now = options.now ?? Date.now;\n  const pathPromise = resolveCacheDir(options);\n  let path = options.cacheDir;\n\n  const flightKey = (cachePath: string, suffix = \"\"): string =>\n    `${cachePath}::${options.key}${suffix}`;\n\n  /** Process-local store used when disk is off (Databricks Apps). */\n  const memoryOnly = new Map<string, MetadataCacheRecord<T>>();\n\n  const resolveValue = (input: MetadataCacheMergeInput<T>): T => options.merge(input);\n\n  const isFresh = (record: MetadataCacheRecord<T> | undefined): boolean =>\n    Boolean(record && now() - record.refreshedAt < ttlMs);\n\n  const cachePath = async (): Promise<string> => {\n    path ??= await pathPromise;\n    return path;\n  };\n\n  const readRecord = async (): Promise<MetadataCacheRecord<T> | undefined> => {\n    if (!diskEnabled) return memoryOnly.get(options.key);\n    const resolvedPath = await cachePath();\n    try {\n      // cacache reads its in-memory memo first unless memoize is false\n      const entry = await cacache.get(resolvedPath, options.key);\n      return decodeRecord<T>(entry.data);\n    } catch (error) {\n      if (isCacheMiss(error)) return undefined;\n      logger.warn(\"metadata cache cacache read failed\", {\n        key: options.key,\n        path: resolvedPath,\n        error,\n      });\n      return undefined;\n    }\n  };\n\n  const writeRecord = async (record: MetadataCacheRecord<T>): Promise<void> => {\n    if (!diskEnabled) {\n      memoryOnly.set(options.key, record);\n      return;\n    }\n    const resolvedPath = await cachePath();\n    try {\n      await cacache.put(resolvedPath, options.key, `${JSON.stringify(record)}\\n`, {\n        memoize: true,\n        metadata: { refreshedAt: record.refreshedAt },\n      });\n    } catch (error) {\n      logger.warn(\"metadata cache cacache write failed\", {\n        key: options.key,\n        path: resolvedPath,\n        error,\n      });\n    }\n  };\n\n  const persist = async (value: T, refreshedAt = now()): Promise<T> => {\n    await writeRecord({ refreshedAt, value });\n    return value;\n  };\n\n  const refresh = async (force: boolean): Promise<T> => {\n    const resolvedPath = await cachePath();\n    return coalesce(flightKey(resolvedPath), async () => {\n      const previous = await readRecord();\n      if (!force && isFresh(previous)) {\n        return resolveValue({\n          fresh: undefined,\n          previous: previous?.value,\n          fallback: options.fallback,\n        });\n      }\n\n      let fresh: T | undefined;\n      if (options.load) {\n        try {\n          fresh = await options.load();\n        } catch (error) {\n          logger.warn(\"metadata cache refresh failed; keeping last known good\", {\n            key: options.key,\n            error,\n            path: resolvedPath,\n            diskEnabled,\n          });\n        }\n      }\n\n      const value = resolveValue({\n        fresh,\n        previous: previous?.value,\n        fallback: options.fallback,\n      });\n      if (fresh !== undefined || !previous) {\n        await persist(value);\n      }\n      return value;\n    });\n  };\n\n  return {\n    get path() {\n      if (!path) {\n        throw new Error(\"metadata cache path is not resolved until the first cache read\");\n      }\n      return path;\n    },\n    diskEnabled,\n    get: () => refresh(false),\n    peek: async () => (await readRecord())?.value,\n    refresh: () => refresh(true),\n    update: async (mutator) => {\n      const resolvedPath = await cachePath();\n      return coalesce(flightKey(resolvedPath, \":update\"), async () => {\n        const previous = await readRecord();\n        const baseline = resolveValue({\n          fresh: undefined,\n          previous: previous?.value,\n          fallback: options.fallback,\n        });\n        return persist(mutator(baseline));\n      });\n    },\n  };\n}\n\nasync function resolveCacheDir(options: {\n  readonly cacheDir?: string;\n  readonly version?: string;\n}): Promise<string> {\n  if (options.cacheDir) return options.cacheDir;\n  const version = options.version ?? PACKAGE_IDENTITY.version;\n  return defaultMetadataCacheDir(version);\n}\n\n/** Prefer a non-empty fresh array, else previous, else fallback. */\nexport function mergePreferFreshList<T>(input: MetadataCacheMergeInput<readonly T[]>): T[] {\n  if (input.fresh && input.fresh.length > 0) return [...input.fresh];\n  if (input.previous && input.previous.length > 0) return [...input.previous];\n  return [...input.fallback];\n}\n\n/**\n * Shallow-merge record catalogues: fallback, then previous, then fresh keys.\n * Fresh values win per key.\n */\nexport function mergePreferFreshRecord<T>(\n  input: MetadataCacheMergeInput<Readonly<Record<string, T>>>,\n): Record<string, T> {\n  return {\n    ...input.fallback,\n    ...(input.previous ?? {}),\n    ...(input.fresh ?? {}),\n  };\n}\n\n/** Test helper: wipe a cacache root and clear cacache memoization. */\nexport async function resetMetadataCacheDir(cacheDir: string): Promise<void> {\n  try {\n    await cacache.rm.all(cacheDir);\n  } catch {\n    // empty / missing cache is fine\n  }\n  cacache.clearMemoized();\n  for (const key of [...inflight.keys()]) {\n    if (key.startsWith(`${cacheDir}::`)) inflight.delete(key);\n  }\n}\n\nfunction coalesce<T>(key: string, work: () => Promise<T>): Promise<T> {\n  const existing = inflight.get(key);\n  if (existing) return existing as Promise<T>;\n  const pending = work().finally(() => {\n    if (inflight.get(key) === pending) inflight.delete(key);\n  });\n  inflight.set(key, pending);\n  return pending;\n}\n\nfunction decodeRecord<T>(data: Buffer): MetadataCacheRecord<T> | undefined {\n  try {\n    const parsed = JSON.parse(data.toString(\"utf8\")) as unknown;\n    if (\n      !parsed ||\n      typeof parsed !== \"object\" ||\n      typeof (parsed as MetadataCacheRecord<T>).refreshedAt !== \"number\"\n    ) {\n      return undefined;\n    }\n    return parsed as MetadataCacheRecord<T>;\n  } catch {\n    return undefined;\n  }\n}\n\nfunction isCacheMiss(error: unknown): boolean {\n  return Boolean(\n    error &&\n    typeof error === \"object\" &&\n    \"code\" in error &&\n    (error as { code?: string }).code === \"ENOENT\",\n  );\n}\n"]}
+//# 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 * Daily model metadata cache built on the shared memory-first cache package.\n *\n * @module\n */\n\nimport { createCache, getOrSet } from \"@dbx-tools/cache/cache\";\nimport * as errorUtils from \"@dbx-tools/shared-core/error-utils\";\nimport * as log from \"@dbx-tools/shared-core/log\";\n\nimport { modelMetadataCache } from \"./_cache.ts\";\nimport { MODEL_METADATA_TTL_MS } from \"./_metadata-contract.ts\";\n\nconst logger = log.logger(\"model/metadata-cache\");\n\n/** Factory inputs for one named metadata cache. */\nexport interface MetadataCacheOptions<T> {\n  /** Stable cache key. */\n  readonly key: string;\n  /** Hard-coded / committed baseline used when store and load both miss. */\n  readonly fallback: T;\n  /** Optional refresh source. */\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 one day. */\n  readonly ttlMs?: 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 namespaced view over the shared metadata cache. */\nexport interface MetadataCache<T> {\n  /** Return a fresh-or-fallback value, refreshing when stale. */\n  get(): Promise<T>;\n  /** Read process memory 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\n/** Create one namespaced view over the shared model metadata cache. */\nexport function createMetadataCache<T>(\n  options: MetadataCacheOptions<T>,\n  cache: ReturnType<typeof createCache> = modelMetadataCache,\n): MetadataCache<T> {\n  const ttlMs = options.ttlMs ?? MODEL_METADATA_TTL_MS;\n  const valueKey = `model-metadata:value:${options.key}`;\n  const refreshKey = `model-metadata:refresh:${options.key}`;\n\n  const read = (): Promise<T | undefined> => cache.get<T>(valueKey);\n  const persist = async (value: T): Promise<T> => {\n    await cache.set(valueKey, value);\n    return value;\n  };\n  const resolveValue = (fresh: T | undefined, previous: T | undefined): T =>\n    options.merge({ fresh, previous, fallback: options.fallback });\n\n  const refresh = async (force: boolean): Promise<T> => {\n    if (force) await cache.delete(refreshKey);\n    let staleRefreshFailed = false;\n    await getOrSet(\n      cache,\n      refreshKey,\n      async () => {\n        const previous = await read();\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; using cached or committed value\", {\n              key: options.key,\n              error: errorUtils.toError(error),\n            });\n            staleRefreshFailed = previous !== undefined;\n          }\n        }\n        const resolved = resolveValue(fresh, previous);\n        if (fresh !== undefined || previous === undefined) await persist(resolved);\n        return true;\n      },\n      { ttl: ttlMs, throwErrors: true },\n    );\n    if (staleRefreshFailed) await cache.delete(refreshKey);\n    return resolveValue(undefined, await read());\n  };\n\n  return {\n    get: () => refresh(false),\n    peek: read,\n    refresh: () => refresh(true),\n    update: async (mutator) => {\n      const value = await persist(mutator(resolveValue(undefined, await read())));\n      await cache.set(refreshKey, true, { ttl: ttlMs });\n      return value;\n    },\n  };\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/** Shallow-merge record catalogues: fallback, then previous, then fresh keys. */\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"]}

package/lib/src/metadata.d.ts

@@ -16,14 +16,12 @@ interface MetadataIndex {
  * 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. */
+/** Load shared cache 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;
 export { modelStatusFor, retiredModelNames } from "./_retirement.ts";
 /** Return the committed reasoning-effort catalogue. Cached per process. */
 export declare function reasoningModelCatalogue(): ReasoningModelCatalogue;
-/** Return error-learned reasoning ladders persisted in the metadata cache. */
+/** Return error-learned reasoning ladders from the shared model cache. */
 export declare function learnedReasoningCatalogue(): ReasoningModelCatalogue;
 /**
  * Store levels learned from an upstream error and persist them write-through.
@@ -37,7 +35,7 @@ export declare function rememberReasoningLevels(model: string, levels: readonly
  *
  * 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.
+ * 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. */