@dbx-tools/shared-model 0.3.22 → 0.3.23

package/package.json

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

package/src/display.ts

@@ -103,11 +103,7 @@ function renderSegment(segment: string): string {
     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]!)
-    ) {
+    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;
     }

package/test/display.test.ts

@@ -0,0 +1,45 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { toModelDisplayName } from "../src/display";
+
+describe("toModelDisplayName", () => {
+  it("strips a leading databricks prefix and dots the version", () => {
+    assert.equal(toModelDisplayName("databricks-claude-sonnet-4-6"), "Claude Sonnet 4.6");
+  });
+
+  it("strips the system.ai namespace and uppercases acronyms", () => {
+    assert.equal(toModelDisplayName("system.ai.bge_large_en"), "BGE Large En");
+  });
+
+  it("uppercases GPT/OSS and glues the size unit", () => {
+    assert.equal(toModelDisplayName("databricks-gpt-oss-120b"), "GPT OSS 120B");
+  });
+
+  it("restores AI casing", () => {
+    assert.equal(toModelDisplayName("databricks-ai-router"), "AI Router");
+  });
+
+  it("joins multi-part version runs with dots", () => {
+    assert.equal(
+      toModelDisplayName("databricks-meta-llama-3-3-70b-instruct"),
+      "Meta Llama 3.3 70B Instruct",
+    );
+  });
+
+  it("prefers a Databricks-provided name verbatim", () => {
+    assert.equal(
+      toModelDisplayName("databricks-claude-sonnet-4-6", "Claude Sonnet 4.6 (Preview)"),
+      "Claude Sonnet 4.6 (Preview)",
+    );
+  });
+
+  it("ignores a blank provided name and falls back to the derived label", () => {
+    assert.equal(toModelDisplayName("databricks-gpt-5-5", "   "), "GPT 5.5");
+  });
+
+  it("title-cases a bare vendor token when nothing else remains", () => {
+    // Only leading vendor prefixes are stripped, and never the last
+    // remaining token, so a name that is *only* a vendor word stays.
+    assert.equal(toModelDisplayName("databricks"), "Databricks");
+  });
+});

package/test/openai-chat.test.ts

@@ -0,0 +1,80 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import {
+  UNSUPPORTED_CHAT_FIELDS,
+  chatContentToText,
+  stripUnsupportedChatFields,
+} from "../src/openai-chat";
+
+describe("chatContentToText", () => {
+  it("passes a string through and flattens typed parts", () => {
+    assert.equal(chatContentToText("hello"), "hello");
+    assert.equal(
+      chatContentToText([{ type: "input_text", text: "a" }, { type: "output_text", text: "b" }]),
+      "ab",
+    );
+  });
+
+  it("honors a separator and a type filter", () => {
+    const content = [
+      { type: "text", text: "one" },
+      { type: "thinking", text: "hidden" },
+      { type: "text", text: "two" },
+    ];
+    assert.equal(chatContentToText(content, { separator: "\n\n", types: ["text"] }), "one\n\ntwo");
+  });
+
+  it("yields empty string for anything it can't read", () => {
+    assert.equal(chatContentToText(null), "");
+    assert.equal(chatContentToText(undefined), "");
+    assert.equal(chatContentToText([{ type: "image_url" }]), "");
+  });
+});
+
+describe("stripUnsupportedChatFields", () => {
+  it("drops parallel_tool_calls, the field Databricks rejects outright", () => {
+    const body: Record<string, unknown> = {
+      model: "databricks-claude-opus-4-8",
+      messages: [],
+      parallel_tool_calls: false,
+    };
+    assert.deepEqual(stripUnsupportedChatFields(body), ["parallel_tool_calls"]);
+    assert.deepEqual(body, { model: "databricks-claude-opus-4-8", messages: [] });
+  });
+
+  it("drops a field present with a falsy or null value", () => {
+    const body: Record<string, unknown> = { store: false, metadata: null };
+    assert.deepEqual(stripUnsupportedChatFields(body).sort(), ["metadata", "store"]);
+    assert.deepEqual(body, {});
+  });
+
+  it("leaves a supported body untouched and reports nothing dropped", () => {
+    const body: Record<string, unknown> = {
+      model: "m",
+      messages: [{ role: "user", content: "hi" }],
+      stream: true,
+      tools: [],
+      tool_choice: "auto",
+      temperature: 0.2,
+      max_tokens: 64,
+    };
+    const before = structuredClone(body);
+    assert.deepEqual(stripUnsupportedChatFields(body), []);
+    assert.deepEqual(body, before);
+  });
+
+  it("drops caller-supplied extra fields alongside the built-in list", () => {
+    const body: Record<string, unknown> = { store: true, future_field: 1, keep: 2 };
+    assert.deepEqual(stripUnsupportedChatFields(body, ["future_field"]), [
+      "store",
+      "future_field",
+    ]);
+    assert.deepEqual(body, { keep: 2 });
+  });
+
+  it("covers every name it advertises", () => {
+    const body = Object.fromEntries(UNSUPPORTED_CHAT_FIELDS.map((field) => [field, 1]));
+    assert.deepEqual(stripUnsupportedChatFields(body), [...UNSUPPORTED_CHAT_FIELDS]);
+    assert.deepEqual(body, {});
+  });
+});

