@dbx-tools/model 0.9.21 → 0.9.29

package/lib/src/resolve.js

@@ -1,215 +1,30 @@
-/**
- * Workspace-aware model selection.
- *
- * Given a caller's intent - a search string, a capability {@link ModelClass}
- * ceiling, both, or nothing - the toolkit returns matching endpoints ranked by
- * match quality then class, or collapses to the single best id the workspace
- * actually has, degrading from "best in range" down to the static fallback
- * floor. Selection is chat-only: embedding endpoints surface only when
- * `modelClass` is explicitly {@link ModelClass.Embedding}.
- *
- * Two shapes of selection, each in a pure form (over an endpoint list the
- * caller already holds) and an I/O wrapper (that lists `/serving-endpoints`
- * first): ranking, which returns a match- then class-ordered list, and
- * single-selection, which collapses to one id plus how it was reached and
- * layers the operator-pinned fallback / static-floor safety net on top. A chat
- * `modelClass` acts as a ceiling: that band and the less-capable chat bands
- * below it are eligible (see {@link classesAtOrBelow}), so a `chat-balanced`
- * ask can fall to `chat-fast` but never escalate to `chat-thinking`.
- *
- * @module
- */
-import { object } from "@dbx-tools/shared-core";
-import { rankEndpoints } from "./_native.js";
-import { FALLBACK_MODEL_IDS, modelsForClass } from "./fallback.js";
+import { lookupModels, rankModelId, resolveModel, } from "./_selection.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";
-/**
- * Rank the live catalogue against a {@link ModelQuery}, best-first.
- *
- * 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 = {}) {
-    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 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 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.
- */
-export function rankModelId(endpoints, search, options = {}) {
-    const [top] = lookupModels(endpoints, {
-        search,
-        limit: 1,
-        ...(options.threshold !== undefined ? { threshold: options.threshold } : {}),
-        ...(options.requiresTools !== undefined ? { requiresTools: options.requiresTools } : {}),
-    });
-    if (!top)
-        return { modelId: search, matched: false };
-    return { modelId: top.endpoint.name, matched: true, score: top.score };
-}
-/**
- * {@link rankModelId} against a catalogue the caller may be holding stale:
- * match the loaded snapshot, and on a miss reload once with `force` and match
- * again. That way a model deployed after the catalogue was cached still
- * resolves on first use, without a restart and without giving up caching.
- *
- * The catalogue arrives as a loader rather than a client so the caller keeps
- * ownership of *how* it is cached - {@link listServingEndpoints} and its
- * `CacheManager`, a plain process-lifetime field in a CLI, or a test double.
- * Only one reload is attempted: a genuinely unknown name should fail fast
- * rather than re-list on every request.
- *
- * @param load - Returns the catalogue; `force` asks it to bypass its cache.
- */
+export { lookupModels, rankModelId, resolveModel } from "./_selection.js";
+/** Resolve against a potentially stale catalogue, refreshing once on a miss. */
 export async function rankModelIdLive(load, search, options = {}) {
     const resolved = rankModelId(await load(false), search, options);
     if (resolved.matched)
         return resolved;
     return rankModelId(await load(true), search, options);
 }
-/**
- * Rank a workspace's catalogue in one call: list its `/serving-endpoints`
- * (cached) and run {@link lookupModels} over the result. The list counterpart to
- * {@link selectModel}, for a consumer that wants the full ranked set (a model
- * picker, a CLI) rather than a single id. Catalogue fetches fail loud: network
- * / auth errors propagate so the caller sees the real SDK message.
- *
- * @param host - Workspace host used as the cache key. Pass the value resolved
- *   from `client.config.getHost()`.
- */
+/** List and rank a workspace model catalogue. */
 export async function searchModels(client, host, input = {}) {
-    const endpoints = await listServingEndpoints(client, host, {
-        ...(input.ttlMs !== undefined ? { ttlMs: input.ttlMs } : {}),
-        ...(input.cacheIdentity !== undefined ? { cacheIdentity: input.cacheIdentity } : {}),
-    });
+    const endpoints = await listServingEndpoints(client, host, catalogueOptions(input));
     return lookupModels(endpoints, input);
 }
