@dbx-tools/model 0.9.5 → 0.9.7

package/README.md

@@ -103,12 +103,12 @@ class policy.
 ## Work With A Held Catalogue
 
 When you already have endpoint summaries, use the pure resolver functions from
-`resolve` and `serving` without another workspace call:
+`resolve` and `modelCatalog` without another workspace call:
 
 ```ts
-import { resolve, serving } from "@dbx-tools/model";
+import { modelCatalog, resolve } from "@dbx-tools/model";
 
-const endpoints = await serving.listServingEndpoints(client, host);
+const endpoints = await modelCatalog.listServingEndpoints(client, host);
 const ranked = resolve.lookupModels(endpoints, { search: "sonnet", limit: 3 });
 const picked = resolve.resolveModel(endpoints, {
   explicit: "claude sonnet",
@@ -124,14 +124,14 @@ when the requested class is `embedding`.
 ## List And Cache Serving Endpoints
 
 ```ts
-import { serving } from "@dbx-tools/model";
+import { modelCatalog } from "@dbx-tools/model";
 
-const endpoints = await serving.listServingEndpoints(client, host, {
+const endpoints = await modelCatalog.listServingEndpoints(client, host, {
   ttlMs: 5 * 60_000,
 });
 
-const raw = await serving.listServingEndpointsUncached(client);
-await serving.clearServingEndpointsCache(host);
+const raw = await modelCatalog.listServingEndpointsUncached(client);
+await modelCatalog.clearServingEndpointsCache(host);
 ```
 
 `listServingEndpoints()` uses AppKit's `CacheManager`, enriches endpoints with

package/index.ts

@@ -3,17 +3,17 @@
 // Hand edits are overwritten on the next watch; this file is read-only.
 
 export const PACKAGE_IDENTIFIER = "@dbx-tools/model";
-export const PACKAGE_VERSION = "0.9.5";
+export const PACKAGE_VERSION = "0.9.7";
 export * as classes from "./src/classes.ts";
 export * as fallback from "./src/fallback.ts";
 export * as invoke from "./src/invoke.ts";
+export * as modelCatalog from "./src/model-catalog.ts";
 export * as policy from "./src/policy.ts";
 export * as resolve from "./src/resolve.ts";
-export * as serving from "./src/serving.ts";
 export { CHAT_CLASS_ORDER, MODEL_CLASS_ORDER } from "./src/classes.ts";
 export { FALLBACK_MODEL_IDS } from "./src/fallback.ts";
 export { INVOCATIONS_SUFFIX, RESPONSES_PATH, OPEN_RESPONSES_PATH, CHAT_COMPLETIONS_PATH } from "./src/invoke.ts";
 export type { AuthenticatingClientLike } from "./src/invoke.ts";
+export { DEFAULT_MODEL_CACHE_TTL_MS, DEFAULT_FUZZY_THRESHOLD } from "./src/model-catalog.ts";
+export type { WorkspaceClientLike, ListServingEndpointsOptions, ResolvedModel, ResolveModelOptions, ScoredEndpoint } from "./src/model-catalog.ts";
 export type { ResolveModelInput, ResolvedModelSelection, SelectModelInput, SearchModelsInput } from "./src/resolve.ts";
-export { DEFAULT_MODEL_CACHE_TTL_MS, DEFAULT_FUZZY_THRESHOLD } from "./src/serving.ts";
-export type { WorkspaceClientLike, ListServingEndpointsOptions, ResolvedModel, ResolveModelOptions, ScoredEndpoint } from "./src/serving.ts";

package/lib/index.d.ts

@@ -1,15 +1,15 @@
 export declare const PACKAGE_IDENTIFIER = "@dbx-tools/model";
-export declare const PACKAGE_VERSION = "0.9.5";
+export declare const PACKAGE_VERSION = "0.9.7";
 export * as classes from "./src/classes.ts";
 export * as fallback from "./src/fallback.ts";
 export * as invoke from "./src/invoke.ts";
+export * as modelCatalog from "./src/model-catalog.ts";
 export * as policy from "./src/policy.ts";
 export * as resolve from "./src/resolve.ts";
-export * as serving from "./src/serving.ts";
 export { CHAT_CLASS_ORDER, MODEL_CLASS_ORDER } from "./src/classes.ts";
 export { FALLBACK_MODEL_IDS } from "./src/fallback.ts";
 export { INVOCATIONS_SUFFIX, RESPONSES_PATH, OPEN_RESPONSES_PATH, CHAT_COMPLETIONS_PATH } from "./src/invoke.ts";
 export type { AuthenticatingClientLike } from "./src/invoke.ts";
+export { DEFAULT_MODEL_CACHE_TTL_MS, DEFAULT_FUZZY_THRESHOLD } from "./src/model-catalog.ts";
+export type { WorkspaceClientLike, ListServingEndpointsOptions, ResolvedModel, ResolveModelOptions, ScoredEndpoint } from "./src/model-catalog.ts";
 export type { ResolveModelInput, ResolvedModelSelection, SelectModelInput, SearchModelsInput } from "./src/resolve.ts";
-export { DEFAULT_MODEL_CACHE_TTL_MS, DEFAULT_FUZZY_THRESHOLD } from "./src/serving.ts";
-export type { WorkspaceClientLike, ListServingEndpointsOptions, ResolvedModel, ResolveModelOptions, ScoredEndpoint } from "./src/serving.ts";

package/lib/index.js

@@ -2,15 +2,15 @@
 // Regenerated from the exporting modules in ./src.
 // Hand edits are overwritten on the next watch; this file is read-only.
 export const PACKAGE_IDENTIFIER = "@dbx-tools/model";
-export const PACKAGE_VERSION = "0.9.5";
+export const PACKAGE_VERSION = "0.9.7";
 export * as classes from "./src/classes.js";
 export * as fallback from "./src/fallback.js";
 export * as invoke from "./src/invoke.js";
+export * as modelCatalog from "./src/model-catalog.js";
 export * as policy from "./src/policy.js";
 export * as resolve from "./src/resolve.js";
-export * as serving from "./src/serving.js";
 export { CHAT_CLASS_ORDER, MODEL_CLASS_ORDER } from "./src/classes.js";
 export { FALLBACK_MODEL_IDS } from "./src/fallback.js";
 export { INVOCATIONS_SUFFIX, RESPONSES_PATH, OPEN_RESPONSES_PATH, CHAT_COMPLETIONS_PATH } from "./src/invoke.js";
-export { DEFAULT_MODEL_CACHE_TTL_MS, DEFAULT_FUZZY_THRESHOLD } from "./src/serving.js";
-//# sourceMappingURL=data:application/json;base64,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
+export { DEFAULT_MODEL_CACHE_TTL_MS, DEFAULT_FUZZY_THRESHOLD } from "./src/model-catalog.js";
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/_native.d.ts

@@ -0,0 +1,14 @@
+import { model, type ModelQuery, type RankedModel, type ServingEndpointSummary } from "@dbx-tools/shared-model";
+type ModelClass = model.ModelClass;
+interface NativeRankingOptions {
+    readonly includeDeprecated?: boolean;
+    readonly modelClass?: ModelClass;
+    readonly task?: string;
+}
+/** Rank public endpoint records through the Rust-owned model policy. */
+export declare function rankEndpoints(endpoints: readonly ServingEndpointSummary[], query?: ModelQuery, options?: NativeRankingOptions): RankedModel[];
+/** Classify chat and embedding endpoints through the Rust-owned policy. */
+export declare function classifyEndpointClasses(endpoints: readonly ServingEndpointSummary[]): ReadonlyMap<string, ModelClass>;
+/** Normalize serialized SDK endpoint records through the Rust-owned catalogue policy. */
+export declare function normalizeEndpoints(endpoints: readonly unknown[]): ServingEndpointSummary[];
+export {};

package/lib/src/_native.js

@@ -0,0 +1,124 @@
+import { ModelClass as NativeModelClass, ReasoningEffort as NativeReasoningEffort, normalizeServingEndpointsJson, rankModels as rankModelsWithRust, } from "@dbx-tools/model-rs";
+import { model, } from "@dbx-tools/shared-model";
+const MODEL_CLASS_TO_NATIVE = {
+    [model.ModelClass.ChatThinking]: NativeModelClass.ChatThinking,
+    [model.ModelClass.ChatBalanced]: NativeModelClass.ChatBalanced,
+    [model.ModelClass.ChatFast]: NativeModelClass.ChatFast,
+    [model.ModelClass.Embedding]: NativeModelClass.Embedding,
+};
+const REASONING_EFFORT_TO_NATIVE = {
+    none: NativeReasoningEffort.None,
+    minimal: NativeReasoningEffort.Minimal,
+    low: NativeReasoningEffort.Low,
+    medium: NativeReasoningEffort.Medium,
+    high: NativeReasoningEffort.High,
+    xhigh: NativeReasoningEffort.Xhigh,
+    max: NativeReasoningEffort.Max,
+};
+const REASONING_EFFORT_FROM_NATIVE = {
+    [NativeReasoningEffort.None]: "none",
+    [NativeReasoningEffort.Minimal]: "minimal",
+    [NativeReasoningEffort.Low]: "low",
+    [NativeReasoningEffort.Medium]: "medium",
+    [NativeReasoningEffort.High]: "high",
+    [NativeReasoningEffort.Xhigh]: "xhigh",
+    [NativeReasoningEffort.Max]: "max",
+};
+/** Rank public endpoint records through the Rust-owned model policy. */
+export function rankEndpoints(endpoints, query = {}, options = {}) {
+    const endpointsByName = new Map(endpoints.map((endpoint) => [endpoint.name, endpoint]));
+    return rankModelsWithRust(endpoints.map((endpoint) => toNativeEndpoint(endpoint, options)), toNativeQuery(query, options.includeDeprecated ?? false)).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: fromNativeClass(ranked.modelClass),
+            ...(ranked.score !== undefined ? { score: ranked.score } : {}),
+        };
+    });
+}
+/** Classify chat and embedding endpoints through the Rust-owned policy. */
+export function classifyEndpointClasses(endpoints) {
+    const chat = rankEndpoints(endpoints, {}, { includeDeprecated: true });
+    const embeddings = rankEndpoints(endpoints, { modelClass: model.ModelClass.Embedding }, { includeDeprecated: true });
+    return new Map([...chat, ...embeddings].map((ranked) => [ranked.endpoint.name, ranked.modelClass]));
+}
+/** Normalize serialized SDK endpoint records through the Rust-owned catalogue policy. */
+export function normalizeEndpoints(endpoints) {
+    return normalizeServingEndpointsJson(JSON.stringify({ endpoints })).map(fromNativeEndpoint);
+}
+function toNativeQuery(query, includeDeprecated) {
+    return {
+        search: query.search,
+        modelClass: query.modelClass === undefined ? undefined : MODEL_CLASS_TO_NATIVE[query.modelClass],
+        requiresTools: query.requiresTools,
+        includeDeprecated: includeDeprecated || undefined,
+        limit: query.limit,
+        threshold: query.threshold,
+    };
+}
+function toNativeEndpoint(endpoint, options) {
+    const modelClass = options.modelClass ?? endpoint.class;
+    return {
+        name: endpoint.name,
+        displayName: endpoint.displayName,
+        family: endpoint.family,
+        task: options.task ?? endpoint.task,
+        state: endpoint.state,
+        description: endpoint.description,
+        supportsTools: endpoint.supportsTools,
+        profile: endpoint.profile,
+        modelClass: modelClass === undefined ? undefined : MODEL_CLASS_TO_NATIVE[modelClass],
+        serviceNames: new Map(Object.entries(endpoint.serviceNames ?? {})),
+        modelServiceName: endpoint.modelServiceName,
+        reasoningEfforts: (endpoint.reasoningEfforts ?? []).map((effort) => {
+            const native = REASONING_EFFORT_TO_NATIVE[effort];
+            if (native === undefined)
+                throw new Error(`Unknown reasoning effort "${effort}"`);
+            return native;
+        }),
+        status: { deprecated: endpoint.status?.deprecated ?? false },
+        dimension: endpoint.dimension,
+    };
+}
+function fromNativeEndpoint(endpoint) {
+    return {
+        name: endpoint.name,
+        ...(endpoint.displayName !== undefined ? { displayName: endpoint.displayName } : {}),
+        ...(endpoint.family !== undefined ? { family: endpoint.family } : {}),
+        ...(endpoint.task !== undefined ? { task: endpoint.task } : {}),
+        ...(endpoint.state !== undefined ? { state: endpoint.state } : {}),
+        ...(endpoint.description !== undefined ? { description: endpoint.description } : {}),
+        ...(endpoint.supportsTools !== undefined ? { supportsTools: endpoint.supportsTools } : {}),
+        ...(endpoint.profile !== undefined ? { profile: endpoint.profile } : {}),
+        ...(endpoint.modelClass !== undefined ? { class: fromNativeClass(endpoint.modelClass) } : {}),
+        ...(endpoint.serviceNames.size > 0
+            ? { serviceNames: Object.fromEntries(endpoint.serviceNames) }
+            : {}),
+        ...(endpoint.modelServiceName !== undefined
+            ? { modelServiceName: endpoint.modelServiceName }
+            : {}),
+        ...(endpoint.reasoningEfforts.length > 0
+            ? {
+                reasoningEfforts: endpoint.reasoningEfforts.map((effort) => REASONING_EFFORT_FROM_NATIVE[effort]),
+            }
+            : {}),
+        status: { deprecated: endpoint.status.deprecated },
+        ...(endpoint.dimension !== undefined ? { dimension: endpoint.dimension } : {}),
+    };
+}
+function fromNativeClass(modelClass) {
+    switch (modelClass) {
+        case NativeModelClass.ChatThinking:
+            return model.ModelClass.ChatThinking;
+        case NativeModelClass.ChatBalanced:
+            return model.ModelClass.ChatBalanced;
+        case NativeModelClass.ChatFast:
+            return model.ModelClass.ChatFast;
+        case NativeModelClass.Embedding:
+            return model.ModelClass.Embedding;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"_native.js","sourceRoot":"","sources":["../../src/_native.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ModelClass as NativeModelClass,\n  ReasoningEffort as NativeReasoningEffort,\n  normalizeServingEndpointsJson,\n  rankModels as rankModelsWithRust,\n  type ModelQuery as NativeModelQuery,\n  type ServingEndpointSummary as NativeServingEndpointSummary,\n} from \"@dbx-tools/model-rs\";\nimport {\n  model,\n  type ModelQuery,\n  type RankedModel,\n  type ReasoningEffort,\n  type ServingEndpointSummary,\n} from \"@dbx-tools/shared-model\";\n\ntype ModelClass = model.ModelClass;\n\nconst MODEL_CLASS_TO_NATIVE: Readonly<Record<ModelClass, NativeModelClass>> = {\n  [model.ModelClass.ChatThinking]: NativeModelClass.ChatThinking,\n  [model.ModelClass.ChatBalanced]: NativeModelClass.ChatBalanced,\n  [model.ModelClass.ChatFast]: NativeModelClass.ChatFast,\n  [model.ModelClass.Embedding]: NativeModelClass.Embedding,\n};\n\nconst REASONING_EFFORT_TO_NATIVE: Readonly<Record<string, NativeReasoningEffort>> = {\n  none: NativeReasoningEffort.None,\n  minimal: NativeReasoningEffort.Minimal,\n  low: NativeReasoningEffort.Low,\n  medium: NativeReasoningEffort.Medium,\n  high: NativeReasoningEffort.High,\n  xhigh: NativeReasoningEffort.Xhigh,\n  max: NativeReasoningEffort.Max,\n};\n\nconst REASONING_EFFORT_FROM_NATIVE: Readonly<Record<NativeReasoningEffort, ReasoningEffort>> = {\n  [NativeReasoningEffort.None]: \"none\",\n  [NativeReasoningEffort.Minimal]: \"minimal\",\n  [NativeReasoningEffort.Low]: \"low\",\n  [NativeReasoningEffort.Medium]: \"medium\",\n  [NativeReasoningEffort.High]: \"high\",\n  [NativeReasoningEffort.Xhigh]: \"xhigh\",\n  [NativeReasoningEffort.Max]: \"max\",\n};\n\ninterface NativeRankingOptions {\n  readonly includeDeprecated?: boolean;\n  readonly modelClass?: ModelClass;\n  readonly task?: string;\n}\n\n/** Rank public endpoint records through the Rust-owned model policy. */\nexport function rankEndpoints(\n  endpoints: readonly ServingEndpointSummary[],\n  query: ModelQuery = {},\n  options: NativeRankingOptions = {},\n): RankedModel[] {\n  const endpointsByName = new Map(endpoints.map((endpoint) => [endpoint.name, endpoint]));\n  return rankModelsWithRust(\n    endpoints.map((endpoint) => toNativeEndpoint(endpoint, options)),\n    toNativeQuery(query, options.includeDeprecated ?? false),\n  ).map((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: fromNativeClass(ranked.modelClass),\n      ...(ranked.score !== undefined ? { score: ranked.score } : {}),\n    };\n  });\n}\n\n/** Classify chat and embedding endpoints through the Rust-owned policy. */\nexport function classifyEndpointClasses(\n  endpoints: readonly ServingEndpointSummary[],\n): ReadonlyMap<string, ModelClass> {\n  const chat = rankEndpoints(endpoints, {}, { includeDeprecated: true });\n  const embeddings = rankEndpoints(\n    endpoints,\n    { modelClass: model.ModelClass.Embedding },\n    { includeDeprecated: true },\n  );\n  return new Map(\n    [...chat, ...embeddings].map((ranked) => [ranked.endpoint.name, ranked.modelClass]),\n  );\n}\n\n/** Normalize serialized SDK endpoint records through the Rust-owned catalogue policy. */\nexport function normalizeEndpoints(endpoints: readonly unknown[]): ServingEndpointSummary[] {\n  return normalizeServingEndpointsJson(JSON.stringify({ endpoints })).map(fromNativeEndpoint);\n}\n\nfunction toNativeQuery(query: ModelQuery, includeDeprecated: boolean): NativeModelQuery {\n  return {\n    search: query.search,\n    modelClass:\n      query.modelClass === undefined ? undefined : MODEL_CLASS_TO_NATIVE[query.modelClass],\n    requiresTools: query.requiresTools,\n    includeDeprecated: includeDeprecated || undefined,\n    limit: query.limit,\n    threshold: query.threshold,\n  };\n}\n\nfunction toNativeEndpoint(\n  endpoint: ServingEndpointSummary,\n  options: NativeRankingOptions,\n): NativeServingEndpointSummary {\n  const modelClass = options.modelClass ?? endpoint.class;\n  return {\n    name: endpoint.name,\n    displayName: endpoint.displayName,\n    family: endpoint.family,\n    task: options.task ?? endpoint.task,\n    state: endpoint.state,\n    description: endpoint.description,\n    supportsTools: endpoint.supportsTools,\n    profile: endpoint.profile,\n    modelClass: modelClass === undefined ? undefined : MODEL_CLASS_TO_NATIVE[modelClass],\n    serviceNames: new Map(Object.entries(endpoint.serviceNames ?? {})),\n    modelServiceName: endpoint.modelServiceName,\n    reasoningEfforts: (endpoint.reasoningEfforts ?? []).map((effort) => {\n      const native = REASONING_EFFORT_TO_NATIVE[effort];\n      if (native === undefined) throw new Error(`Unknown reasoning effort \"${effort}\"`);\n      return native;\n    }),\n    status: { deprecated: endpoint.status?.deprecated ?? false },\n    dimension: endpoint.dimension,\n  };\n}\n\nfunction fromNativeEndpoint(endpoint: NativeServingEndpointSummary): ServingEndpointSummary {\n  return {\n    name: endpoint.name,\n    ...(endpoint.displayName !== undefined ? { displayName: endpoint.displayName } : {}),\n    ...(endpoint.family !== undefined ? { family: endpoint.family } : {}),\n    ...(endpoint.task !== undefined ? { task: endpoint.task } : {}),\n    ...(endpoint.state !== undefined ? { state: endpoint.state } : {}),\n    ...(endpoint.description !== undefined ? { description: endpoint.description } : {}),\n    ...(endpoint.supportsTools !== undefined ? { supportsTools: endpoint.supportsTools } : {}),\n    ...(endpoint.profile !== undefined ? { profile: endpoint.profile } : {}),\n    ...(endpoint.modelClass !== undefined ? { class: fromNativeClass(endpoint.modelClass) } : {}),\n    ...(endpoint.serviceNames.size > 0\n      ? { serviceNames: Object.fromEntries(endpoint.serviceNames) }\n      : {}),\n    ...(endpoint.modelServiceName !== undefined\n      ? { modelServiceName: endpoint.modelServiceName }\n      : {}),\n    ...(endpoint.reasoningEfforts.length > 0\n      ? {\n          reasoningEfforts: endpoint.reasoningEfforts.map(\n            (effort) => REASONING_EFFORT_FROM_NATIVE[effort],\n          ),\n        }\n      : {}),\n    status: { deprecated: endpoint.status.deprecated },\n    ...(endpoint.dimension !== undefined ? { dimension: endpoint.dimension } : {}),\n  };\n}\n\nfunction fromNativeClass(modelClass: NativeModelClass): ModelClass {\n  switch (modelClass) {\n    case NativeModelClass.ChatThinking:\n      return model.ModelClass.ChatThinking;\n    case NativeModelClass.ChatBalanced:\n      return model.ModelClass.ChatBalanced;\n    case NativeModelClass.ChatFast:\n      return model.ModelClass.ChatFast;\n    case NativeModelClass.Embedding:\n      return model.ModelClass.Embedding;\n  }\n}\n"]}

