@dbx-tools/shared-model 0.3.43 → 0.4.0

package/lib/index.d.ts

@@ -0,0 +1,14 @@
+export * as classify from "./src/classify.js";
+export * as display from "./src/display.js";
+export * as model from "./src/model.js";
+export * as openaiChat from "./src/openai-chat.js";
+export * as openaiResponses from "./src/openai-responses.js";
+export { endpointCapabilities, versionTuple, classifyByFamily, classifyEndpoints } from "./src/classify.js";
+export type { EndpointCapabilities, FamilyClass } from "./src/classify.js";
+export { toModelDisplayName } from "./src/display.js";
+export { ModelClass, ModelClassSchema, ModelProfileSchema, ServingEndpointSummarySchema, ModelQuerySchema, RankedModelSchema } from "./src/model.js";
+export type { ModelProfile, ServingEndpointSummary, ModelQuery, RankedModel } from "./src/model.js";
+export { UNSUPPORTED_CHAT_FIELDS, stripUnsupportedChatFields, chatContentToText } from "./src/openai-chat.js";
+export type { ChatRole, ChatContentPart, ChatToolCallFunction, ChatToolCall, ChatMessage, ChatContentToTextOptions } from "./src/openai-chat.js";
+export { responsesToChat, chatToResponsesRequest, chatToResponse, responseToChatCompletion, createResponsesStreamTranslator, readResponsesOutput, sanitizeResponsesTools, REASONING_TYPES, sanitizeOpenResponsesInput, sanitizeOpenResponsesRequest } from "./src/openai-responses.js";
+export type { ResponsesStreamTranslator, ResponsesCitation, ResponsesOutput } from "./src/openai-responses.js";

package/lib/index.js

@@ -0,0 +1,14 @@
+// GENERATED by projen watch - DO NOT EDIT.
+// Regenerated from the exporting modules in ./src.
+// Hand edits are overwritten on the next watch; this file is read-only.
+export * as classify from "./src/classify.js";
+export * as display from "./src/display.js";
+export * as model from "./src/model.js";
+export * as openaiChat from "./src/openai-chat.js";
+export * as openaiResponses from "./src/openai-responses.js";
+export { endpointCapabilities, versionTuple, classifyByFamily, classifyEndpoints } from "./src/classify.js";
+export { toModelDisplayName } from "./src/display.js";
+export { ModelClass, ModelClassSchema, ModelProfileSchema, ServingEndpointSummarySchema, ModelQuerySchema, RankedModelSchema } from "./src/model.js";
+export { UNSUPPORTED_CHAT_FIELDS, stripUnsupportedChatFields, chatContentToText } from "./src/openai-chat.js";
+export { responsesToChat, chatToResponsesRequest, chatToResponse, responseToChatCompletion, createResponsesStreamTranslator, readResponsesOutput, sanitizeResponsesTools, REASONING_TYPES, sanitizeOpenResponsesInput, sanitizeOpenResponsesRequest } from "./src/openai-responses.js";
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/classify.d.ts

