@dbx-tools/model 0.3.44 → 0.4.1

package/lib/src/resolve.d.ts

@@ -0,0 +1,156 @@
+/**
+ * Workspace-aware model selection.
+ *
+ * Given a caller's intent - a search string, a capability {@link ModelClass}
+ * ceiling, both, or nothing - the toolkit returns matching endpoints ranked by
+ * match quality then class, or collapses to the single best id the workspace
+ * actually has, degrading from "best in range" down to the static fallback
+ * floor. Selection is chat-only: embedding endpoints surface only when
+ * `modelClass` is explicitly {@link ModelClass.Embedding}.
+ *
+ * Two shapes of selection, each in a pure form (over an endpoint list the
+ * caller already holds) and an I/O wrapper (that lists `/serving-endpoints`
+ * first): ranking, which returns a match- then class-ordered list, and
+ * single-selection, which collapses to one id plus how it was reached and
+ * layers the operator-pinned fallback / static-floor safety net on top. A chat
+ * `modelClass` acts as a ceiling: that band and the less-capable chat bands
+ * below it are eligible (see {@link classesAtOrBelow}), so a `chat-balanced`
+ * ask can fall to `chat-fast` but never escalate to `chat-thinking`.
+ *
+ * @module
+ */
+import { model, type ModelQuery, type RankedModel, type ServingEndpointSummary } from "@dbx-tools/shared-model";
+import { type ResolvedModel, type ResolveModelOptions, type WorkspaceClientLike } from "./serving.js";
+type ModelClass = model.ModelClass;
+/** Caller intent passed to {@link resolveModel}. */
+export interface ResolveModelInput {
+    /**
+     * Explicit model id / loose name (per-request override, agent / plugin
+     * default, or env var). When set it wins over `modelClass` and `fallbacks`.
+     */
+    explicit?: string;
+    /**
+     * Fuzzy-match an `explicit` name against the live catalogue so loose names
+     * like `"claude sonnet"` resolve. Default `true`. When `false` the explicit
+     * input is returned verbatim (Databricks surfaces the canonical 404 if it
+     * doesn't exist).
+     */
+    fuzzy?: boolean;
+    /** Fuse.js threshold forwarded to the fuzzy `search` match ({@link searchServingEndpoints}). */
+    threshold?: number;
+    /**
+     * Chat capability class to resolve when no `explicit` id is given. The live
+     * catalogue is classified by its Foundation Model API scores and the top
+     * available model in the class (and the chat bands below it) wins, falling
+     * back to the class's small static list.
+     */
+    modelClass?: ModelClass;
+    /**
+     * Operator-supplied fallback ids tried *first* in the no-explicit, no-class
+     * path (e.g. a regulated workspace pinned to an approved subset), ahead of
+     * the auto-classified catalogue.
+     */
+    fallbacks?: readonly string[];
+}
+/** Outcome of {@link resolveModel}: the chosen id plus how it was reached. */
+export interface ResolvedModelSelection {
+    modelId: string;
+    source: "explicit" | "fuzzy-match" | "class" | "fallback";
+}
+/** Intent + catalogue knobs passed to {@link selectModel}. */
+export interface SelectModelInput extends ResolveModelInput {
+    /** TTL override for the cached `/serving-endpoints` listing, in ms. */
+    ttlMs?: number;
+}
+/** TTL override merged into a {@link ModelQuery} for {@link searchModels}. */
+export interface SearchModelsInput extends ModelQuery {
+    /** TTL override for the cached `/serving-endpoints` listing, in ms. */
+    ttlMs?: number;
+}
+/**
+ * Rank the live catalogue against a {@link ModelQuery}, best-first.
+ *
+ * Candidates are the classified endpoints in the eligible classes:
+ * {@link classesAtOrBelow} the requested `modelClass`, or - when none is given
+ * - the chat bands only ({@link CHAT_CLASS_ORDER}), so a general ask never
+ * surfaces an embedding endpoint. Each class bucket is already best-first from
+ * {@link classify.classifyEndpoints}. Ranking is **match then class**:
+ *
+ * 1. With a `search`, only endpoints matching it survive, ordered by match
+ *    distance (bucketed via {@link matchBucket} so near-identical scores tie),
+ *    then by class (more capable first), then by the stable within-class rank.
+ * 2. Without a `search`, the class-then-rank candidate order stands.
+ *
+ * A `limit` truncates the result. Returns `[]` when nothing is eligible or
+ * matches - callers layer their own fallback.
+ */
+export declare function rankModels(endpoints: readonly ServingEndpointSummary[], query?: ModelQuery): RankedModel[];
+/**
+ * Collapse {@link rankModels} to a single id: the closest endpoint to `search`
+ * in a catalogue snapshot, or the input verbatim when nothing scores within the
+ * threshold.
+ *
+ * The rank-based counterpart to the Fuse-only {@link resolveModelId}: equal
+ * match scores are broken by class and then within-class version, so a loose
+ * `"opus"` prefers `opus-5` over `opus-4-7` instead of picking whichever
+ * sibling Fuse happened to order first. Returning the input unmatched (rather
+ * than a near neighbour) is deliberate - a deliberate endpoint id is never
+ * silently rewritten, and Databricks surfaces a clean 404.
+ */
+export declare function rankModelId(endpoints: readonly ServingEndpointSummary[], search: string, options?: ResolveModelOptions): ResolvedModel;
+/**
+ * {@link rankModelId} against a catalogue the caller may be holding stale:
+ * match the loaded snapshot, and on a miss reload once with `force` and match
+ * again. That way a model deployed after the catalogue was cached still
+ * resolves on first use, without a restart and without giving up caching.
+ *
+ * The catalogue arrives as a loader rather than a client so the caller keeps
+ * ownership of *how* it is cached - {@link listServingEndpoints} and its
+ * `CacheManager`, a plain process-lifetime field in a CLI, or a test double.
+ * Only one reload is attempted: a genuinely unknown name should fail fast
+ * rather than re-list on every request.
+ *
+ * @param load - Returns the catalogue; `force` asks it to bypass its cache.
+ */
+export declare function rankModelIdLive(load: (force: boolean) => Promise<readonly ServingEndpointSummary[]>, search: string, options?: ResolveModelOptions): Promise<ResolvedModel>;
+/**
+ * Rank a workspace's catalogue in one call: list its `/serving-endpoints`
+ * (cached) and run {@link rankModels} over the result. The list counterpart to
+ * {@link selectModel}, for a consumer that wants the full ranked set (a model
+ * picker, a CLI) rather than a single id. Catalogue fetches fail loud: network
+ * / auth errors propagate so the caller sees the real SDK message.
+ *
+ * @param host - Workspace host used as the cache key. Pass the value resolved
+ *   from `client.config.getHost()`.
+ */
+export declare function searchModels(client: WorkspaceClientLike, host: string, input?: SearchModelsInput): Promise<RankedModel[]>;
+/**
+ * Resolve a model id for a workspace in one call: list its `/serving-endpoints`
+ * (cached) and run {@link resolveModel} over the result. This is the entry
+ * point for any consumer that holds a `WorkspaceClient` and just wants a usable
+ * model name - a Lakeflow job, a one-off script, or the Mastra plugin alike.
+ *
+ * Cheap exit: when an `explicit` name is given and `fuzzy` is off, the
+ * catalogue is never fetched - the name is returned verbatim and Databricks
+ * surfaces the canonical 404 if it doesn't exist. Catalogue fetches otherwise
+ * fail loud: network / auth errors propagate so the caller sees the real SDK
+ * message instead of a silent fallback.
+ *
+ * @param host - Workspace host used as the cache key. Pass the value resolved
+ *   from `client.config.getHost()`.
+ */
+export declare function selectModel(client: WorkspaceClientLike, host: string, input?: SelectModelInput): Promise<ResolvedModelSelection>;
+/**
+ * Resolve a single model id from the live catalogue and caller intent,
+ * delegating the live selection to {@link rankModels} with `limit: 1`.
+ *
+ * 1. **Explicit ask**: with `fuzzy` off, returned verbatim; otherwise
+ *    fuzzy-ranked within the (optional) class ceiling and the best taken,
+ *    falling back to the input verbatim when nothing matches.
+ * 2. **No explicit ask**: an operator-pinned `fallback` that exists in the live
+ *    catalogue wins first; then the ranked live catalogue (class ceiling
+ *    applied); then the static {@link FALLBACK_MODEL_IDS} floor when the
+ *    catalogue yields nothing in range.
+ */
+export declare function resolveModel(endpoints: readonly ServingEndpointSummary[], input?: ResolveModelInput): ResolvedModelSelection;
+export {};