package/lib/src/classes.d.ts

@@ -11,7 +11,12 @@
  */
 import { model } from "@dbx-tools/shared-model";
 type ModelClass = model.ModelClass;
-declare const ModelClass: typeof model.ModelClass;
+declare const ModelClass: {
+    readonly ChatThinking: "chat-thinking";
+    readonly ChatBalanced: "chat-balanced";
+    readonly ChatFast: "chat-fast";
+    readonly Embedding: "embedding";
+};
 /**
  * Chat capability ladder in descending order - most capable
  * ({@link ModelClass.ChatThinking}) first, least ({@link ModelClass.ChatFast})

package/lib/src/fallback.d.ts

@@ -5,27 +5,30 @@
  * token, the service principal can't list, or the workspace is unreachable -
  * the resolver still has to name *some* endpoint. This module holds that floor:
  * a small, hard-coded set of well-known Foundation Model API endpoint names,
- * each bucketed into a chat {@link ModelClass} by the shared
- * {@link classify.classifyByFamily} heuristic (no classes are hard-coded here)
+ * each bucketed into a chat {@link ModelClass} by the Rust family policy
  * and ordered best-first.
  *
  * This is deliberately *server-only*. A browser client never talks to
  * Databricks directly - it always goes through this server - so it has nothing
  * to fall back to and must not assume a stale, baked-in model list; it consumes
- * the live `/models` response instead. The pure classifier
- * ({@link classify.classifyEndpoints}) is what the client shares.
+ * the classified live `/models` response instead.
  *
  * @module
  */
 import { model } from "@dbx-tools/shared-model";
 type ModelClass = model.ModelClass;