-/**
- * Resolve a model id for a workspace in one call: list its `/serving-endpoints`
- * (cached) and run {@link resolveModel} over the result. This is the entry
- * point for any consumer that holds a `WorkspaceClient` and just wants a usable
- * model name - a Lakeflow job, a one-off script, or the Mastra plugin alike.
- *
- * Cheap exit: when an `explicit` name is given, `fuzzy` is off, and tool
- * capability is not required, the catalogue is never fetched. Catalogue
- * fetches otherwise fail loud: network / auth errors propagate so the caller
- * sees the real SDK message instead of a silent fallback.
- *
- * @param host - Workspace host used as the cache key. Pass the value resolved
- *   from `client.config.getHost()`.
- */
+/** List a workspace catalogue and resolve one model. */
 export async function selectModel(client, host, input = {}) {
     if (input.explicit !== undefined && input.fuzzy === false && !input.requiresTools) {
         return { modelId: input.explicit, source: "explicit" };
     }
-    const endpoints = await listServingEndpoints(client, host, {
-        ...(input.ttlMs !== undefined ? { ttlMs: input.ttlMs } : {}),
-        ...(input.cacheIdentity !== undefined ? { cacheIdentity: input.cacheIdentity } : {}),
-    });
+    const endpoints = await listServingEndpoints(client, host, catalogueOptions(input));
     return resolveModel(endpoints, input);
 }
-/**
- * Resolve a single model id from the live catalogue and caller intent,
- * delegating the live selection to {@link lookupModels} with `limit: 1`.
- *
- * 1. **Explicit ask**: with `fuzzy` off, returned verbatim; otherwise
- *    fuzzy-ranked within the (optional) class ceiling and the best taken,
- *    falling back to the input verbatim when nothing matches.
- * 2. **No explicit ask**: an operator-pinned `fallback` that exists in the live
- *    catalogue wins first. 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) {
-        if (input.fuzzy === false) {
-            if (input.requiresTools)
-                assertToolSupport(endpoints, input.explicit);
-            return { modelId: input.explicit, source: "explicit" };
-        }
-        const [top] = lookupModels(endpoints, buildQuery(input, input.explicit));
-        if (input.requiresTools && !top) {
-            throw new Error(`No tool-capable model matches "${input.explicit}"`);
-        }
-        return { modelId: top?.endpoint.name ?? input.explicit, source: "fuzzy-match" };
-    }
-    // Operator-pinned fallbacks win when present and live (e.g. a regulated
-    // workspace restricted to an approved subset).
-    if (input.modelClass === undefined && input.fallbacks && input.fallbacks.length > 0) {
-        const present = new Set(endpoints
-            .filter((endpoint) => !input.requiresTools || endpointSupportsTools(endpoint))
-            .map((endpoint) => endpoint.name));
-        const pinned = input.fallbacks.find((id) => present.has(id));
-        if (pinned)
-            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();
-    if (input.requiresTools) {
-        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");
-        return { modelId: selected, source };
-    }
-    return { modelId: pickFirstAvailable(floor, endpoints), source };
-}
-/** Build a {@link ModelQuery} from {@link ResolveModelInput} for the `limit: 1` delegation. */
-function buildQuery(input, search) {
+function catalogueOptions(input) {
     return {
-        ...(search !== undefined ? { search } : {}),
-        ...(input.modelClass !== undefined ? { modelClass: input.modelClass } : {}),
-        ...(input.requiresTools !== undefined ? { requiresTools: input.requiresTools } : {}),
-        ...(input.threshold !== undefined ? { threshold: input.threshold } : {}),
-        limit: 1,
+        ...(input.ttlMs !== undefined ? { ttlMs: input.ttlMs } : {}),
+        ...(input.cacheIdentity !== undefined ? { cacheIdentity: input.cacheIdentity } : {}),
     };
 }
-/** 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 || !endpointSupportsTools(endpoint)) {
-        throw new Error(`Model "${modelId}" does not support function tools`);
-    }
-}
-/**
- * Find the first id in `candidates` whose endpoint is present in `endpoints`.
- * Returns the top candidate when the workspace has none of them so callers
- * always get a string; an offline workspace then receives a clean 404 from
- * Databricks instead of a malformed config.
- */
-function pickFirstAvailable(candidates, endpoints) {
-    const present = new Set(endpoints.map((e) => e.name));
-    for (const candidate of candidates) {
-        if (present.has(candidate))
-            return candidate;
-    }
-    return candidates[0] ?? FALLBACK_MODEL_IDS[0];
-}
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"resolve.js","sourceRoot":"","sources":["../../src/resolve.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Workspace-aware model selection.\n *\n * Given a caller's intent - a search string, a capability {@link ModelClass}\n * ceiling, both, or nothing - the toolkit returns matching endpoints ranked by\n * match quality then class, or collapses to the single best id the workspace\n * actually has, degrading from \"best in range\" down to the static fallback\n * floor. Selection is chat-only: embedding endpoints surface only when\n * `modelClass` is explicitly {@link ModelClass.Embedding}.\n *\n * Two shapes of selection, each in a pure form (over an endpoint list the\n * caller already holds) and an I/O wrapper (that lists `/serving-endpoints`\n * first): ranking, which returns a match- then class-ordered list, and\n * single-selection, which collapses to one id plus how it was reached and\n * layers the operator-pinned fallback / static-floor safety net on top. A chat\n * `modelClass` acts as a ceiling: that band and the less-capable chat bands\n * below it are eligible (see {@link classesAtOrBelow}), so a `chat-balanced`\n * ask can fall to `chat-fast` but never escalate to `chat-thinking`.\n *\n * @module\n */\n\nimport { object } from \"@dbx-tools/shared-core\";\nimport {\n  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"]}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"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"}
+{"root":["../src/_metadata-contract.ts","../src/_metadata-generator.ts","../src/_ranking.ts","../src/_selection.ts","../src/classes.ts","../src/classify.ts","../src/fallback.ts","../src/invoke.ts","../src/metadata.ts","../src/model-catalog.ts","../src/model-client.ts","../src/policy.ts","../src/python.ts","../src/resolve.ts","../index.ts"],"version":"5.9.3"}

