@dbx-tools/shared-model 0.9.5 → 0.9.6

package/README.md

@@ -1,25 +1,19 @@
 # @dbx-tools/shared-model
 
-Browser-safe model-selection contract and classifier.
+Browser-safe model-selection contracts generated from the canonical model
+owner.
 
 Import this package when UI code, route handlers, tools, or tests need to
-validate model lookup requests, type ranked model responses, or classify serving
-endpoints without talking to Databricks. Live workspace listing and fuzzy
-resolution live in [`@dbx-tools/model`](../../node/model).
+validate model lookup requests or type ranked model responses without talking
+to Databricks. Normalization, classification, capability policy, ranking, and
+fuzzy resolution are exposed through [`@dbx-tools/model`](../../node/model).
 
 Key features:
 
-- Shared `ModelClass` taxonomy for chat-thinking, chat-balanced, chat-fast, and
-  embedding workloads.
-- Browser-safe zod schemas for lookup requests, endpoint summaries, ranked
-  results, and profile metadata.
-- Endpoint classifier that groups serving endpoints by score profile and family
-  naming conventions, plus `classify.endpointCapabilities` for chat / embedding
-  / tool-calling capability flags.
-- Version/family parsing helpers for model catalogues and tests.
+- Generated `ModelClass`, endpoint, query, status, profile, ranking, and
+  reasoning-effort contracts as browser-safe TypeScript and zod.
 - Human-readable endpoint display names via `display.toModelDisplayName`.
-- OpenAI wire contracts: chat message/tool-call types plus a Responses API
-  translator, so a proxy, a route, and a UI all speak the same payload shapes.
+- Browser-safe OpenAI Chat message and tool-call contracts.
 - Types that match the server selection API without depending on the Databricks
   SDK.
 
@@ -34,12 +28,9 @@ display.toModelDisplayName("x", "Claude 4.6 (Preview)"); // provided name wins
 ```
 
 `ServingEndpointSummary.displayName` is the optional friendly label for the
-picker; `name` stays the invoke id. A Databricks-provided name (a
-`display_name`/`displayName`/`name` endpoint tag, or an external-model name
-extracted in [`@dbx-tools/model`](../../node/model)'s `serving.ts`) wins;
-otherwise the pure helper strips leading vendor prefixes and title-cases via
-`@dbx-tools/shared-core`'s tokenizer. It flows through `GET /models`
-automatically, and the UI picker shows `displayName ?? name`.
+picker; `name` stays the invoke id. A Databricks-provided name wins. Otherwise,
+the pure helper strips leading vendor prefixes and title-cases through
+`@dbx-tools/shared-core`'s tokenizer.
 
 ## Validate A Model Lookup Request
 
@@ -58,135 +49,38 @@ Use `model.ModelQuerySchema` for route query/body validation and agent tool
 inputs. It keeps client model pickers and backend resolution endpoints on the
 same request shape.
 
-## Type Ranked Results
+## Use Classified Endpoint Catalogues
 
 ```ts
