@dbx-tools/model 0.3.37 → 0.3.39

package/package.json

@@ -13,22 +13,26 @@
   "dependencies": {
     "@databricks/appkit": "^0.43.0",
     "fuse.js": "^7.4.2",
-    "@dbx-tools/shared-model": "0.3.37",
-    "@dbx-tools/appkit": "0.3.37",
-    "@dbx-tools/shared-core": "0.3.37"
+    "@dbx-tools/appkit": "0.3.39",
+    "@dbx-tools/shared-model": "0.3.39",
+    "@dbx-tools/shared-core": "0.3.39"
   },
   "main": "index.ts",
   "license": "UNLICENSED",
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.3.37",
+  "version": "0.3.39",
   "types": "index.ts",
   "type": "module",
   "exports": {
     ".": "./index.ts",
     "./package.json": "./package.json"
   },
+  "files": [
+    "index.ts",
+    "src"
+  ],
   "dbxToolsConfig": {
     "tags": [
       "node"

package/test/classes.test.ts

@@ -1,74 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-
-import { model } from "@dbx-tools/shared-model";
-
-import {
-  CHAT_CLASS_ORDER,
-  classesAtOrBelow,
-  isChatClass,
-  MODEL_CLASS_ORDER,
-  parseModelClass,
-} from "../src/classes";
-
-const { ModelClass } = model;
-
-describe("CHAT_CLASS_ORDER / MODEL_CLASS_ORDER", () => {
-  it("orders chat bands most-capable first, embedding excluded from the ladder", () => {
-    assert.deepEqual(CHAT_CLASS_ORDER, [
-      ModelClass.ChatThinking,
-      ModelClass.ChatBalanced,
-      ModelClass.ChatFast,
-    ]);
-    assert.deepEqual(MODEL_CLASS_ORDER, [
-      ModelClass.ChatThinking,
-      ModelClass.ChatBalanced,
-      ModelClass.ChatFast,
-      ModelClass.Embedding,
-    ]);
-  });
-});
-
-describe("isChatClass", () => {
-  it("is true for chat bands and false for embedding", () => {
-    assert.equal(isChatClass(ModelClass.ChatThinking), true);
-    assert.equal(isChatClass(ModelClass.ChatFast), true);
-    assert.equal(isChatClass(ModelClass.Embedding), false);
-  });
-});
-
-describe("classesAtOrBelow", () => {
-  it("treats a chat band as a ceiling - the band and everything below it", () => {
-    assert.deepEqual(classesAtOrBelow(ModelClass.ChatThinking), [
-      ModelClass.ChatThinking,
-      ModelClass.ChatBalanced,
-      ModelClass.ChatFast,
-    ]);
-    assert.deepEqual(classesAtOrBelow(ModelClass.ChatBalanced), [
-      ModelClass.ChatBalanced,
-      ModelClass.ChatFast,
-    ]);
-    assert.deepEqual(classesAtOrBelow(ModelClass.ChatFast), [ModelClass.ChatFast]);
-  });
-
-  it("keeps embedding to itself - it is not a rung on the chat ladder", () => {
-    assert.deepEqual(classesAtOrBelow(ModelClass.Embedding), [ModelClass.Embedding]);
-  });
-});
-
-describe("parseModelClass", () => {
-  it("accepts full slugs and rejects junk", () => {
-    assert.equal(parseModelClass("chat-thinking"), ModelClass.ChatThinking);
-    assert.equal(parseModelClass("chat-balanced"), ModelClass.ChatBalanced);
-    assert.equal(parseModelClass("chat-fast"), ModelClass.ChatFast);
-    assert.equal(parseModelClass("embedding"), ModelClass.Embedding);
-    assert.equal(parseModelClass("medium"), null);
-    assert.equal(parseModelClass(undefined), null);
-  });
-
-  it("resolves a bare chat band via the chat- prefix shorthand", () => {
-    assert.equal(parseModelClass("thinking"), ModelClass.ChatThinking);
-    assert.equal(parseModelClass("balanced"), ModelClass.ChatBalanced);
-    assert.equal(parseModelClass("fast"), ModelClass.ChatFast);
-  });
-});

package/test/resolve.test.ts

@@ -1,169 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-
-import { model, type ServingEndpointSummary } from "@dbx-tools/shared-model";
-
-import { FALLBACK_MODEL_IDS, modelsForClass } from "../src/fallback";
-import { rankModels, resolveModel } from "../src/resolve";
-import { resolveModelId, searchServingEndpoints } from "../src/serving";
-
-const { ModelClass } = model;
-
-const CHAT_TASK = "llm/v1/chat";
-const EMBEDDING_TASK = "llm/v1/embeddings";
-
-/**
- * Unscored chat endpoints classify deterministically by family name (opus ->
- * ChatThinking, sonnet -> ChatBalanced, haiku -> ChatFast), so class membership
- * in these tests doesn't depend on quality quantiles.
- */
-function chat(name: string): ServingEndpointSummary {
-  return { name, task: CHAT_TASK };
-}
-
-/** An embedding endpoint - classified into ModelClass.Embedding by task. */
-function embedding(name: string): ServingEndpointSummary {
-  return { name, task: EMBEDDING_TASK };
-}
-
-const OPUS_8 = "databricks-claude-opus-4-8";
-const OPUS_7 = "databricks-claude-opus-4-7";
-const OPUS_6 = "databricks-claude-opus-4-6";
-const SONNET = "databricks-claude-sonnet-4-6";
-const HAIKU_5 = "databricks-claude-haiku-4-5";
-const HAIKU_3 = "databricks-claude-haiku-4-3";
-const GTE = "databricks-gte-large-en";
-const BGE = "databricks-bge-large-en";
-
-/** opus (ChatThinking) / sonnet (ChatBalanced) / haiku (ChatFast) - one per band. */
-const TIERED = [chat(OPUS_8), chat(SONNET), chat(HAIKU_5)];
-
-function names(models: { endpoint: ServingEndpointSummary }[]): string[] {
-  return models.map((m) => m.endpoint.name);
-}
-
-describe("searchServingEndpoints / resolveModelId", () => {
-  const endpoints = [chat(OPUS_8), chat(SONNET), chat(HAIKU_5)];
-
-  it("short-circuits an exact name to score 0", () => {
-    const [best] = searchServingEndpoints(SONNET, endpoints);
-    assert.equal(best?.endpoint.name, SONNET);
-    assert.equal(best?.score, 0);
-  });
-
-  it("tokenized fuzzy-matches a loose name", () => {
-    const result = resolveModelId("claude sonnet", endpoints);
-    assert.equal(result.matched, true);
-    assert.equal(result.modelId, SONNET);
-  });
-
-  it("returns the input verbatim when nothing matches", () => {
-    const result = resolveModelId("zzz-no-such-model", endpoints);
-    assert.equal(result.matched, false);
-    assert.equal(result.modelId, "zzz-no-such-model");
-  });
-
-  it("returns [] for an empty catalogue", () => {
-    assert.deepEqual(searchServingEndpoints("opus", []), []);
-  });
-});
-
-describe("rankModels", () => {
-  it("ranks a search match-then-class, version breaking the tie", () => {
-    const ranked = rankModels([chat(OPUS_6), chat(OPUS_8), chat(OPUS_7)], {
-      search: "opus",
-    });
-    assert.deepEqual(names(ranked), [OPUS_8, OPUS_7, OPUS_6]);
-  });
-
-  it("with no search, orders by class then within-class rank", () => {
-    const ranked = rankModels(TIERED);
-    assert.deepEqual(names(ranked), [OPUS_8, SONNET, HAIKU_5]);
-    assert.deepEqual(
-      ranked.map((m) => m.modelClass),
-      [ModelClass.ChatThinking, ModelClass.ChatBalanced, ModelClass.ChatFast],
-    );
-  });
-
-  it("excludes embeddings from the default (chat-only) ranking", () => {
-    const ranked = rankModels([chat(OPUS_8), embedding(GTE), embedding(BGE)]);
-    assert.deepEqual(names(ranked), [OPUS_8]);
-  });
-
-  it("ranks embeddings only when ModelClass.Embedding is requested", () => {
-    const ranked = rankModels([chat(OPUS_8), embedding(GTE), embedding(BGE)], {
-      modelClass: ModelClass.Embedding,
-    });
-    assert.deepEqual(names(ranked), [GTE, BGE]); // no chat model leaks in
-  });
-
-  it("treats a chat class as a ceiling: that band and below, never above", () => {
-    const ranked = rankModels(TIERED, { modelClass: ModelClass.ChatBalanced });
-    assert.deepEqual(names(ranked), [SONNET, HAIKU_5]); // no opus (ChatThinking)
-  });
-
-  it("degrades to a lower band when the requested band is empty", () => {
-    // "medium" requested but only "small" exists -> the highest small is
-    // returned, never a "large".
-    const ranked = rankModels([chat(OPUS_8), chat(HAIKU_5), chat(HAIKU_3)], {
-      modelClass: ModelClass.ChatBalanced,
-      limit: 1,
-    });
-    assert.deepEqual(names(ranked), [HAIKU_5]);
-  });
-
-  it("scopes a search to the class ceiling", () => {
-    const ranked = rankModels(TIERED, {
-      search: "claude",
-      modelClass: ModelClass.ChatFast,
-    });
-    assert.deepEqual(names(ranked), [HAIKU_5]); // opus / sonnet excluded by ceiling
-  });
-
-  it("applies a limit", () => {
-    assert.equal(rankModels(TIERED, { limit: 2 }).length, 2);
-  });
-});
-
-describe("resolveModel", () => {
-  it("fuzzy-resolves an explicit name to the best ranked match (limit 1)", () => {
-    const result = resolveModel([chat(OPUS_6), chat(OPUS_8), chat(OPUS_7)], {
-      explicit: "opus",
-    });
-    assert.deepEqual(result, { modelId: OPUS_8, source: "fuzzy-match" });
-  });
-
-  it("returns an explicit name verbatim when fuzzy is off", () => {
-    const result = resolveModel(TIERED, { explicit: "my-pinned-model", fuzzy: false });
-    assert.deepEqual(result, { modelId: "my-pinned-model", source: "explicit" });
-  });
-
-  it("resolves a class ask to the top of that band and below", () => {
-    const result = resolveModel(TIERED, { modelClass: ModelClass.ChatBalanced });
-    assert.deepEqual(result, { modelId: SONNET, source: "class" });
-  });
-
-  it("never selects an embedding model for a general (chat) ask", () => {
-    const result = resolveModel([embedding(GTE), chat(SONNET)]);
-    assert.equal(result.modelId, SONNET);
-  });
-
-  it("lets an operator-pinned fallback present in the catalogue win", () => {
-    const pinned = "databricks-approved-custom";
-    const result = resolveModel([...TIERED, chat(pinned)], { fallbacks: [pinned] });
-    assert.deepEqual(result, { modelId: pinned, source: "fallback" });
-  });
-
-  it("falls back to the class's static floor for an empty catalogue", () => {
-    const result = resolveModel([], { modelClass: ModelClass.ChatBalanced });
-    assert.deepEqual(result, {
-      modelId: modelsForClass(ModelClass.ChatBalanced)[0]!,
-      source: "class",
-    });
-  });
-
-  it("falls back to the static floor with no intent and an empty catalogue", () => {
-    const result = resolveModel([], {});
-    assert.deepEqual(result, { modelId: FALLBACK_MODEL_IDS[0]!, source: "fallback" });
-  });
-});

package/test/tsconfig.json

@@ -1,14 +0,0 @@
-// ~~ Generated by projen. To modify, edit .projenrc.js and run "pnpm exec projen".
-{
-  "extends": "../tsconfig.json",
-  "compilerOptions": {
-    "noEmit": true,
-    "rootDir": ".."
-  },
-  "include": [
-    "**/*.ts"
-  ],
-  "exclude": [
-    "node_modules"
-  ]
-}

package/tsconfig.json

@@ -1,41 +0,0 @@
-// ~~ Generated by projen. To modify, edit .projenrc.js and run "pnpm exec projen".
-{
-  "compilerOptions": {
-    "rootDir": "src",
-    "outDir": "lib",
-    "alwaysStrict": true,
-    "declaration": true,
-    "esModuleInterop": true,
-    "experimentalDecorators": true,
-    "inlineSourceMap": true,
-    "inlineSources": true,
-    "lib": [
-      "ES2022"
-    ],
-    "module": "ESNext",
-    "noEmitOnError": false,
-    "noFallthroughCasesInSwitch": true,
-    "noImplicitAny": true,
-    "noImplicitReturns": true,
-    "noImplicitThis": true,
-    "noUnusedLocals": true,
-    "noUnusedParameters": true,
-    "resolveJsonModule": true,
-    "strict": true,
-    "strictNullChecks": true,
-    "strictPropertyInitialization": true,
-    "stripInternal": true,
-    "target": "ES2022",
-    "types": [
-      "node"
-    ],
-    "moduleResolution": "bundler",
-    "skipLibCheck": true
-  },
-  "include": [
-    "src/**/*.ts"
-  ],
-  "exclude": [
-    "node_modules"
-  ]
-}