package/lib/src/resolve.js

@@ -0,0 +1,227 @@
+/**
+ * Workspace-aware model selection.
+ *
+ * Given a caller's intent - a search string, a capability {@link ModelClass}
+ * ceiling, both, or nothing - the toolkit returns matching endpoints ranked by
+ * match quality then class, or collapses to the single best id the workspace
+ * actually has, degrading from "best in range" down to the static fallback
+ * floor. Selection is chat-only: embedding endpoints surface only when
+ * `modelClass` is explicitly {@link ModelClass.Embedding}.
+ *
+ * Two shapes of selection, each in a pure form (over an endpoint list the
+ * caller already holds) and an I/O wrapper (that lists `/serving-endpoints`
+ * first): ranking, which returns a match- then class-ordered list, and
+ * single-selection, which collapses to one id plus how it was reached and
+ * layers the operator-pinned fallback / static-floor safety net on top. A chat
+ * `modelClass` acts as a ceiling: that band and the less-capable chat bands
+ * below it are eligible (see {@link classesAtOrBelow}), so a `chat-balanced`
+ * ask can fall to `chat-fast` but never escalate to `chat-thinking`.
+ *
+ * @module
+ */
+import { object } from "@dbx-tools/shared-core";
+import { classify, } from "@dbx-tools/shared-model";
+import { CHAT_CLASS_ORDER, classesAtOrBelow, MODEL_CLASS_ORDER } from "./classes.js";
+import { FALLBACK_MODEL_IDS, modelsForClass } from "./fallback.js";
+import { listServingEndpoints, searchServingEndpoints, } from "./serving.js";
+/**
+ * Round a Fuse score to the display precision so version siblings that match a
+ * token identically (e.g. `opus-4-7` vs `opus-4-8` for the query `"opus"`) tie
+ * on match and let the class / within-class rank decide - which is what
+ * surfaces the newer, higher-quality sibling.
+ */
+function matchBucket(score) {
+    return Math.round((score ?? 0) * 1000);
+}
+/**
+ * Rank the live catalogue against a {@link ModelQuery}, best-first.
+ *
+ * Candidates are the classified endpoints in the eligible classes:
+ * {@link classesAtOrBelow} the requested `modelClass`, or - when none is given
+ * - the chat bands only ({@link CHAT_CLASS_ORDER}), so a general ask never
+ * surfaces an embedding endpoint. Each class bucket is already best-first from
+ * {@link classify.classifyEndpoints}. Ranking is **match then class**:
+ *
+ * 1. With a `search`, only endpoints matching it survive, ordered by match
+ *    distance (bucketed via {@link matchBucket} so near-identical scores tie),
+ *    then by class (more capable first), then by the stable within-class rank.
+ * 2. Without a `search`, the class-then-rank candidate order stands.
+ *
+ * A `limit` truncates the result. Returns `[]` when nothing is eligible or
+ * matches - callers layer their own fallback.
+ */
+export function rankModels(endpoints, query = {}) {
+    const classified = classify.classifyEndpoints(endpoints);
+    const eligible = query.modelClass !== undefined ? classesAtOrBelow(query.modelClass) : CHAT_CLASS_ORDER;
+    // Flatten eligible classes in capability order, carrying each endpoint's
+    // class; bucket order is already best-first.
+    const candidates = [];
+    for (const modelClass of eligible) {
+        for (const endpoint of classified[modelClass])
+            candidates.push({ endpoint, modelClass });
+    }
+    const search = query.search?.trim();
+    let ranked;
+    if (search) {
+        const scores = new Map();
+        for (const match of searchServingEndpoints(search, candidates.map((c) => c.endpoint), query.threshold !== undefined ? { threshold: query.threshold } : {})) {
+            scores.set(match.endpoint.name, match.score);
+        }
+        // `Array.prototype.sort` is stable, so endpoints equal on match and class
+        // keep their best-first within-class order.
+        ranked = candidates
+            .filter((c) => scores.has(c.endpoint.name))
+            .map((c) => ({ ...c, score: scores.get(c.endpoint.name) }))
+            .sort((a, b) => {
+            const byMatch = matchBucket(a.score) - matchBucket(b.score);
+            if (byMatch !== 0)
+                return byMatch;
+            return MODEL_CLASS_ORDER.indexOf(a.modelClass) - MODEL_CLASS_ORDER.indexOf(b.modelClass);
+        });
+    }
+    else {
+        ranked = candidates;
+    }
+    return query.limit !== undefined ? ranked.slice(0, Math.max(0, query.limit)) : ranked;
+}
+/**
+ * Collapse {@link rankModels} to a single id: the closest endpoint to `search`
+ * in a catalogue snapshot, or the input verbatim when nothing scores within the
+ * threshold.
+ *
+ * The rank-based counterpart to the Fuse-only {@link resolveModelId}: equal
+ * match scores are broken by class and then within-class version, so a loose
+ * `"opus"` prefers `opus-5` over `opus-4-7` instead of picking whichever
+ * sibling Fuse happened to order first. Returning the input unmatched (rather
+ * than a near neighbour) is deliberate - a deliberate endpoint id is never
+ * silently rewritten, and Databricks surfaces a clean 404.
+ */
+export function rankModelId(endpoints, search, options = {}) {
+    const [top] = rankModels(endpoints, {
+        search,
+        limit: 1,
+        ...(options.threshold !== undefined ? { threshold: options.threshold } : {}),
+    });
+    if (!top)
+        return { modelId: search, matched: false };
+    return { modelId: top.endpoint.name, matched: true, score: top.score };
+}
+/**
+ * {@link rankModelId} against a catalogue the caller may be holding stale:
+ * match the loaded snapshot, and on a miss reload once with `force` and match
+ * again. That way a model deployed after the catalogue was cached still
+ * resolves on first use, without a restart and without giving up caching.
+ *
+ * The catalogue arrives as a loader rather than a client so the caller keeps
+ * ownership of *how* it is cached - {@link listServingEndpoints} and its
+ * `CacheManager`, a plain process-lifetime field in a CLI, or a test double.
+ * Only one reload is attempted: a genuinely unknown name should fail fast
+ * rather than re-list on every request.
+ *
+ * @param load - Returns the catalogue; `force` asks it to bypass its cache.
+ */
+export async function rankModelIdLive(load, search, options = {}) {
+    const resolved = rankModelId(await load(false), search, options);
+    if (resolved.matched)
+        return resolved;
+    return rankModelId(await load(true), search, options);
+}
+/**
+ * Rank a workspace's catalogue in one call: list its `/serving-endpoints`
+ * (cached) and run {@link rankModels} over the result. The list counterpart to
+ * {@link selectModel}, for a consumer that wants the full ranked set (a model
+ * picker, a CLI) rather than a single id. Catalogue fetches fail loud: network
+ * / auth errors propagate so the caller sees the real SDK message.
+ *
+ * @param host - Workspace host used as the cache key. Pass the value resolved
+ *   from `client.config.getHost()`.
+ */
+export async function searchModels(client, host, input = {}) {
+    const endpoints = await listServingEndpoints(client, host, input.ttlMs !== undefined ? { ttlMs: input.ttlMs } : {});
+    return rankModels(endpoints, input);
+}
+/**
+ * Resolve a model id for a workspace in one call: list its `/serving-endpoints`
+ * (cached) and run {@link resolveModel} over the result. This is the entry
+ * point for any consumer that holds a `WorkspaceClient` and just wants a usable
+ * model name - a Lakeflow job, a one-off script, or the Mastra plugin alike.
+ *
+ * Cheap exit: when an `explicit` name is given and `fuzzy` is off, the
+ * catalogue is never fetched - the name is returned verbatim and Databricks
+ * surfaces the canonical 404 if it doesn't exist. Catalogue fetches otherwise
+ * fail loud: network / auth errors propagate so the caller sees the real SDK
+ * message instead of a silent fallback.
+ *
+ * @param host - Workspace host used as the cache key. Pass the value resolved
+ *   from `client.config.getHost()`.
+ */
+export async function selectModel(client, host, input = {}) {
+    if (input.explicit !== undefined && input.fuzzy === false) {
+        return { modelId: input.explicit, source: "explicit" };
+    }
+    const endpoints = await listServingEndpoints(client, host, {
+        ...(input.ttlMs !== undefined ? { ttlMs: input.ttlMs } : {}),
+    });
+    return resolveModel(endpoints, input);
+}
+/**
+ * Resolve a single model id from the live catalogue and caller intent,
+ * delegating the live selection to {@link rankModels} with `limit: 1`.
+ *
+ * 1. **Explicit ask**: with `fuzzy` off, returned verbatim; otherwise
+ *    fuzzy-ranked within the (optional) class ceiling and the best taken,
+ *    falling back to the input verbatim when nothing matches.
+ * 2. **No explicit ask**: an operator-pinned `fallback` that exists in the live
+ *    catalogue wins first; then the ranked live catalogue (class ceiling
+ *    applied); then the static {@link FALLBACK_MODEL_IDS} floor when the
+ *    catalogue yields nothing in range.
+ */
+export function resolveModel(endpoints, input = {}) {
+    if (input.explicit !== undefined) {
+        if (input.fuzzy === false) {
+            return { modelId: input.explicit, source: "explicit" };
+        }
+        const [top] = rankModels(endpoints, buildQuery(input, input.explicit));
+        return { modelId: top?.endpoint.name ?? input.explicit, source: "fuzzy-match" };
+    }
+    // Operator-pinned fallbacks win when present and live (e.g. a regulated
+    // workspace restricted to an approved subset).
+    if (input.modelClass === undefined && input.fallbacks && input.fallbacks.length > 0) {
+        const present = new Set(endpoints.map((e) => e.name));
+        const pinned = input.fallbacks.find((id) => present.has(id));
+        if (pinned)
+            return { modelId: pinned, source: "fallback" };
+    }
+    const source = input.modelClass !== undefined ? "class" : "fallback";
+    const [top] = rankModels(endpoints, buildQuery(input, undefined));
+    if (top)
+        return { modelId: top.endpoint.name, source };
+    // Live catalogue yielded nothing in range: walk the static floor.
+    const floorSource = input.modelClass !== undefined ? modelsForClass(input.modelClass) : (input.fallbacks ?? []);
+    const floor = object.sequence(floorSource).concat(FALLBACK_MODEL_IDS).distinct().toArray();
+    return { modelId: pickFirstAvailable(floor, endpoints), source };
+}
+/** Build a {@link ModelQuery} from {@link ResolveModelInput} for the `limit: 1` delegation. */
+function buildQuery(input, search) {
+    return {
+        ...(search !== undefined ? { search } : {}),
+        ...(input.modelClass !== undefined ? { modelClass: input.modelClass } : {}),
+        ...(input.threshold !== undefined ? { threshold: input.threshold } : {}),
+        limit: 1,
+    };
+}
+/**
+ * Find the first id in `candidates` whose endpoint is present in `endpoints`.
+ * Returns the top candidate when the workspace has none of them so callers
+ * always get a string; an offline workspace then receives a clean 404 from
+ * Databricks instead of a malformed config.
+ */
+function pickFirstAvailable(candidates, endpoints) {
+    const present = new Set(endpoints.map((e) => e.name));
+    for (const candidate of candidates) {
+        if (present.has(candidate))
+            return candidate;
+    }
+    return candidates[0] ?? FALLBACK_MODEL_IDS[0];
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"resolve.js","sourceRoot":"","sources":["../../src/resolve.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Workspace-aware model selection.\n *\n * Given a caller's intent - a search string, a capability {@link ModelClass}\n * ceiling, both, or nothing - the toolkit returns matching endpoints ranked by\n * match quality then class, or collapses to the single best id the workspace\n * actually has, degrading from \"best in range\" down to the static fallback\n * floor. Selection is chat-only: embedding endpoints surface only when\n * `modelClass` is explicitly {@link ModelClass.Embedding}.\n *\n * Two shapes of selection, each in a pure form (over an endpoint list the\n * caller already holds) and an I/O wrapper (that lists `/serving-endpoints`\n * first): ranking, which returns a match- then class-ordered list, and\n * single-selection, which collapses to one id plus how it was reached and\n * layers the operator-pinned fallback / static-floor safety net on top. A chat\n * `modelClass` acts as a ceiling: that band and the less-capable chat bands\n * below it are eligible (see {@link classesAtOrBelow}), so a `chat-balanced`\n * ask can fall to `chat-fast` but never escalate to `chat-thinking`.\n *\n * @module\n */\n\nimport { object } from \"@dbx-tools/shared-core\";\nimport {\n  classify,\n  model,\n  type ModelQuery,\n  type RankedModel,\n  type ServingEndpointSummary,\n} from \"@dbx-tools/shared-model\";\n\nimport { CHAT_CLASS_ORDER, classesAtOrBelow, MODEL_CLASS_ORDER } from \"./classes\";\nimport { FALLBACK_MODEL_IDS, modelsForClass } from \"./fallback\";\nimport {\n  listServingEndpoints,\n  searchServingEndpoints,\n  type ResolvedModel,\n  type ResolveModelOptions,\n  type WorkspaceClientLike,\n} from \"./serving\";\n\ntype ModelClass = model.ModelClass;\n\n/** Caller intent passed to {@link resolveModel}. */\nexport interface ResolveModelInput {\n  /**\n   * Explicit model id / loose name (per-request override, agent / plugin\n   * default, or env var). When set it wins over `modelClass` and `fallbacks`.\n   */\n  explicit?: string;\n  /**\n   * Fuzzy-match an `explicit` name against the live catalogue so loose names\n   * like `\"claude sonnet\"` resolve. Default `true`. When `false` the explicit\n   * input is returned verbatim (Databricks surfaces the canonical 404 if it\n   * doesn't exist).\n   */\n  fuzzy?: boolean;\n  /** Fuse.js threshold forwarded to the fuzzy `search` match ({@link searchServingEndpoints}). */\n  threshold?: number;\n  /**\n   * Chat capability class to resolve when no `explicit` id is given. The live\n   * catalogue is classified by its Foundation Model API scores and the top\n   * available model in the class (and the chat bands below it) wins, falling\n   * back to the class's small static list.\n   */\n  modelClass?: ModelClass;\n  /**\n   * Operator-supplied fallback ids tried *first* in the no-explicit, no-class\n   * path (e.g. a regulated workspace pinned to an approved subset), ahead of\n   * the auto-classified catalogue.\n   */\n  fallbacks?: readonly string[];\n}\n\n/** Outcome of {@link resolveModel}: the chosen id plus how it was reached. */\nexport interface ResolvedModelSelection {\n  modelId: string;\n  source: \"explicit\" | \"fuzzy-match\" | \"class\" | \"fallback\";\n}\n\n/** Intent + catalogue knobs passed to {@link selectModel}. */\nexport interface SelectModelInput extends ResolveModelInput {\n  /** TTL override for the cached `/serving-endpoints` listing, in ms. */\n  ttlMs?: number;\n}\n\n/** TTL override merged into a {@link ModelQuery} for {@link searchModels}. */\nexport interface SearchModelsInput extends ModelQuery {\n  /** TTL override for the cached `/serving-endpoints` listing, in ms. */\n  ttlMs?: number;\n}\n\n/**\n * Round a Fuse score to the display precision so version siblings that match a\n * token identically (e.g. `opus-4-7` vs `opus-4-8` for the query `\"opus\"`) tie\n * on match and let the class / within-class rank decide - which is what\n * surfaces the newer, higher-quality sibling.\n */\nfunction matchBucket(score: number | undefined): number {\n  return Math.round((score ?? 0) * 1000);\n}\n\n/**\n * Rank the live catalogue against a {@link ModelQuery}, best-first.\n *\n * Candidates are the classified endpoints in the eligible classes:\n * {@link classesAtOrBelow} the requested `modelClass`, or - when none is given\n * - the chat bands only ({@link CHAT_CLASS_ORDER}), so a general ask never\n * surfaces an embedding endpoint. Each class bucket is already best-first from\n * {@link classify.classifyEndpoints}. Ranking is **match then class**:\n *\n * 1. With a `search`, only endpoints matching it survive, ordered by match\n *    distance (bucketed via {@link matchBucket} so near-identical scores tie),\n *    then by class (more capable first), then by the stable within-class rank.\n * 2. Without a `search`, the class-then-rank candidate order stands.\n *\n * A `limit` truncates the result. Returns `[]` when nothing is eligible or\n * matches - callers layer their own fallback.\n */\nexport function rankModels(\n  endpoints: readonly ServingEndpointSummary[],\n  query: ModelQuery = {},\n): RankedModel[] {\n  const classified = classify.classifyEndpoints(endpoints);\n  const eligible =\n    query.modelClass !== undefined ? classesAtOrBelow(query.modelClass) : CHAT_CLASS_ORDER;\n\n  // Flatten eligible classes in capability order, carrying each endpoint's\n  // class; bucket order is already best-first.\n  const candidates: RankedModel[] = [];\n  for (const modelClass of eligible) {\n    for (const endpoint of classified[modelClass]) candidates.push({ endpoint, modelClass });\n  }\n\n  const search = query.search?.trim();\n  let ranked: RankedModel[];\n  if (search) {\n    const scores = new Map<string, number>();\n    for (const match of searchServingEndpoints(\n      search,\n      candidates.map((c) => c.endpoint),\n      query.threshold !== undefined ? { threshold: query.threshold } : {},\n    )) {\n      scores.set(match.endpoint.name, match.score);\n    }\n    // `Array.prototype.sort` is stable, so endpoints equal on match and class\n    // keep their best-first within-class order.\n    ranked = candidates\n      .filter((c) => scores.has(c.endpoint.name))\n      .map((c) => ({ ...c, score: scores.get(c.endpoint.name) }))\n      .sort((a, b) => {\n        const byMatch = matchBucket(a.score) - matchBucket(b.score);\n        if (byMatch !== 0) return byMatch;\n        return MODEL_CLASS_ORDER.indexOf(a.modelClass) - MODEL_CLASS_ORDER.indexOf(b.modelClass);\n      });\n  } else {\n    ranked = candidates;\n  }\n\n  return query.limit !== undefined ? ranked.slice(0, Math.max(0, query.limit)) : ranked;\n}\n\n/**\n * Collapse {@link rankModels} to a single id: the closest endpoint to `search`\n * in a catalogue snapshot, or the input verbatim when nothing scores within the\n * threshold.\n *\n * The rank-based counterpart to the Fuse-only {@link resolveModelId}: equal\n * match scores are broken by class and then within-class version, so a loose\n * `\"opus\"` prefers `opus-5` over `opus-4-7` instead of picking whichever\n * sibling Fuse happened to order first. Returning the input unmatched (rather\n * than a near neighbour) is deliberate - a deliberate endpoint id is never\n * silently rewritten, and Databricks surfaces a clean 404.\n */\nexport function rankModelId(\n  endpoints: readonly ServingEndpointSummary[],\n  search: string,\n  options: ResolveModelOptions = {},\n): ResolvedModel {\n  const [top] = rankModels(endpoints, {\n    search,\n    limit: 1,\n    ...(options.threshold !== undefined ? { threshold: options.threshold } : {}),\n  });\n  if (!top) return { modelId: search, matched: false };\n  return { modelId: top.endpoint.name, matched: true, score: top.score };\n}\n\n/**\n * {@link rankModelId} against a catalogue the caller may be holding stale:\n * match the loaded snapshot, and on a miss reload once with `force` and match\n * again. That way a model deployed after the catalogue was cached still\n * resolves on first use, without a restart and without giving up caching.\n *\n * The catalogue arrives as a loader rather than a client so the caller keeps\n * ownership of *how* it is cached - {@link listServingEndpoints} and its\n * `CacheManager`, a plain process-lifetime field in a CLI, or a test double.\n * Only one reload is attempted: a genuinely unknown name should fail fast\n * rather than re-list on every request.\n *\n * @param load - Returns the catalogue; `force` asks it to bypass its cache.\n */\nexport async function rankModelIdLive(\n  load: (force: boolean) => Promise<readonly ServingEndpointSummary[]>,\n  search: string,\n  options: ResolveModelOptions = {},\n): Promise<ResolvedModel> {\n  const resolved = rankModelId(await load(false), search, options);\n  if (resolved.matched) return resolved;\n  return rankModelId(await load(true), search, options);\n}\n\n/**\n * Rank a workspace's catalogue in one call: list its `/serving-endpoints`\n * (cached) and run {@link rankModels} over the result. The list counterpart to\n * {@link selectModel}, for a consumer that wants the full ranked set (a model\n * picker, a CLI) rather than a single id. Catalogue fetches fail loud: network\n * / auth errors propagate so the caller sees the real SDK message.\n *\n * @param host - Workspace host used as the cache key. Pass the value resolved\n *   from `client.config.getHost()`.\n */\nexport async function searchModels(\n  client: WorkspaceClientLike,\n  host: string,\n  input: SearchModelsInput = {},\n): Promise<RankedModel[]> {\n  const endpoints = await listServingEndpoints(\n    client,\n    host,\n    input.ttlMs !== undefined ? { ttlMs: input.ttlMs } : {},\n  );\n  return rankModels(endpoints, input);\n}\n\n/**\n * Resolve a model id for a workspace in one call: list its `/serving-endpoints`\n * (cached) and run {@link resolveModel} over the result. This is the entry\n * point for any consumer that holds a `WorkspaceClient` and just wants a usable\n * model name - a Lakeflow job, a one-off script, or the Mastra plugin alike.\n *\n * Cheap exit: when an `explicit` name is given and `fuzzy` is off, the\n * catalogue is never fetched - the name is returned verbatim and Databricks\n * surfaces the canonical 404 if it doesn't exist. Catalogue fetches otherwise\n * fail loud: network / auth errors propagate so the caller sees the real SDK\n * message instead of a silent fallback.\n *\n * @param host - Workspace host used as the cache key. Pass the value resolved\n *   from `client.config.getHost()`.\n */\nexport async function selectModel(\n  client: WorkspaceClientLike,\n  host: string,\n  input: SelectModelInput = {},\n): Promise<ResolvedModelSelection> {\n  if (input.explicit !== undefined && input.fuzzy === false) {\n    return { modelId: input.explicit, source: \"explicit\" };\n  }\n  const endpoints = await listServingEndpoints(client, host, {\n    ...(input.ttlMs !== undefined ? { ttlMs: input.ttlMs } : {}),\n  });\n  return resolveModel(endpoints, input);\n}\n\n/**\n * Resolve a single model id from the live catalogue and caller intent,\n * delegating the live selection to {@link rankModels} with `limit: 1`.\n *\n * 1. **Explicit ask**: with `fuzzy` off, returned verbatim; otherwise\n *    fuzzy-ranked within the (optional) class ceiling and the best taken,\n *    falling back to the input verbatim when nothing matches.\n * 2. **No explicit ask**: an operator-pinned `fallback` that exists in the live\n *    catalogue wins first; then the ranked live catalogue (class ceiling\n *    applied); then the static {@link FALLBACK_MODEL_IDS} floor when the\n *    catalogue yields nothing in range.\n */\nexport function resolveModel(\n  endpoints: readonly ServingEndpointSummary[],\n  input: ResolveModelInput = {},\n): ResolvedModelSelection {\n  if (input.explicit !== undefined) {\n    if (input.fuzzy === false) {\n      return { modelId: input.explicit, source: \"explicit\" };\n    }\n    const [top] = rankModels(endpoints, buildQuery(input, input.explicit));\n    return { modelId: top?.endpoint.name ?? input.explicit, source: \"fuzzy-match\" };\n  }\n\n  // Operator-pinned fallbacks win when present and live (e.g. a regulated\n  // workspace restricted to an approved subset).\n  if (input.modelClass === undefined && input.fallbacks && input.fallbacks.length > 0) {\n    const present = new Set(endpoints.map((e) => e.name));\n    const pinned = input.fallbacks.find((id) => present.has(id));\n    if (pinned) return { modelId: pinned, source: \"fallback\" };\n  }\n\n  const source = input.modelClass !== undefined ? \"class\" : \"fallback\";\n  const [top] = rankModels(endpoints, buildQuery(input, undefined));\n  if (top) return { modelId: top.endpoint.name, source };\n\n  // Live catalogue yielded nothing in range: walk the static floor.\n  const floorSource =\n    input.modelClass !== undefined ? modelsForClass(input.modelClass) : (input.fallbacks ?? []);\n  const floor = object.sequence(floorSource).concat(FALLBACK_MODEL_IDS).distinct().toArray();\n  return { modelId: pickFirstAvailable(floor, endpoints), source };\n}\n\n/** Build a {@link ModelQuery} from {@link ResolveModelInput} for the `limit: 1` delegation. */\nfunction buildQuery(input: ResolveModelInput, search: string | undefined): ModelQuery {\n  return {\n    ...(search !== undefined ? { search } : {}),\n    ...(input.modelClass !== undefined ? { modelClass: input.modelClass } : {}),\n    ...(input.threshold !== undefined ? { threshold: input.threshold } : {}),\n    limit: 1,\n  };\n}\n\n/**\n * Find the first id in `candidates` whose endpoint is present in `endpoints`.\n * Returns the top candidate when the workspace has none of them so callers\n * always get a string; an offline workspace then receives a clean 404 from\n * Databricks instead of a malformed config.\n */\nfunction pickFirstAvailable(\n  candidates: readonly string[],\n  endpoints: readonly ServingEndpointSummary[],\n): string {\n  const present = new Set(endpoints.map((e) => e.name));\n  for (const candidate of candidates) {\n    if (present.has(candidate)) return candidate;\n  }\n  return candidates[0] ?? FALLBACK_MODEL_IDS[0]!;\n}\n"]}