-import { model, type RankedModel } from "@dbx-tools/shared-model";
-
-const ranked: RankedModel = model.RankedModelSchema.parse(response);
-```
-
-`model.ServingEndpointSummarySchema` describes the stable endpoint fields exposed
-to clients: endpoint name, parsed family, task, state, optional profile scores,
-classified class, `supportsTools`, provider service names, Rust-derived
-reasoning-effort wire values, lifecycle status, and embedding dimension.
-`requiresTools: true` filters
-search/ranking to endpoints that can complete both a function call and the
-subsequent `function_call_output` replay.
-
-## Classify Endpoint Catalogues
-
-```ts
-import { classify, model } from "@dbx-tools/shared-model";
-
-const byClass = classify.classifyEndpoints(endpoints);
-const fast = byClass[model.ModelClass.ChatFast];
-const agentModels = endpoints.filter((endpoint) => classify.endpointCapabilities(endpoint).tools);
-```
-
-Databricks currently exposes no tool-capability attribute in the endpoint list
-or OpenAPI schema. `supportsTools` therefore uses a conservative, live-verified
-provider-family policy: GPT (except GPT-OSS), Claude, Qwen, GLM, and Llama.
-Gemini is excluded because its Open Responses tool-result replay requires a
-thought signature the wire does not currently accept; GPT-OSS rejects Responses
-passthrough. An explicit `supportsTools` stamp overrides the family fallback.
-
-The classifier uses Foundation Model API quality/speed/cost scores when present
-and family-name heuristics when scores are missing. This is useful for client
-grouping, tests, and offline catalogue analysis.
-
-## Parse Model Families
-
-```ts
-const family = classify.classifyByFamily("databricks-claude-sonnet-4-6");
-const version = classify.versionTuple("llama-3-1-70b");
-```
-
-Family parsing helps callers bucket custom lists or explain why an endpoint
-landed in a class before the live workspace scores are available.
-
-## Ask What An Endpoint Can Do
-
-```ts
-const caps = classify.endpointCapabilities(endpoint);
-if (caps.chat) offerInChatPicker(endpoint);
-```
-
-Capability comes from the Databricks task hint (`llm/v1/chat` /
-`llm/v1/embeddings`) with the classified class as the fallback for endpoints
-Databricks left untagged. Filter on this rather than comparing raw `task`
-strings, so every picker, CLI, and route agrees on what "chat-capable" means.
-
-## Translate The OpenAI Responses API
-
-```ts
-import { openaiResponses } from "@dbx-tools/shared-model";
-
-const { chat, stream } = openaiResponses.responsesToChat(requestBody);
-// ... POST `chat` to the endpoint's invocations URL ...
-const response = openaiResponses.chatToResponse(completion, modelId);
-```
-
-Databricks serving endpoints speak Chat Completions; some clients (the Codex
-CLI, for one) speak only the Responses API. `openaiResponses` bridges the two in
-both directions, including a streaming translator
-(`createResponsesStreamTranslator`) that lifts `chat.completion.chunk` SSE into
-the Responses event stream, and `readResponsesOutput` for pulling the answer and
-its citations back out of a native Responses reply. Pure functions over plain
-JSON, so the same translation runs in a proxy, a server route, or a test.
-
-## Sanitize A Replayed Conversation
-
-```ts
-import { openaiResponses } from "@dbx-tools/shared-model";
+import { model } from "@dbx-tools/shared-model";
 
-const body = openaiResponses.sanitizeOpenResponsesRequest(requestBody);
+const fast = endpoints.filter((endpoint) => endpoint.class === model.ModelClass.ChatFast);
+const agentModels = endpoints.filter((endpoint) => endpoint.supportsTools);
 ```
 
-`/open-responses` (the cross-provider path used for Claude and Gemini) rejects
-content parts that its own previous turn produced: an `output_text` part replayed
-as input fails with `Open Responses input content part type 'output_text' is not
-supported`. `sanitizeOpenResponsesRequest` rewrites `output_*` parts back to their
-`input_*` form and drops extended-thinking parts before the body goes out.
-
-The thinking-block types live in one exported constant,
-`openaiResponses.REASONING_TYPES`. Both wire sanitizers (this one and the Chat
-Completions sanitizer in [`@dbx-tools/appkit-mastra`](../../node/appkit-mastra))
-must strip exactly the same set: Anthropic signs `redacted_thinking` blocks, so a
-replay in which one path mutates a block the other preserved is rejected
-outright. Import the constant rather than re-listing the types.
+The server stamps class and capability fields before returning `/models`.
+Browser clients consume those fields directly; model-family policy does not run
+in the browser.
 
 ## Strip Fields Databricks Rejects
 
 ```ts
 import { openaiChat } from "@dbx-tools/shared-model";
 