-declare const ModelClass: typeof model.ModelClass;
+declare const ModelClass: {
+    readonly ChatThinking: "chat-thinking";
+    readonly ChatBalanced: "chat-balanced";
+    readonly ChatFast: "chat-fast";
+    readonly Embedding: "embedding";
+};
 /**
  * Static fallback model ids for a chat class, drawn from the small built-in
  * {@link FALLBACK_MODEL_NAMES} list and ordered best-first by family rank. Sync
  * and workspace-independent: this is the *fallback opinion* used to seed default
  * lists or when the live catalogue is unreachable - live resolution prefers
- * {@link classify.classifyEndpoints}. Returns `[]` for
+ * the Rust-classified workspace catalogue. Returns `[]` for
  * {@link ModelClass.Embedding} (the floor is chat-only).
  */
 export declare function modelsForClass(cls: ModelClass): readonly string[];

package/lib/src/fallback.js

@@ -5,23 +5,22 @@
  * token, the service principal can't list, or the workspace is unreachable -
  * the resolver still has to name *some* endpoint. This module holds that floor:
  * a small, hard-coded set of well-known Foundation Model API endpoint names,
- * each bucketed into a chat {@link ModelClass} by the shared
- * {@link classify.classifyByFamily} heuristic (no classes are hard-coded here)
+ * each bucketed into a chat {@link ModelClass} by the Rust family policy
  * and ordered best-first.
  *
  * This is deliberately *server-only*. A browser client never talks to
  * Databricks directly - it always goes through this server - so it has nothing
  * to fall back to and must not assume a stale, baked-in model list; it consumes