package/package.json

@@ -21,14 +21,16 @@
   "devDependencies": {
     "@types/bun": "1.3.14",
     "@types/node": "^24.6.0",
+    "cheerio": "^1.2.0",
     "typescript": "^5.9.3"
   },
   "dependencies": {
     "@databricks/appkit": "0.81.0",
-    "@dbx-tools/appkit": "^0.9.21",
-    "@dbx-tools/model-rs": "^0.9.21",
-    "@dbx-tools/shared-core": "^0.9.21",
-    "@dbx-tools/shared-model": "^0.9.21"
+    "@dbx-tools/appkit": "^0.9.29",
+    "@dbx-tools/auth": "^0.9.29",
+    "@dbx-tools/shared-core": "^0.9.29",
+    "@dbx-tools/shared-model": "^0.9.29",
+    "fuse.js": "^7.4.2"
   },
   "main": "./lib/index.js",
   "license": "Apache-2.0",
@@ -41,10 +43,14 @@
         "types": "./lib/index.d.ts",
         "default": "./lib/index.js"
       },
+      "./python": {
+        "types": "./lib/src/python.d.ts",
+        "default": "./lib/src/python.js"
+      },
       "./package.json": "./package.json"
     }
   },
-  "version": "0.9.21",
+  "version": "0.9.29",
   "types": "./lib/index.d.ts",
   "type": "module",
   "exports": {
@@ -52,6 +58,10 @@
       "types": "./lib/index.d.ts",
       "default": "./lib/index.js"
     },
