@dbx-tools/shared-model 0.1.23 → 0.1.24

package/package.json

@@ -12,14 +12,14 @@
   },
   "dependencies": {
     "zod": "^4.3.6",
-    "@dbx-tools/shared-core": "0.1.23"
+    "@dbx-tools/shared-core": "0.1.24"
   },
   "main": "index.ts",
   "license": "UNLICENSED",
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.1.23",
+  "version": "0.1.24",
   "types": "index.ts",
   "type": "module",
   "exports": {

package/src/display.ts

@@ -19,41 +19,92 @@ import { string } from "@dbx-tools/shared-core";
  */
 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: Record<string, string> = { system: "ai" };
+
+/** Segment-internal tokens rendered fully uppercased (acronyms), not title-cased. */
+const ACRONYMS = new Set(["gpt", "gte", "bge", "dbrx", "oss", "ai", "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 `name` is
- * tokenized with the shared-core tokenizer (which title-cases and
- * special-cases "AI"), known leading vendor prefixes are dropped, and the
- * remaining tokens are joined with spaces. Falls back to the trimmed raw
- * `name` if stripping leaves nothing.
+ * 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("system.ai.bge_large_en")       // "Bge Large En"
- * toModelDisplayName("x", "GPT-5 (Preview)")          // "GPT-5 (Preview)"
+ * 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: string, provided?: string | null): string {
   const providedTrimmed = string.trimToNull(provided);
   if (providedTrimmed) return providedTrimmed;
 
-  const tokens = [...string.tokenizeWithOptions({ capitalize: true }, name)];
-  // Drop known vendor/namespace prefixes only while they lead the list, so
-  // a model literally named after one of these words mid-string is kept.
+  const segments = name.split(SEGMENT_SPLIT).filter(Boolean);
+  // Drop known vendor/namespace prefixes only while they lead the list.
   let start = 0;
-  while (start < tokens.length && STRIP_LEADING_TOKENS.has(tokens[start]!.toLowerCase())) {
-    // `system` is followed by `ai` in the `system.ai.*` builtin namespace;
-    // consume that `ai` too (but only right after `system`, never alone).
-    if (
-      tokens[start]!.toLowerCase() === "system" &&
-      tokens[start + 1]?.toLowerCase() === "ai"
-    ) {
+  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 = tokens.slice(start);
-  const label = (kept.length > 0 ? kept : tokens).join(" ");
-  return label || name.trim();
+  const kept = segments.slice(start);
+  const source = kept.length > 0 ? kept : segments;
+
+  const pieces: string[] = [];
+  let versionRun: string[] = [];
+  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: string): string {
+  const tokens = [...string.tokenizeWithOptions({ capitalize: true }, segment)];
+  const out: string[] = [];
+  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(" ");
 }