- * the live `/models` response instead. The pure classifier
- * ({@link classify.classifyEndpoints}) is what the client shares.
+ * the classified live `/models` response instead.
  *
  * @module
  */
-import { classify, model } from "@dbx-tools/shared-model";
+import { model } from "@dbx-tools/shared-model";
+import { rankEndpoints } from "./_native.js";
 const { ModelClass } = model;
 /**
  * Small, last-resort set of well-known Foundation Model API endpoint names,
- * ordered best-first within each class by {@link classify.classifyByFamily}.
+ * ordered best-first within each class by the Rust model ranker.
  * Used only as the floor when the live `/serving-endpoints` catalogue can't be
  * read at resolve time; the live, score-driven classification supersedes it
  * whenever the workspace listing is available. Classes are not hard-coded here
@@ -38,19 +37,22 @@ const FALLBACK_MODEL_NAMES = [
     "databricks-gpt-5-nano",
     "databricks-meta-llama-3-1-8b-instruct",
 ];
+const FALLBACK_ENDPOINTS = FALLBACK_MODEL_NAMES.map((name) => ({
+    name,
+    task: "llm/v1/chat",
+}));
 /**
  * Static fallback model ids for a chat class, drawn from the small built-in
  * {@link FALLBACK_MODEL_NAMES} list and ordered best-first by family rank. Sync
  * and workspace-independent: this is the *fallback opinion* used to seed default
  * lists or when the live catalogue is unreachable - live resolution prefers
- * {@link classify.classifyEndpoints}. Returns `[]` for
+ * the Rust-classified workspace catalogue. Returns `[]` for
  * {@link ModelClass.Embedding} (the floor is chat-only).
  */
 export function modelsForClass(cls) {
-    return FALLBACK_MODEL_NAMES.map((name) => ({ name, c: classify.classifyByFamily(name) }))
-        .filter((x) => x.c !== null && x.c.class === cls)
-        .sort((a, b) => b.c.rank - a.c.rank)
-        .map((x) => x.name);
+    return rankEndpoints(FALLBACK_ENDPOINTS, { modelClass: cls })
+        .filter((ranked) => ranked.modelClass === cls)
+        .map((ranked) => ranked.endpoint.name);
 }
 /** Top static fallback model id for a chat class. */
 export function modelForClass(cls) {
@@ -66,4 +68,4 @@ export const FALLBACK_MODEL_IDS = [
     ...modelsForClass(ModelClass.ChatBalanced),
     ...modelsForClass(ModelClass.ChatFast),
 ];
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/{serving.d.ts → model-catalog.d.ts}

@@ -1,15 +1,15 @@
 /**
  * Live Databricks Model Serving catalogue access.
  *
- * Lists the workspace's `/serving-endpoints` once per host and caches the
- * result with a TTL via AppKit's `CacheManager`, with concurrent callers
- * sharing one in-flight promise (the coalescing pattern of Python's
- * `cachetools-async`). Surfaces each endpoint as a stable
+ * 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 `fuse.js` extended search so tokens like `"claude sonnet"` resolve to
+ * 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:
@@ -30,7 +30,7 @@ import { type ServingEndpointSummary } from "@dbx-tools/shared-model";
 export type WorkspaceClientLike = Pick<appkit.WorkspaceClientLike, "servingEndpoints">;
 /** Default TTL for the in-memory endpoint cache. Matches the Databricks SDK's session lifetime budget. */
 export declare const DEFAULT_MODEL_CACHE_TTL_MS: number;
-/** Default Fuse.js score threshold below which a fuzzy match is accepted. */
+/** Default Rust distance threshold below which a fuzzy match is accepted. */
 export declare const DEFAULT_FUZZY_THRESHOLD = 0.4;
 /** Options for {@link listServingEndpoints}. */
 export interface ListServingEndpointsOptions {
@@ -39,6 +39,15 @@ export interface ListServingEndpointsOptions {
      * `CacheManager` as seconds.
      */
     ttlMs?: number;
+    /**
+     * Trusted identity of the credential used by `client`.
+     *
+     * The value is hashed before it enters the cache key and is never logged.
+     * Omit it when the caller cannot prove the credential identity; that call
+     * bypasses shared caching so one principal can never read another's
+     * catalogue.
+     */
+    cacheIdentity?: string;
 }
 /**
  * List Model Serving endpoints for the workspace owning `client`, routed
@@ -73,16 +82,15 @@ export declare function listServingEndpoints(client: WorkspaceClientLike, host:
  */
 export declare function listServingEndpointsUncached(client: WorkspaceClientLike): Promise<ServingEndpointSummary[]>;
 /**
- * Force-evict cached endpoint listings via AppKit's `CacheManager`. With a
- * `host` deletes that one workspace's entry; without one clears every cache
- * entry on the manager (since `CacheManager` doesn't expose a namespace-scoped
- * clear, this is the brute-force path - fine for tests, avoid in steady-state
- * code).
+ * 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 declare function clearServingEndpointsCache(host?: string): Promise<void>;
+export declare function clearServingEndpointsCache(host?: string, cacheIdentity?: string): Promise<void>;
 /**
  * Result of fuzzy-resolving a user-supplied model name against the live
- * endpoint list. `score` is Fuse.js's distance (`0` is exact, `1` is no match);
+ * endpoint list. `score` is the Rust ranker's distance (`0` is exact, `1` is no match);
  * `matched` is `false` when the score exceeds the configured threshold so
  * callers can fall back to the original input (Databricks will then return a
  * clean 404).
@@ -94,7 +102,7 @@ export interface ResolvedModel {
 }
 /** Options accepted by {@link resolveModelId} / {@link searchServingEndpoints}. */
 export interface ResolveModelOptions {
-    /** Fuse.js threshold (0 = exact, 1 = anything). Default `0.4`. */
+    /** Fuzzy distance threshold (0 = exact, 1 = anything). Default `0.4`. */
     threshold?: number;
     /** Require a model verified for a complete function-tool round-trip. */
     requiresTools?: boolean;
@@ -102,7 +110,7 @@ export interface ResolveModelOptions {
 /** A serving endpoint paired with its fuzzy-match distance for a query. */
 export interface ScoredEndpoint {
     endpoint: ServingEndpointSummary;
-    /** Fuse.js distance: `0` is exact, `1` is no match. */
+    /** Fuzzy distance: `0` is exact, `1` is no match. */
     score: number;
 }
 /**
@@ -110,11 +118,8 @@ export interface ScoredEndpoint {
  * (lowest score) first, keeping only those within `threshold`:
  *
  * 1. An exact name match short-circuits to a single `score: 0` result.
- * 2. Otherwise the input is tokenized (dashes / underscores / spaces become
- *    separators) and fed through Fuse.js extended search, which AND-s each
- *    token with fuzzy matching enabled - the "tokenized fuzzy match" a caller
- *    reaches for when they type `"claude sonnet"` instead of the full endpoint
- *    name.
+ * 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.