+    "./python": {
+      "types": "./lib/src/python.d.ts",
+      "default": "./lib/src/python.js"
+    },
     "./package.json": "./package.json"
   },
   "files": [

package/src/_metadata-contract.ts

@@ -0,0 +1,56 @@
+/** One day, matching the refresh cadence of Databricks model documentation. */
+export const MODEL_METADATA_TTL_MS = 24 * 60 * 60 * 1000;
+
+/** Databricks documentation URL for retired foundation models. */
+export const RETIRED_MODELS_URL =
+  "https://docs.databricks.com/aws/en/machine-learning/retired-models-policy";
+
+/** Databricks documentation URL for OpenAI Responses model support. */
+export const OPENAI_RESPONSES_MODELS_URL =
+  "https://docs.databricks.com/aws/en/machine-learning/model-serving/query-openai-responses";
+
+/** Databricks documentation URL for native web-search model support. */
+export const WEB_SEARCH_MODELS_URL =
+  "https://docs.databricks.com/aws/en/machine-learning/model-serving/web-search";
+
+/** Databricks documentation URL for Foundation Model API limits. */
+export const MODEL_RATE_LIMITS_URL =
+  "https://docs.databricks.com/aws/en/machine-learning/foundation-model-apis/limits";
+
+/** Build-generated retired-model snapshot. */
+export interface RetiredModelsSnapshot {
+  readonly generatedAt: number;
+  readonly models: readonly string[];
+}
+
+/** Normalized model identities grouped by documented capability. */
+export interface ModelCapabilityCatalogue {
+  readonly responses: readonly string[];
+  readonly imageInput: readonly string[];
+  readonly applyPatch: readonly string[];
+  readonly webSearch: readonly string[];
+}
+
+/** Build-generated model-capability snapshot. */
+export interface ModelCapabilitiesSnapshot {
+  readonly generatedAt: number;
+  readonly capabilities: ModelCapabilityCatalogue;
+}
+
+/** Published pay-per-token limits for one model. */
+export interface ModelRateLimits {
+  readonly inputTokensPerMinute: number | null;
+  readonly outputTokensPerMinute: number | null;
+  readonly queriesPerHour: number | null;
+}
+
+/** Model limits keyed by normalized Databricks model identity. */
+export interface ModelRateLimitCatalogue {
+  readonly models: Readonly<Record<string, ModelRateLimits>>;
+}
+
+/** Build-generated model-rate-limit snapshot. */
+export interface ModelRateLimitsSnapshot {
+  readonly generatedAt: number;
+  readonly catalogue: ModelRateLimitCatalogue;
+}

package/src/_metadata-generator.ts

@@ -0,0 +1,199 @@
+import { load, type CheerioAPI } from "cheerio";
+
+import type {
+  ModelCapabilitiesSnapshot,
+  ModelRateLimitCatalogue,
+  ModelRateLimitsSnapshot,
+  RetiredModelsSnapshot,
+} from "./_metadata-contract.ts";
+import { modelSearchQuery } from "./policy.ts";
+
+type Selection = ReturnType<CheerioAPI>;
+
+/** Parse retired model names from Databricks retirement-policy HTML. */
+export function parseRetiredModels(html: string, generatedAt: number): RetiredModelsSnapshot {
+  const $ = load(html);
+  const models = new Set<string>();
+  $("table").each((_, table) => {
+    const rows = $(table).find("tr");
+    const header = collapseText($(rows.get(0)).find("th, td").first()).toLowerCase();
+    if (header !== "open model" && header !== "partner model") return;
+    rows.slice(1).each((__, row) => {
+      for (const name of collapseText($(row).find("th, td").first()).split("/")) {
+        const trimmed = name.trim();
+        if (trimmed) models.add(trimmed);
+      }
+    });
+  });
+  if (models.size === 0) throw new Error("Databricks retirement tables contained no model names");
+  return {
+    generatedAt,
+    models: [...models].sort((left, right) =>
+      left.localeCompare(right, "en", { sensitivity: "base" }),
+    ),
+  };
+}
+
+/** Parse Responses and web-search documentation into model capability sets. */
+export function parseModelCapabilities(
+  responsesHtml: string,
+  webSearchHtml: string,
+  generatedAt: number,
+): ModelCapabilitiesSnapshot {
+  const responsesDocument = load(responsesHtml);
+  const responses = modelsAfterHeading(responsesDocument, "databricks-hosted-foundation-models");
+  if (responses.length === 0) {
+    throw new Error("Databricks documentation contained no OpenAI Responses models");
+  }
+  const inputTypes = sectionElements(responsesDocument, "supported-input-types")
+    .map((element) => collapseText(element))
+    .join(" ")
+    .toLowerCase();
+  const inputTypeWords = new Set(inputTypes.split(/[^a-z0-9]+/).filter(Boolean));
+  const imageInput = inputTypeWords.has("text") && inputTypeWords.has("image") ? responses : [];
+  const applyPatch = codeValuesAfterHeading(responsesDocument, "limitations").includes(
+    "apply_patch",
+  )
+    ? responses
+    : [];
+  const webSearch = nativeWebSearchModels(load(webSearchHtml), responses);
+  if (webSearch.length === 0) {
+    throw new Error("Databricks documentation contained no native web-search models");
+  }
+  return {
+    generatedAt,
+    capabilities: { responses, imageInput, applyPatch, webSearch },
+  };
+}
+
+/** Parse pay-per-token limits from Databricks Foundation Model API HTML. */
+export function parseModelRateLimits(html: string, generatedAt: number): ModelRateLimitsSnapshot {
+  const $ = load(html);
+  const models: Record<string, ModelRateLimitCatalogue["models"][string]> = {};
+  $("table").each((_, table) => {
+    const rows = $(table).find("tr");
+    const headers = $(rows.get(0))
+      .find("th, td")
+      .toArray()
+      .map((cell) => collapseText($(cell)).toLowerCase());
+    const modelIndex = headers.findIndex((value) => value.includes("model"));
+    const inputIndex = headers.findIndex((value) => value.includes("itpm"));
+    const outputIndex = headers.findIndex((value) => value.includes("otpm"));
+    const queryIndex = headers.findIndex((value) => value.includes("qph"));
+    if (modelIndex < 0 || inputIndex < 0 || outputIndex < 0) return;
+    rows.slice(1).each((__, row) => {
+      const cells = $(row)
+        .find("th, td")
+        .toArray()
+        .map((cell) => collapseText($(cell)));
+      const key = modelKey(cells[modelIndex]);
+      if (!key) return;
+      models[key] = {
+        inputTokensPerMinute: number(cells[inputIndex]),
+        outputTokensPerMinute: number(cells[outputIndex]),
+        queriesPerHour: queryIndex < 0 ? null : number(cells[queryIndex]),
+      };
+    });
+  });
+  if (Object.keys(models).length === 0) {
+    throw new Error("Databricks model-limit documentation contained no models");
+  }
+  return { generatedAt, catalogue: { models: sortRecord(models) } };
+}
+
+function modelsAfterHeading($: CheerioAPI, headingId: string): string[] {
+  return [
+    ...new Set(codeValuesAfterHeading($, headingId).flatMap((value) => modelKey(value) ?? [])),
+  ].sort();
+}
+
+function nativeWebSearchModels($: CheerioAPI, responses: readonly string[]): string[] {
+  const families = new Set<string>();
+  const models = new Set<string>();
+  let nativeSection = false;
+  for (const element of sectionElements($, "supported-models")) {
+    if (headingLevel(nodeTagName(element.get(0))) !== undefined) {
+      nativeSection = !collapseText(element).toLowerCase().includes("via mcp");
+      continue;
+    }
+    if (!nativeSection) continue;
+    const values = nodeTagName(element.get(0)) === "code" ? [collapseText(element)] : [];
+    element.find("code").each((_, code) => {
+      values.push(collapseText($(code)));
+    });
+    for (const value of values) {
+      const model = modelKey(value);
+      if (!model) continue;
+      models.add(model);
+      families.add(model.split("-", 1)[0]);
+    }
+  }
+  for (const model of responses) {
+    if (families.has(model.split("-", 1)[0])) models.add(model);
+  }
+  return [...models].sort();
+}
+
+function codeValuesAfterHeading($: CheerioAPI, headingId: string): string[] {
+  const values: string[] = [];
+  for (const element of sectionElements($, headingId)) {
+    if (nodeTagName(element.get(0)) === "code") values.push(collapseText(element));
+    element.find("code").each((_, code) => {
+      values.push(collapseText($(code)));
+    });
+  }
+  return values;
+}
+
+function sectionElements($: CheerioAPI, headingId: string): Selection[] {
+  const heading = $(`#${headingId}`).first();
+  if (heading.length === 0)
+    throw new Error(`Databricks capability page is missing section ${headingId}`);
+  const level = headingLevel(nodeTagName(heading.get(0)));
+  if (level === undefined)
+    throw new Error(`Databricks capability section ${headingId} is not a heading`);
+  const elements: Selection[] = [];
+  let sibling = heading.next();
+  while (sibling.length > 0) {
+    const siblingLevel = headingLevel(nodeTagName(sibling.get(0)));
+    if (siblingLevel !== undefined && siblingLevel <= level) break;
+    elements.push(sibling);
+    sibling = sibling.next();
+  }
+  return elements;
+}
+
+function headingLevel(name: string | undefined): number | undefined {
+  const match = /^h([1-6])$/.exec(name ?? "");
+  return match ? Number(match[1]) : undefined;
+}
+
+function collapseText(element: Selection): string {
+  return element.text().split(/\s+/).filter(Boolean).join(" ");
+}
+
+function nodeTagName(node: unknown): string | undefined {
+  if (!node || typeof node !== "object" || !("tagName" in node)) return undefined;
+  return typeof node.tagName === "string" ? node.tagName : undefined;
+}
+
+function modelKey(value: string | undefined): string | undefined {
+  if (!value) return undefined;
+  let name = value.trim().replace(/\*+$/, "").trim();
+  for (const suffix of ["(Public Preview)", "(Beta)", "(Preview)"]) {
+    if (name.endsWith(suffix)) name = name.slice(0, -suffix.length).trim();
+  }
+  return modelSearchQuery(name)?.replaceAll(" ", "-");
+}
+
+function number(value: string | undefined): number | null {
+  if (!value) return null;
+  const parsed = Number(value.replaceAll(",", "").trim());
+  return Number.isSafeInteger(parsed) && parsed >= 0 ? parsed : null;
+}
+
+function sortRecord<T>(record: Readonly<Record<string, T>>): Record<string, T> {
+  return Object.fromEntries(
+    Object.entries(record).sort(([left], [right]) => left.localeCompare(right)),
+  );
+}