@dbx-tools/model 0.9.5 → 0.9.6

package/lib/src/model-catalog.js

@@ -0,0 +1,198 @@
+/**
+ * Live Databricks Model Serving catalogue access.
+ *
+ * Lists the workspace's `/serving-endpoints` and, when the caller supplies a
+ * trusted credential identity, caches the result per host and identity with a
+ * TTL via AppKit's `CacheManager`. Concurrent callers in the same scope share
+ * one in-flight promise. Surfaces each endpoint as a stable
+ * {@link ServingEndpointSummary} - including the Foundation Model API
+ * `quality` / `speed` / `cost` profile when present, the classified
+ * {@link ModelClass}, and (for embedding endpoints) the measured vector
+ * `dimension` - and snaps loose, human-typed names to real endpoint ids
+ * through the Rust model ranker so tokens like `"claude sonnet"` resolve to
+ * `databricks-claude-sonnet-4-6`.
+ *
+ * The class stamp and embedding dimension are computed once per cache load:
+ * every embedding endpoint is "pinged" in parallel and the resulting vector
+ * length recorded, so the cost is paid on a cache miss, not per read. The ping
+ * is best-effort - a failure logs at debug and leaves `dimension` unset rather
+ * than failing the whole listing.
+ *
+ * @module
+ */
+import { createHash } from "node:crypto";
+import { CacheManager } from "@databricks/appkit";
+import { errorUtils, log } from "@dbx-tools/shared-core";
+import { model } from "@dbx-tools/shared-model";
+import { classifyEndpointClasses, normalizeEndpoints, rankEndpoints } from "./_native.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. */
+export const DEFAULT_MODEL_CACHE_TTL_MS = 5 * 60 * 1000;
+/** Default Rust distance threshold below which a fuzzy match is accepted. */
+export const DEFAULT_FUZZY_THRESHOLD = 0.4;
+/** Cache key parts under which endpoint listings are stored. */
+const CACHE_KEY_NAMESPACE = "serving-endpoints";
+/** Hash an opaque credential identity before handing it to CacheManager. */
+function cacheUserKey(identity) {
+    return `model-${createHash("sha256").update(identity).digest("hex")}`;
+}
+/**
+ * List Model Serving endpoints for the workspace owning `client`, routed
+ * through AppKit's `CacheManager`. The manager gives us everything
+ * `cachetools.TTLCache` provides plus what `cachetools-async` adds on top:
+ * per-entry TTL, in-flight request coalescing (concurrent callers share one
+ * fetch via the manager's internal `inFlightRequests` map), bounded size,
+ * telemetry spans (`cache.getOrExecute`), and optional Lakebase persistence so
+ * the catalogue survives restarts when the lakebase plugin is wired up.
+ *
+ * Returns plain {@link ServingEndpointSummary} objects (a stable subset of the
+ * SDK type) so cache hits never expose stale SDK internals. Errors from
+ * `CacheManager` or the SDK fetch propagate to the caller - we don't swallow
+ * them so users see the real auth / network issue.
+ *
+ * @param host - Workspace host used as the cache key. Pass the value resolved
+ *   from `client.config.getHost()` so multi-host apps share one entry per
+ *   workspace.
+ * @param options.ttlMs - Override the default TTL just for this call. Forwarded
+ *   to `CacheManager` as seconds.
+ */
+export async function listServingEndpoints(client, host, options = {}) {
+    if (!options.cacheIdentity)
+        return fetchEndpoints(client);
+    const ttlSec = Math.max(1, Math.round((options.ttlMs ?? DEFAULT_MODEL_CACHE_TTL_MS) / 1000));
+    return CacheManager.getInstanceSync().getOrExecute([CACHE_KEY_NAMESPACE, host], () => fetchEndpoints(client), cacheUserKey(options.cacheIdentity), { ttl: ttlSec });
+}
+/**
+ * List the workspace's serving endpoints as minimal
+ * {@link ServingEndpointSummary} objects straight from the SDK: no caching, and
+ * none of the cache-load enrichment ({@link listServingEndpoints} adds the
+ * {@link ModelClass} stamp and the embedding-dimension probe). Use this for a
+ * one-shot, dependency-light listing - e.g. a CLI that only needs names/tasks
+ * for fuzzy resolution and doesn't want AppKit's `CacheManager` or the
+ * per-embedding ping cost. Prefer {@link listServingEndpoints} for the cached,
+ * enriched view.
+ */
+export async function listServingEndpointsUncached(client) {
+    const endpoints = [];
+    for await (const ep of client.servingEndpoints.list()) {
+        endpoints.push(ep);
+    }
+    return normalizeEndpoints(endpoints);
+}
+async function fetchEndpoints(client) {
+    const startedAt = Date.now();
+    const out = await listServingEndpointsUncached(client);
+    stampModelClasses(out);
+    await measureEmbeddingDimensions(client, out);
+    logger.debug("listed", { count: out.length, elapsedMs: Date.now() - startedAt });
+    return out;
+}
+/**
+ * Stamp each summary's {@link ServingEndpointSummary.class} from the relative
+ * classification of the whole set. Mutates `summaries` in place. Endpoints the
+ * classifier doesn't recognize (custom, unscored, non-LLM) are left without a
+ * class.
+ */
+function stampModelClasses(summaries) {
+    const classOf = classifyEndpointClasses(summaries);
+    for (const summary of summaries) {
+        const cls = classOf.get(summary.name);
+        if (cls !== undefined)
+            summary.class = cls;
+    }
+}
+/**
+ * Measure the embedding vector dimension of every {@link ModelClass.Embedding}
+ * endpoint by pinging it once, all in parallel. Mutates the matching summaries
+ * in place with the resulting `dimension`. Runs only on a cache miss (it's
+ * called from {@link fetchEndpoints}), so the probe cost is amortized across the
+ * cached TTL window. Per-endpoint failures are swallowed (logged at warn) so
+ * one unreachable embedding model never fails the listing.
+ */
+async function measureEmbeddingDimensions(client, summaries) {
+    await Promise.all(summaries
+        .filter((s) => s.class === ModelClass.Embedding)
+        .map(async (summary) => {
+        const dimension = await pingEmbeddingDimension(client, summary.name);
+        if (dimension !== undefined)
+            summary.dimension = dimension;
+    }));
+}
+/**
+ * Best-effort embedding dimension probe: query `name` with a tiny `"ping"`
+ * input and return the length of the returned vector. Returns `undefined` (and
+ * logs at warn) when the endpoint can't be queried or returns no vector - the
+ * dimension is informational, never required.
+ */
+async function pingEmbeddingDimension(client, name) {
+    try {
+        const response = await client.servingEndpoints.query({ name, input: "ping" });
+        const dimension = response.data?.[0]?.embedding?.length;
+        if (typeof dimension === "number" && dimension > 0)
+            return dimension;
+        logger.warn("embedding ping returned no vector", { name });
+        return undefined;
+    }
+    catch (err) {
+        logger.warn("embedding ping failed", { name, error: errorUtils.errorMessage(err) });
+        return undefined;
+    }
+}
+/**
+ * Force-evict cached endpoint listings via AppKit's `CacheManager`. A host and
+ * identity delete only that principal's workspace entry. Because CacheManager
+ * cannot enumerate a namespace, omitting either value clears the complete
+ * manager and should be reserved for tests or administrative refreshes.
+ */
+export async function clearServingEndpointsCache(host, cacheIdentity) {
+    const cache = CacheManager.getInstanceSync();
+    if (host && cacheIdentity) {
+        const key = cache.generateKey([CACHE_KEY_NAMESPACE, host], cacheUserKey(cacheIdentity));
+        await cache.delete(key);
+    }
+    else {
+        await cache.clear();
+    }
+}
+/**
+ * Fuzzy-rank endpoints by how closely their `name` matches `input`, best
+ * (lowest score) first, keeping only those within `threshold`:
+ *
+ * 1. An exact name match short-circuits to a single `score: 0` result.
+ * 2. Otherwise Rust tokenizes the input and scores every endpoint through the
+ *    same fuzzy-distance policy used by {@link lookupModels}.
+ *
+ * Returns `[]` for an empty endpoint list or when `input` tokenizes to nothing,
+ * so callers fall back to the raw input and let Databricks surface a clean 404.
+ * This multi-result core is shared by {@link resolveModelId} (single best) and
+ * the ranked `lookupModels` selector.
+ */
+export function searchServingEndpoints(input, endpoints, options = {}) {
+    if (endpoints.length === 0 || !input.trim())
+        return [];
+    return rankEndpoints(endpoints, {
+        search: input,
+        ...(options.requiresTools !== undefined ? { requiresTools: options.requiresTools } : {}),
+        threshold: options.threshold ?? DEFAULT_FUZZY_THRESHOLD,
+    }, {
+        includeDeprecated: true,
+        modelClass: model.ModelClass.ChatBalanced,
+        task: "llm/v1/chat",
+    }).map((ranked) => ({ endpoint: ranked.endpoint, score: ranked.score ?? 0 }));
+}
+/**
+ * Snap a user-supplied model name to the single closest configured serving
+ * endpoint via {@link searchServingEndpoints}. Returns the input unchanged with
+ * `matched: false` when nothing scores within the threshold (or the catalogue
+ * is empty), so a deliberate model id is never silently rewritten to a
+ * similar-looking neighbour and the upstream call surfaces the canonical 404.
+ */
+export function resolveModelId(input, endpoints, options = {}) {
+    const [best] = searchServingEndpoints(input, endpoints, options);
+    if (best) {
+        return { modelId: best.endpoint.name, matched: true, score: best.score };
+    }
+    return { modelId: input, matched: false };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"model-catalog.js","sourceRoot":"","sources":["../../src/model-catalog.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Live Databricks Model Serving catalogue access.\n *\n * Lists the workspace's `/serving-endpoints` and, when the caller supplies a\n * trusted credential identity, caches the result per host and identity with a\n * TTL via AppKit's `CacheManager`. Concurrent callers in the same scope share\n * one in-flight promise. 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 the Rust model ranker 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 { createHash } from \"node:crypto\";\nimport { CacheManager } from \"@databricks/appkit\";\nimport { appkit } from \"@dbx-tools/appkit\";\nimport { errorUtils, log } from \"@dbx-tools/shared-core\";\nimport { model, type ServingEndpointSummary } from \"@dbx-tools/shared-model\";\n\nimport { classifyEndpointClasses, normalizeEndpoints, rankEndpoints } from \"./_native.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 Rust distance 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/** 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   * Trusted identity of the credential used by `client`.\n   *\n   * The value is hashed before it enters the cache key and is never logged.\n   * Omit it when the caller cannot prove the credential identity; that call\n   * bypasses shared caching so one principal can never read another's\n   * catalogue.\n   */\n  cacheIdentity?: string;\n}\n\n/** Hash an opaque credential identity before handing it to CacheManager. */\nfunction cacheUserKey(identity: string): string {\n  return `model-${createHash(\"sha256\").update(identity).digest(\"hex\")}`;\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  if (!options.cacheIdentity) return fetchEndpoints(client);\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    cacheUserKey(options.cacheIdentity),\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 endpoints: unknown[] = [];\n  for await (const ep of client.servingEndpoints.list()) {\n    endpoints.push(ep);\n  }\n  return normalizeEndpoints(endpoints);\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 classOf = classifyEndpointClasses(summaries);\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: errorUtils.errorMessage(err) });\n    return undefined;\n  }\n}\n\n/**\n * Force-evict cached endpoint listings via AppKit's `CacheManager`. A host and\n * identity delete only that principal's workspace entry. Because CacheManager\n * cannot enumerate a namespace, omitting either value clears the complete\n * manager and should be reserved for tests or administrative refreshes.\n */\nexport async function clearServingEndpointsCache(\n  host?: string,\n  cacheIdentity?: string,\n): Promise<void> {\n  const cache = CacheManager.getInstanceSync();\n  if (host && cacheIdentity) {\n    const key = cache.generateKey([CACHE_KEY_NAMESPACE, host], cacheUserKey(cacheIdentity));\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 the Rust ranker'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  /** Fuzzy distance 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  /** Fuzzy 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 Rust tokenizes the input and scores every endpoint through the\n *    same fuzzy-distance policy used by {@link lookupModels}.\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 || !input.trim()) return [];\n  return rankEndpoints(\n    endpoints,\n    {\n      search: input,\n      ...(options.requiresTools !== undefined ? { requiresTools: options.requiresTools } : {}),\n      threshold: options.threshold ?? DEFAULT_FUZZY_THRESHOLD,\n    },\n    {\n      includeDeprecated: true,\n      modelClass: model.ModelClass.ChatBalanced,\n      task: \"llm/v1/chat\",\n    },\n  ).map((ranked) => ({ endpoint: ranked.endpoint, score: ranked.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/src/policy.d.ts

@@ -3,8 +3,12 @@
  *
  * @module
  */
-import type { ReasoningEffort } from "@dbx-tools/shared-model";
+import { type ReasoningEffort, type ServingEndpointSummary } 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[];
+/** Return whether Rust policy verifies a complete tool-calling round trip. */
+export declare function modelSupportsTools(name: string): boolean;
+/** Return whether a discovered endpoint can be used for a tool-calling chat. */
+export declare function endpointSupportsTools(endpoint: ServingEndpointSummary): boolean;

package/lib/src/policy.js

@@ -3,13 +3,24 @@
  *
  * @module
  */
-import { modelFamily as modelFamilyWithRust, reasoningEffortNamesByFamily, } from "@dbx-tools/model-rs";
+import { modelFamily as modelFamilyWithRust, reasoningEffortNamesByFamily, supportsToolsByFamily as supportsToolsByFamilyWithRust, } from "@dbx-tools/model-rs";
+import { model, ReasoningEffortSchema, } from "@dbx-tools/shared-model";
 /** 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);
+    return ReasoningEffortSchema.array().parse(reasoningEffortNamesByFamily(name));
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG9saWN5LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3BvbGljeS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7OztHQUlHO0FBRUgsT0FBTyxFQUNMLFdBQVcsSUFBSSxtQkFBbUIsRUFDbEMsNEJBQTRCLEdBQzdCLE1BQU0scUJBQXFCLENBQUM7QUFHN0IseUVBQXlFO0FBQ3pFLE1BQU0sVUFBVSxXQUFXLENBQUMsSUFBWTtJQUN0QyxPQUFPLG1CQUFtQixDQUFDLElBQUksQ0FBQyxDQUFDO0FBQ25DLENBQUM7QUFFRCwrREFBK0Q7QUFDL0QsTUFBTSxVQUFVLHFCQUFxQixDQUFDLElBQVk7SUFDaEQsT0FBTyw0QkFBNEIsQ0FBQyxJQUFJLENBQUMsQ0FBQztBQUM1QyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBCcm93c2VyLXNhZmUgbW9kZWwgbWV0YWRhdGEgcHJvamVjdGVkIGZyb20gdGhlIFJ1c3QgcG9saWN5IGJpbmRpbmdzLlxuICpcbiAqIEBtb2R1bGVcbiAqL1xuXG5pbXBvcnQge1xuICBtb2RlbEZhbWlseSBhcyBtb2RlbEZhbWlseVdpdGhSdXN0LFxuICByZWFzb25pbmdFZmZvcnROYW1lc0J5RmFtaWx5LFxufSBmcm9tIFwiQGRieC10b29scy9tb2RlbC1yc1wiO1xuaW1wb3J0IHR5cGUgeyBSZWFzb25pbmdFZmZvcnQgfSBmcm9tIFwiQGRieC10b29scy9zaGFyZWQtbW9kZWxcIjtcblxuLyoqIFJldHVybiB0aGUgbm9ybWFsaXplZCBmYW1pbHkgcGFyc2VkIGJ5IHRoZSBSdXN0IG1vZGVsLW5hbWUgcG9saWN5LiAqL1xuZXhwb3J0IGZ1bmN0aW9uIG1vZGVsRmFtaWx5KG5hbWU6IHN0cmluZyk6IHN0cmluZyB8IHVuZGVmaW5lZCB7XG4gIHJldHVybiBtb2RlbEZhbWlseVdpdGhSdXN0KG5hbWUpO1xufVxuXG4vKiogUmV0dXJuIHRoZSByZWFzb25pbmcgZWZmb3J0cyBhY2NlcHRlZCBieSBhIG1vZGVsIGZhbWlseS4gKi9cbmV4cG9ydCBmdW5jdGlvbiBtb2RlbFJlYXNvbmluZ0VmZm9ydHMobmFtZTogc3RyaW5nKTogUmVhc29uaW5nRWZmb3J0W10ge1xuICByZXR1cm4gcmVhc29uaW5nRWZmb3J0TmFtZXNCeUZhbWlseShuYW1lKTtcbn1cbiJdfQ==
+/** Return whether Rust policy verifies a complete tool-calling round trip. */
+export function modelSupportsTools(name) {
+    return supportsToolsByFamilyWithRust(name);
+}
+/** Return whether a discovered endpoint can be used for a tool-calling chat. */
+export function endpointSupportsTools(endpoint) {
+    const embedding = endpoint.task === "llm/v1/embeddings" || endpoint.class === model.ModelClass.Embedding;
+    const chat = !embedding && (endpoint.task === "llm/v1/chat" || endpoint.class !== undefined);
+    return chat && (endpoint.supportsTools ?? modelSupportsTools(endpoint.name));
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/resolve.d.ts

@@ -20,7 +20,7 @@
  * @module
  */
 import { model, type ModelQuery, type RankedModel, type ServingEndpointSummary } from "@dbx-tools/shared-model";
-import { type ResolvedModel, type ResolveModelOptions, type WorkspaceClientLike } from "./serving.ts";
+import { type ResolvedModel, type ResolveModelOptions, type WorkspaceClientLike } from "./model-catalog.ts";
 type ModelClass = model.ModelClass;
 /** Caller intent passed to {@link resolveModel}. */
 export interface ResolveModelInput {
@@ -36,7 +36,7 @@ export interface ResolveModelInput {
      * doesn't exist).
      */
     fuzzy?: boolean;
-    /** Fuse.js threshold forwarded to the fuzzy `search` match ({@link searchServingEndpoints}). */
+    /** Rust fuzzy-distance threshold forwarded to the search match. */
     threshold?: number;
     /** Require a model that supports a complete function-tool round-trip. */
     requiresTools?: boolean;
@@ -69,11 +69,15 @@ export interface ResolvedModelSelection {
 export interface SelectModelInput extends ResolveModelInput {
     /** TTL override for the cached `/serving-endpoints` listing, in ms. */
     ttlMs?: number;
+    /** Trusted opaque identity of the credential used by the workspace client. */
+    cacheIdentity?: string;
 }
 /** TTL override merged into a {@link ModelQuery} for {@link searchModels}. */
 export interface SearchModelsInput extends ModelQuery {
     /** TTL override for the cached `/serving-endpoints` listing, in ms. */
     ttlMs?: number;
+    /** Trusted opaque identity of the credential used by the workspace client. */
+    cacheIdentity?: string;
 }
 /**
  * Rank the live catalogue against a {@link ModelQuery}, best-first.
@@ -89,10 +93,10 @@ export declare function lookupModels(endpoints: readonly ServingEndpointSummary[
  * in a catalogue snapshot, or the input verbatim when nothing scores within the
  * threshold.
  *
- * The rank-based counterpart to the Fuse-only {@link resolveModelId}: equal
+ * The ranked counterpart to {@link resolveModelId}: equal
  * match scores are broken by class and then within-class version, so a loose
  * `"opus"` prefers `opus-5` over `opus-4-7` instead of picking whichever
- * sibling Fuse happened to order first. Returning the input unmatched (rather
+ * sibling appeared first. Returning the input unmatched (rather
  * than a near neighbour) is deliberate - a deliberate endpoint id is never
  * silently rewritten, and Databricks surfaces a clean 404.
  */

package/lib/src/resolve.js

@@ -20,18 +20,12 @@
  * @module
  */
 import { object } from "@dbx-tools/shared-core";
-import { ModelClass as ModelRsModelClass, rankModels as rankModelsWithRust, } from "@dbx-tools/model-rs";
-import { classify, model, } from "@dbx-tools/shared-model";
+import { rankEndpoints } from "./_native.js";
 import { FALLBACK_MODEL_IDS, modelsForClass } from "./fallback.js";
-import { listServingEndpoints, } from "./serving.js";
+import { listServingEndpoints, } from "./model-catalog.js";
+import { endpointSupportsTools } from "./policy.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.
  *
@@ -41,69 +35,17 @@ const MODEL_CLASS_TO_RS = {
  * available unchanged.
  */
 export function lookupModels(endpoints, query = {}) {
-    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 } : {}),
-        };
-    });
-}
-/** 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 rankEndpoints(endpoints, query);
 }
 /**
  * Collapse {@link lookupModels} to a single id: the closest endpoint to `search`
  * in a catalogue snapshot, or the input verbatim when nothing scores within the
  * threshold.
  *
- * The rank-based counterpart to the Fuse-only {@link resolveModelId}: equal
+ * The ranked counterpart to {@link resolveModelId}: equal
  * match scores are broken by class and then within-class version, so a loose
  * `"opus"` prefers `opus-5` over `opus-4-7` instead of picking whichever
- * sibling Fuse happened to order first. Returning the input unmatched (rather
+ * sibling appeared first. Returning the input unmatched (rather
  * than a near neighbour) is deliberate - a deliberate endpoint id is never
  * silently rewritten, and Databricks surfaces a clean 404.
  */
@@ -149,7 +91,10 @@ export async function rankModelIdLive(load, search, options = {}) {
  *   from `client.config.getHost()`.
  */
 export async function searchModels(client, host, input = {}) {
-    const endpoints = await listServingEndpoints(client, host, input.ttlMs !== undefined ? { ttlMs: input.ttlMs } : {});
+    const endpoints = await listServingEndpoints(client, host, {
+        ...(input.ttlMs !== undefined ? { ttlMs: input.ttlMs } : {}),
+        ...(input.cacheIdentity !== undefined ? { cacheIdentity: input.cacheIdentity } : {}),
+    });
     return lookupModels(endpoints, input);
 }
 /**
@@ -172,6 +117,7 @@ export async function selectModel(client, host, input = {}) {
     }
     const endpoints = await listServingEndpoints(client, host, {
         ...(input.ttlMs !== undefined ? { ttlMs: input.ttlMs } : {}),
+        ...(input.cacheIdentity !== undefined ? { cacheIdentity: input.cacheIdentity } : {}),
     });
     return resolveModel(endpoints, input);
 }
@@ -205,7 +151,7 @@ export function resolveModel(endpoints, input = {}) {
     // workspace restricted to an approved subset).
     if (input.modelClass === undefined && input.fallbacks && input.fallbacks.length > 0) {
         const present = new Set(endpoints
-            .filter((endpoint) => !input.requiresTools || classify.endpointCapabilities(endpoint).tools)
+            .filter((endpoint) => !input.requiresTools || endpointSupportsTools(endpoint))
             .map((endpoint) => endpoint.name));
         const pinned = input.fallbacks.find((id) => present.has(id));
         if (pinned)
@@ -227,9 +173,7 @@ export function resolveModel(endpoints, input = {}) {
     const floorSource = input.modelClass !== undefined ? modelsForClass(input.modelClass) : (input.fallbacks ?? []);
     const floor = object.sequence(floorSource).concat(FALLBACK_MODEL_IDS).distinct().toArray();
     if (input.requiresTools) {
-        const available = new Set(endpoints
-            .filter((endpoint) => classify.endpointCapabilities(endpoint).tools)
-            .map((endpoint) => endpoint.name));
+        const available = new Set(endpoints.filter(endpointSupportsTools).map((endpoint) => endpoint.name));
         const selected = floor.find((id) => available.has(id));
         if (!selected)
             throw new Error("No tool-capable model is available");
@@ -250,7 +194,7 @@ function buildQuery(input, search) {
 /** Throw when an explicit id is absent or not verified for function tools. */
 function assertToolSupport(endpoints, modelId) {
     const endpoint = endpoints.find((candidate) => candidate.name === modelId);
-    if (!endpoint || !classify.endpointCapabilities(endpoint).tools) {
+    if (!endpoint || !endpointSupportsTools(endpoint)) {
         throw new Error(`Model "${modelId}" does not support function tools`);
     }
 }
@@ -268,4 +212,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":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAChD,OAAO,EACL,UAAU,IAAI,iBAAiB,EAC/B,UAAU,IAAI,kBAAkB,GAGjC,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,QAAQ,EACR,KAAK,GAIN,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EAAE,kBAAkB,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AACnE,OAAO,EACL,oBAAoB,GAKrB,MAAM,cAAc,CAAC;AAItB,8EAA8E;AAC9E,MAAM,2BAA2B,GAAG,KAAK,CAAC;AAE1C,MAAM,iBAAiB,GAAoD;IACzE,CAAC,KAAK,CAAC,UAAU,CAAC,YAAY,CAAC,EAAE,iBAAiB,CAAC,YAAY;IAC/D,CAAC,KAAK,CAAC,UAAU,CAAC,YAAY,CAAC,EAAE,iBAAiB,CAAC,YAAY;IAC/D,CAAC,KAAK,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,iBAAiB,CAAC,QAAQ;IACvD,CAAC,KAAK,CAAC,UAAU,CAAC,SAAS,CAAC,EAAE,iBAAiB,CAAC,SAAS;CAC1D,CAAC;AA2DF;;;;;;;GAOG;AACH,MAAM,UAAU,YAAY,CAC1B,SAA4C,EAC5C,QAAoB,EAAE;IAEtB,MAAM,eAAe,GAAG,IAAI,GAAG,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC;IACxF,OAAO,kBAAkB,CAAC,SAAS,CAAC,GAAG,CAAC,iBAAiB,CAAC,EAAE,cAAc,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,CACpF,CAAC,MAAM,EAAE,EAAE;QACT,MAAM,QAAQ,GAAG,eAAe,CAAC,GAAG,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;QAC3D,IAAI,CAAC,QAAQ,EAAE,CAAC;YACd,MAAM,IAAI,KAAK,CAAC,iDAAiD,MAAM,CAAC,QAAQ,CAAC,IAAI,GAAG,CAAC,CAAC;QAC5F,CAAC;QACD,OAAO;YACL,QAAQ;YACR,UAAU,EAAE,gBAAgB,CAAC,MAAM,CAAC,UAAU,CAAC;YAC/C,GAAG,CAAC,MAAM,CAAC,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;SAC/D,CAAC;IACJ,CAAC,CACF,CAAC;AACJ,CAAC;AAED,2EAA2E;AAC3E,SAAS,cAAc,CAAC,KAAiB;IACvC,OAAO;QACL,MAAM,EAAE,KAAK,CAAC,MAAM;QACpB,UAAU,EAAE,KAAK,CAAC,UAAU,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,iBAAiB,CAAC,KAAK,CAAC,UAAU,CAAC;QAC5F,aAAa,EAAE,KAAK,CAAC,aAAa,IAAI,KAAK;QAC3C,iBAAiB,EAAE,KAAK;QACxB,KAAK,EAAE,KAAK,CAAC,KAAK;QAClB,SAAS,EAAE,KAAK,CAAC,SAAS;KAC3B,CAAC;AACJ,CAAC;AAED,4EAA4E;AAC5E,SAAS,iBAAiB,CAAC,QAAgC;IACzD,OAAO;QACL,IAAI,EAAE,QAAQ,CAAC,IAAI;QACnB,WAAW,EAAE,QAAQ,CAAC,WAAW;QACjC,IAAI,EAAE,QAAQ,CAAC,IAAI;QACnB,KAAK,EAAE,QAAQ,CAAC,KAAK;QACrB,WAAW,EAAE,QAAQ,CAAC,WAAW;QACjC,aAAa,EAAE,QAAQ,CAAC,aAAa;QACrC,OAAO,EAAE,QAAQ,CAAC,OAAO;QACzB,UAAU,EAAE,QAAQ,CAAC,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,iBAAiB,CAAC,QAAQ,CAAC,KAAK,CAAC;QACxF,YAAY,EAAE,IAAI,GAAG,CAAC,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,YAAY,IAAI,EAAE,CAAC,CAAC;QAClE,gBAAgB,EAAE,QAAQ,CAAC,gBAAgB;QAC3C,gBAAgB,EAAE,EAAE;QACpB,MAAM,EAAE,EAAE,UAAU,EAAE,QAAQ,CAAC,MAAM,EAAE,UAAU,IAAI,KAAK,EAAE;KAC7D,CAAC;AACJ,CAAC;AAED,sEAAsE;AACtE,SAAS,gBAAgB,CAAC,UAA6B;IACrD,QAAQ,UAAU,EAAE,CAAC;QACnB,KAAK,iBAAiB,CAAC,YAAY;YACjC,OAAO,KAAK,CAAC,UAAU,CAAC,YAAY,CAAC;QACvC,KAAK,iBAAiB,CAAC,YAAY;YACjC,OAAO,KAAK,CAAC,UAAU,CAAC,YAAY,CAAC;QACvC,KAAK,iBAAiB,CAAC,QAAQ;YAC7B,OAAO,KAAK,CAAC,UAAU,CAAC,QAAQ,CAAC;QACnC,KAAK,iBAAiB,CAAC,SAAS;YAC9B,OAAO,KAAK,CAAC,UAAU,CAAC,SAAS,CAAC;IACtC,CAAC;AACH,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,WAAW,CACzB,SAA4C,EAC5C,MAAc,EACd,UAA+B,EAAE;IAEjC,MAAM,CAAC,GAAG,CAAC,GAAG,YAAY,CAAC,SAAS,EAAE;QACpC,MAAM;QACN,KAAK,EAAE,CAAC;QACR,GAAG,CAAC,OAAO,CAAC,SAAS,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,OAAO,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QAC5E,GAAG,CAAC,OAAO,CAAC,aAAa,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,aAAa,EAAE,OAAO,CAAC,aAAa,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KACzF,CAAC,CAAC;IACH,IAAI,CAAC,GAAG;QAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;IACrD,OAAO,EAAE,OAAO,EAAE,GAAG,CAAC,QAAQ,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,CAAC,KAAK,EAAE,CAAC;AACzE,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,KAAK,UAAU,eAAe,CACnC,IAAoE,EACpE,MAAc,EACd,UAA+B,EAAE;IAEjC,MAAM,QAAQ,GAAG,WAAW,CAAC,MAAM,IAAI,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;IACjE,IAAI,QAAQ,CAAC,OAAO;QAAE,OAAO,QAAQ,CAAC;IACtC,OAAO,WAAW,CAAC,MAAM,IAAI,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;AACxD,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,CAAC,KAAK,UAAU,YAAY,CAChC,MAA2B,EAC3B,IAAY,EACZ,QAA2B,EAAE;IAE7B,MAAM,SAAS,GAAG,MAAM,oBAAoB,CAC1C,MAAM,EACN,IAAI,EACJ,KAAK,CAAC,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,CACxD,CAAC;IACF,OAAO,YAAY,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;AACxC,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,KAAK,UAAU,WAAW,CAC/B,MAA2B,EAC3B,IAAY,EACZ,QAA0B,EAAE;IAE5B,IAAI,KAAK,CAAC,QAAQ,KAAK,SAAS,IAAI,KAAK,CAAC,KAAK,KAAK,KAAK,IAAI,CAAC,KAAK,CAAC,aAAa,EAAE,CAAC;QAClF,OAAO,EAAE,OAAO,EAAE,KAAK,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,CAAC;IACzD,CAAC;IACD,MAAM,SAAS,GAAG,MAAM,oBAAoB,CAAC,MAAM,EAAE,IAAI,EAAE;QACzD,GAAG,CAAC,KAAK,CAAC,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KAC7D,CAAC,CAAC;IACH,OAAO,YAAY,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;AACxC,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,YAAY,CAC1B,SAA4C,EAC5C,QAA2B,EAAE;IAE7B,IAAI,KAAK,CAAC,QAAQ,KAAK,SAAS,EAAE,CAAC;QACjC,IAAI,KAAK,CAAC,KAAK,KAAK,KAAK,EAAE,CAAC;YAC1B,IAAI,KAAK,CAAC,aAAa;gBAAE,iBAAiB,CAAC,SAAS,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAC;YACtE,OAAO,EAAE,OAAO,EAAE,KAAK,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,CAAC;QACzD,CAAC;QACD,MAAM,CAAC,GAAG,CAAC,GAAG,YAAY,CAAC,SAAS,EAAE,UAAU,CAAC,KAAK,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC;QACzE,IAAI,KAAK,CAAC,aAAa,IAAI,CAAC,GAAG,EAAE,CAAC;YAChC,MAAM,IAAI,KAAK,CAAC,kCAAkC,KAAK,CAAC,QAAQ,GAAG,CAAC,CAAC;QACvE,CAAC;QACD,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,CAAC,IAAI,IAAI,KAAK,CAAC,QAAQ,EAAE,MAAM,EAAE,aAAa,EAAE,CAAC;IAClF,CAAC;IAED,wEAAwE;IACxE,+CAA+C;IAC/C,IAAI,KAAK,CAAC,UAAU,KAAK,SAAS,IAAI,KAAK,CAAC,SAAS,IAAI,KAAK,CAAC,SAAS,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACpF,MAAM,OAAO,GAAG,IAAI,GAAG,CACrB,SAAS;aACN,MAAM,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,aAAa,IAAI,QAAQ,CAAC,oBAAoB,CAAC,QAAQ,CAAC,CAAC,KAAK,CAAC;aAC3F,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,CACpC,CAAC;QACF,MAAM,MAAM,GAAG,KAAK,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC;QAC7D,IAAI,MAAM;YAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,CAAC;IAC7D,CAAC;IAED,MAAM,MAAM,GAAG,KAAK,CAAC,UAAU,KAAK,SAAS,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,UAAU,CAAC;IACrE,IAAI,KAAK,CAAC,UAAU,KAAK,SAAS,EAAE,CAAC;QACnC,MAAM,CAAC,SAAS,CAAC,GAAG,YAAY,CAAC,SAAS,EAAE,UAAU,CAAC,KAAK,EAAE,2BAA2B,CAAC,CAAC,CAAC;QAC5F,IAAI,SAAS;YAAE,OAAO,EAAE,OAAO,EAAE,SAAS,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC;IACrE,CAAC;IACD,MAAM,CAAC,GAAG,CAAC,GAAG,YAAY,CAAC,SAAS,EAAE,UAAU,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC;IACpE,IAAI,GAAG;QAAE,OAAO,EAAE,OAAO,EAAE,GAAG,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC;IAEvD,IAAI,KAAK,CAAC,QAAQ,EAAE,CAAC;QACnB,MAAM,IAAI,KAAK,CAAC,sDAAsD,CAAC,CAAC;IAC1E,CAAC;IAED,kEAAkE;IAClE,MAAM,WAAW,GACf,KAAK,CAAC,UAAU,KAAK,SAAS,CAAC,CAAC,CAAC,cAAc,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,SAAS,IAAI,EAAE,CAAC,CAAC;IAC9F,MAAM,KAAK,GAAG,MAAM,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC,MAAM,CAAC,kBAAkB,CAAC,CAAC,QAAQ,EAAE,CAAC,OAAO,EAAE,CAAC;IAC3F,IAAI,KAAK,CAAC,aAAa,EAAE,CAAC;QACxB,MAAM,SAAS,GAAG,IAAI,GAAG,CACvB,SAAS;aACN,MAAM,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,oBAAoB,CAAC,QAAQ,CAAC,CAAC,KAAK,CAAC;aACnE,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,CACpC,CAAC;QACF,MAAM,QAAQ,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,SAAS,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC;QACvD,IAAI,CAAC,QAAQ;YAAE,MAAM,IAAI,KAAK,CAAC,oCAAoC,CAAC,CAAC;QACrE,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,CAAC;IACvC,CAAC;IACD,OAAO,EAAE,OAAO,EAAE,kBAAkB,CAAC,KAAK,EAAE,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;AACnE,CAAC;AAED,+FAA+F;AAC/F,SAAS,UAAU,CAAC,KAAwB,EAAE,MAA0B;IACtE,OAAO;QACL,GAAG,CAAC,MAAM,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QAC3C,GAAG,CAAC,KAAK,CAAC,UAAU,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,UAAU,EAAE,KAAK,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QAC3E,GAAG,CAAC,KAAK,CAAC,aAAa,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,aAAa,EAAE,KAAK,CAAC,aAAa,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QACpF,GAAG,CAAC,KAAK,CAAC,SAAS,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,KAAK,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QACxE,KAAK,EAAE,CAAC;KACT,CAAC;AACJ,CAAC;AAED,8EAA8E;AAC9E,SAAS,iBAAiB,CAAC,SAA4C,EAAE,OAAe;IACtF,MAAM,QAAQ,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,SAAS,CAAC,IAAI,KAAK,OAAO,CAAC,CAAC;IAC3E,IAAI,CAAC,QAAQ,IAAI,CAAC,QAAQ,CAAC,oBAAoB,CAAC,QAAQ,CAAC,CAAC,KAAK,EAAE,CAAC;QAChE,MAAM,IAAI,KAAK,CAAC,UAAU,OAAO,mCAAmC,CAAC,CAAC;IACxE,CAAC;AACH,CAAC;AAED;;;;;GAKG;AACH,SAAS,kBAAkB,CACzB,UAA6B,EAC7B,SAA4C;IAE5C,MAAM,OAAO,GAAG,IAAI,GAAG,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;IACtD,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE,CAAC;QACnC,IAAI,OAAO,CAAC,GAAG,CAAC,SAAS,CAAC;YAAE,OAAO,SAAS,CAAC;IAC/C,CAAC;IACD,OAAO,UAAU,CAAC,CAAC,CAAC,IAAI,kBAAkB,CAAC,CAAC,CAAE,CAAC;AACjD,CAAC","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"]}
+//# 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  model,\n  type ModelQuery,\n  type RankedModel,\n  type ServingEndpointSummary,\n} from \"@dbx-tools/shared-model\";\n\nimport { rankEndpoints } from \"./_native.ts\";\nimport { FALLBACK_MODEL_IDS, modelsForClass } from \"./fallback.ts\";\nimport {\n  listServingEndpoints,\n  type ResolvedModel,\n  type ResolveModelOptions,\n  type WorkspaceClientLike,\n} from \"./model-catalog.ts\";\nimport { endpointSupportsTools } from \"./policy.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\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  /** Rust fuzzy-distance threshold forwarded to the search match. */\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  /** Trusted opaque identity of the credential used by the workspace client. */\n  cacheIdentity?: string;\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  /** Trusted opaque identity of the credential used by the workspace client. */\n  cacheIdentity?: string;\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  return rankEndpoints(endpoints, query);\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 ranked counterpart to {@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 appeared 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(client, host, {\n    ...(input.ttlMs !== undefined ? { ttlMs: input.ttlMs } : {}),\n    ...(input.cacheIdentity !== undefined ? { cacheIdentity: input.cacheIdentity } : {}),\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    ...(input.cacheIdentity !== undefined ? { cacheIdentity: input.cacheIdentity } : {}),\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 || endpointSupportsTools(endpoint))\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.filter(endpointSupportsTools).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 || !endpointSupportsTools(endpoint)) {\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/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"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"}
+{"root":["../src/_native.ts","../src/classes.ts","../src/fallback.ts","../src/invoke.ts","../src/model-catalog.ts","../src/policy.ts","../src/resolve.ts","../index.ts"],"version":"5.9.3"}