package/test/openai-responses.test.ts

@@ -0,0 +1,242 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import type { ChatMessage } from "../src/openai-chat";
+import {
+  chatToResponse,
+  createResponsesStreamTranslator,
+  readResponsesOutput,
+  responsesToChat,
+} from "../src/openai-responses";
+
+/** The `messages` a lowered Responses body produced, typed for assertions. */
+function messagesOf(body: Record<string, unknown>): ChatMessage[] {
+  const { chat } = responsesToChat(body);
+  return chat.messages as ChatMessage[];
+}
+
+/** Event names, in order, from a block of SSE text. */
+function eventNames(sse: string): string[] {
+  return sse
+    .split("\n")
+    .filter((line) => line.startsWith("event: "))
+    .map((line) => line.slice("event: ".length));
+}
+
+/** Parsed `data:` payloads from a block of SSE text. */
+function eventData(sse: string): Record<string, unknown>[] {
+  return sse
+    .split("\n")
+    .filter((line) => line.startsWith("data: "))
+    .map((line) => JSON.parse(line.slice("data: ".length)) as Record<string, unknown>);
+}
+
+describe("responsesToChat", () => {
+  it("lowers instructions and message items into a chat transcript", () => {
+    const messages = messagesOf({
+      instructions: "be terse",
+      input: [{ type: "message", role: "user", content: [{ type: "input_text", text: "hi" }] }],
+    });
+    assert.deepEqual(messages, [
+      { role: "system", content: "be terse" },
+      { role: "user", content: "hi" },
+    ]);
+  });
+
+  it("maps the developer role to system (chat has no developer role)", () => {
+    const [first] = messagesOf({ input: [{ role: "developer", content: "policy" }] });
+    assert.equal(first?.role, "system");
+  });
+
+  it("re-attaches a prior function_call to an assistant turn", () => {
+    const [first] = messagesOf({
+      input: [{ type: "function_call", call_id: "c1", name: "lookup", arguments: '{"q":1}' }],
+    });
+    assert.equal(first?.role, "assistant");
+    assert.equal(first?.content, null);
+    assert.deepEqual(first?.tool_calls, [
+      { id: "c1", type: "function", function: { name: "lookup", arguments: '{"q":1}' } },
+    ]);
+  });
+
+  it("keys a function_call_output back to the call it answers", () => {
+    const [first] = messagesOf({
+      input: [{ type: "function_call_output", call_id: "c1", output: "42" }],
+    });
+    assert.deepEqual(first, { role: "tool", tool_call_id: "c1", content: "42" });
+  });
+
+  it("nests flat Responses function tools and drops built-in tool types", () => {
+    const { chat } = responsesToChat({
+      input: [],
+      tools: [
+        { type: "function", name: "lookup", description: "d", parameters: { type: "object" } },
+        { type: "local_shell" },
+        { type: "web_search" },
+      ],
+      tool_choice: "auto",
+    });
+    assert.deepEqual(chat.tools, [
+      {
+        type: "function",
+        function: { name: "lookup", description: "d", parameters: { type: "object" } },
+      },
+    ]);
+    assert.equal(chat.tool_choice, "auto");
+  });
+
+  it("never forwards parallel_tool_calls (Databricks rejects unknown fields)", () => {
+    const { chat } = responsesToChat({
+      input: [],
+      parallel_tool_calls: true,
+      tools: [{ type: "function", name: "lookup" }],
+    });
+    assert.ok(!("parallel_tool_calls" in chat));
+  });
+
+  it("reports the streaming flag", () => {
+    assert.equal(responsesToChat({ input: [] }).stream, false);
+    assert.equal(responsesToChat({ input: [], stream: true }).stream, true);
+  });
+});
+
+describe("chatToResponse", () => {
+  it("lifts assistant text, tool calls, and usage into a response object", () => {
+    const response = chatToResponse(
+      {
+        id: "chatcmpl-1",
+        created: 1700000000,
+        choices: [
+          {
+            message: {
+              content: "done",
+              tool_calls: [{ id: "c1", function: { name: "lookup", arguments: '{"q":1}' } }],
+            },
+          },
+        ],
+        usage: { prompt_tokens: 3, completion_tokens: 4, total_tokens: 7 },
+      },
+      "databricks-claude-opus-4-8",
+    ) as Record<string, unknown>;
+
+    assert.equal(response.id, "chatcmpl-1");
+    assert.equal(response.status, "completed");
+    assert.equal(response.model, "databricks-claude-opus-4-8");
+    assert.deepEqual(response.output, [
+      { type: "message", role: "assistant", content: [{ type: "output_text", text: "done" }] },
+      { type: "function_call", call_id: "c1", name: "lookup", arguments: '{"q":1}' },
+    ]);
+    assert.deepEqual(response.usage, { input_tokens: 3, output_tokens: 4, total_tokens: 7 });
+  });
+
+  it("omits the message item when the turn was tool calls only", () => {
+    const response = chatToResponse(
+      { choices: [{ message: { content: null, tool_calls: [] } }] },
+      "m",
+    ) as { output: unknown[] };
+    assert.deepEqual(response.output, []);
+  });
+});
+
+describe("createResponsesStreamTranslator", () => {
+  it("opens on the first chunk and closes the text run at finish", () => {
+    const translator = createResponsesStreamTranslator("m", "resp-1");
+    const first = translator.feed({ choices: [{ delta: { content: "he" } }] });
+    assert.deepEqual(eventNames(first), [
+      "response.created",
+      "response.output_item.added",
+      "response.output_text.delta",
+    ]);
+
+    const second = translator.feed({ choices: [{ delta: { content: "llo" } }] });
+    assert.deepEqual(eventNames(second), ["response.output_text.delta"]);
+
+    const done = translator.finish();
+    assert.deepEqual(eventNames(done), [
+      "response.output_text.done",
+      "response.output_item.done",
+      "response.completed",
+    ]);
+    // The buffered text is what the client renders as the final message.
+    assert.equal(eventData(done)[0]?.text, "hello");
+  });
+
+  it("assembles argument fragments into one function_call item", () => {
+    const translator = createResponsesStreamTranslator("m", "resp-1");
+    translator.feed({
+      choices: [
+        { delta: { tool_calls: [{ index: 0, id: "c1", function: { name: "lookup" } }] } },
+      ],
+    });
+    translator.feed({ choices: [{ delta: { tool_calls: [{ index: 0, function: { arguments: '{"q' } }] } }] });
+    translator.feed({ choices: [{ delta: { tool_calls: [{ index: 0, function: { arguments: '":1}' } }] } }] });
+
+    const done = translator.finish();
+    const [args] = eventData(done);
+    assert.equal(args?.arguments, '{"q":1}');
+    assert.ok(eventNames(done).includes("response.function_call_arguments.done"));
+  });
+
+  it("closes an open text run before opening a tool call so output stays ordered", () => {
+    const translator = createResponsesStreamTranslator("m", "resp-1");
+    translator.feed({ choices: [{ delta: { content: "thinking" } }] });
+    const withTool = translator.feed({
+      choices: [{ delta: { tool_calls: [{ index: 0, id: "c1", function: { name: "f" } }] } }],
+    });
+    assert.deepEqual(eventNames(withTool), [
+      "response.output_text.done",
+      "response.output_item.done",
+      "response.output_item.added",
+    ]);
+  });
+
+  it("emits nothing but the lifecycle for an empty chunk", () => {
+    const translator = createResponsesStreamTranslator("m", "resp-1");
+    assert.deepEqual(eventNames(translator.feed({})), ["response.created"]);
+    assert.deepEqual(eventNames(translator.finish()), ["response.completed"]);
+  });
+});
+
+describe("readResponsesOutput", () => {
+  it("prefers the flattened output_text", () => {
+    const { text } = readResponsesOutput({
+      output_text: "  the answer  ",
+      output: [{ content: [{ text: "ignored" }] }],
+    });
+    assert.equal(text, "the answer");
+  });
+
+  it("falls back to joining the output items", () => {
+    const { text } = readResponsesOutput({
+      output: [{ content: [{ text: "one" }, { text: "two" }] }],
+    });
+    assert.equal(text, "one\ntwo");
+  });
+
+  it("collects url_citation annotations, deduplicated by url", () => {
+    const { citations } = readResponsesOutput({
+      output: [
+        {
+          content: [
+            {
+              text: "answer",
+              annotations: [
+                { type: "url_citation", url: "https://a.example", title: "A" },
+                { type: "url_citation", url: "https://a.example", title: "A again" },
+                { type: "url_citation", url: "https://b.example" },
+                { type: "file_citation" },
+              ],
+            },
+          ],
+        },
+      ],
+    });
+    assert.deepEqual(citations, [
+      { url: "https://a.example", title: "A" },
+      { url: "https://b.example" },
+    ]);
+  });
+
+  it("returns empty results for a payload with no output", () => {
+    assert.deepEqual(readResponsesOutput({}), { text: "", citations: [] });
+  });
+});

package/test/tsconfig.json

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