@@ -0,0 +1,111 @@
+/**
+ * Model-class classification for Databricks Model Serving endpoints.
+ *
+ * Chat capability bands are derived from the live workspace catalogue
+ * rather than a hand-maintained table. Databricks publishes
+ * per-endpoint `quality` / `speed` / `cost` scores (the AI Playground
+ * bars) on the serving list; {@link classifyEndpoints} buckets scored
+ * chat models into the chat {@link ModelClass} bands by the *relative*
+ * distribution of those scores (quantiles, not fixed cut-offs) so a
+ * brand-new model that lands outside today's score range still slots in
+ * next to its peers. Embedding endpoints (`task === "llm/v1/embeddings"`)
+ * are bucketed into {@link ModelClass.Embedding} by task, independent of
+ * any score.
+ *
+ * Unscored-but-recognizable chat endpoints are still placed by a small
+ * family heuristic ({@link classifyByFamily}) so a workspace whose
+ * models predate Foundation Model API scoring keeps working. The
+ * offline fallback floor - the hard-coded model list reached for when
+ * the live catalogue can't be read at all - is a server concern and
+ * lives in `@dbx-tools/model`, not here: a browser client never talks
+ * to Databricks directly, so it has nothing to fall back to.
+ *
+ * Pure (no Node-only imports), so a client can classify a `/models`
+ * response without server dependencies.
+ *
+ * @module
+ */
+import { ModelClass, type ServingEndpointSummary } from "./model.js";
+/** What an endpoint can be asked to do, as derived by {@link endpointCapabilities}. */
+export interface EndpointCapabilities {
+    /** OpenAI chat/completions + Responses: the surface a chat agent needs. */
+    chat: boolean;
+    /** Embedding (vector) endpoint. */
+    embedding: boolean;
+    /** Function / tool calling. Every chat endpoint on Databricks supports it. */
+    tools: boolean;
+}
+/**
+ * Derive an endpoint's capabilities from its Databricks task hint and its
+ * classified {@link ModelClass}, so consumers filter on capability instead of
+ * re-deriving it from raw `task` / `class` strings.
+ *
+ * Either signal alone is enough: the task hint is authoritative when present,
+ * and the class covers endpoints Databricks left untasked but the classifier
+ * recognized. Embedding wins over chat when both point at it, since the two are
+ * not interchangeable.
+ */
+export declare function endpointCapabilities(endpoint: ServingEndpointSummary): EndpointCapabilities;
+/** Family-heuristic classification of a single endpoint name. */
+export interface FamilyClass {
+    /** Chat capability band the family maps to (never embedding). */
+    class: ModelClass;
+    /** Intra-family ordering hint (higher is newer / more capable). */
+    rank: number;
+}
+/**
+ * Numeric `[major, minor, patch]` version parsed from an endpoint
+ * name, used to order siblings within a family/tier. Starts at the
+ * first digit in the name, then reads successive separator-delimited,
+ * digit-prefixed chunks as the three components (missing ones default
+ * to `0`):
+ *
+ *   - `databricks-claude-opus-4-8`   -> `[4, 8, 0]`
+ *   - `databricks-claude-opus-4-10`  -> `[4, 10, 0]` (sorts above 4-8)
+ *   - `databricks-meta-llama-3-3-70b`-> `[3, 3, 70]`
+ *   - `databricks-bge-large-en`      -> `[0, 0, 0]` (no digits)
+ *
+ * Component-wise comparison (not a decimal collapse) so `4.10` beats
+ * `4.8` - the bug a `major + minor/10` score would hit.
+ */
+export declare function versionTuple(name: string): [number, number, number];
+/**
+ * Best-effort chat capability band for an endpoint we have no live
+ * score for, keyed off provider family and the well-known variant words
+ * in the name (`opus`/`sonnet`/`haiku`, `pro`/`mini`/`nano`,
+ * `flash`/`flash-lite`, Llama parameter sizes, etc). Returns `null` for
+ * names we don't recognize so unknown custom endpoints are never
+ * auto-selected as a default. The accompanying `rank` orders siblings
+ * within a class. Only ever returns a chat band - embedding endpoints
+ * are classified by task, not name.
+ */
+export declare function classifyByFamily(name: string): FamilyClass | null;
+/**
+ * Bucket live endpoints into {@link ModelClass}es, ranked best-first
+ * within each chat band.
+ *
+ * Embedding endpoints (`task === "llm/v1/embeddings"`) go into
+ * {@link ModelClass.Embedding} by task, in listing order (they carry no
+ * capability score to rank on).
+ *
+ * Chat endpoints (`task === "llm/v1/chat"`) split into the three chat
+ * bands. Scored endpoints (those carrying a `profile.quality`) drive
+ * the banding: the observed quality distribution is split at its 1/3
+ * and 2/3 quantiles, so the top third is {@link ModelClass.ChatThinking},
+ * the bottom third {@link ModelClass.ChatFast}, and the middle
+ * {@link ModelClass.ChatBalanced}. Because the thresholds come from the
+ * data, the split adapts as Databricks adds or rescores models -
+ * nothing is pinned to a fixed score band.
+ *
+ * Unscored chat endpoints are placed by {@link classifyByFamily} and
+ * ranked after the scored ones in their band; unrecognized, unscored
+ * endpoints (e.g. custom external models) are omitted entirely so they
+ * are never picked as an automatic default.
+ *
+ * Within a chat band, scored models sort by `quality` desc, then `cost`
+ * asc, then `speed` desc, then parsed name version desc; family-only
+ * models sort by version rank then parsed version. The version
+ * tie-break ({@link versionTuple}) is what separates point releases
+ * that share a score profile (e.g. `opus-4-8` ahead of `opus-4-7`).
+ */
+export declare function classifyEndpoints(endpoints: readonly ServingEndpointSummary[]): Record<ModelClass, ServingEndpointSummary[]>;

package/lib/src/classify.js