package/lib/src/serving.d.ts

@@ -0,0 +1,130 @@
+/**
+ * Live Databricks Model Serving catalogue access.
+ *
+ * Lists the workspace's `/serving-endpoints` once per host and caches the
+ * result with a TTL via AppKit's `CacheManager`, with concurrent callers
+ * sharing one in-flight promise (the coalescing pattern of Python's
+ * `cachetools-async`). Surfaces each endpoint as a stable
+ * {@link ServingEndpointSummary} - including the Foundation Model API
+ * `quality` / `speed` / `cost` profile when present, the classified
+ * {@link ModelClass}, and (for embedding endpoints) the measured vector
+ * `dimension` - and snaps loose, human-typed names to real endpoint ids
+ * through `fuse.js` extended search so tokens like `"claude sonnet"` resolve to
+ * `databricks-claude-sonnet-4-6`.
+ *
+ * The class stamp and embedding dimension are computed once per cache load:
+ * every embedding endpoint is "pinged" in parallel and the resulting vector
+ * length recorded, so the cost is paid on a cache miss, not per read. The ping
+ * is best-effort - a failure logs at debug and leaves `dimension` unset rather
+ * than failing the whole listing.
+ *
+ * @module
+ */
+import { appkit } from "@dbx-tools/appkit";
+import { type ServingEndpointSummary } from "@dbx-tools/shared-model";
+/**
+ * Structural type for the Databricks workspace client, re-exported so the rest
+ * of this package can keep importing it from here. See
+ * `appkit.WorkspaceClientLike` (node-appkit) for the canonical definition.
+ */
+export type WorkspaceClientLike = appkit.WorkspaceClientLike;
+/** Default TTL for the in-memory endpoint cache. Matches the Databricks SDK's session lifetime budget. */
+export declare const DEFAULT_MODEL_CACHE_TTL_MS: number;
+/** Default Fuse.js score threshold below which a fuzzy match is accepted. */
+export declare const DEFAULT_FUZZY_THRESHOLD = 0.4;
+/** Options for {@link listServingEndpoints}. */
+export interface ListServingEndpointsOptions {
+    /**
+     * Override the default cache TTL for this call, in milliseconds. Forwarded to
+     * `CacheManager` as seconds.
+     */
+    ttlMs?: number;
+}
+/**
+ * List Model Serving endpoints for the workspace owning `client`, routed
+ * through AppKit's `CacheManager`. The manager gives us everything
+ * `cachetools.TTLCache` provides plus what `cachetools-async` adds on top:
+ * per-entry TTL, in-flight request coalescing (concurrent callers share one
+ * fetch via the manager's internal `inFlightRequests` map), bounded size,
+ * telemetry spans (`cache.getOrExecute`), and optional Lakebase persistence so
+ * the catalogue survives restarts when the lakebase plugin is wired up.
+ *
+ * Returns plain {@link ServingEndpointSummary} objects (a stable subset of the
+ * SDK type) so cache hits never expose stale SDK internals. Errors from
+ * `CacheManager` or the SDK fetch propagate to the caller - we don't swallow
+ * them so users see the real auth / network issue.
+ *
+ * @param host - Workspace host used as the cache key. Pass the value resolved
+ *   from `client.config.getHost()` so multi-host apps share one entry per
+ *   workspace.
+ * @param options.ttlMs - Override the default TTL just for this call. Forwarded
+ *   to `CacheManager` as seconds.
+ */
+export declare function listServingEndpoints(client: WorkspaceClientLike, host: string, options?: ListServingEndpointsOptions): Promise<ServingEndpointSummary[]>;
+/**
+ * List the workspace's serving endpoints as minimal
+ * {@link ServingEndpointSummary} objects straight from the SDK: no caching, and
+ * none of the cache-load enrichment ({@link listServingEndpoints} adds the
+ * {@link ModelClass} stamp and the embedding-dimension probe). Use this for a
+ * one-shot, dependency-light listing - e.g. a CLI that only needs names/tasks
+ * for fuzzy resolution and doesn't want AppKit's `CacheManager` or the
+ * per-embedding ping cost. Prefer {@link listServingEndpoints} for the cached,
+ * enriched view.
+ */
+export declare function listServingEndpointsUncached(client: WorkspaceClientLike): Promise<ServingEndpointSummary[]>;
+/**
+ * Force-evict cached endpoint listings via AppKit's `CacheManager`. With a
+ * `host` deletes that one workspace's entry; without one clears every cache
+ * entry on the manager (since `CacheManager` doesn't expose a namespace-scoped
+ * clear, this is the brute-force path - fine for tests, avoid in steady-state
+ * code).
+ */
+export declare function clearServingEndpointsCache(host?: string): Promise<void>;
+/**
+ * Result of fuzzy-resolving a user-supplied model name against the live
+ * endpoint list. `score` is Fuse.js's distance (`0` is exact, `1` is no match);
+ * `matched` is `false` when the score exceeds the configured threshold so
+ * callers can fall back to the original input (Databricks will then return a
+ * clean 404).
+ */
+export interface ResolvedModel {
+    modelId: string;
+    matched: boolean;
+    score?: number;
+}
+/** Options accepted by {@link resolveModelId} / {@link searchServingEndpoints}. */
+export interface ResolveModelOptions {
+    /** Fuse.js threshold (0 = exact, 1 = anything). Default `0.4`. */
+    threshold?: number;
+}
+/** A serving endpoint paired with its fuzzy-match distance for a query. */
+export interface ScoredEndpoint {
+    endpoint: ServingEndpointSummary;
+    /** Fuse.js distance: `0` is exact, `1` is no match. */
+    score: number;
+}
+/**
+ * Fuzzy-rank endpoints by how closely their `name` matches `input`, best
+ * (lowest score) first, keeping only those within `threshold`:
+ *
+ * 1. An exact name match short-circuits to a single `score: 0` result.
+ * 2. Otherwise the input is tokenized (dashes / underscores / spaces become
+ *    separators) and fed through Fuse.js extended search, which AND-s each
+ *    token with fuzzy matching enabled - the "tokenized fuzzy match" a caller
+ *    reaches for when they type `"claude sonnet"` instead of the full endpoint
+ *    name.
+ *
+ * Returns `[]` for an empty endpoint list or when `input` tokenizes to nothing,
+ * so callers fall back to the raw input and let Databricks surface a clean 404.
+ * This multi-result core is shared by {@link resolveModelId} (single best) and
+ * the ranked `rankModels` selector.
+ */
+export declare function searchServingEndpoints(input: string, endpoints: readonly ServingEndpointSummary[], options?: ResolveModelOptions): ScoredEndpoint[];
+/**
+ * Snap a user-supplied model name to the single closest configured serving
+ * endpoint via {@link searchServingEndpoints}. Returns the input unchanged with
+ * `matched: false` when nothing scores within the threshold (or the catalogue
+ * is empty), so a deliberate model id is never silently rewritten to a
+ * similar-looking neighbour and the upstream call surfaces the canonical 404.
+ */
+export declare function resolveModelId(input: string, endpoints: readonly ServingEndpointSummary[], options?: ResolveModelOptions): ResolvedModel;