@dbx-tools/model 0.6.223 → 0.6.225

package/README.md

@@ -14,7 +14,8 @@ Browser-safe request/result schemas and endpoint classification types live in
 Key features:
 
 - Lists Databricks Model Serving endpoints through the SDK and normalizes them
-  into a stable summary shape.
+  into a stable summary shape with Rust-derived family and reasoning-effort
+  metadata.
 - Classifies endpoints into chat-thinking, chat-balanced, chat-fast, and
   embedding classes using Foundation Model API scores and family heuristics.
 - Resolves loose user input such as `"sonnet"` or `"chat fast"` to a concrete
@@ -69,6 +70,11 @@ console.log(selected.modelId, selected.source);
 `selectModel()` is the high-level helper for agents and CLIs. It reads the live
 catalogue, applies fuzzy matching when an explicit string is present, then
 returns a single `modelId` plus a source label explaining why that endpoint won.
+Set `liveOnly: true` for an unpinned production default that must select the
+highest-ranked currently available endpoint and must not fall through to an
+offline static id when the catalogue has no match.
+With no explicit id or class, automatic selection prefers the highest-ranked
+live GPT family member, then falls back to the highest-ranked live chat model.
 
 The `source` label is useful for logs and debug UIs. It distinguishes explicit
 matches from class-based selection, environment defaults, and fallback results,
