@dbx-tools/model 0.9.19 → 0.9.28

package/src/resolve.ts

@@ -1,165 +1,41 @@
 /**
- * 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`.
+ * Workspace-aware model selection wrappers.
  *
  * @module
  */
+import type { ModelQuery, RankedModel, ServingEndpointSummary } from "@dbx-tools/shared-model";
 
-import { object } from "@dbx-tools/shared-core";
 import {
-  model,
-  type ModelQuery,
-  type RankedModel,
-  type ServingEndpointSummary,
-} from "@dbx-tools/shared-model";
-
-import { rankEndpoints } from "./_native.ts";
-import { FALLBACK_MODEL_IDS, modelsForClass } from "./fallback.ts";
+  lookupModels,
+  rankModelId,
+  type ResolveModelInput,
+  type ResolvedModelSelection,
+  resolveModel,
+} from "./_selection.ts";
 import {
   listServingEndpoints,
+  type ListServingEndpointsOptions,
   type ResolvedModel,
   type ResolveModelOptions,
   type WorkspaceClientLike,
 } from "./model-catalog.ts";
-import { endpointSupportsTools } from "./policy.ts";
-
-type ModelClass = model.ModelClass;
 
-/** Preferred live family for an unconfigured general-purpose chat default. */
-const DEFAULT_MODEL_FAMILY_SEARCH = "gpt";
-
-/** Caller intent passed to {@link resolveModel}. */
-export interface ResolveModelInput {
-  /**
-   * Explicit model id / loose name (per-request override, agent / plugin
-   * default, or env var). When set it wins over `modelClass` and `fallbacks`.
-   */
-  explicit?: string;
-  /**
-   * Fuzzy-match an `explicit` name against the live catalogue so loose names
-   * like `"claude sonnet"` resolve. Default `true`. When `false` the explicit
-   * input is returned verbatim (Databricks surfaces the canonical 404 if it
-   * doesn't exist).
-   */
-  fuzzy?: boolean;
-  /** Rust fuzzy-distance threshold forwarded to the search match. */
-  threshold?: number;
-  /** Require a model that supports a complete function-tool round-trip. */
-  requiresTools?: boolean;
-  /**
-   * Chat capability class to resolve when no `explicit` id is given. The live
-   * catalogue is classified by its Foundation Model API scores and the top
-   * available model in the class (and the chat bands below it) wins, falling
-   * back to the class's small static list.
-   */
-  modelClass?: ModelClass;
-  /**
-   * Operator-supplied fallback ids tried *first* in the no-explicit, no-class
-   * path (e.g. a regulated workspace pinned to an approved subset), ahead of
-   * the auto-classified catalogue.
-   */
-  fallbacks?: readonly string[];
-  /**
-   * Refuse the static offline floor when the live catalogue has no match.
-   * Use for unpinned defaults that must always name a currently available
-   * endpoint.
-   */
-  liveOnly?: boolean;
-}
-
-/** Outcome of {@link resolveModel}: the chosen id plus how it was reached. */
-export interface ResolvedModelSelection {
-  modelId: string;
-  source: "explicit" | "fuzzy-match" | "class" | "fallback";
-}
+export { lookupModels, rankModelId, resolveModel } from "./_selection.ts";
+export type { ResolveModelInput, ResolvedModelSelection } from "./_selection.ts";
 
-/** Intent + catalogue knobs passed to {@link selectModel}. */
+/** Intent plus catalogue cache controls passed to {@link selectModel}. */
 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}. */
+/** Query plus catalogue cache controls passed to {@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.
- *
- * Rust owns classification, fuzzy scoring, family-version ordering, preferred
- * variants, class ceilings, tool filtering, and result limiting. Node retains
- * the caller's endpoint objects so fields outside the ranking contract remain
- * available unchanged.
- */
-export function lookupModels(
-  endpoints: readonly ServingEndpointSummary[],
-  query: ModelQuery = {},
-): RankedModel[] {
-  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: readonly ServingEndpointSummary[],
-  search: string,
-  options: ResolveModelOptions = {},
-): ResolvedModel {
-  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.
- */
+/** Resolve against a potentially stale catalogue, refreshing once on a miss. */
 export async function rankModelIdLive(
   load: (force: boolean) => Promise<readonly ServingEndpointSummary[]>,
   search: string,
@@ -170,42 +46,17 @@ export async function rankModelIdLive(
   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: WorkspaceClientLike,
   host: string,
   input: SearchModelsInput = {},
 ): Promise<RankedModel[]> {
-  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: WorkspaceClientLike,
   host: string,
@@ -214,113 +65,16 @@ export async function selectModel(
   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: readonly ServingEndpointSummary[],
-  input: ResolveModelInput = {},
-): ResolvedModelSelection {
-  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: ResolveModelInput, search: string | undefined): ModelQuery {
+function catalogueOptions(input: {
+  readonly ttlMs?: number;
+  readonly cacheIdentity?: string;
+}): ListServingEndpointsOptions {
   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: readonly ServingEndpointSummary[], modelId: string): void {
-  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: readonly string[],
-  endpoints: readonly ServingEndpointSummary[],
-): string {
-  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]!;
-}

package/lib/src/_native.d.ts

@@ -1,14 +0,0 @@
-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

@@ -1,124 +0,0 @@
-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"]}