@@ -0,0 +1,261 @@
+/**
+ * Model-class classification for Databricks Model Serving endpoints.
+ *
+ * Chat capability bands are derived from the live workspace catalogue
+ * rather than a hand-maintained table. Databricks publishes
+ * per-endpoint `quality` / `speed` / `cost` scores (the AI Playground
+ * bars) on the serving list; {@link classifyEndpoints} buckets scored
+ * chat models into the chat {@link ModelClass} bands by the *relative*
+ * distribution of those scores (quantiles, not fixed cut-offs) so a
+ * brand-new model that lands outside today's score range still slots in
+ * next to its peers. Embedding endpoints (`task === "llm/v1/embeddings"`)
+ * are bucketed into {@link ModelClass.Embedding} by task, independent of
+ * any score.
+ *
+ * Unscored-but-recognizable chat endpoints are still placed by a small
+ * family heuristic ({@link classifyByFamily}) so a workspace whose
+ * models predate Foundation Model API scoring keeps working. The
+ * offline fallback floor - the hard-coded model list reached for when
+ * the live catalogue can't be read at all - is a server concern and
+ * lives in `@dbx-tools/model`, not here: a browser client never talks
+ * to Databricks directly, so it has nothing to fall back to.
+ *
+ * Pure (no Node-only imports), so a client can classify a `/models`
+ * response without server dependencies.
+ *
+ * @module
+ */
+import { ModelClass } from "./model.js";
+/** Task hint Databricks stamps on chat completion endpoints. */
+const CHAT_TASK = "llm/v1/chat";
+/** Task hint Databricks stamps on embedding endpoints. */
+const EMBEDDING_TASK = "llm/v1/embeddings";
+/**
+ * Derive an endpoint's capabilities from its Databricks task hint and its
+ * classified {@link ModelClass}, so consumers filter on capability instead of
+ * re-deriving it from raw `task` / `class` strings.
+ *
+ * Either signal alone is enough: the task hint is authoritative when present,
+ * and the class covers endpoints Databricks left untasked but the classifier
+ * recognized. Embedding wins over chat when both point at it, since the two are
+ * not interchangeable.
+ */
+export function endpointCapabilities(endpoint) {
+    const embedding = endpoint.task === EMBEDDING_TASK || endpoint.class === ModelClass.Embedding;
+    // Every non-embedding class is a chat band, so "classified but not embedding"
+    // is the class-side test for chat capability.
+    const chat = !embedding && (endpoint.task === CHAT_TASK || endpoint.class !== undefined);
+    return { chat, embedding, tools: chat };
+}
+/**
+ * Numeric `[major, minor, patch]` version parsed from an endpoint
+ * name, used to order siblings within a family/tier. Starts at the
+ * first digit in the name, then reads successive separator-delimited,
+ * digit-prefixed chunks as the three components (missing ones default
+ * to `0`):
+ *
+ *   - `databricks-claude-opus-4-8`   -> `[4, 8, 0]`
+ *   - `databricks-claude-opus-4-10`  -> `[4, 10, 0]` (sorts above 4-8)
+ *   - `databricks-meta-llama-3-3-70b`-> `[3, 3, 70]`
+ *   - `databricks-bge-large-en`      -> `[0, 0, 0]` (no digits)
+ *
+ * Component-wise comparison (not a decimal collapse) so `4.10` beats
+ * `4.8` - the bug a `major + minor/10` score would hit.
+ */
+export function versionTuple(name) {
+    const start = name.search(/\d/);
+    if (start < 0)
+        return [0, 0, 0];
+    const nums = name
+        .slice(start)
+        .split(/[^a-z0-9]+/i)
+        .map((chunk) => chunk.match(/^\d+/)?.[0])
+        .filter((digits) => digits !== undefined)
+        .map(Number);
+    return [nums[0] ?? 0, nums[1] ?? 0, nums[2] ?? 0];
+}
+/** Compare two version tuples so the higher version sorts first (descending). */
+function compareVersionDesc(a, b) {
+    for (let i = 0; i < 3; i++) {
+        const diff = (b[i] ?? 0) - (a[i] ?? 0);
+        if (diff !== 0)
+            return diff;
+    }
+    return 0;
+}
+/**
+ * Monotonic version key for ordering siblings within a family/tier
+ * (e.g. `opus-4-8` over `opus-4-7`). Encodes the {@link versionTuple}
+ * as a single number so callers that need a scalar rank (the family
+ * heuristic, the static fallback ordering) keep working; the encoding
+ * preserves component order without the decimal-collapse bug.
+ */
+function versionScore(name) {
+    const [major, minor, patch] = versionTuple(name);
+    return major * 1_000_000 + minor * 1_000 + patch;
+}
+/**
+ * Best-effort chat capability band for an endpoint we have no live
+ * score for, keyed off provider family and the well-known variant words
+ * in the name (`opus`/`sonnet`/`haiku`, `pro`/`mini`/`nano`,
+ * `flash`/`flash-lite`, Llama parameter sizes, etc). Returns `null` for
+ * names we don't recognize so unknown custom endpoints are never
+ * auto-selected as a default. The accompanying `rank` orders siblings
+ * within a class. Only ever returns a chat band - embedding endpoints
+ * are classified by task, not name.
+ */
+export function classifyByFamily(name) {
+    const n = name.toLowerCase();
+    const at = (cls) => ({ class: cls, rank: versionScore(n) });
+    // Anthropic Claude
+    if (n.includes("opus"))
+        return at(ModelClass.ChatThinking);
+    if (n.includes("sonnet"))
+        return at(ModelClass.ChatBalanced);
+    if (n.includes("haiku"))
+        return at(ModelClass.ChatFast);
+    // OpenAI open-weights (check before the generic gpt branch)
+    if (n.includes("gpt-oss")) {
+        return at(n.includes("120b") ? ModelClass.ChatBalanced : ModelClass.ChatFast);
+    }
+    // OpenAI GPT family
+    if (n.includes("gpt")) {
+        if (n.includes("pro"))
+            return at(ModelClass.ChatThinking);
+        if (n.includes("mini") || n.includes("nano"))
+            return at(ModelClass.ChatFast);
+        return at(ModelClass.ChatBalanced);
+    }
+    // Google Gemini / Gemma
+    if (n.includes("gemini")) {
+        if (n.includes("flash-lite"))
+            return at(ModelClass.ChatFast);
+        if (n.includes("pro"))
+            return at(ModelClass.ChatThinking);
+        return at(ModelClass.ChatBalanced);
+    }
+    if (n.includes("gemma"))
+        return at(ModelClass.ChatFast);
+    // Meta Llama
+    if (n.includes("llama")) {
+        if (n.includes("maverick") || n.includes("405b"))
+            return at(ModelClass.ChatThinking);
+        if (n.includes("70b"))
+            return at(ModelClass.ChatBalanced);
+        if (n.includes("8b") || n.includes("1b"))
+            return at(ModelClass.ChatFast);
+        return at(ModelClass.ChatBalanced);
+    }
+    // Alibaba Qwen
+    if (n.includes("qwen"))
+        return at(ModelClass.ChatBalanced);
+    return null;
+}
+/** Linear-interpolated quantile of an ascending-sorted numeric array. */
+function quantile(sortedAsc, p) {
+    if (sortedAsc.length === 0)
+        return Number.NaN;
+    const idx = (sortedAsc.length - 1) * p;
+    const lo = Math.floor(idx);
+    const hi = Math.ceil(idx);
+    if (lo === hi)
+        return sortedAsc[lo];
+    return sortedAsc[lo] + (sortedAsc[hi] - sortedAsc[lo]) * (idx - lo);
+}
+function rankOrder(a, b) {
+    if (a.scored !== b.scored)
+        return a.scored ? -1 : 1;
+    if (b.sort !== a.sort)
+        return b.sort - a.sort;
+    if (a.tieCost !== b.tieCost)
+        return a.tieCost - b.tieCost;
+    if (b.tieSpeed !== a.tieSpeed)
+        return b.tieSpeed - a.tieSpeed;
+    // Same scored-ness, quality, cost, and speed (e.g. several Claude
+    // Opus point releases): prefer the newer parsed version so
+    // `opus-4-8` beats `opus-4-7`.
+    return compareVersionDesc(a.version, b.version);
+}
+/**
+ * Bucket live endpoints into {@link ModelClass}es, ranked best-first
+ * within each chat band.
+ *
+ * Embedding endpoints (`task === "llm/v1/embeddings"`) go into
+ * {@link ModelClass.Embedding} by task, in listing order (they carry no
+ * capability score to rank on).
+ *
+ * Chat endpoints (`task === "llm/v1/chat"`) split into the three chat
+ * bands. Scored endpoints (those carrying a `profile.quality`) drive
+ * the banding: the observed quality distribution is split at its 1/3
+ * and 2/3 quantiles, so the top third is {@link ModelClass.ChatThinking},
+ * the bottom third {@link ModelClass.ChatFast}, and the middle
+ * {@link ModelClass.ChatBalanced}. Because the thresholds come from the
+ * data, the split adapts as Databricks adds or rescores models -
+ * nothing is pinned to a fixed score band.
+ *
+ * Unscored chat endpoints are placed by {@link classifyByFamily} and
+ * ranked after the scored ones in their band; unrecognized, unscored
+ * endpoints (e.g. custom external models) are omitted entirely so they
+ * are never picked as an automatic default.
+ *
+ * Within a chat band, scored models sort by `quality` desc, then `cost`
+ * asc, then `speed` desc, then parsed name version desc; family-only
+ * models sort by version rank then parsed version. The version
+ * tie-break ({@link versionTuple}) is what separates point releases
+ * that share a score profile (e.g. `opus-4-8` ahead of `opus-4-7`).
+ */
+export function classifyEndpoints(endpoints) {
+    const chat = endpoints.filter((e) => e.task === CHAT_TASK);
+    const qualities = chat
+        .map((e) => e.profile?.quality)
+        .filter((q) => Number.isFinite(q))
+        .sort((a, b) => a - b);
+    const low = quantile(qualities, 1 / 3);
+    const high = quantile(qualities, 2 / 3);
+    const buckets = {
+        [ModelClass.ChatThinking]: [],
+        [ModelClass.ChatBalanced]: [],
+        [ModelClass.ChatFast]: [],
+        [ModelClass.Embedding]: [],
+    };
+    for (const ep of chat) {
+        const q = ep.profile?.quality;
+        if (Number.isFinite(q)) {
+            const quality = q;
+            const cls = quality >= high
+                ? ModelClass.ChatThinking
+                : quality <= low
+                    ? ModelClass.ChatFast
+                    : ModelClass.ChatBalanced;
+            buckets[cls].push({
+                ep,
+                sort: quality,
+                scored: true,
+                tieCost: ep.profile?.cost ?? Number.POSITIVE_INFINITY,
+                tieSpeed: ep.profile?.speed ?? 0,
+                version: versionTuple(ep.name),
+            });
+            continue;
+        }
+        const family = classifyByFamily(ep.name);
+        if (!family)
+            continue;
+        buckets[family.class].push({
+            ep,
+            sort: family.rank,
+            scored: false,
+            tieCost: Number.POSITIVE_INFINITY,
+            tieSpeed: 0,
+            version: versionTuple(ep.name),
+        });
+    }
+    // Embeddings are bucketed by task in listing order - no score to rank.
+    const embeddings = endpoints.filter((e) => e.task === EMBEDDING_TASK);
+    return {
+        [ModelClass.ChatThinking]: buckets[ModelClass.ChatThinking].sort(rankOrder).map((x) => x.ep),
+        [ModelClass.ChatBalanced]: buckets[ModelClass.ChatBalanced].sort(rankOrder).map((x) => x.ep),
+        [ModelClass.ChatFast]: buckets[ModelClass.ChatFast].sort(rankOrder).map((x) => x.ep),
+        [ModelClass.Embedding]: embeddings,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classify.js","sourceRoot":"","sources":["../../src/classify.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Model-class classification for Databricks Model Serving endpoints.\n *\n * Chat capability bands are derived from the live workspace catalogue\n * rather than a hand-maintained table. Databricks publishes\n * per-endpoint `quality` / `speed` / `cost` scores (the AI Playground\n * bars) on the serving list; {@link classifyEndpoints} buckets scored\n * chat models into the chat {@link ModelClass} bands by the *relative*\n * distribution of those scores (quantiles, not fixed cut-offs) so a\n * brand-new model that lands outside today's score range still slots in\n * next to its peers. Embedding endpoints (`task === \"llm/v1/embeddings\"`)\n * are bucketed into {@link ModelClass.Embedding} by task, independent of\n * any score.\n *\n * Unscored-but-recognizable chat endpoints are still placed by a small\n * family heuristic ({@link classifyByFamily}) so a workspace whose\n * models predate Foundation Model API scoring keeps working. The\n * offline fallback floor - the hard-coded model list reached for when\n * the live catalogue can't be read at all - is a server concern and\n * lives in `@dbx-tools/model`, not here: a browser client never talks\n * to Databricks directly, so it has nothing to fall back to.\n *\n * Pure (no Node-only imports), so a client can classify a `/models`\n * response without server dependencies.\n *\n * @module\n */\n\nimport { ModelClass, type ServingEndpointSummary } from \"./model\";\n\n/** Task hint Databricks stamps on chat completion endpoints. */\nconst CHAT_TASK = \"llm/v1/chat\";\n\n/** Task hint Databricks stamps on embedding endpoints. */\nconst EMBEDDING_TASK = \"llm/v1/embeddings\";\n\n/** What an endpoint can be asked to do, as derived by {@link endpointCapabilities}. */\nexport interface EndpointCapabilities {\n  /** OpenAI chat/completions + Responses: the surface a chat agent needs. */\n  chat: boolean;\n  /** Embedding (vector) endpoint. */\n  embedding: boolean;\n  /** Function / tool calling. Every chat endpoint on Databricks supports it. */\n  tools: boolean;\n}\n\n/**\n * Derive an endpoint's capabilities from its Databricks task hint and its\n * classified {@link ModelClass}, so consumers filter on capability instead of\n * re-deriving it from raw `task` / `class` strings.\n *\n * Either signal alone is enough: the task hint is authoritative when present,\n * and the class covers endpoints Databricks left untasked but the classifier\n * recognized. Embedding wins over chat when both point at it, since the two are\n * not interchangeable.\n */\nexport function endpointCapabilities(endpoint: ServingEndpointSummary): EndpointCapabilities {\n  const embedding = endpoint.task === EMBEDDING_TASK || endpoint.class === ModelClass.Embedding;\n  // Every non-embedding class is a chat band, so \"classified but not embedding\"\n  // is the class-side test for chat capability.\n  const chat = !embedding && (endpoint.task === CHAT_TASK || endpoint.class !== undefined);\n  return { chat, embedding, tools: chat };\n}\n\n/** Family-heuristic classification of a single endpoint name. */\nexport interface FamilyClass {\n  /** Chat capability band the family maps to (never embedding). */\n  class: ModelClass;\n  /** Intra-family ordering hint (higher is newer / more capable). */\n  rank: number;\n}\n\n/**\n * Numeric `[major, minor, patch]` version parsed from an endpoint\n * name, used to order siblings within a family/tier. Starts at the\n * first digit in the name, then reads successive separator-delimited,\n * digit-prefixed chunks as the three components (missing ones default\n * to `0`):\n *\n *   - `databricks-claude-opus-4-8`   -> `[4, 8, 0]`\n *   - `databricks-claude-opus-4-10`  -> `[4, 10, 0]` (sorts above 4-8)\n *   - `databricks-meta-llama-3-3-70b`-> `[3, 3, 70]`\n *   - `databricks-bge-large-en`      -> `[0, 0, 0]` (no digits)\n *\n * Component-wise comparison (not a decimal collapse) so `4.10` beats\n * `4.8` - the bug a `major + minor/10` score would hit.\n */\nexport function versionTuple(name: string): [number, number, number] {\n  const start = name.search(/\\d/);\n  if (start < 0) return [0, 0, 0];\n  const nums = name\n    .slice(start)\n    .split(/[^a-z0-9]+/i)\n    .map((chunk) => chunk.match(/^\\d+/)?.[0])\n    .filter((digits): digits is string => digits !== undefined)\n    .map(Number);\n  return [nums[0] ?? 0, nums[1] ?? 0, nums[2] ?? 0];\n}\n\n/** Compare two version tuples so the higher version sorts first (descending). */\nfunction compareVersionDesc(a: readonly number[], b: readonly number[]): number {\n  for (let i = 0; i < 3; i++) {\n    const diff = (b[i] ?? 0) - (a[i] ?? 0);\n    if (diff !== 0) return diff;\n  }\n  return 0;\n}\n\n/**\n * Monotonic version key for ordering siblings within a family/tier\n * (e.g. `opus-4-8` over `opus-4-7`). Encodes the {@link versionTuple}\n * as a single number so callers that need a scalar rank (the family\n * heuristic, the static fallback ordering) keep working; the encoding\n * preserves component order without the decimal-collapse bug.\n */\nfunction versionScore(name: string): number {\n  const [major, minor, patch] = versionTuple(name);\n  return major * 1_000_000 + minor * 1_000 + patch;\n}\n\n/**\n * Best-effort chat capability band for an endpoint we have no live\n * score for, keyed off provider family and the well-known variant words\n * in the name (`opus`/`sonnet`/`haiku`, `pro`/`mini`/`nano`,\n * `flash`/`flash-lite`, Llama parameter sizes, etc). Returns `null` for\n * names we don't recognize so unknown custom endpoints are never\n * auto-selected as a default. The accompanying `rank` orders siblings\n * within a class. Only ever returns a chat band - embedding endpoints\n * are classified by task, not name.\n */\nexport function classifyByFamily(name: string): FamilyClass | null {\n  const n = name.toLowerCase();\n  const at = (cls: ModelClass): FamilyClass => ({ class: cls, rank: versionScore(n) });\n\n  // Anthropic Claude\n  if (n.includes(\"opus\")) return at(ModelClass.ChatThinking);\n  if (n.includes(\"sonnet\")) return at(ModelClass.ChatBalanced);\n  if (n.includes(\"haiku\")) return at(ModelClass.ChatFast);\n\n  // OpenAI open-weights (check before the generic gpt branch)\n  if (n.includes(\"gpt-oss\")) {\n    return at(n.includes(\"120b\") ? ModelClass.ChatBalanced : ModelClass.ChatFast);\n  }\n  // OpenAI GPT family\n  if (n.includes(\"gpt\")) {\n    if (n.includes(\"pro\")) return at(ModelClass.ChatThinking);\n    if (n.includes(\"mini\") || n.includes(\"nano\")) return at(ModelClass.ChatFast);\n    return at(ModelClass.ChatBalanced);\n  }\n\n  // Google Gemini / Gemma\n  if (n.includes(\"gemini\")) {\n    if (n.includes(\"flash-lite\")) return at(ModelClass.ChatFast);\n    if (n.includes(\"pro\")) return at(ModelClass.ChatThinking);\n    return at(ModelClass.ChatBalanced);\n  }\n  if (n.includes(\"gemma\")) return at(ModelClass.ChatFast);\n\n  // Meta Llama\n  if (n.includes(\"llama\")) {\n    if (n.includes(\"maverick\") || n.includes(\"405b\")) return at(ModelClass.ChatThinking);\n    if (n.includes(\"70b\")) return at(ModelClass.ChatBalanced);\n    if (n.includes(\"8b\") || n.includes(\"1b\")) return at(ModelClass.ChatFast);\n    return at(ModelClass.ChatBalanced);\n  }\n\n  // Alibaba Qwen\n  if (n.includes(\"qwen\")) return at(ModelClass.ChatBalanced);\n\n  return null;\n}\n\n/** Linear-interpolated quantile of an ascending-sorted numeric array. */\nfunction quantile(sortedAsc: readonly number[], p: number): number {\n  if (sortedAsc.length === 0) return Number.NaN;\n  const idx = (sortedAsc.length - 1) * p;\n  const lo = Math.floor(idx);\n  const hi = Math.ceil(idx);\n  if (lo === hi) return sortedAsc[lo]!;\n  return sortedAsc[lo]! + (sortedAsc[hi]! - sortedAsc[lo]!) * (idx - lo);\n}\n\n/** Internal sortable wrapper carrying the ordering keys for a bucket entry. */\ninterface Ranked {\n  ep: ServingEndpointSummary;\n  /** Quality (scored) or family version (unscored) - higher first. */\n  sort: number;\n  /** Scored endpoints rank ahead of family-only guesses. */\n  scored: boolean;\n  tieCost: number;\n  tieSpeed: number;\n  /** Parsed name version, the final tie-breaker (newer sibling first). */\n  version: readonly number[];\n}\n\nfunction rankOrder(a: Ranked, b: Ranked): number {\n  if (a.scored !== b.scored) return a.scored ? -1 : 1;\n  if (b.sort !== a.sort) return b.sort - a.sort;\n  if (a.tieCost !== b.tieCost) return a.tieCost - b.tieCost;\n  if (b.tieSpeed !== a.tieSpeed) return b.tieSpeed - a.tieSpeed;\n  // Same scored-ness, quality, cost, and speed (e.g. several Claude\n  // Opus point releases): prefer the newer parsed version so\n  // `opus-4-8` beats `opus-4-7`.\n  return compareVersionDesc(a.version, b.version);\n}\n\n/**\n * Bucket live endpoints into {@link ModelClass}es, ranked best-first\n * within each chat band.\n *\n * Embedding endpoints (`task === \"llm/v1/embeddings\"`) go into\n * {@link ModelClass.Embedding} by task, in listing order (they carry no\n * capability score to rank on).\n *\n * Chat endpoints (`task === \"llm/v1/chat\"`) split into the three chat\n * bands. Scored endpoints (those carrying a `profile.quality`) drive\n * the banding: the observed quality distribution is split at its 1/3\n * and 2/3 quantiles, so the top third is {@link ModelClass.ChatThinking},\n * the bottom third {@link ModelClass.ChatFast}, and the middle\n * {@link ModelClass.ChatBalanced}. Because the thresholds come from the\n * data, the split adapts as Databricks adds or rescores models -\n * nothing is pinned to a fixed score band.\n *\n * Unscored chat endpoints are placed by {@link classifyByFamily} and\n * ranked after the scored ones in their band; unrecognized, unscored\n * endpoints (e.g. custom external models) are omitted entirely so they\n * are never picked as an automatic default.\n *\n * Within a chat band, scored models sort by `quality` desc, then `cost`\n * asc, then `speed` desc, then parsed name version desc; family-only\n * models sort by version rank then parsed version. The version\n * tie-break ({@link versionTuple}) is what separates point releases\n * that share a score profile (e.g. `opus-4-8` ahead of `opus-4-7`).\n */\nexport function classifyEndpoints(\n  endpoints: readonly ServingEndpointSummary[],\n): Record<ModelClass, ServingEndpointSummary[]> {\n  const chat = endpoints.filter((e) => e.task === CHAT_TASK);\n  const qualities = chat\n    .map((e) => e.profile?.quality)\n    .filter((q): q is number => Number.isFinite(q))\n    .sort((a, b) => a - b);\n  const low = quantile(qualities, 1 / 3);\n  const high = quantile(qualities, 2 / 3);\n\n  const buckets: Record<ModelClass, Ranked[]> = {\n    [ModelClass.ChatThinking]: [],\n    [ModelClass.ChatBalanced]: [],\n    [ModelClass.ChatFast]: [],\n    [ModelClass.Embedding]: [],\n  };\n\n  for (const ep of chat) {\n    const q = ep.profile?.quality;\n    if (Number.isFinite(q)) {\n      const quality = q as number;\n      const cls =\n        quality >= high\n          ? ModelClass.ChatThinking\n          : quality <= low\n            ? ModelClass.ChatFast\n            : ModelClass.ChatBalanced;\n      buckets[cls].push({\n        ep,\n        sort: quality,\n        scored: true,\n        tieCost: ep.profile?.cost ?? Number.POSITIVE_INFINITY,\n        tieSpeed: ep.profile?.speed ?? 0,\n        version: versionTuple(ep.name),\n      });\n      continue;\n    }\n    const family = classifyByFamily(ep.name);\n    if (!family) continue;\n    buckets[family.class].push({\n      ep,\n      sort: family.rank,\n      scored: false,\n      tieCost: Number.POSITIVE_INFINITY,\n      tieSpeed: 0,\n      version: versionTuple(ep.name),\n    });\n  }\n\n  // Embeddings are bucketed by task in listing order - no score to rank.\n  const embeddings = endpoints.filter((e) => e.task === EMBEDDING_TASK);\n\n  return {\n    [ModelClass.ChatThinking]: buckets[ModelClass.ChatThinking].sort(rankOrder).map((x) => x.ep),\n    [ModelClass.ChatBalanced]: buckets[ModelClass.ChatBalanced].sort(rankOrder).map((x) => x.ep),\n    [ModelClass.ChatFast]: buckets[ModelClass.ChatFast].sort(rankOrder).map((x) => x.ep),\n    [ModelClass.Embedding]: embeddings,\n  };\n}\n"]}