@@ -89,7 +95,10 @@ const ranked = await resolve.searchModels(client, host, {
 
 Use `searchModels()` for UI pickers and debug routes. It returns ranked models
 with match scores and endpoint summaries, using the same fuzzy threshold and
-class ceiling logic as `selectModel()`.
+class ceiling logic as `selectModel()`. Both delegate catalogue ranking to the
+generated [`@dbx-tools/model-rs`](../model-rs) binding, so Node and the Rust
+model proxy use one fuzzy scorer, family-version order, variant preference, and
+class policy.
 
 ## Work With A Held Catalogue
 
@@ -100,7 +109,7 @@ When you already have endpoint summaries, use the pure resolver functions from
 import { resolve, serving } from "@dbx-tools/model";
 
 const endpoints = await serving.listServingEndpoints(client, host);
-const ranked = resolve.rankModels(endpoints, { search: "sonnet", limit: 3 });
+const ranked = resolve.lookupModels(endpoints, { search: "sonnet", limit: 3 });
 const picked = resolve.resolveModel(endpoints, {
   explicit: "claude sonnet",
   modelClass: "chat-balanced",
@@ -205,13 +214,14 @@ policy decisions; fallbacks are a last resort.
 
 ## Modules
 
-- `resolve` - high-level `selectModel`, ranked search, and catalogue-held
-  resolver functions.
+- `resolve` - high-level `selectModel`, Rust-backed ranked search, and
+  catalogue-held resolver functions.
 - `serving` - Databricks serving-endpoint listing, cache management, fuzzy
   search, and endpoint-id resolution.
 - `invoke` - serving-path constants, URL construction, and per-request auth
   headers for calling an endpoint over raw HTTP.
 - `classes` - model-class parsing, ordering, and class-ceiling helpers.
+- `policy` - Rust-backed family and reasoning-effort metadata projection.
 - `fallback` - static fallback model ids per class.
 
 The AppKit-Mastra integration uses this package through

package/index.ts

@@ -3,10 +3,11 @@
 // 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.6.223";
+export const PACKAGE_VERSION = "0.6.225";
 export * as classes from "./src/classes.ts";
 export * as fallback from "./src/fallback.ts";
 export * as invoke from "./src/invoke.ts";
+export * as policy from "./src/policy.ts";
 export * as resolve from "./src/resolve.ts";
 export * as serving from "./src/serving.ts";
 export { CHAT_CLASS_ORDER, MODEL_CLASS_ORDER } from "./src/classes.ts";

package/lib/index.d.ts

@@ -1,8 +1,9 @@
 export declare const PACKAGE_IDENTIFIER = "@dbx-tools/model";
-export declare const PACKAGE_VERSION = "0.6.223";
+export declare const PACKAGE_VERSION = "0.6.225";
 export * as classes from "./src/classes.ts";
 export * as fallback from "./src/fallback.ts";
 export * as invoke from "./src/invoke.ts";
+export * as policy from "./src/policy.ts";
 export * as resolve from "./src/resolve.ts";
 export * as serving from "./src/serving.ts";
 export { CHAT_CLASS_ORDER, MODEL_CLASS_ORDER } from "./src/classes.ts";

package/lib/index.js

@@ -2,14 +2,15 @@
 // 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.6.223";
+export const PACKAGE_VERSION = "0.6.225";
 export * as classes from "./src/classes.js";
 export * as fallback from "./src/fallback.js";
 export * as invoke from "./src/invoke.js";
+export * as policy from "./src/policy.js";
 export * as resolve from "./src/resolve.js";
 export * as serving from "./src/serving.js";
 export { CHAT_CLASS_ORDER, MODEL_CLASS_ORDER } from "./src/classes.js";
 export { FALLBACK_MODEL_IDS } from "./src/fallback.js";
 export { INVOCATIONS_SUFFIX, RESPONSES_PATH, OPEN_RESPONSES_PATH, CHAT_COMPLETIONS_PATH } from "./src/invoke.js";
 export { DEFAULT_MODEL_CACHE_TTL_MS, DEFAULT_FUZZY_THRESHOLD } from "./src/serving.js";
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/policy.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Browser-safe model metadata projected from the Rust policy bindings.
+ *
+ * @module
+ */
+import type { ReasoningEffort } from "@dbx-tools/shared-model";
+/** Return the normalized family parsed by the Rust model-name policy. */
+export declare function modelFamily(name: string): string | undefined;
+/** Return the reasoning efforts accepted by a model family. */
+export declare function modelReasoningEfforts(name: string): ReasoningEffort[];

package/lib/src/policy.js

@@ -0,0 +1,15 @@
+/**
+ * Browser-safe model metadata projected from the Rust policy bindings.
+ *
+ * @module
+ */
+import { modelFamily as modelFamilyWithRust, reasoningEffortNamesByFamily, } from "@dbx-tools/model-rs";
+/** Return the normalized family parsed by the Rust model-name policy. */
+export function modelFamily(name) {
+    return modelFamilyWithRust(name);
+}
+/** Return the reasoning efforts accepted by a model family. */
+export function modelReasoningEfforts(name) {
+    return reasoningEffortNamesByFamily(name);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG9saWN5LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3BvbGljeS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7OztHQUlHO0FBRUgsT0FBTyxFQUNMLFdBQVcsSUFBSSxtQkFBbUIsRUFDbEMsNEJBQTRCLEdBQzdCLE1BQU0scUJBQXFCLENBQUM7QUFHN0IseUVBQXlFO0FBQ3pFLE1BQU0sVUFBVSxXQUFXLENBQUMsSUFBWTtJQUN0QyxPQUFPLG1CQUFtQixDQUFDLElBQUksQ0FBQyxDQUFDO0FBQ25DLENBQUM7QUFFRCwrREFBK0Q7QUFDL0QsTUFBTSxVQUFVLHFCQUFxQixDQUFDLElBQVk7SUFDaEQsT0FBTyw0QkFBNEIsQ0FBQyxJQUFJLENBQUMsQ0FBQztBQUM1QyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBCcm93c2VyLXNhZmUgbW9kZWwgbWV0YWRhdGEgcHJvamVjdGVkIGZyb20gdGhlIFJ1c3QgcG9saWN5IGJpbmRpbmdzLlxuICpcbiAqIEBtb2R1bGVcbiAqL1xuXG5pbXBvcnQge1xuICBtb2RlbEZhbWlseSBhcyBtb2RlbEZhbWlseVdpdGhSdXN0LFxuICByZWFzb25pbmdFZmZvcnROYW1lc0J5RmFtaWx5LFxufSBmcm9tIFwiQGRieC10b29scy9tb2RlbC1yc1wiO1xuaW1wb3J0IHR5cGUgeyBSZWFzb25pbmdFZmZvcnQgfSBmcm9tIFwiQGRieC10b29scy9zaGFyZWQtbW9kZWxcIjtcblxuLyoqIFJldHVybiB0aGUgbm9ybWFsaXplZCBmYW1pbHkgcGFyc2VkIGJ5IHRoZSBSdXN0IG1vZGVsLW5hbWUgcG9saWN5LiAqL1xuZXhwb3J0IGZ1bmN0aW9uIG1vZGVsRmFtaWx5KG5hbWU6IHN0cmluZyk6IHN0cmluZyB8IHVuZGVmaW5lZCB7XG4gIHJldHVybiBtb2RlbEZhbWlseVdpdGhSdXN0KG5hbWUpO1xufVxuXG4vKiogUmV0dXJuIHRoZSByZWFzb25pbmcgZWZmb3J0cyBhY2NlcHRlZCBieSBhIG1vZGVsIGZhbWlseS4gKi9cbmV4cG9ydCBmdW5jdGlvbiBtb2RlbFJlYXNvbmluZ0VmZm9ydHMobmFtZTogc3RyaW5nKTogUmVhc29uaW5nRWZmb3J0W10ge1xuICByZXR1cm4gcmVhc29uaW5nRWZmb3J0TmFtZXNCeUZhbWlseShuYW1lKTtcbn1cbiJdfQ==

package/lib/src/resolve.d.ts

@@ -53,6 +53,12 @@ export interface ResolveModelInput {
      * the auto-classified catalogue.
      */
     fallbacks?: readonly string[];
+    /**
+     * Refuse the static offline floor when the live catalogue has no match.
+     * Use for unpinned defaults that must always name a currently available
+     * endpoint.
+     */
+    liveOnly?: boolean;
 }
 /** Outcome of {@link resolveModel}: the chosen id plus how it was reached. */
 export interface ResolvedModelSelection {
@@ -72,20 +78,10 @@ export interface SearchModelsInput extends ModelQuery {
 /**
  * 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 version, preferred model variant, class (more capable first), and
- *    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.
+ * Rust owns classification, fuzzy scoring, family-version ordering, preferred
+ * variants, class ceilings, tool filtering, and result limiting. Node retains
+ * the caller's endpoint objects so fields outside the ranking contract remain
+ * available unchanged.
  */
 export declare function lookupModels(endpoints: readonly ServingEndpointSummary[], query?: ModelQuery): RankedModel[];
 /**
@@ -150,9 +146,10 @@ export declare function selectModel(client: WorkspaceClientLike, host: string, i
  *    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.
+ *    catalogue wins first. A class request ranks within that ceiling. A
+ *    general request prefers the highest-ranked live GPT, then any ranked live
+ *    chat model. The static {@link FALLBACK_MODEL_IDS} floor is used only when
+ *    the catalogue yields nothing in range.
  */
 export declare function resolveModel(endpoints: readonly ServingEndpointSummary[], input?: ResolveModelInput): ResolvedModelSelection;
 export {};

package/lib/src/resolve.js

@@ -20,106 +20,80 @@
  * @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 { ModelClass as ModelRsModelClass, rankModels as rankModelsWithRust, } from "@dbx-tools/model-rs";
+import { classify, model, } from "@dbx-tools/shared-model";
 import { FALLBACK_MODEL_IDS, modelsForClass } from "./fallback.js";
-import { listServingEndpoints, searchServingEndpoints, } from "./serving.js";
-const VERSIONED_FAMILY_SEARCHES = new Set([
-    "claude",
-    "gemini",
-    "gemma",
-    "glm",
-    "gpt",
-    "llama",
-    "qwen",
-]);
-/**
- * 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);
-}
-function modelVariantRank(name) {
-    if (!/(?:^|[-_.])gpt(?:[-_.]|$)/i.test(name))
-        return 2;
-    if (/(?:^|[-_.])sol(?:[-_.]|$)/i.test(name))
-        return 0;
-    if (/(?:^|[-_.])luna(?:[-_.]|$)/i.test(name))
-        return 1;
-    return 2;
-}
+import { listServingEndpoints, } from "./serving.js";
+/** Preferred live family for an unconfigured general-purpose chat default. */
+const DEFAULT_MODEL_FAMILY_SEARCH = "gpt";
+const MODEL_CLASS_TO_RS = {
+    [model.ModelClass.ChatThinking]: ModelRsModelClass.ChatThinking,
+    [model.ModelClass.ChatBalanced]: ModelRsModelClass.ChatBalanced,
+    [model.ModelClass.ChatFast]: ModelRsModelClass.ChatFast,
+    [model.ModelClass.Embedding]: ModelRsModelClass.Embedding,
+};
 /**
  * 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 version, preferred model variant, class (more capable first), and
- *    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.
+ * Rust owns classification, fuzzy scoring, family-version ordering, preferred
+ * variants, class ceilings, tool filtering, and result limiting. Node retains
+ * the caller's endpoint objects so fields outside the ranking contract remain
+ * available unchanged.
  */
 export function lookupModels(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]) {
-            if (query.requiresTools && !classify.endpointCapabilities(endpoint).tools)
-                continue;
-            candidates.push({ endpoint, modelClass });
-        }
-    }
-    const search = query.search?.trim();
-    let ranked;
-    if (search) {
-        const gptFamilySearch = search.toLowerCase() === "gpt";
-        const versionedFamilySearch = VERSIONED_FAMILY_SEARCHES.has(search.toLowerCase());
-        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);
+    const endpointsByName = new Map(endpoints.map((endpoint) => [endpoint.name, endpoint]));
+    return rankModelsWithRust(endpoints.map(toModelRsEndpoint), toModelRsQuery(query)).map((ranked) => {
+        const endpoint = endpointsByName.get(ranked.endpoint.name);
+        if (!endpoint) {
+            throw new Error(`Rust model ranking returned unknown endpoint "${ranked.endpoint.name}"`);
         }
-        // `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))
-            .filter((c) => !gptFamilySearch || !/(?:^|[-_.])gpt[-_.]?oss(?:[-_.]|$)/i.test(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;
-            if (versionedFamilySearch) {
-                const aVersion = classify.versionTuple(a.endpoint.name);
-                const bVersion = classify.versionTuple(b.endpoint.name);
-                for (let index = 0; index < 3; index++) {
-                    const byVersion = (bVersion[index] ?? 0) - (aVersion[index] ?? 0);
-                    if (byVersion !== 0)
-                        return byVersion;
-                }
-            }
-            const byVariant = modelVariantRank(a.endpoint.name) - modelVariantRank(b.endpoint.name);
-            if (byVariant !== 0)
-                return byVariant;
-            return MODEL_CLASS_ORDER.indexOf(a.modelClass) - MODEL_CLASS_ORDER.indexOf(b.modelClass);
-        });
-    }
-    else {
-        ranked = candidates;
+        return {
+            endpoint,
+            modelClass: fromModelRsClass(ranked.modelClass),
+            ...(ranked.score !== undefined ? { score: ranked.score } : {}),
+        };
+    });
+}
+/** Convert a public model query to the generated Rust ranking contract. */
+function toModelRsQuery(query) {
+    return {
+        search: query.search,
+        modelClass: query.modelClass === undefined ? undefined : MODEL_CLASS_TO_RS[query.modelClass],
+        requiresTools: query.requiresTools ?? false,
+        includeDeprecated: false,
+        limit: query.limit,
+        threshold: query.threshold,
+    };
+}
+/** Convert a discovered endpoint to the generated Rust ranking contract. */
+function toModelRsEndpoint(endpoint) {
+    return {
+        name: endpoint.name,
+        displayName: endpoint.displayName,
+        task: endpoint.task,
+        state: endpoint.state,
+        description: endpoint.description,
+        supportsTools: endpoint.supportsTools,
+        profile: endpoint.profile,
+        modelClass: endpoint.class === undefined ? undefined : MODEL_CLASS_TO_RS[endpoint.class],
+        serviceNames: new Map(Object.entries(endpoint.serviceNames ?? {})),
+        modelServiceName: endpoint.modelServiceName,
+        reasoningEfforts: [],
+        status: { deprecated: endpoint.status?.deprecated ?? false },
+    };
+}
+/** Convert a generated Rust class to the browser-safe public enum. */
+function fromModelRsClass(modelClass) {
+    switch (modelClass) {
+        case ModelRsModelClass.ChatThinking:
+            return model.ModelClass.ChatThinking;
+        case ModelRsModelClass.ChatBalanced:
+            return model.ModelClass.ChatBalanced;
+        case ModelRsModelClass.ChatFast:
+            return model.ModelClass.ChatFast;
+        case ModelRsModelClass.Embedding:
+            return model.ModelClass.Embedding;
     }
-    return query.limit !== undefined ? ranked.slice(0, Math.max(0, query.limit)) : ranked;
 }
 /**
  * Collapse {@link lookupModels} to a single id: the closest endpoint to `search`
@@ -209,9 +183,10 @@ export async function selectModel(client, host, input = {}) {
  *    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.
+ *    catalogue wins first. A class request ranks within that ceiling. A
+ *    general request prefers the highest-ranked live GPT, then any ranked live
+ *    chat model. The static {@link FALLBACK_MODEL_IDS} floor is used only when
+ *    the catalogue yields nothing in range.
  */
 export function resolveModel(endpoints, input = {}) {
     if (input.explicit !== undefined) {
@@ -237,9 +212,17 @@ export function resolveModel(endpoints, input = {}) {
             return { modelId: pinned, source: "fallback" };
     }
     const source = input.modelClass !== undefined ? "class" : "fallback";
+    if (input.modelClass === undefined) {
+        const [preferred] = lookupModels(endpoints, buildQuery(input, DEFAULT_MODEL_FAMILY_SEARCH));
+        if (preferred)
+            return { modelId: preferred.endpoint.name, source };
+    }
     const [top] = lookupModels(endpoints, buildQuery(input, undefined));
     if (top)
         return { modelId: top.endpoint.name, source };
+    if (input.liveOnly) {
+        throw new Error("No matching live Model Serving endpoint is available");
+    }
     // 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();
@@ -285,4 +268,4 @@ function pickFirstAvailable(candidates, endpoints) {
     }
     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.ts\";\nimport { FALLBACK_MODEL_IDS, modelsForClass } from \"./fallback.ts\";\nimport {\n  listServingEndpoints,\n  searchServingEndpoints,\n  type ResolvedModel,\n  type ResolveModelOptions,\n  type WorkspaceClientLike,\n} from \"./serving.ts\";\n\ntype ModelClass = model.ModelClass;\n\nconst VERSIONED_FAMILY_SEARCHES = new Set([\n  \"claude\",\n  \"gemini\",\n  \"gemma\",\n  \"glm\",\n  \"gpt\",\n  \"llama\",\n  \"qwen\",\n]);\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  /** Require a model that supports a complete function-tool round-trip. */\n  requiresTools?: boolean;\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\nfunction modelVariantRank(name: string): number {\n  if (!/(?:^|[-_.])gpt(?:[-_.]|$)/i.test(name)) return 2;\n  if (/(?:^|[-_.])sol(?:[-_.]|$)/i.test(name)) return 0;\n  if (/(?:^|[-_.])luna(?:[-_.]|$)/i.test(name)) return 1;\n  return 2;\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 version, preferred model variant, class (more capable first), and\n *    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 lookupModels(\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]) {\n      if (query.requiresTools && !classify.endpointCapabilities(endpoint).tools) continue;\n      candidates.push({ endpoint, modelClass });\n    }\n  }\n\n  const search = query.search?.trim();\n  let ranked: RankedModel[];\n  if (search) {\n    const gptFamilySearch = search.toLowerCase() === \"gpt\";\n    const versionedFamilySearch = VERSIONED_FAMILY_SEARCHES.has(search.toLowerCase());\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      .filter(\n        (c) => !gptFamilySearch || !/(?:^|[-_.])gpt[-_.]?oss(?:[-_.]|$)/i.test(c.endpoint.name),\n      )\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        if (versionedFamilySearch) {\n          const aVersion = classify.versionTuple(a.endpoint.name);\n          const bVersion = classify.versionTuple(b.endpoint.name);\n          for (let index = 0; index < 3; index++) {\n            const byVersion = (bVersion[index] ?? 0) - (aVersion[index] ?? 0);\n            if (byVersion !== 0) return byVersion;\n          }\n        }\n        const byVariant = modelVariantRank(a.endpoint.name) - modelVariantRank(b.endpoint.name);\n        if (byVariant !== 0) return byVariant;\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 lookupModels} 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] = lookupModels(endpoints, {\n    search,\n    limit: 1,\n    ...(options.threshold !== undefined ? { threshold: options.threshold } : {}),\n    ...(options.requiresTools !== undefined ? { requiresTools: options.requiresTools } : {}),\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 lookupModels} 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 lookupModels(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, `fuzzy` is off, and tool\n * capability is not required, the catalogue is never fetched. Catalogue\n * fetches otherwise fail loud: network / auth errors propagate so the caller\n * sees the real SDK 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 && !input.requiresTools) {\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 lookupModels} 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      if (input.requiresTools) assertToolSupport(endpoints, input.explicit);\n      return { modelId: input.explicit, source: \"explicit\" };\n    }\n    const [top] = lookupModels(endpoints, buildQuery(input, input.explicit));\n    if (input.requiresTools && !top) {\n      throw new Error(`No tool-capable model matches \"${input.explicit}\"`);\n    }\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(\n      endpoints\n        .filter((endpoint) => !input.requiresTools || classify.endpointCapabilities(endpoint).tools)\n        .map((endpoint) => endpoint.name),\n    );\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] = lookupModels(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  if (input.requiresTools) {\n    const available = new Set(\n      endpoints\n        .filter((endpoint) => classify.endpointCapabilities(endpoint).tools)\n        .map((endpoint) => endpoint.name),\n    );\n    const selected = floor.find((id) => available.has(id));\n    if (!selected) throw new Error(\"No tool-capable model is available\");\n    return { modelId: selected, source };\n  }\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.requiresTools !== undefined ? { requiresTools: input.requiresTools } : {}),\n    ...(input.threshold !== undefined ? { threshold: input.threshold } : {}),\n    limit: 1,\n  };\n}\n\n/** Throw when an explicit id is absent or not verified for function tools. */\nfunction assertToolSupport(endpoints: readonly ServingEndpointSummary[], modelId: string): void {\n  const endpoint = endpoints.find((candidate) => candidate.name === modelId);\n  if (!endpoint || !classify.endpointCapabilities(endpoint).tools) {\n    throw new Error(`Model \"${modelId}\" does not support function tools`);\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"]}
+//# 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  ModelClass as ModelRsModelClass,\n  rankModels as rankModelsWithRust,\n  type ModelQuery as ModelRsModelQuery,\n  type ServingEndpointSummary as ModelRsServingEndpointSummary,\n} from \"@dbx-tools/model-rs\";\nimport {\n  classify,\n  model,\n  type ModelQuery,\n  type RankedModel,\n  type ServingEndpointSummary,\n} from \"@dbx-tools/shared-model\";\n\nimport { FALLBACK_MODEL_IDS, modelsForClass } from \"./fallback.ts\";\nimport {\n  listServingEndpoints,\n  searchServingEndpoints,\n  type ResolvedModel,\n  type ResolveModelOptions,\n  type WorkspaceClientLike,\n} from \"./serving.ts\";\n\ntype ModelClass = model.ModelClass;\n\n/** Preferred live family for an unconfigured general-purpose chat default. */\nconst DEFAULT_MODEL_FAMILY_SEARCH = \"gpt\";\n\nconst MODEL_CLASS_TO_RS: Readonly<Record<ModelClass, ModelRsModelClass>> = {\n  [model.ModelClass.ChatThinking]: ModelRsModelClass.ChatThinking,\n  [model.ModelClass.ChatBalanced]: ModelRsModelClass.ChatBalanced,\n  [model.ModelClass.ChatFast]: ModelRsModelClass.ChatFast,\n  [model.ModelClass.Embedding]: ModelRsModelClass.Embedding,\n};\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  /** Require a model that supports a complete function-tool round-trip. */\n  requiresTools?: boolean;\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   * Refuse the static offline floor when the live catalogue has no match.\n   * Use for unpinned defaults that must always name a currently available\n   * endpoint.\n   */\n  liveOnly?: boolean;\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 * Rank the live catalogue against a {@link ModelQuery}, best-first.\n *\n * Rust owns classification, fuzzy scoring, family-version ordering, preferred\n * variants, class ceilings, tool filtering, and result limiting. Node retains\n * the caller's endpoint objects so fields outside the ranking contract remain\n * available unchanged.\n */\nexport function lookupModels(\n  endpoints: readonly ServingEndpointSummary[],\n  query: ModelQuery = {},\n): RankedModel[] {\n  const endpointsByName = new Map(endpoints.map((endpoint) => [endpoint.name, endpoint]));\n  return rankModelsWithRust(endpoints.map(toModelRsEndpoint), toModelRsQuery(query)).map(\n    (ranked) => {\n      const endpoint = endpointsByName.get(ranked.endpoint.name);\n      if (!endpoint) {\n        throw new Error(`Rust model ranking returned unknown endpoint \"${ranked.endpoint.name}\"`);\n      }\n      return {\n        endpoint,\n        modelClass: fromModelRsClass(ranked.modelClass),\n        ...(ranked.score !== undefined ? { score: ranked.score } : {}),\n      };\n    },\n  );\n}\n\n/** Convert a public model query to the generated Rust ranking contract. */\nfunction toModelRsQuery(query: ModelQuery): ModelRsModelQuery {\n  return {\n    search: query.search,\n    modelClass: query.modelClass === undefined ? undefined : MODEL_CLASS_TO_RS[query.modelClass],\n    requiresTools: query.requiresTools ?? false,\n    includeDeprecated: false,\n    limit: query.limit,\n    threshold: query.threshold,\n  };\n}\n\n/** Convert a discovered endpoint to the generated Rust ranking contract. */\nfunction toModelRsEndpoint(endpoint: ServingEndpointSummary): ModelRsServingEndpointSummary {\n  return {\n    name: endpoint.name,\n    displayName: endpoint.displayName,\n    task: endpoint.task,\n    state: endpoint.state,\n    description: endpoint.description,\n    supportsTools: endpoint.supportsTools,\n    profile: endpoint.profile,\n    modelClass: endpoint.class === undefined ? undefined : MODEL_CLASS_TO_RS[endpoint.class],\n    serviceNames: new Map(Object.entries(endpoint.serviceNames ?? {})),\n    modelServiceName: endpoint.modelServiceName,\n    reasoningEfforts: [],\n    status: { deprecated: endpoint.status?.deprecated ?? false },\n  };\n}\n\n/** Convert a generated Rust class to the browser-safe public enum. */\nfunction fromModelRsClass(modelClass: ModelRsModelClass): ModelClass {\n  switch (modelClass) {\n    case ModelRsModelClass.ChatThinking:\n      return model.ModelClass.ChatThinking;\n    case ModelRsModelClass.ChatBalanced:\n      return model.ModelClass.ChatBalanced;\n    case ModelRsModelClass.ChatFast:\n      return model.ModelClass.ChatFast;\n    case ModelRsModelClass.Embedding:\n      return model.ModelClass.Embedding;\n  }\n}\n\n/**\n * Collapse {@link lookupModels} 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] = lookupModels(endpoints, {\n    search,\n    limit: 1,\n    ...(options.threshold !== undefined ? { threshold: options.threshold } : {}),\n    ...(options.requiresTools !== undefined ? { requiresTools: options.requiresTools } : {}),\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 lookupModels} 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 lookupModels(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, `fuzzy` is off, and tool\n * capability is not required, the catalogue is never fetched. Catalogue\n * fetches otherwise fail loud: network / auth errors propagate so the caller\n * sees the real SDK 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 && !input.requiresTools) {\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 lookupModels} 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. A class request ranks within that ceiling. A\n *    general request prefers the highest-ranked live GPT, then any ranked live\n *    chat model. The static {@link FALLBACK_MODEL_IDS} floor is used only when\n *    the 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      if (input.requiresTools) assertToolSupport(endpoints, input.explicit);\n      return { modelId: input.explicit, source: \"explicit\" };\n    }\n    const [top] = lookupModels(endpoints, buildQuery(input, input.explicit));\n    if (input.requiresTools && !top) {\n      throw new Error(`No tool-capable model matches \"${input.explicit}\"`);\n    }\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(\n      endpoints\n        .filter((endpoint) => !input.requiresTools || classify.endpointCapabilities(endpoint).tools)\n        .map((endpoint) => endpoint.name),\n    );\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  if (input.modelClass === undefined) {\n    const [preferred] = lookupModels(endpoints, buildQuery(input, DEFAULT_MODEL_FAMILY_SEARCH));\n    if (preferred) return { modelId: preferred.endpoint.name, source };\n  }\n  const [top] = lookupModels(endpoints, buildQuery(input, undefined));\n  if (top) return { modelId: top.endpoint.name, source };\n\n  if (input.liveOnly) {\n    throw new Error(\"No matching live Model Serving endpoint is available\");\n  }\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  if (input.requiresTools) {\n    const available = new Set(\n      endpoints\n        .filter((endpoint) => classify.endpointCapabilities(endpoint).tools)\n        .map((endpoint) => endpoint.name),\n    );\n    const selected = floor.find((id) => available.has(id));\n    if (!selected) throw new Error(\"No tool-capable model is available\");\n    return { modelId: selected, source };\n  }\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.requiresTools !== undefined ? { requiresTools: input.requiresTools } : {}),\n    ...(input.threshold !== undefined ? { threshold: input.threshold } : {}),\n    limit: 1,\n  };\n}\n\n/** Throw when an explicit id is absent or not verified for function tools. */\nfunction assertToolSupport(endpoints: readonly ServingEndpointSummary[], modelId: string): void {\n  const endpoint = endpoints.find((candidate) => candidate.name === modelId);\n  if (!endpoint || !classify.endpointCapabilities(endpoint).tools) {\n    throw new Error(`Model \"${modelId}\" does not support function tools`);\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.js

@@ -25,6 +25,7 @@ import { error, log, string } from "@dbx-tools/shared-core";
 import { classify, display, model, } from "@dbx-tools/shared-model";
 import Fuse from "fuse.js";
 import { MODEL_CLASS_ORDER } from "./classes.js";
+import { modelFamily, modelReasoningEfforts } from "./policy.js";
 const { ModelClass } = model;
 const logger = log.logger("model/serving");
 /** Default TTL for the in-memory endpoint cache. Matches the Databricks SDK's session lifetime budget. */
@@ -82,16 +83,20 @@ export async function listServingEndpointsUncached(client) {
         if (!ep.name)
             continue;
         const profile = extractProfile(ep);
+        const family = modelFamily(ep.name);
+        const reasoningEfforts = modelReasoningEfforts(ep.name);
         out.push({
             name: ep.name,
             // Prefer a Databricks-provided human name (a display-name tag or an
             // external-model name); else derive a title-cased label from the id.
             displayName: display.toModelDisplayName(ep.name, providedDisplayName(ep)),
+            ...(family !== undefined ? { family } : {}),
             ...(ep.task !== undefined ? { task: ep.task } : {}),
             ...(ep.state?.ready !== undefined ? { state: String(ep.state.ready) } : {}),
             ...(ep.description !== undefined ? { description: ep.description } : {}),
             supportsTools: classify.supportsToolsByFamily(ep.name),
             ...(profile ? { profile } : {}),
+            ...(reasoningEfforts.length > 0 ? { reasoningEfforts } : {}),
         });
     }
     return out;
@@ -284,4 +289,4 @@ export function resolveModelId(input, endpoints, options = {}) {
     }
     return { modelId: input, matched: false };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"serving.js","sourceRoot":"","sources":["../../src/serving.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAC5D,OAAO,EACL,QAAQ,EACR,OAAO,EACP,KAAK,GAGN,MAAM,yBAAyB,CAAC;AACjC,OAAO,IAAI,MAAM,SAAS,CAAC;AAE3B,OAAO,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAEjD,MAAM,EAAE,UAAU,EAAE,GAAG,KAAK,CAAC;AAE7B,MAAM,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,eAAe,CAAC,CAAC;AAS3C,0GAA0G;AAC1G,MAAM,CAAC,MAAM,0BAA0B,GAAG,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC;AAExD,6EAA6E;AAC7E,MAAM,CAAC,MAAM,uBAAuB,GAAG,GAAG,CAAC;AAE3C,gEAAgE;AAChE,MAAM,mBAAmB,GAAG,mBAAmB,CAAC;AAEhD;;;;;;;GAOG;AACH,MAAM,eAAe,GAAG,cAAc,CAAC;AAWvC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,CAAC,KAAK,UAAU,oBAAoB,CACxC,MAA2B,EAC3B,IAAY,EACZ,UAAuC,EAAE;IAEzC,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,KAAK,IAAI,0BAA0B,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC;IAC7F,OAAO,YAAY,CAAC,eAAe,EAAE,CAAC,YAAY,CAChD,CAAC,mBAAmB,EAAE,IAAI,CAAC,EAC3B,GAAG,EAAE,CAAC,cAAc,CAAC,MAAM,CAAC,EAC5B,eAAe,EACf,EAAE,GAAG,EAAE,MAAM,EAAE,CAChB,CAAC;AACJ,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,CAAC,KAAK,UAAU,4BAA4B,CAChD,MAA2B;IAE3B,MAAM,GAAG,GAA6B,EAAE,CAAC;IACzC,IAAI,KAAK,EAAE,MAAM,EAAE,IAAI,MAAM,CAAC,gBAAgB,CAAC,IAAI,EAAE,EAAE,CAAC;QACtD,IAAI,CAAC,EAAE,CAAC,IAAI;YAAE,SAAS;QACvB,MAAM,OAAO,GAAG,cAAc,CAAC,EAAE,CAAC,CAAC;QACnC,GAAG,CAAC,IAAI,CAAC;YACP,IAAI,EAAE,EAAE,CAAC,IAAI;YACb,oEAAoE;YACpE,qEAAqE;YACrE,WAAW,EAAE,OAAO,CAAC,kBAAkB,CAAC,EAAE,CAAC,IAAI,EAAE,mBAAmB,CAAC,EAAE,CAAC,CAAC;YACzE,GAAG,CAAC,EAAE,CAAC,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YACnD,GAAG,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,CAAC,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YAC3E,GAAG,CAAC,EAAE,CAAC,WAAW,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,WAAW,EAAE,EAAE,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YACxE,aAAa,EAAE,QAAQ,CAAC,qBAAqB,CAAC,EAAE,CAAC,IAAI,CAAC;YACtD,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;SAChC,CAAC,CAAC;IACL,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED;;;;;;;GAOG;AACH,SAAS,mBAAmB,CAAC,EAG5B;IACC,MAAM,GAAG,GAAG,EAAE,CAAC,IAAI,EAAE,IAAI,CACvB,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,KAAK,cAAc,IAAI,CAAC,CAAC,GAAG,KAAK,aAAa,IAAI,CAAC,CAAC,GAAG,KAAK,MAAM,CAC/E,CAAC;IACF,MAAM,OAAO,GAAG,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;IAC9C,IAAI,OAAO;QAAE,OAAO,OAAO,CAAC;IAC5B,KAAK,MAAM,MAAM,IAAI,EAAE,CAAC,MAAM,EAAE,eAAe,IAAI,EAAE,EAAE,CAAC;QACtD,MAAM,QAAQ,GAAG,MAAM,CAAC,UAAU,CAAC,MAAM,CAAC,cAAc,EAAE,IAAI,CAAC,CAAC;QAChE,IAAI,QAAQ;YAAE,OAAO,QAAQ,CAAC;IAChC,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED,KAAK,UAAU,cAAc,CAAC,MAA2B;IACvD,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;IAC7B,MAAM,GAAG,GAAG,MAAM,4BAA4B,CAAC,MAAM,CAAC,CAAC;IACvD,iBAAiB,CAAC,GAAG,CAAC,CAAC;IACvB,MAAM,0BAA0B,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC9C,MAAM,CAAC,KAAK,CAAC,QAAQ,EAAE,EAAE,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,EAAE,IAAI,CAAC,GAAG,EAAE,GAAG,SAAS,EAAE,CAAC,CAAC;IACjF,OAAO,GAAG,CAAC;AACb,CAAC;AAED;;;;;GAKG;AACH,SAAS,iBAAiB,CAAC,SAAmC;IAC5D,MAAM,OAAO,GAAG,QAAQ,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAC;IACtD,MAAM,OAAO,GAAG,IAAI,GAAG,EAA4B,CAAC;IACpD,KAAK,MAAM,GAAG,IAAI,iBAAiB,EAAE,CAAC;QACpC,KAAK,MAAM,EAAE,IAAI,OAAO,CAAC,GAAG,CAAC;YAAE,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;IAC3D,CAAC;IACD,KAAK,MAAM,OAAO,IAAI,SAAS,EAAE,CAAC;QAChC,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QACtC,IAAI,GAAG,KAAK,SAAS;YAAE,OAAO,CAAC,KAAK,GAAG,GAAG,CAAC;IAC7C,CAAC;AACH,CAAC;AAED;;;;;;;GAOG;AACH,KAAK,UAAU,0BAA0B,CACvC,MAA2B,EAC3B,SAAmC;IAEnC,MAAM,OAAO,CAAC,GAAG,CACf,SAAS;SACN,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,KAAK,UAAU,CAAC,SAAS,CAAC;SAC/C,GAAG,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE;QACrB,MAAM,SAAS,GAAG,MAAM,sBAAsB,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;QACrE,IAAI,SAAS,KAAK,SAAS;YAAE,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC;IAC7D,CAAC,CAAC,CACL,CAAC;AACJ,CAAC;AAED;;;;;GAKG;AACH,KAAK,UAAU,sBAAsB,CACnC,MAA2B,EAC3B,IAAY;IAEZ,IAAI,CAAC;QACH,MAAM,QAAQ,GAAG,MAAM,MAAM,CAAC,gBAAgB,CAAC,KAAK,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,CAAC;QAC9E,MAAM,SAAS,GAAG,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,MAAM,CAAC;QACxD,IAAI,OAAO,SAAS,KAAK,QAAQ,IAAI,SAAS,GAAG,CAAC;YAAE,OAAO,SAAS,CAAC;QACrE,MAAM,CAAC,IAAI,CAAC,mCAAmC,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC;QAC3D,OAAO,SAAS,CAAC;IACnB,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,MAAM,CAAC,IAAI,CAAC,uBAAuB,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,CAAC,YAAY,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;QAC/E,OAAO,SAAS,CAAC;IACnB,CAAC;AACH,CAAC;AAED;;;;;;;;;GASG;AACH,SAAS,cAAc,CAAC,EAAW;IACjC,MAAM,QAAQ,GACZ,EAaD,CAAC,MAAM,EAAE,eAAe,CAAC;IAC1B,IAAI,CAAC,QAAQ;QAAE,OAAO,SAAS,CAAC;IAChC,KAAK,MAAM,MAAM,IAAI,QAAQ,EAAE,CAAC;QAC9B,MAAM,GAAG,GAAG,MAAM,CAAC,gBAAgB,EAAE,wBAAwB,CAAC;QAC9D,IAAI,CAAC,GAAG;YAAE,SAAS;QACnB,MAAM,OAAO,GAAiB,EAAE,CAAC;QACjC,IAAI,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC;YAAE,OAAO,CAAC,OAAO,GAAG,GAAG,CAAC,OAAO,CAAC;QAChE,IAAI,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,KAAK,CAAC;YAAE,OAAO,CAAC,KAAK,GAAG,GAAG,CAAC,KAAK,CAAC;QAC1D,IAAI,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC;YAAE,OAAO,CAAC,IAAI,GAAG,GAAG,CAAC,IAAI,CAAC;QACvD,IAAI,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,MAAM,GAAG,CAAC;YAAE,OAAO,OAAO,CAAC;IACtD,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC;AAED;;;;;;GAMG;AACH,MAAM,CAAC,KAAK,UAAU,0BAA0B,CAAC,IAAa;IAC5D,MAAM,KAAK,GAAG,YAAY,CAAC,eAAe,EAAE,CAAC;IAC7C,IAAI,IAAI,EAAE,CAAC;QACT,MAAM,GAAG,GAAG,KAAK,CAAC,WAAW,CAAC,CAAC,mBAAmB,EAAE,IAAI,CAAC,EAAE,eAAe,CAAC,CAAC;QAC5E,MAAM,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;IAC1B,CAAC;SAAM,CAAC;QACN,MAAM,KAAK,CAAC,KAAK,EAAE,CAAC;IACtB,CAAC;AACH,CAAC;AA8BD;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,sBAAsB,CACpC,KAAa,EACb,SAA4C,EAC5C,UAA+B,EAAE;IAEjC,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,EAAE,CAAC;IACtC,KAAK,MAAM,EAAE,IAAI,SAAS,EAAE,CAAC;QAC3B,IAAI,EAAE,CAAC,IAAI,KAAK,KAAK;YAAE,OAAO,CAAC,EAAE,QAAQ,EAAE,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC,CAAC;IAC7D,CAAC;IACD,MAAM,SAAS,GAAG,OAAO,CAAC,SAAS,IAAI,uBAAuB,CAAC;IAC/D,8EAA8E;IAC9E,uEAAuE;IACvE,iFAAiF;IACjF,MAAM,KAAK,GAAG,KAAK,CAAC,IAAI,CACtB,MAAM,CAAC,mBAAmB,CAAC,EAAE,SAAS,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,EAAE,KAAK,CAAC,CACzE,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACZ,IAAI,CAAC,KAAK;QAAE,OAAO,EAAE,CAAC;IACtB,MAAM,IAAI,GAAG,IAAI,IAAI,CAAC,SAAS,EAAE;QAC/B,IAAI,EAAE,CAAC,MAAM,CAAC;QACd,SAAS;QACT,cAAc,EAAE,IAAI;QACpB,YAAY,EAAE,IAAI;QAClB,iBAAiB,EAAE,IAAI;QACvB,eAAe,EAAE,KAAK;KACvB,CAAC,CAAC;IACH,OAAO,IAAI;SACR,MAAM,CAAC,KAAK,CAAC;SACb,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,IAAI,SAAS,CAAC;SAC1C,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC,KAAK,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC;AAC7D,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,cAAc,CAC5B,KAAa,EACb,SAA4C,EAC5C,UAA+B,EAAE;IAEjC,MAAM,CAAC,IAAI,CAAC,GAAG,sBAAsB,CAAC,KAAK,EAAE,SAAS,EAAE,OAAO,CAAC,CAAC;IACjE,IAAI,IAAI,EAAE,CAAC;QACT,OAAO,EAAE,OAAO,EAAE,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,CAAC;IAC3E,CAAC;IACD,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;AAC5C,CAAC","sourcesContent":["/**\n * Live Databricks Model Serving catalogue access.\n *\n * Lists the workspace's `/serving-endpoints` once per host and caches the\n * result with a TTL via AppKit's `CacheManager`, with concurrent callers\n * sharing one in-flight promise (the coalescing pattern of Python's\n * `cachetools-async`). Surfaces each endpoint as a stable\n * {@link ServingEndpointSummary} - including the Foundation Model API\n * `quality` / `speed` / `cost` profile when present, the classified\n * {@link ModelClass}, and (for embedding endpoints) the measured vector\n * `dimension` - and snaps loose, human-typed names to real endpoint ids\n * through `fuse.js` extended search so tokens like `\"claude sonnet\"` resolve to\n * `databricks-claude-sonnet-4-6`.\n *\n * The class stamp and embedding dimension are computed once per cache load:\n * every embedding endpoint is \"pinged\" in parallel and the resulting vector\n * length recorded, so the cost is paid on a cache miss, not per read. The ping\n * is best-effort - a failure logs at debug and leaves `dimension` unset rather\n * than failing the whole listing.\n *\n * @module\n */\n\nimport { CacheManager } from \"@databricks/appkit\";\nimport { appkit } from \"@dbx-tools/appkit\";\nimport { error, log, string } from \"@dbx-tools/shared-core\";\nimport {\n  classify,\n  display,\n  model,\n  type ModelProfile,\n  type ServingEndpointSummary,\n} from \"@dbx-tools/shared-model\";\nimport Fuse from \"fuse.js\";\n\nimport { MODEL_CLASS_ORDER } from \"./classes.ts\";\n\nconst { ModelClass } = model;\n\nconst logger = log.logger(\"model/serving\");\n\n/**\n * Structural type for the Databricks workspace client, re-exported so the rest\n * of this package can keep importing it from here. See\n * `appkit.WorkspaceClientLike` (node-appkit) for the canonical definition.\n */\nexport type WorkspaceClientLike = Pick<appkit.WorkspaceClientLike, \"servingEndpoints\">;\n\n/** Default TTL for the in-memory endpoint cache. Matches the Databricks SDK's session lifetime budget. */\nexport const DEFAULT_MODEL_CACHE_TTL_MS = 5 * 60 * 1000;\n\n/** Default Fuse.js score threshold below which a fuzzy match is accepted. */\nexport const DEFAULT_FUZZY_THRESHOLD = 0.4;\n\n/** Cache key parts under which endpoint listings are stored. */\nconst CACHE_KEY_NAMESPACE = \"serving-endpoints\";\n\n/**\n * Stable `userKey` arg for AppKit's `CacheManager.getOrExecute`. Endpoint\n * visibility is effectively workspace-scoped (we cache by host in the key\n * parts), so a single shared key lets every user of the same workspace share\n * one cached fetch and coalesce on the in-flight promise. Permissions can\n * differ in theory, but the Foundation Model API catalogue is the same view for\n * every caller.\n */\nconst SHARED_USER_KEY = \"model-shared\";\n\n/** Options for {@link listServingEndpoints}. */\nexport interface ListServingEndpointsOptions {\n  /**\n   * Override the default cache TTL for this call, in milliseconds. Forwarded to\n   * `CacheManager` as seconds.\n   */\n  ttlMs?: number;\n}\n\n/**\n * List Model Serving endpoints for the workspace owning `client`, routed\n * through AppKit's `CacheManager`. The manager gives us everything\n * `cachetools.TTLCache` provides plus what `cachetools-async` adds on top:\n * per-entry TTL, in-flight request coalescing (concurrent callers share one\n * fetch via the manager's internal `inFlightRequests` map), bounded size,\n * telemetry spans (`cache.getOrExecute`), and optional Lakebase persistence so\n * the catalogue survives restarts when the lakebase plugin is wired up.\n *\n * Returns plain {@link ServingEndpointSummary} objects (a stable subset of the\n * SDK type) so cache hits never expose stale SDK internals. Errors from\n * `CacheManager` or the SDK fetch propagate to the caller - we don't swallow\n * them so users see the real auth / network issue.\n *\n * @param host - Workspace host used as the cache key. Pass the value resolved\n *   from `client.config.getHost()` so multi-host apps share one entry per\n *   workspace.\n * @param options.ttlMs - Override the default TTL just for this call. Forwarded\n *   to `CacheManager` as seconds.\n */\nexport async function listServingEndpoints(\n  client: WorkspaceClientLike,\n  host: string,\n  options: ListServingEndpointsOptions = {},\n): Promise<ServingEndpointSummary[]> {\n  const ttlSec = Math.max(1, Math.round((options.ttlMs ?? DEFAULT_MODEL_CACHE_TTL_MS) / 1000));\n  return CacheManager.getInstanceSync().getOrExecute(\n    [CACHE_KEY_NAMESPACE, host],\n    () => fetchEndpoints(client),\n    SHARED_USER_KEY,\n    { ttl: ttlSec },\n  );\n}\n\n/**\n * List the workspace's serving endpoints as minimal\n * {@link ServingEndpointSummary} objects straight from the SDK: no caching, and\n * none of the cache-load enrichment ({@link listServingEndpoints} adds the\n * {@link ModelClass} stamp and the embedding-dimension probe). Use this for a\n * one-shot, dependency-light listing - e.g. a CLI that only needs names/tasks\n * for fuzzy resolution and doesn't want AppKit's `CacheManager` or the\n * per-embedding ping cost. Prefer {@link listServingEndpoints} for the cached,\n * enriched view.\n */\nexport async function listServingEndpointsUncached(\n  client: WorkspaceClientLike,\n): Promise<ServingEndpointSummary[]> {\n  const out: ServingEndpointSummary[] = [];\n  for await (const ep of client.servingEndpoints.list()) {\n    if (!ep.name) continue;\n    const profile = extractProfile(ep);\n    out.push({\n      name: ep.name,\n      // Prefer a Databricks-provided human name (a display-name tag or an\n      // external-model name); else derive a title-cased label from the id.\n      displayName: display.toModelDisplayName(ep.name, providedDisplayName(ep)),\n      ...(ep.task !== undefined ? { task: ep.task } : {}),\n      ...(ep.state?.ready !== undefined ? { state: String(ep.state.ready) } : {}),\n      ...(ep.description !== undefined ? { description: ep.description } : {}),\n      supportsTools: classify.supportsToolsByFamily(ep.name),\n      ...(profile ? { profile } : {}),\n    });\n  }\n  return out;\n}\n\n/**\n * Pull a Databricks-provided human name off a serving endpoint, if any:\n * a `display_name` / `displayName` / `name` tag first, then an\n * external-model `name` from the served-entity config. Returns `null`\n * when the endpoint carries no explicit name (the common case for\n * Foundation Model API endpoints), so the caller falls back to deriving\n * one from the id.\n */\nfunction providedDisplayName(ep: {\n  tags?: Array<{ key: string; value?: string }>;\n  config?: { served_entities?: Array<{ external_model?: { name?: string } }> };\n}): string | null {\n  const tag = ep.tags?.find(\n    (t) => t.key === \"display_name\" || t.key === \"displayName\" || t.key === \"name\",\n  );\n  const fromTag = string.trimToNull(tag?.value);\n  if (fromTag) return fromTag;\n  for (const entity of ep.config?.served_entities ?? []) {\n    const external = string.trimToNull(entity.external_model?.name);\n    if (external) return external;\n  }\n  return null;\n}\n\nasync function fetchEndpoints(client: WorkspaceClientLike): Promise<ServingEndpointSummary[]> {\n  const startedAt = Date.now();\n  const out = await listServingEndpointsUncached(client);\n  stampModelClasses(out);\n  await measureEmbeddingDimensions(client, out);\n  logger.debug(\"listed\", { count: out.length, elapsedMs: Date.now() - startedAt });\n  return out;\n}\n\n/**\n * Stamp each summary's {@link ServingEndpointSummary.class} from the relative\n * classification of the whole set. Mutates `summaries` in place. Endpoints the\n * classifier doesn't recognize (custom, unscored, non-LLM) are left without a\n * class.\n */\nfunction stampModelClasses(summaries: ServingEndpointSummary[]): void {\n  const buckets = classify.classifyEndpoints(summaries);\n  const classOf = new Map<string, model.ModelClass>();\n  for (const cls of MODEL_CLASS_ORDER) {\n    for (const ep of buckets[cls]) classOf.set(ep.name, cls);\n  }\n  for (const summary of summaries) {\n    const cls = classOf.get(summary.name);\n    if (cls !== undefined) summary.class = cls;\n  }\n}\n\n/**\n * Measure the embedding vector dimension of every {@link ModelClass.Embedding}\n * endpoint by pinging it once, all in parallel. Mutates the matching summaries\n * in place with the resulting `dimension`. Runs only on a cache miss (it's\n * called from {@link fetchEndpoints}), so the probe cost is amortized across the\n * cached TTL window. Per-endpoint failures are swallowed (logged at warn) so\n * one unreachable embedding model never fails the listing.\n */\nasync function measureEmbeddingDimensions(\n  client: WorkspaceClientLike,\n  summaries: ServingEndpointSummary[],\n): Promise<void> {\n  await Promise.all(\n    summaries\n      .filter((s) => s.class === ModelClass.Embedding)\n      .map(async (summary) => {\n        const dimension = await pingEmbeddingDimension(client, summary.name);\n        if (dimension !== undefined) summary.dimension = dimension;\n      }),\n  );\n}\n\n/**\n * Best-effort embedding dimension probe: query `name` with a tiny `\"ping\"`\n * input and return the length of the returned vector. Returns `undefined` (and\n * logs at warn) when the endpoint can't be queried or returns no vector - the\n * dimension is informational, never required.\n */\nasync function pingEmbeddingDimension(\n  client: WorkspaceClientLike,\n  name: string,\n): Promise<number | undefined> {\n  try {\n    const response = await client.servingEndpoints.query({ name, input: \"ping\" });\n    const dimension = response.data?.[0]?.embedding?.length;\n    if (typeof dimension === \"number\" && dimension > 0) return dimension;\n    logger.warn(\"embedding ping returned no vector\", { name });\n    return undefined;\n  } catch (err) {\n    logger.warn(\"embedding ping failed\", { name, error: error.errorMessage(err) });\n    return undefined;\n  }\n}\n\n/**\n * Pull the Foundation Model API `quality` / `speed` / `cost` scores off a\n * serving-endpoint listing entry. Databricks returns these under\n * `config.served_entities[].foundation_model.ai_gateway_model_profile`\n * (snake_case at the wire level, preserved verbatim by the SDK), but the field\n * is newer than the typed `FoundationModel` interface, so we read it through a\n * structural cast. Returns `undefined` when no served entity carries a profile\n * (custom models, embeddings, and brand-new endpoints that Databricks has not\n * scored yet).\n */\nfunction extractProfile(ep: unknown): ModelProfile | undefined {\n  const entities = (\n    ep as {\n      config?: {\n        served_entities?: Array<{\n          foundation_model?: {\n            ai_gateway_model_profile?: {\n              quality?: number;\n              speed?: number;\n              cost?: number;\n            };\n          };\n        }>;\n      };\n    }\n  ).config?.served_entities;\n  if (!entities) return undefined;\n  for (const entity of entities) {\n    const raw = entity.foundation_model?.ai_gateway_model_profile;\n    if (!raw) continue;\n    const profile: ModelProfile = {};\n    if (Number.isFinite(raw.quality)) profile.quality = raw.quality;\n    if (Number.isFinite(raw.speed)) profile.speed = raw.speed;\n    if (Number.isFinite(raw.cost)) profile.cost = raw.cost;\n    if (Object.keys(profile).length > 0) return profile;\n  }\n  return undefined;\n}\n\n/**\n * Force-evict cached endpoint listings via AppKit's `CacheManager`. With a\n * `host` deletes that one workspace's entry; without one clears every cache\n * entry on the manager (since `CacheManager` doesn't expose a namespace-scoped\n * clear, this is the brute-force path - fine for tests, avoid in steady-state\n * code).\n */\nexport async function clearServingEndpointsCache(host?: string): Promise<void> {\n  const cache = CacheManager.getInstanceSync();\n  if (host) {\n    const key = cache.generateKey([CACHE_KEY_NAMESPACE, host], SHARED_USER_KEY);\n    await cache.delete(key);\n  } else {\n    await cache.clear();\n  }\n}\n\n/**\n * Result of fuzzy-resolving a user-supplied model name against the live\n * endpoint list. `score` is Fuse.js's distance (`0` is exact, `1` is no match);\n * `matched` is `false` when the score exceeds the configured threshold so\n * callers can fall back to the original input (Databricks will then return a\n * clean 404).\n */\nexport interface ResolvedModel {\n  modelId: string;\n  matched: boolean;\n  score?: number;\n}\n\n/** Options accepted by {@link resolveModelId} / {@link searchServingEndpoints}. */\nexport interface ResolveModelOptions {\n  /** Fuse.js threshold (0 = exact, 1 = anything). Default `0.4`. */\n  threshold?: number;\n  /** Require a model verified for a complete function-tool round-trip. */\n  requiresTools?: boolean;\n}\n\n/** A serving endpoint paired with its fuzzy-match distance for a query. */\nexport interface ScoredEndpoint {\n  endpoint: ServingEndpointSummary;\n  /** Fuse.js distance: `0` is exact, `1` is no match. */\n  score: number;\n}\n\n/**\n * Fuzzy-rank endpoints by how closely their `name` matches `input`, best\n * (lowest score) first, keeping only those within `threshold`:\n *\n * 1. An exact name match short-circuits to a single `score: 0` result.\n * 2. Otherwise the input is tokenized (dashes / underscores / spaces become\n *    separators) and fed through Fuse.js extended search, which AND-s each\n *    token with fuzzy matching enabled - the \"tokenized fuzzy match\" a caller\n *    reaches for when they type `\"claude sonnet\"` instead of the full endpoint\n *    name.\n *\n * Returns `[]` for an empty endpoint list or when `input` tokenizes to nothing,\n * so callers fall back to the raw input and let Databricks surface a clean 404.\n * This multi-result core is shared by {@link resolveModelId} (single best) and\n * the ranked `lookupModels` selector.\n */\nexport function searchServingEndpoints(\n  input: string,\n  endpoints: readonly ServingEndpointSummary[],\n  options: ResolveModelOptions = {},\n): ScoredEndpoint[] {\n  if (endpoints.length === 0) return [];\n  for (const ep of endpoints) {\n    if (ep.name === input) return [{ endpoint: ep, score: 0 }];\n  }\n  const threshold = options.threshold ?? DEFAULT_FUZZY_THRESHOLD;\n  // Fuse 7.3 has no built-in tokenize hook; in extended search, space-separated\n  // tokens are AND-ed with fuzzy matching enabled. We lean on the shared\n  // tokenizer so the splitting rules stay consistent with the rest of the toolkit.\n  const query = Array.from(\n    string.tokenizeWithOptions({ lowerCase: true, camelCase: false }, input),\n  ).join(\" \");\n  if (!query) return [];\n  const fuse = new Fuse(endpoints, {\n    keys: [\"name\"],\n    threshold,\n    ignoreLocation: true,\n    includeScore: true,\n    useExtendedSearch: true,\n    isCaseSensitive: false,\n  });\n  return fuse\n    .search(query)\n    .filter((r) => (r.score ?? 0) <= threshold)\n    .map((r) => ({ endpoint: r.item, score: r.score ?? 0 }));\n}\n\n/**\n * Snap a user-supplied model name to the single closest configured serving\n * endpoint via {@link searchServingEndpoints}. Returns the input unchanged with\n * `matched: false` when nothing scores within the threshold (or the catalogue\n * is empty), so a deliberate model id is never silently rewritten to a\n * similar-looking neighbour and the upstream call surfaces the canonical 404.\n */\nexport function resolveModelId(\n  input: string,\n  endpoints: readonly ServingEndpointSummary[],\n  options: ResolveModelOptions = {},\n): ResolvedModel {\n  const [best] = searchServingEndpoints(input, endpoints, options);\n  if (best) {\n    return { modelId: best.endpoint.name, matched: true, score: best.score };\n  }\n  return { modelId: input, matched: false };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"serving.js","sourceRoot":"","sources":["../../src/serving.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Live Databricks Model Serving catalogue access.\n *\n * Lists the workspace's `/serving-endpoints` once per host and caches the\n * result with a TTL via AppKit's `CacheManager`, with concurrent callers\n * sharing one in-flight promise (the coalescing pattern of Python's\n * `cachetools-async`). Surfaces each endpoint as a stable\n * {@link ServingEndpointSummary} - including the Foundation Model API\n * `quality` / `speed` / `cost` profile when present, the classified\n * {@link ModelClass}, and (for embedding endpoints) the measured vector\n * `dimension` - and snaps loose, human-typed names to real endpoint ids\n * through `fuse.js` extended search so tokens like `\"claude sonnet\"` resolve to\n * `databricks-claude-sonnet-4-6`.\n *\n * The class stamp and embedding dimension are computed once per cache load:\n * every embedding endpoint is \"pinged\" in parallel and the resulting vector\n * length recorded, so the cost is paid on a cache miss, not per read. The ping\n * is best-effort - a failure logs at debug and leaves `dimension` unset rather\n * than failing the whole listing.\n *\n * @module\n */\n\nimport { CacheManager } from \"@databricks/appkit\";\nimport { appkit } from \"@dbx-tools/appkit\";\nimport { error, log, string } from \"@dbx-tools/shared-core\";\nimport {\n  classify,\n  display,\n  model,\n  type ModelProfile,\n  type ServingEndpointSummary,\n} from \"@dbx-tools/shared-model\";\nimport Fuse from \"fuse.js\";\n\nimport { MODEL_CLASS_ORDER } from \"./classes.ts\";\nimport { modelFamily, modelReasoningEfforts } from \"./policy.ts\";\n\nconst { ModelClass } = model;\n\nconst logger = log.logger(\"model/serving\");\n\n/**\n * Structural type for the Databricks workspace client, re-exported so the rest\n * of this package can keep importing it from here. See\n * `appkit.WorkspaceClientLike` (node-appkit) for the canonical definition.\n */\nexport type WorkspaceClientLike = Pick<appkit.WorkspaceClientLike, \"servingEndpoints\">;\n\n/** Default TTL for the in-memory endpoint cache. Matches the Databricks SDK's session lifetime budget. */\nexport const DEFAULT_MODEL_CACHE_TTL_MS = 5 * 60 * 1000;\n\n/** Default Fuse.js score threshold below which a fuzzy match is accepted. */\nexport const DEFAULT_FUZZY_THRESHOLD = 0.4;\n\n/** Cache key parts under which endpoint listings are stored. */\nconst CACHE_KEY_NAMESPACE = \"serving-endpoints\";\n\n/**\n * Stable `userKey` arg for AppKit's `CacheManager.getOrExecute`. Endpoint\n * visibility is effectively workspace-scoped (we cache by host in the key\n * parts), so a single shared key lets every user of the same workspace share\n * one cached fetch and coalesce on the in-flight promise. Permissions can\n * differ in theory, but the Foundation Model API catalogue is the same view for\n * every caller.\n */\nconst SHARED_USER_KEY = \"model-shared\";\n\n/** Options for {@link listServingEndpoints}. */\nexport interface ListServingEndpointsOptions {\n  /**\n   * Override the default cache TTL for this call, in milliseconds. Forwarded to\n   * `CacheManager` as seconds.\n   */\n  ttlMs?: number;\n}\n\n/**\n * List Model Serving endpoints for the workspace owning `client`, routed\n * through AppKit's `CacheManager`. The manager gives us everything\n * `cachetools.TTLCache` provides plus what `cachetools-async` adds on top:\n * per-entry TTL, in-flight request coalescing (concurrent callers share one\n * fetch via the manager's internal `inFlightRequests` map), bounded size,\n * telemetry spans (`cache.getOrExecute`), and optional Lakebase persistence so\n * the catalogue survives restarts when the lakebase plugin is wired up.\n *\n * Returns plain {@link ServingEndpointSummary} objects (a stable subset of the\n * SDK type) so cache hits never expose stale SDK internals. Errors from\n * `CacheManager` or the SDK fetch propagate to the caller - we don't swallow\n * them so users see the real auth / network issue.\n *\n * @param host - Workspace host used as the cache key. Pass the value resolved\n *   from `client.config.getHost()` so multi-host apps share one entry per\n *   workspace.\n * @param options.ttlMs - Override the default TTL just for this call. Forwarded\n *   to `CacheManager` as seconds.\n */\nexport async function listServingEndpoints(\n  client: WorkspaceClientLike,\n  host: string,\n  options: ListServingEndpointsOptions = {},\n): Promise<ServingEndpointSummary[]> {\n  const ttlSec = Math.max(1, Math.round((options.ttlMs ?? DEFAULT_MODEL_CACHE_TTL_MS) / 1000));\n  return CacheManager.getInstanceSync().getOrExecute(\n    [CACHE_KEY_NAMESPACE, host],\n    () => fetchEndpoints(client),\n    SHARED_USER_KEY,\n    { ttl: ttlSec },\n  );\n}\n\n/**\n * List the workspace's serving endpoints as minimal\n * {@link ServingEndpointSummary} objects straight from the SDK: no caching, and\n * none of the cache-load enrichment ({@link listServingEndpoints} adds the\n * {@link ModelClass} stamp and the embedding-dimension probe). Use this for a\n * one-shot, dependency-light listing - e.g. a CLI that only needs names/tasks\n * for fuzzy resolution and doesn't want AppKit's `CacheManager` or the\n * per-embedding ping cost. Prefer {@link listServingEndpoints} for the cached,\n * enriched view.\n */\nexport async function listServingEndpointsUncached(\n  client: WorkspaceClientLike,\n): Promise<ServingEndpointSummary[]> {\n  const out: ServingEndpointSummary[] = [];\n  for await (const ep of client.servingEndpoints.list()) {\n    if (!ep.name) continue;\n    const profile = extractProfile(ep);\n    const family = modelFamily(ep.name);\n    const reasoningEfforts = modelReasoningEfforts(ep.name);\n    out.push({\n      name: ep.name,\n      // Prefer a Databricks-provided human name (a display-name tag or an\n      // external-model name); else derive a title-cased label from the id.\n      displayName: display.toModelDisplayName(ep.name, providedDisplayName(ep)),\n      ...(family !== undefined ? { family } : {}),\n      ...(ep.task !== undefined ? { task: ep.task } : {}),\n      ...(ep.state?.ready !== undefined ? { state: String(ep.state.ready) } : {}),\n      ...(ep.description !== undefined ? { description: ep.description } : {}),\n      supportsTools: classify.supportsToolsByFamily(ep.name),\n      ...(profile ? { profile } : {}),\n      ...(reasoningEfforts.length > 0 ? { reasoningEfforts } : {}),\n    });\n  }\n  return out;\n}\n\n/**\n * Pull a Databricks-provided human name off a serving endpoint, if any:\n * a `display_name` / `displayName` / `name` tag first, then an\n * external-model `name` from the served-entity config. Returns `null`\n * when the endpoint carries no explicit name (the common case for\n * Foundation Model API endpoints), so the caller falls back to deriving\n * one from the id.\n */\nfunction providedDisplayName(ep: {\n  tags?: Array<{ key: string; value?: string }>;\n  config?: { served_entities?: Array<{ external_model?: { name?: string } }> };\n}): string | null {\n  const tag = ep.tags?.find(\n    (t) => t.key === \"display_name\" || t.key === \"displayName\" || t.key === \"name\",\n  );\n  const fromTag = string.trimToNull(tag?.value);\n  if (fromTag) return fromTag;\n  for (const entity of ep.config?.served_entities ?? []) {\n    const external = string.trimToNull(entity.external_model?.name);\n    if (external) return external;\n  }\n  return null;\n}\n\nasync function fetchEndpoints(client: WorkspaceClientLike): Promise<ServingEndpointSummary[]> {\n  const startedAt = Date.now();\n  const out = await listServingEndpointsUncached(client);\n  stampModelClasses(out);\n  await measureEmbeddingDimensions(client, out);\n  logger.debug(\"listed\", { count: out.length, elapsedMs: Date.now() - startedAt });\n  return out;\n}\n\n/**\n * Stamp each summary's {@link ServingEndpointSummary.class} from the relative\n * classification of the whole set. Mutates `summaries` in place. Endpoints the\n * classifier doesn't recognize (custom, unscored, non-LLM) are left without a\n * class.\n */\nfunction stampModelClasses(summaries: ServingEndpointSummary[]): void {\n  const buckets = classify.classifyEndpoints(summaries);\n  const classOf = new Map<string, model.ModelClass>();\n  for (const cls of MODEL_CLASS_ORDER) {\n    for (const ep of buckets[cls]) classOf.set(ep.name, cls);\n  }\n  for (const summary of summaries) {\n    const cls = classOf.get(summary.name);\n    if (cls !== undefined) summary.class = cls;\n  }\n}\n\n/**\n * Measure the embedding vector dimension of every {@link ModelClass.Embedding}\n * endpoint by pinging it once, all in parallel. Mutates the matching summaries\n * in place with the resulting `dimension`. Runs only on a cache miss (it's\n * called from {@link fetchEndpoints}), so the probe cost is amortized across the\n * cached TTL window. Per-endpoint failures are swallowed (logged at warn) so\n * one unreachable embedding model never fails the listing.\n */\nasync function measureEmbeddingDimensions(\n  client: WorkspaceClientLike,\n  summaries: ServingEndpointSummary[],\n): Promise<void> {\n  await Promise.all(\n    summaries\n      .filter((s) => s.class === ModelClass.Embedding)\n      .map(async (summary) => {\n        const dimension = await pingEmbeddingDimension(client, summary.name);\n        if (dimension !== undefined) summary.dimension = dimension;\n      }),\n  );\n}\n\n/**\n * Best-effort embedding dimension probe: query `name` with a tiny `\"ping\"`\n * input and return the length of the returned vector. Returns `undefined` (and\n * logs at warn) when the endpoint can't be queried or returns no vector - the\n * dimension is informational, never required.\n */\nasync function pingEmbeddingDimension(\n  client: WorkspaceClientLike,\n  name: string,\n): Promise<number | undefined> {\n  try {\n    const response = await client.servingEndpoints.query({ name, input: \"ping\" });\n    const dimension = response.data?.[0]?.embedding?.length;\n    if (typeof dimension === \"number\" && dimension > 0) return dimension;\n    logger.warn(\"embedding ping returned no vector\", { name });\n    return undefined;\n  } catch (err) {\n    logger.warn(\"embedding ping failed\", { name, error: error.errorMessage(err) });\n    return undefined;\n  }\n}\n\n/**\n * Pull the Foundation Model API `quality` / `speed` / `cost` scores off a\n * serving-endpoint listing entry. Databricks returns these under\n * `config.served_entities[].foundation_model.ai_gateway_model_profile`\n * (snake_case at the wire level, preserved verbatim by the SDK), but the field\n * is newer than the typed `FoundationModel` interface, so we read it through a\n * structural cast. Returns `undefined` when no served entity carries a profile\n * (custom models, embeddings, and brand-new endpoints that Databricks has not\n * scored yet).\n */\nfunction extractProfile(ep: unknown): ModelProfile | undefined {\n  const entities = (\n    ep as {\n      config?: {\n        served_entities?: Array<{\n          foundation_model?: {\n            ai_gateway_model_profile?: {\n              quality?: number;\n              speed?: number;\n              cost?: number;\n            };\n          };\n        }>;\n      };\n    }\n  ).config?.served_entities;\n  if (!entities) return undefined;\n  for (const entity of entities) {\n    const raw = entity.foundation_model?.ai_gateway_model_profile;\n    if (!raw) continue;\n    const profile: ModelProfile = {};\n    if (Number.isFinite(raw.quality)) profile.quality = raw.quality;\n    if (Number.isFinite(raw.speed)) profile.speed = raw.speed;\n    if (Number.isFinite(raw.cost)) profile.cost = raw.cost;\n    if (Object.keys(profile).length > 0) return profile;\n  }\n  return undefined;\n}\n\n/**\n * Force-evict cached endpoint listings via AppKit's `CacheManager`. With a\n * `host` deletes that one workspace's entry; without one clears every cache\n * entry on the manager (since `CacheManager` doesn't expose a namespace-scoped\n * clear, this is the brute-force path - fine for tests, avoid in steady-state\n * code).\n */\nexport async function clearServingEndpointsCache(host?: string): Promise<void> {\n  const cache = CacheManager.getInstanceSync();\n  if (host) {\n    const key = cache.generateKey([CACHE_KEY_NAMESPACE, host], SHARED_USER_KEY);\n    await cache.delete(key);\n  } else {\n    await cache.clear();\n  }\n}\n\n/**\n * Result of fuzzy-resolving a user-supplied model name against the live\n * endpoint list. `score` is Fuse.js's distance (`0` is exact, `1` is no match);\n * `matched` is `false` when the score exceeds the configured threshold so\n * callers can fall back to the original input (Databricks will then return a\n * clean 404).\n */\nexport interface ResolvedModel {\n  modelId: string;\n  matched: boolean;\n  score?: number;\n}\n\n/** Options accepted by {@link resolveModelId} / {@link searchServingEndpoints}. */\nexport interface ResolveModelOptions {\n  /** Fuse.js threshold (0 = exact, 1 = anything). Default `0.4`. */\n  threshold?: number;\n  /** Require a model verified for a complete function-tool round-trip. */\n  requiresTools?: boolean;\n}\n\n/** A serving endpoint paired with its fuzzy-match distance for a query. */\nexport interface ScoredEndpoint {\n  endpoint: ServingEndpointSummary;\n  /** Fuse.js distance: `0` is exact, `1` is no match. */\n  score: number;\n}\n\n/**\n * Fuzzy-rank endpoints by how closely their `name` matches `input`, best\n * (lowest score) first, keeping only those within `threshold`:\n *\n * 1. An exact name match short-circuits to a single `score: 0` result.\n * 2. Otherwise the input is tokenized (dashes / underscores / spaces become\n *    separators) and fed through Fuse.js extended search, which AND-s each\n *    token with fuzzy matching enabled - the \"tokenized fuzzy match\" a caller\n *    reaches for when they type `\"claude sonnet\"` instead of the full endpoint\n *    name.\n *\n * Returns `[]` for an empty endpoint list or when `input` tokenizes to nothing,\n * so callers fall back to the raw input and let Databricks surface a clean 404.\n * This multi-result core is shared by {@link resolveModelId} (single best) and\n * the ranked `lookupModels` selector.\n */\nexport function searchServingEndpoints(\n  input: string,\n  endpoints: readonly ServingEndpointSummary[],\n  options: ResolveModelOptions = {},\n): ScoredEndpoint[] {\n  if (endpoints.length === 0) return [];\n  for (const ep of endpoints) {\n    if (ep.name === input) return [{ endpoint: ep, score: 0 }];\n  }\n  const threshold = options.threshold ?? DEFAULT_FUZZY_THRESHOLD;\n  // Fuse 7.3 has no built-in tokenize hook; in extended search, space-separated\n  // tokens are AND-ed with fuzzy matching enabled. We lean on the shared\n  // tokenizer so the splitting rules stay consistent with the rest of the toolkit.\n  const query = Array.from(\n    string.tokenizeWithOptions({ lowerCase: true, camelCase: false }, input),\n  ).join(\" \");\n  if (!query) return [];\n  const fuse = new Fuse(endpoints, {\n    keys: [\"name\"],\n    threshold,\n    ignoreLocation: true,\n    includeScore: true,\n    useExtendedSearch: true,\n    isCaseSensitive: false,\n  });\n  return fuse\n    .search(query)\n    .filter((r) => (r.score ?? 0) <= threshold)\n    .map((r) => ({ endpoint: r.item, score: r.score ?? 0 }));\n}\n\n/**\n * Snap a user-supplied model name to the single closest configured serving\n * endpoint via {@link searchServingEndpoints}. Returns the input unchanged with\n * `matched: false` when nothing scores within the threshold (or the catalogue\n * is empty), so a deliberate model id is never silently rewritten to a\n * similar-looking neighbour and the upstream call surfaces the canonical 404.\n */\nexport function resolveModelId(\n  input: string,\n  endpoints: readonly ServingEndpointSummary[],\n  options: ResolveModelOptions = {},\n): ResolvedModel {\n  const [best] = searchServingEndpoints(input, endpoints, options);\n  if (best) {\n    return { modelId: best.endpoint.name, matched: true, score: best.score };\n  }\n  return { modelId: input, matched: false };\n}\n"]}

package/lib/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../src/classes.ts","../src/fallback.ts","../src/invoke.ts","../src/resolve.ts","../src/serving.ts","../index.ts"],"version":"5.9.3"}
+{"root":["../src/classes.ts","../src/fallback.ts","../src/invoke.ts","../src/policy.ts","../src/resolve.ts","../src/serving.ts","../index.ts"],"version":"5.9.3"}

package/package.json

@@ -25,10 +25,10 @@
   },
   "dependencies": {
     "@databricks/appkit": "^0.60.0",
-    "@dbx-tools/appkit": "0.6.223",
-    "@dbx-tools/model-rs": "0.6.223",
-    "@dbx-tools/shared-core": "0.6.223",
-    "@dbx-tools/shared-model": "0.6.223",
+    "@dbx-tools/appkit": "0.6.225",
+    "@dbx-tools/model-rs": "0.6.225",
+    "@dbx-tools/shared-core": "0.6.225",
+    "@dbx-tools/shared-model": "0.6.225",
     "fuse.js": "^7.4.2"
   },
   "main": "./lib/index.js",
@@ -45,7 +45,7 @@
       "./package.json": "./package.json"
     }
   },
-  "version": "0.6.223",
+  "version": "0.6.225",
   "types": "./lib/index.d.ts",
   "type": "module",
   "exports": {

package/src/policy.ts

@@ -0,0 +1,21 @@
+/**
+ * Browser-safe model metadata projected from the Rust policy bindings.
+ *
+ * @module
+ */
+
+import {
+  modelFamily as modelFamilyWithRust,
+  reasoningEffortNamesByFamily,
+} from "@dbx-tools/model-rs";
+import type { ReasoningEffort } from "@dbx-tools/shared-model";
+
+/** Return the normalized family parsed by the Rust model-name policy. */
+export function modelFamily(name: string): string | undefined {
+  return modelFamilyWithRust(name);
+}
+
+/** Return the reasoning efforts accepted by a model family. */
+export function modelReasoningEfforts(name: string): ReasoningEffort[] {
+  return reasoningEffortNamesByFamily(name);
+}

package/src/resolve.ts

@@ -21,6 +21,12 @@
  */
 
 import { object } from "@dbx-tools/shared-core";
+import {
+  ModelClass as ModelRsModelClass,
+  rankModels as rankModelsWithRust,
+  type ModelQuery as ModelRsModelQuery,
+  type ServingEndpointSummary as ModelRsServingEndpointSummary,
+} from "@dbx-tools/model-rs";
 import {
   classify,
   model,
@@ -29,7 +35,6 @@ import {
   type ServingEndpointSummary,
 } from "@dbx-tools/shared-model";
 
-import { CHAT_CLASS_ORDER, classesAtOrBelow, MODEL_CLASS_ORDER } from "./classes.ts";
 import { FALLBACK_MODEL_IDS, modelsForClass } from "./fallback.ts";
 import {
   listServingEndpoints,
@@ -41,15 +46,15 @@ import {
 
 type ModelClass = model.ModelClass;
 
-const VERSIONED_FAMILY_SEARCHES = new Set([
-  "claude",
-  "gemini",
-  "gemma",
-  "glm",
-  "gpt",
-  "llama",
-  "qwen",
-]);
+/** Preferred live family for an unconfigured general-purpose chat default. */
+const DEFAULT_MODEL_FAMILY_SEARCH = "gpt";
+
+const MODEL_CLASS_TO_RS: Readonly<Record<ModelClass, ModelRsModelClass>> = {
+  [model.ModelClass.ChatThinking]: ModelRsModelClass.ChatThinking,
+  [model.ModelClass.ChatBalanced]: ModelRsModelClass.ChatBalanced,
+  [model.ModelClass.ChatFast]: ModelRsModelClass.ChatFast,
+  [model.ModelClass.Embedding]: ModelRsModelClass.Embedding,
+};
 
 /** Caller intent passed to {@link resolveModel}. */
 export interface ResolveModelInput {
@@ -82,6 +87,12 @@ export interface ResolveModelInput {
    * the auto-classified catalogue.
    */
   fallbacks?: readonly string[];
+  /**
+   * Refuse the static offline floor when the live catalogue has no match.
+   * Use for unpinned defaults that must always name a currently available
+   * endpoint.
+   */
+  liveOnly?: boolean;
 }
 
 /** Outcome of {@link resolveModel}: the chosen id plus how it was reached. */
@@ -102,100 +113,76 @@ export interface SearchModelsInput extends ModelQuery {
   ttlMs?: number;
 }
 
-/**
- * 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: number | undefined): number {
-  return Math.round((score ?? 0) * 1000);
-}
-
-function modelVariantRank(name: string): number {
-  if (!/(?:^|[-_.])gpt(?:[-_.]|$)/i.test(name)) return 2;
-  if (/(?:^|[-_.])sol(?:[-_.]|$)/i.test(name)) return 0;
-  if (/(?:^|[-_.])luna(?:[-_.]|$)/i.test(name)) return 1;
-  return 2;
-}
-
 /**
  * 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 version, preferred model variant, class (more capable first), and
- *    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.
+ * Rust owns classification, fuzzy scoring, family-version ordering, preferred
+ * variants, class ceilings, tool filtering, and result limiting. Node retains
+ * the caller's endpoint objects so fields outside the ranking contract remain
+ * available unchanged.
  */
 export function lookupModels(
   endpoints: readonly ServingEndpointSummary[],
   query: ModelQuery = {},
 ): RankedModel[] {
-  const classified = classify.classifyEndpoints(endpoints);
-  const eligible =
-    query.modelClass !== undefined ? classesAtOrBelow(query.modelClass) : CHAT_CLASS_ORDER;
+  const endpointsByName = new Map(endpoints.map((endpoint) => [endpoint.name, endpoint]));
+  return rankModelsWithRust(endpoints.map(toModelRsEndpoint), toModelRsQuery(query)).map(
+    (ranked) => {
+      const endpoint = endpointsByName.get(ranked.endpoint.name);
+      if (!endpoint) {
+        throw new Error(`Rust model ranking returned unknown endpoint "${ranked.endpoint.name}"`);
+      }
+      return {
+        endpoint,
+        modelClass: fromModelRsClass(ranked.modelClass),
+        ...(ranked.score !== undefined ? { score: ranked.score } : {}),
+      };
+    },
+  );
+}
 
-  // Flatten eligible classes in capability order, carrying each endpoint's
-  // class; bucket order is already best-first.
-  const candidates: RankedModel[] = [];
-  for (const modelClass of eligible) {
-    for (const endpoint of classified[modelClass]) {
-      if (query.requiresTools && !classify.endpointCapabilities(endpoint).tools) continue;
-      candidates.push({ endpoint, modelClass });
-    }
-  }
+/** Convert a public model query to the generated Rust ranking contract. */
+function toModelRsQuery(query: ModelQuery): ModelRsModelQuery {
+  return {
+    search: query.search,
+    modelClass: query.modelClass === undefined ? undefined : MODEL_CLASS_TO_RS[query.modelClass],
+    requiresTools: query.requiresTools ?? false,
+    includeDeprecated: false,
+    limit: query.limit,
+    threshold: query.threshold,
+  };
+}
 
-  const search = query.search?.trim();
-  let ranked: RankedModel[];
-  if (search) {
-    const gptFamilySearch = search.toLowerCase() === "gpt";
-    const versionedFamilySearch = VERSIONED_FAMILY_SEARCHES.has(search.toLowerCase());
-    const scores = new Map<string, number>();
-    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))
-      .filter(
-        (c) => !gptFamilySearch || !/(?:^|[-_.])gpt[-_.]?oss(?:[-_.]|$)/i.test(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;
-        if (versionedFamilySearch) {
-          const aVersion = classify.versionTuple(a.endpoint.name);
-          const bVersion = classify.versionTuple(b.endpoint.name);
-          for (let index = 0; index < 3; index++) {
-            const byVersion = (bVersion[index] ?? 0) - (aVersion[index] ?? 0);
-            if (byVersion !== 0) return byVersion;
-          }
-        }
-        const byVariant = modelVariantRank(a.endpoint.name) - modelVariantRank(b.endpoint.name);
-        if (byVariant !== 0) return byVariant;
-        return MODEL_CLASS_ORDER.indexOf(a.modelClass) - MODEL_CLASS_ORDER.indexOf(b.modelClass);
-      });
-  } else {
-    ranked = candidates;
-  }
+/** Convert a discovered endpoint to the generated Rust ranking contract. */
+function toModelRsEndpoint(endpoint: ServingEndpointSummary): ModelRsServingEndpointSummary {
+  return {
+    name: endpoint.name,
+    displayName: endpoint.displayName,
+    task: endpoint.task,
+    state: endpoint.state,
+    description: endpoint.description,
+    supportsTools: endpoint.supportsTools,
+    profile: endpoint.profile,
+    modelClass: endpoint.class === undefined ? undefined : MODEL_CLASS_TO_RS[endpoint.class],
+    serviceNames: new Map(Object.entries(endpoint.serviceNames ?? {})),
+    modelServiceName: endpoint.modelServiceName,
+    reasoningEfforts: [],
+    status: { deprecated: endpoint.status?.deprecated ?? false },
+  };
+}
 
-  return query.limit !== undefined ? ranked.slice(0, Math.max(0, query.limit)) : ranked;
+/** Convert a generated Rust class to the browser-safe public enum. */
+function fromModelRsClass(modelClass: ModelRsModelClass): ModelClass {
+  switch (modelClass) {
+    case ModelRsModelClass.ChatThinking:
+      return model.ModelClass.ChatThinking;
+    case ModelRsModelClass.ChatBalanced:
+      return model.ModelClass.ChatBalanced;
+    case ModelRsModelClass.ChatFast:
+      return model.ModelClass.ChatFast;
+    case ModelRsModelClass.Embedding:
+      return model.ModelClass.Embedding;
+  }
 }
 
 /**
@@ -308,9 +295,10 @@ export async function selectModel(
  *    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.
+ *    catalogue wins first. A class request ranks within that ceiling. A
+ *    general request prefers the highest-ranked live GPT, then any ranked live
+ *    chat model. The static {@link FALLBACK_MODEL_IDS} floor is used only when
+ *    the catalogue yields nothing in range.
  */
 export function resolveModel(
   endpoints: readonly ServingEndpointSummary[],
@@ -341,9 +329,17 @@ export function resolveModel(
   }
 
   const source = input.modelClass !== undefined ? "class" : "fallback";
+  if (input.modelClass === undefined) {
+    const [preferred] = lookupModels(endpoints, buildQuery(input, DEFAULT_MODEL_FAMILY_SEARCH));
+    if (preferred) return { modelId: preferred.endpoint.name, source };
+  }
   const [top] = lookupModels(endpoints, buildQuery(input, undefined));
   if (top) return { modelId: top.endpoint.name, source };
 
+  if (input.liveOnly) {
+    throw new Error("No matching live Model Serving endpoint is available");
+  }
+
   // Live catalogue yielded nothing in range: walk the static floor.
   const floorSource =
     input.modelClass !== undefined ? modelsForClass(input.modelClass) : (input.fallbacks ?? []);

package/src/serving.ts

@@ -34,6 +34,7 @@ import {
 import Fuse from "fuse.js";
 
 import { MODEL_CLASS_ORDER } from "./classes.ts";
+import { modelFamily, modelReasoningEfforts } from "./policy.ts";
 
 const { ModelClass } = model;
 
@@ -125,16 +126,20 @@ export async function listServingEndpointsUncached(
   for await (const ep of client.servingEndpoints.list()) {
     if (!ep.name) continue;
     const profile = extractProfile(ep);
+    const family = modelFamily(ep.name);
+    const reasoningEfforts = modelReasoningEfforts(ep.name);
     out.push({
       name: ep.name,
       // Prefer a Databricks-provided human name (a display-name tag or an
       // external-model name); else derive a title-cased label from the id.
       displayName: display.toModelDisplayName(ep.name, providedDisplayName(ep)),
+      ...(family !== undefined ? { family } : {}),
       ...(ep.task !== undefined ? { task: ep.task } : {}),
       ...(ep.state?.ready !== undefined ? { state: String(ep.state.ready) } : {}),
       ...(ep.description !== undefined ? { description: ep.description } : {}),
       supportsTools: classify.supportsToolsByFamily(ep.name),
       ...(profile ? { profile } : {}),
+      ...(reasoningEfforts.length > 0 ? { reasoningEfforts } : {}),
     });
   }
   return out;