-const dropped = openaiChat.stripUnsupportedChatFields(body); // mutates `body`
+const dropped = openaiChat.stripUnsupportedChatFields(body);
 ```
 
-Databricks Model Serving validates the chat body strictly: one unrecognized
-top-level key fails the entire turn rather than being ignored. An OpenAI client
-that sends `parallel_tool_calls` gets back
-`parallel_tool_calls: Extra inputs are not permitted` and no completion at all.
-
-`stripUnsupportedChatFields` deletes the known offenders in place and returns
-what it removed, so a caller can log the difference. Reach for it on any path
-that forwards a client body largely as-is; a translator that copies fields
-one-by-one (`openaiResponses.responsesToChat`) already can't leak them. Pass
-`extra` names to cover a workspace that rejects something not yet in
-`openaiChat.UNSUPPORTED_CHAT_FIELDS`.
+Databricks Model Serving validates Chat Completions bodies strictly.
+`stripUnsupportedChatFields` deletes known unsupported fields in place and
+returns the removed names so a caller can log the difference.
 
 ## Modules
 
-- `model` - `ModelClass`, reasoning-effort wire schema, and inferred types for
-  profiles, endpoint summaries, lookup requests, and ranked results.
-- `classify` - family parsing, version tuple parsing, endpoint classification,
-  and capability flags.
+- `model` - model classes, reasoning-effort schema, endpoint summaries, lookup
+  requests, and ranked results.
 - `display` - human-readable endpoint labels.
-- `openaiChat` - Chat Completions message / tool-call types,
-  `chatContentParts`, `chatContentToText`, and `stripUnsupportedChatFields`.
-- `openaiResponses` - Responses API translation in both directions, plus
-  `sanitizeOpenResponsesRequest` and the shared `REASONING_TYPES` constant.
+- `openaiChat` - Chat Completions message and tool-call types, content helpers,
+  and rejected-field sanitization.
 
 Server-side selection, cache, and fuzzy endpoint matching are in
 [`@dbx-tools/model`](../../node/model).

package/index.ts

@@ -3,16 +3,11 @@
 // Hand edits are overwritten on the next watch; this file is read-only.
 
 export const PACKAGE_IDENTIFIER = "@dbx-tools/shared-model";
-export const PACKAGE_VERSION = "0.9.5";
-export * as classify from "./src/classify.ts";
+export const PACKAGE_VERSION = "0.9.6";
 export * as display from "./src/display.ts";
 export * as model from "./src/model.ts";
 export * as openaiChat from "./src/openai-chat.ts";
-export * as openaiResponses from "./src/openai-responses.ts";
-export type { EndpointCapabilities, FamilyClass } from "./src/classify.ts";
-export { ModelClass, ModelClassSchema, ModelProfileSchema, ReasoningEffortSchema, ModelStatusSchema, ServingEndpointSummarySchema, ModelQuerySchema, RankedModelSchema } from "./src/model.ts";
-export type { ModelProfile, ReasoningEffort, ModelStatus, ServingEndpointSummary, ModelQuery, RankedModel } from "./src/model.ts";
+export { ModelClass, ReasoningEffortValues, ModelClassSchema, ModelProfileSchema, ReasoningEffortSchema, ModelStatusSchema, ServingEndpointSummarySchema, ModelQuerySchema, RankedModelSchema } from "./src/model.ts";
+export type { ModelProfile, ModelQuery, ModelStatus, RankedModel, ReasoningEffort, ServingEndpointSummary } from "./src/model.ts";
 export { UNSUPPORTED_CHAT_FIELDS } from "./src/openai-chat.ts";
 export type { ChatRole, ChatContentPart, ChatToolCallFunction, ChatToolCall, ChatMessage, ChatContentToTextOptions } from "./src/openai-chat.ts";
-export { REASONING_TYPES } from "./src/openai-responses.ts";
-export type { ResponsesStreamTranslator, ResponsesCitation, ResponsesOutput } from "./src/openai-responses.ts";

package/lib/index.d.ts

@@ -1,14 +1,9 @@
 export declare const PACKAGE_IDENTIFIER = "@dbx-tools/shared-model";
-export declare const PACKAGE_VERSION = "0.9.5";
-export * as classify from "./src/classify.ts";
+export declare const PACKAGE_VERSION = "0.9.6";
 export * as display from "./src/display.ts";
 export * as model from "./src/model.ts";
 export * as openaiChat from "./src/openai-chat.ts";
-export * as openaiResponses from "./src/openai-responses.ts";
-export type { EndpointCapabilities, FamilyClass } from "./src/classify.ts";
-export { ModelClass, ModelClassSchema, ModelProfileSchema, ReasoningEffortSchema, ModelStatusSchema, ServingEndpointSummarySchema, ModelQuerySchema, RankedModelSchema } from "./src/model.ts";
-export type { ModelProfile, ReasoningEffort, ModelStatus, ServingEndpointSummary, ModelQuery, RankedModel } from "./src/model.ts";
+export { ModelClass, ReasoningEffortValues, ModelClassSchema, ModelProfileSchema, ReasoningEffortSchema, ModelStatusSchema, ServingEndpointSummarySchema, ModelQuerySchema, RankedModelSchema } from "./src/model.ts";
+export type { ModelProfile, ModelQuery, ModelStatus, RankedModel, ReasoningEffort, ServingEndpointSummary } from "./src/model.ts";
 export { UNSUPPORTED_CHAT_FIELDS } from "./src/openai-chat.ts";
 export type { ChatRole, ChatContentPart, ChatToolCallFunction, ChatToolCall, ChatMessage, ChatContentToTextOptions } from "./src/openai-chat.ts";
-export { REASONING_TYPES } from "./src/openai-responses.ts";
-export type { ResponsesStreamTranslator, ResponsesCitation, ResponsesOutput } from "./src/openai-responses.ts";

package/lib/index.js

@@ -2,13 +2,10 @@
 // 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/shared-model";
-export const PACKAGE_VERSION = "0.9.5";
-export * as classify from "./src/classify.js";
+export const PACKAGE_VERSION = "0.9.6";
 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 { ModelClass, ModelClassSchema, ModelProfileSchema, ReasoningEffortSchema, ModelStatusSchema, ServingEndpointSummarySchema, ModelQuerySchema, RankedModelSchema } from "./src/model.js";
+export { ModelClass, ReasoningEffortValues, ModelClassSchema, ModelProfileSchema, ReasoningEffortSchema, ModelStatusSchema, ServingEndpointSummarySchema, ModelQuerySchema, RankedModelSchema } from "./src/model.js";
 export { UNSUPPORTED_CHAT_FIELDS } from "./src/openai-chat.js";
-export { REASONING_TYPES } from "./src/openai-responses.js";
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwyQ0FBMkM7QUFDM0MsbURBQW1EO0FBQ25ELHdFQUF3RTtBQUV4RSxNQUFNLENBQUMsTUFBTSxrQkFBa0IsR0FBRyx5QkFBeUIsQ0FBQztBQUM1RCxNQUFNLENBQUMsTUFBTSxlQUFlLEdBQUcsT0FBTyxDQUFDO0FBQ3ZDLE9BQU8sS0FBSyxPQUFPLE1BQU0sa0JBQWtCLENBQUM7QUFDNUMsT0FBTyxLQUFLLEtBQUssTUFBTSxnQkFBZ0IsQ0FBQztBQUN4QyxPQUFPLEtBQUssVUFBVSxNQUFNLHNCQUFzQixDQUFDO0FBQ25ELE9BQU8sRUFBRSxVQUFVLEVBQUUscUJBQXFCLEVBQUUsZ0JBQWdCLEVBQUUsa0JBQWtCLEVBQUUscUJBQXFCLEVBQUUsaUJBQWlCLEVBQUUsNEJBQTRCLEVBQUUsZ0JBQWdCLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQztBQUV0TixPQUFPLEVBQUUsdUJBQXVCLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIEdFTkVSQVRFRCBieSBwcm9qZW4gd2F0Y2ggLSBETyBOT1QgRURJVC5cbi8vIFJlZ2VuZXJhdGVkIGZyb20gdGhlIGV4cG9ydGluZyBtb2R1bGVzIGluIC4vc3JjLlxuLy8gSGFuZCBlZGl0cyBhcmUgb3ZlcndyaXR0ZW4gb24gdGhlIG5leHQgd2F0Y2g7IHRoaXMgZmlsZSBpcyByZWFkLW9ubHkuXG5cbmV4cG9ydCBjb25zdCBQQUNLQUdFX0lERU5USUZJRVIgPSBcIkBkYngtdG9vbHMvc2hhcmVkLW1vZGVsXCI7XG5leHBvcnQgY29uc3QgUEFDS0FHRV9WRVJTSU9OID0gXCIwLjkuNlwiO1xuZXhwb3J0ICogYXMgZGlzcGxheSBmcm9tIFwiLi9zcmMvZGlzcGxheS50c1wiO1xuZXhwb3J0ICogYXMgbW9kZWwgZnJvbSBcIi4vc3JjL21vZGVsLnRzXCI7XG5leHBvcnQgKiBhcyBvcGVuYWlDaGF0IGZyb20gXCIuL3NyYy9vcGVuYWktY2hhdC50c1wiO1xuZXhwb3J0IHsgTW9kZWxDbGFzcywgUmVhc29uaW5nRWZmb3J0VmFsdWVzLCBNb2RlbENsYXNzU2NoZW1hLCBNb2RlbFByb2ZpbGVTY2hlbWEsIFJlYXNvbmluZ0VmZm9ydFNjaGVtYSwgTW9kZWxTdGF0dXNTY2hlbWEsIFNlcnZpbmdFbmRwb2ludFN1bW1hcnlTY2hlbWEsIE1vZGVsUXVlcnlTY2hlbWEsIFJhbmtlZE1vZGVsU2NoZW1hIH0gZnJvbSBcIi4vc3JjL21vZGVsLnRzXCI7XG5leHBvcnQgdHlwZSB7IE1vZGVsUHJvZmlsZSwgTW9kZWxRdWVyeSwgTW9kZWxTdGF0dXMsIFJhbmtlZE1vZGVsLCBSZWFzb25pbmdFZmZvcnQsIFNlcnZpbmdFbmRwb2ludFN1bW1hcnkgfSBmcm9tIFwiLi9zcmMvbW9kZWwudHNcIjtcbmV4cG9ydCB7IFVOU1VQUE9SVEVEX0NIQVRfRklFTERTIH0gZnJvbSBcIi4vc3JjL29wZW5haS1jaGF0LnRzXCI7XG5leHBvcnQgdHlwZSB7IENoYXRSb2xlLCBDaGF0Q29udGVudFBhcnQsIENoYXRUb29sQ2FsbEZ1bmN0aW9uLCBDaGF0VG9vbENhbGwsIENoYXRNZXNzYWdlLCBDaGF0Q29udGVudFRvVGV4dE9wdGlvbnMgfSBmcm9tIFwiLi9zcmMvb3BlbmFpLWNoYXQudHNcIjtcbiJdfQ==

package/lib/src/display.js

@@ -9,7 +9,7 @@
  *
  * @module
  */
-import { string } from "@dbx-tools/shared-core";
+import { stringUtils } from "@dbx-tools/shared-core";
 /**
  * Vendor / namespace prefixes stripped from a tokenized endpoint name
  * before title-casing. Lowercased tokens; matched only as leading tokens
@@ -50,7 +50,7 @@ const SEGMENT_SPLIT = /[-_.\s/]+/;
  * toModelDisplayName("x", "Claude 4.6 (Preview)")    // provided wins
  */
 export function toModelDisplayName(name, provided) {
-    const providedTrimmed = string.trimToNull(provided);
+    const providedTrimmed = stringUtils.trimToNull(provided);
     if (providedTrimmed)
         return providedTrimmed;
     const segments = name.split(SEGMENT_SPLIT).filter(Boolean);
@@ -89,7 +89,7 @@ export function toModelDisplayName(name, provided) {
 }
 /** Title-case one name segment, uppercasing acronyms and gluing size units. */
 function renderSegment(segment) {
-    const tokens = [...string.tokenizeWithOptions({ capitalize: true }, segment)];
+    const tokens = [...stringUtils.tokenizeWithOptions({ capitalize: true }, segment)];
     const out = [];
     for (let i = 0; i < tokens.length; i += 1) {
         const token = tokens[i];
@@ -103,4 +103,4 @@ function renderSegment(segment) {
     }
     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"]}
+//# 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 { stringUtils } 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 = stringUtils.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 = [...stringUtils.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"]}

package/lib/src/generated/_contracts.d.ts

@@ -0,0 +1,142 @@
+export declare const ModelClass: {
+    readonly ChatThinking: "chat-thinking";
+    readonly ChatBalanced: "chat-balanced";
+    readonly ChatFast: "chat-fast";
+    readonly Embedding: "embedding";
+};
+export type ModelClass = "chat-thinking" | "chat-balanced" | "chat-fast" | "embedding";
+export declare const ReasoningEffort: {
+    readonly None: "none";
+    readonly Minimal: "minimal";
+    readonly Low: "low";
+    readonly Medium: "medium";
+    readonly High: "high";
+    readonly Xhigh: "xhigh";
+    readonly Max: "max";
+};
+export type ReasoningEffort = "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+export type ModelProfile = {
+    /**
+     * Relative model quality score.
+     */
+    quality?: number;
+    /**
+     * Relative model speed score.
+     */
+    speed?: number;
+    /**
+     * Relative model cost score.
+     */
+    cost?: number;
+};
+export type ModelStatus = {
+    /**
+     * Whether Databricks lists the model as retired or deprecated.
+     *
+     * @default false
+     */
+    deprecated: boolean;
+};
+export type ServingEndpointSummary = {
+    /**
+     * Model Serving endpoint name used for invocation.
+     */
+    name: string;
+    /**
+     * Human-readable endpoint or model name.
+     */
+    displayName?: string;
+    /**
+     * Normalized model family parsed from the endpoint identities.
+     */
+    family?: string;
+    /**
+     * Endpoint task, such as chat or embeddings.
+     */
+    task?: string;
+    /**
+     * Endpoint readiness state.
+     */
+    state?: string;
+    /**
+     * Endpoint description supplied by Databricks.
+     */
+    description?: string;
+    /**
+     * Whether the endpoint supports tool calling.
+     */
+    supportsTools?: boolean;
+    /**
+     * AI Gateway model profile scores.
+     */
+    profile?: ModelProfile;
+    /**
+     * Intent-oriented endpoint class.
+     */
+    class?: ModelClass;
+    /**
+     * Provider names mapped to provider-specific model names.
+     */
+    serviceNames?: Record<string, string>;
+    /**
+     * Foundation model name reported by the served entity.
+     */
+    modelServiceName?: string;
+    /**
+     * Reasoning effort values accepted by the endpoint.
+     */
+    reasoningEfforts?: Array<ReasoningEffort>;
+    /**
+     * Retirement status for the served model.
+     */
+    status?: ModelStatus;
+    /**
+     * Embedding vector dimension measured by the caller, when available.
+     */
+    dimension?: number;
+};
+export type ModelQuery = {
+    /**
+     * Optional fuzzy model-name search.
+     */
+    search?: string;
+    /**
+     * Requested model-class ceiling, or the exact embedding class.
+     */
+    modelClass?: ModelClass;
+    /**
+     * Whether candidates must support tool calling.
+     */
+    requiresTools?: boolean;
+    /**
+     * Whether retired models remain eligible.
+     */
+    includeDeprecated?: boolean;
+    /**
+     * Maximum number of results.
+     *
+     * @schema number().int().min(1).max(50).optional()
+     */
+    limit?: number;
+    /**
+     * Maximum fuzzy-match distance.
+     *
+     * @minimum 0
+     * @maximum 1
+     */
+    threshold?: number;
+};
+export type RankedModel = {
+    /**
+     * Matching endpoint metadata.
+     */
+    endpoint: ServingEndpointSummary;
+    /**
+     * Intent-oriented endpoint class.
+     */
+    modelClass: ModelClass;
+    /**
+     * Fuzzy-match distance, where lower values are closer.
+     */
+    score?: number;
+};

package/lib/src/generated/_contracts.js

@@ -0,0 +1,17 @@
+// Generated from packages/rs/model. Do not edit.
+export const ModelClass = {
+    ChatThinking: "chat-thinking",
+    ChatBalanced: "chat-balanced",
+    ChatFast: "chat-fast",
+    Embedding: "embedding",
+};
+export const ReasoningEffort = {
+    None: "none",
+    Minimal: "minimal",
+    Low: "low",
+    Medium: "medium",
+    High: "high",
+    Xhigh: "xhigh",
+    Max: "max",
+};
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/generated/_schemas.d.ts

@@ -0,0 +1,67 @@
+import { z } from "zod";
+export declare const modelClassSchema: z.ZodUnion<readonly [z.ZodLiteral<"chat-thinking">, z.ZodLiteral<"chat-balanced">, z.ZodLiteral<"chat-fast">, z.ZodLiteral<"embedding">]>;
+export declare const reasoningEffortSchema: z.ZodUnion<readonly [z.ZodLiteral<"none">, z.ZodLiteral<"minimal">, z.ZodLiteral<"low">, z.ZodLiteral<"medium">, z.ZodLiteral<"high">, z.ZodLiteral<"xhigh">, z.ZodLiteral<"max">]>;
+export declare const modelProfileSchema: z.ZodObject<{
+    quality: z.ZodOptional<z.ZodNumber>;
+    speed: z.ZodOptional<z.ZodNumber>;
+    cost: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const modelStatusSchema: z.ZodObject<{
+    deprecated: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const servingEndpointSummarySchema: z.ZodObject<{
+    name: z.ZodString;
+    displayName: z.ZodOptional<z.ZodString>;
+    family: z.ZodOptional<z.ZodString>;
+    task: z.ZodOptional<z.ZodString>;
+    state: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    supportsTools: z.ZodOptional<z.ZodBoolean>;
+    profile: z.ZodOptional<z.ZodObject<{
+        quality: z.ZodOptional<z.ZodNumber>;
+        speed: z.ZodOptional<z.ZodNumber>;
+        cost: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    class: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"chat-thinking">, z.ZodLiteral<"chat-balanced">, z.ZodLiteral<"chat-fast">, z.ZodLiteral<"embedding">]>>;
+    serviceNames: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    modelServiceName: z.ZodOptional<z.ZodString>;
+    reasoningEfforts: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodLiteral<"none">, z.ZodLiteral<"minimal">, z.ZodLiteral<"low">, z.ZodLiteral<"medium">, z.ZodLiteral<"high">, z.ZodLiteral<"xhigh">, z.ZodLiteral<"max">]>>>;
+    status: z.ZodOptional<z.ZodObject<{
+        deprecated: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    dimension: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const modelQuerySchema: z.ZodObject<{
+    search: z.ZodOptional<z.ZodString>;
+    modelClass: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"chat-thinking">, z.ZodLiteral<"chat-balanced">, z.ZodLiteral<"chat-fast">, z.ZodLiteral<"embedding">]>>;
+    requiresTools: z.ZodOptional<z.ZodBoolean>;
+    includeDeprecated: z.ZodOptional<z.ZodBoolean>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    threshold: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const rankedModelSchema: z.ZodObject<{
+    endpoint: z.ZodObject<{
+        name: z.ZodString;
+        displayName: z.ZodOptional<z.ZodString>;
+        family: z.ZodOptional<z.ZodString>;
+        task: z.ZodOptional<z.ZodString>;
+        state: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        supportsTools: z.ZodOptional<z.ZodBoolean>;
+        profile: z.ZodOptional<z.ZodObject<{
+            quality: z.ZodOptional<z.ZodNumber>;
+            speed: z.ZodOptional<z.ZodNumber>;
+            cost: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        class: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"chat-thinking">, z.ZodLiteral<"chat-balanced">, z.ZodLiteral<"chat-fast">, z.ZodLiteral<"embedding">]>>;
+        serviceNames: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        modelServiceName: z.ZodOptional<z.ZodString>;
+        reasoningEfforts: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodLiteral<"none">, z.ZodLiteral<"minimal">, z.ZodLiteral<"low">, z.ZodLiteral<"medium">, z.ZodLiteral<"high">, z.ZodLiteral<"xhigh">, z.ZodLiteral<"max">]>>>;
+        status: z.ZodOptional<z.ZodObject<{
+            deprecated: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        dimension: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    modelClass: z.ZodUnion<readonly [z.ZodLiteral<"chat-thinking">, z.ZodLiteral<"chat-balanced">, z.ZodLiteral<"chat-fast">, z.ZodLiteral<"embedding">]>;
+    score: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;