package/lib/src/display.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Derive a human-readable display name for a serving endpoint.
+ *
+ * When `provided` is a non-blank string (a Databricks display-name tag or
+ * external-model name), it wins verbatim (trimmed). Otherwise the endpoint
+ * `name` is humanized: leading vendor prefixes (`databricks`, the
+ * `system.ai` namespace, `dbx`) are dropped, then each `-`/`_`/`.`-separated
+ * segment is title-cased (acronyms like GPT/GTE/BGE uppercased, "AI" kept),
+ * runs of purely-numeric segments are joined into a dotted version
+ * (`...-4-6` -> "4.6"), and a size unit glued to its number (`120b` ->
+ * "120B"). Falls back to the trimmed raw `name` if stripping leaves nothing.
+ *
+ * @example
+ * toModelDisplayName("databricks-claude-sonnet-4-6") // "Claude Sonnet 4.6"
+ * toModelDisplayName("databricks-gpt-oss-120b")      // "GPT OSS 120B"
+ * toModelDisplayName("system.ai.bge_large_en")       // "BGE Large En"
+ * toModelDisplayName("x", "Claude 4.6 (Preview)")    // provided wins
+ */
+export declare function toModelDisplayName(name: string, provided?: string | null): string;

package/lib/src/display.js

@@ -0,0 +1,106 @@
+/**
+ * Human-readable model display names. Pure (no Node-only imports) so a
+ * browser client can label a `/models` response without server deps.
+ *
+ * The endpoint `name` is the invoke id (e.g. `databricks-claude-sonnet-4-6`);
+ * this derives a friendly label from it. Prefer a Databricks-provided name
+ * (a display-name tag or an external-model name) when the server has one -
+ * see `@dbx-tools/model`'s serving lister, which passes it as `provided`.
+ *
+ * @module
+ */
+import { string } from "@dbx-tools/shared-core";
+/**
+ * Vendor / namespace prefixes stripped from a tokenized endpoint name
+ * before title-casing. Lowercased tokens; matched only as leading tokens
+ * so a legitimate mid-name token is never dropped. `ai` is stripped ONLY
+ * as the second half of the `system.ai.*` builtin namespace (handled
+ * below), never on its own - so a model literally named `...-ai-...`
+ * keeps its "AI" word via the tokenizer's built-in casing override.
+ */
+const STRIP_LEADING_TOKENS = new Set(["databricks", "system", "dbx"]);
+/** `ai` is stripped only as the `system.ai.*` namespace half (after `system`). */
+const NAMESPACE_SECOND_TOKENS = { system: "ai" };
+/**
+ * Segment-internal tokens rendered fully uppercased (acronyms), not
+ * title-cased. `ai` is intentionally omitted: the shared tokenizer already
+ * force-cases `ai` -> `AI` via its {@link string.TokenizeOptions} `capitalize`
+ * override, which `renderSegment` always passes.
+ */
+const ACRONYMS = new Set(["gpt", "gte", "bge", "dbrx", "oss", "llm", "moe"]);
+/** Parameter-count unit letters glued to a preceding number (`120b` -> `120B`). */
+const SIZE_UNITS = new Set(["b", "m", "k"]);
+const SEGMENT_SPLIT = /[-_.\s/]+/;
+/**
+ * Derive a human-readable display name for a serving endpoint.
+ *
+ * When `provided` is a non-blank string (a Databricks display-name tag or
+ * external-model name), it wins verbatim (trimmed). Otherwise the endpoint
+ * `name` is humanized: leading vendor prefixes (`databricks`, the
+ * `system.ai` namespace, `dbx`) are dropped, then each `-`/`_`/`.`-separated
+ * segment is title-cased (acronyms like GPT/GTE/BGE uppercased, "AI" kept),
+ * runs of purely-numeric segments are joined into a dotted version
+ * (`...-4-6` -> "4.6"), and a size unit glued to its number (`120b` ->
+ * "120B"). Falls back to the trimmed raw `name` if stripping leaves nothing.
+ *
+ * @example
+ * toModelDisplayName("databricks-claude-sonnet-4-6") // "Claude Sonnet 4.6"
+ * toModelDisplayName("databricks-gpt-oss-120b")      // "GPT OSS 120B"
+ * toModelDisplayName("system.ai.bge_large_en")       // "BGE Large En"
+ * toModelDisplayName("x", "Claude 4.6 (Preview)")    // provided wins
+ */
+export function toModelDisplayName(name, provided) {
+    const providedTrimmed = string.trimToNull(provided);
+    if (providedTrimmed)
+        return providedTrimmed;
+    const segments = name.split(SEGMENT_SPLIT).filter(Boolean);
+    // Drop known vendor/namespace prefixes only while they lead the list.
+    let start = 0;
+    while (start < segments.length) {
+        const lower = segments[start].toLowerCase();
+        if (!STRIP_LEADING_TOKENS.has(lower))
+            break;
+        // Consume the namespace's second token too (e.g. the `ai` of `system.ai`).
+        if (NAMESPACE_SECOND_TOKENS[lower] === segments[start + 1]?.toLowerCase()) {
+            start += 1;
+        }
+        start += 1;
+    }
+    const kept = segments.slice(start);
+    const source = kept.length > 0 ? kept : segments;
+    const pieces = [];
+    let versionRun = [];
+    const flushVersion = () => {
+        if (versionRun.length > 0) {
+            pieces.push(versionRun.join("."));
+            versionRun = [];
+        }
+    };
+    for (const segment of source) {
+        if (/^\d+$/.test(segment)) {
+            versionRun.push(segment);
+            continue;
+        }
+        flushVersion();
+        pieces.push(renderSegment(segment));
+    }
+    flushVersion();
+    return pieces.join(" ") || name.trim();
+}
+/** Title-case one name segment, uppercasing acronyms and gluing size units. */
+function renderSegment(segment) {
+    const tokens = [...string.tokenizeWithOptions({ capitalize: true }, segment)];
+    const out = [];
+    for (let i = 0; i < tokens.length; i += 1) {
+        const token = tokens[i];
+        const lower = token.toLowerCase();
+        // Glue a size unit onto the preceding number: `120` + `b` -> `120B`.
+        if (SIZE_UNITS.has(lower) && out.length > 0 && /^\d+$/.test(out[out.length - 1])) {
+            out[out.length - 1] = `${out[out.length - 1]}${lower.toUpperCase()}`;
+            continue;
+        }
+        out.push(ACRONYMS.has(lower) ? lower.toUpperCase() : token);
+    }
+    return out.join(" ");
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"display.js","sourceRoot":"","sources":["../../src/display.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Human-readable model display names. Pure (no Node-only imports) so a\n * browser client can label a `/models` response without server deps.\n *\n * The endpoint `name` is the invoke id (e.g. `databricks-claude-sonnet-4-6`);\n * this derives a friendly label from it. Prefer a Databricks-provided name\n * (a display-name tag or an external-model name) when the server has one -\n * see `@dbx-tools/model`'s serving lister, which passes it as `provided`.\n *\n * @module\n */\nimport { string } from \"@dbx-tools/shared-core\";\n\n/**\n * Vendor / namespace prefixes stripped from a tokenized endpoint name\n * before title-casing. Lowercased tokens; matched only as leading tokens\n * so a legitimate mid-name token is never dropped. `ai` is stripped ONLY\n * as the second half of the `system.ai.*` builtin namespace (handled\n * below), never on its own - so a model literally named `...-ai-...`\n * keeps its \"AI\" word via the tokenizer's built-in casing override.\n */\nconst STRIP_LEADING_TOKENS = new Set([\"databricks\", \"system\", \"dbx\"]);\n\n/** `ai` is stripped only as the `system.ai.*` namespace half (after `system`). */\nconst NAMESPACE_SECOND_TOKENS: Record<string, string> = { system: \"ai\" };\n\n/**\n * Segment-internal tokens rendered fully uppercased (acronyms), not\n * title-cased. `ai` is intentionally omitted: the shared tokenizer already\n * force-cases `ai` -> `AI` via its {@link string.TokenizeOptions} `capitalize`\n * override, which `renderSegment` always passes.\n */\nconst ACRONYMS = new Set([\"gpt\", \"gte\", \"bge\", \"dbrx\", \"oss\", \"llm\", \"moe\"]);\n\n/** Parameter-count unit letters glued to a preceding number (`120b` -> `120B`). */\nconst SIZE_UNITS = new Set([\"b\", \"m\", \"k\"]);\n\nconst SEGMENT_SPLIT = /[-_.\\s/]+/;\n\n/**\n * Derive a human-readable display name for a serving endpoint.\n *\n * When `provided` is a non-blank string (a Databricks display-name tag or\n * external-model name), it wins verbatim (trimmed). Otherwise the endpoint\n * `name` is humanized: leading vendor prefixes (`databricks`, the\n * `system.ai` namespace, `dbx`) are dropped, then each `-`/`_`/`.`-separated\n * segment is title-cased (acronyms like GPT/GTE/BGE uppercased, \"AI\" kept),\n * runs of purely-numeric segments are joined into a dotted version\n * (`...-4-6` -> \"4.6\"), and a size unit glued to its number (`120b` ->\n * \"120B\"). Falls back to the trimmed raw `name` if stripping leaves nothing.\n *\n * @example\n * toModelDisplayName(\"databricks-claude-sonnet-4-6\") // \"Claude Sonnet 4.6\"\n * toModelDisplayName(\"databricks-gpt-oss-120b\")      // \"GPT OSS 120B\"\n * toModelDisplayName(\"system.ai.bge_large_en\")       // \"BGE Large En\"\n * toModelDisplayName(\"x\", \"Claude 4.6 (Preview)\")    // provided wins\n */\nexport function toModelDisplayName(name: string, provided?: string | null): string {\n  const providedTrimmed = string.trimToNull(provided);\n  if (providedTrimmed) return providedTrimmed;\n\n  const segments = name.split(SEGMENT_SPLIT).filter(Boolean);\n  // Drop known vendor/namespace prefixes only while they lead the list.\n  let start = 0;\n  while (start < segments.length) {\n    const lower = segments[start]!.toLowerCase();\n    if (!STRIP_LEADING_TOKENS.has(lower)) break;\n    // Consume the namespace's second token too (e.g. the `ai` of `system.ai`).\n    if (NAMESPACE_SECOND_TOKENS[lower] === segments[start + 1]?.toLowerCase()) {\n      start += 1;\n    }\n    start += 1;\n  }\n  const kept = segments.slice(start);\n  const source = kept.length > 0 ? kept : segments;\n\n  const pieces: string[] = [];\n  let versionRun: string[] = [];\n  const flushVersion = () => {\n    if (versionRun.length > 0) {\n      pieces.push(versionRun.join(\".\"));\n      versionRun = [];\n    }\n  };\n  for (const segment of source) {\n    if (/^\\d+$/.test(segment)) {\n      versionRun.push(segment);\n      continue;\n    }\n    flushVersion();\n    pieces.push(renderSegment(segment));\n  }\n  flushVersion();\n\n  return pieces.join(\" \") || name.trim();\n}\n\n/** Title-case one name segment, uppercasing acronyms and gluing size units. */\nfunction renderSegment(segment: string): string {\n  const tokens = [...string.tokenizeWithOptions({ capitalize: true }, segment)];\n  const out: string[] = [];\n  for (let i = 0; i < tokens.length; i += 1) {\n    const token = tokens[i]!;\n    const lower = token.toLowerCase();\n    // Glue a size unit onto the preceding number: `120` + `b` -> `120B`.\n    if (SIZE_UNITS.has(lower) && out.length > 0 && /^\\d+$/.test(out[out.length - 1]!)) {\n      out[out.length - 1] = `${out[out.length - 1]}${lower.toUpperCase()}`;\n      continue;\n    }\n    out.push(ACRONYMS.has(lower) ? lower.toUpperCase() : token);\n  }\n  return out.join(\" \");\n}\n"]}