@dbx-tools/shared-model 0.3.37 → 0.3.39

package/package.json

@@ -12,20 +12,24 @@
   },
   "dependencies": {
     "zod": "4.3.6",
-    "@dbx-tools/shared-core": "0.3.37"
+    "@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": [
       "shared"

package/test/classify.test.ts

@@ -1,211 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import {
-  classifyByFamily,
-  classifyEndpoints,
-  endpointCapabilities,
-  versionTuple,
-} from "../src/classify";
-import { ModelClass, type ModelProfile, type ServingEndpointSummary } from "../src/model";
-
-const CHAT_TASK = "llm/v1/chat";
-const EMBEDDING_TASK = "llm/v1/embeddings";
-
-/** Build a chat serving endpoint, optionally scored, for classifier fixtures. */
-function chat(name: string, profile?: ModelProfile): ServingEndpointSummary {
-  return { name, task: CHAT_TASK, ...(profile ? { profile } : {}) };
-}
-
-/** Build an embedding serving endpoint for classifier fixtures. */
-function embedding(name: string): ServingEndpointSummary {
-  return { name, task: EMBEDDING_TASK };
-}
-
-/** Names of the endpoints classified into `cls`, in ranked order. */
-function classNames(
-  buckets: Record<ModelClass, ServingEndpointSummary[]>,
-  cls: ModelClass,
-): string[] {
-  return buckets[cls].map((e) => e.name);
-}
-
-describe("versionTuple", () => {
-  it("reads major.minor.patch starting at the first digit", () => {
-    assert.deepEqual(versionTuple("databricks-claude-opus-4-8"), [4, 8, 0]);
-    assert.deepEqual(versionTuple("databricks-claude-opus-4-7"), [4, 7, 0]);
-    assert.deepEqual(versionTuple("databricks-gpt-5-5"), [5, 5, 0]);
-  });
-
-  it("keeps double-digit components numeric (no decimal collapse)", () => {
-    assert.deepEqual(versionTuple("databricks-claude-opus-4-10"), [4, 10, 0]);
-    // 4.10 must sort ABOVE 4.8 - the bug a `major + minor/10` score hit.
-    const [, tenMinor] = versionTuple("databricks-claude-opus-4-10");
-    const [, eightMinor] = versionTuple("databricks-claude-opus-4-8");
-    assert.ok(tenMinor > eightMinor);
-  });
-
-  it("reads a parameter-size suffix as the patch component", () => {
-    assert.deepEqual(versionTuple("databricks-meta-llama-3-3-70b-instruct"), [3, 3, 70]);
-    assert.deepEqual(versionTuple("databricks-gpt-oss-120b"), [120, 0, 0]);
-  });
-
-  it("returns all-zero for names with no digits", () => {
-    assert.deepEqual(versionTuple("databricks-bge-large-en"), [0, 0, 0]);
-  });
-});
-
-describe("endpointCapabilities", () => {
-  it("reads capability off the task hint", () => {
-    assert.deepEqual(endpointCapabilities(chat("databricks-gpt-5-5")), {
-      chat: true,
-      embedding: false,
-      tools: true,
-    });
-    assert.deepEqual(endpointCapabilities(embedding("databricks-gte-large-en")), {
-      chat: false,
-      embedding: true,
-      tools: false,
-    });
-  });
-
-  it("falls back to the classified class when the endpoint carries no task", () => {
-    assert.equal(
-      endpointCapabilities({ name: "custom", class: ModelClass.ChatFast }).chat,
-      true,
-    );
-    assert.equal(
-      endpointCapabilities({ name: "custom", class: ModelClass.Embedding }).embedding,
-      true,
-    );
-  });
-
-  it("keeps an unclassified, untasked endpoint out of both buckets", () => {
-    assert.deepEqual(endpointCapabilities({ name: "mystery" }), {
-      chat: false,
-      embedding: false,
-      tools: false,
-    });
-  });
-
-  it("lets embedding win when task and class disagree", () => {
-    const conflicted: ServingEndpointSummary = {
-      name: "databricks-gte-large-en",
-      task: EMBEDDING_TASK,
-      class: ModelClass.ChatFast,
-    };
-    assert.deepEqual(endpointCapabilities(conflicted), {
-      chat: false,
-      embedding: true,
-      tools: false,
-    });
-  });
-});
-
-describe("classifyEndpoints", () => {
-  it("buckets scored models by quality quantiles, best-first", () => {
-    // Three clear quality bands (gaps keep the 1/3 and 2/3 quantiles
-    // between bands), two models per chat band.
-    const buckets = classifyEndpoints([
-      chat("databricks-claude-opus-4-8", { quality: 90, cost: 10, speed: 44 }),
-      chat("databricks-claude-opus-4-7", { quality: 88, cost: 10, speed: 44 }),
-      chat("databricks-claude-sonnet-4-6", { quality: 50, cost: 18, speed: 55 }),
-      chat("databricks-gpt-5-5", { quality: 48, cost: 20, speed: 50 }),
-      chat("databricks-claude-haiku-4-5", { quality: 10, cost: 5, speed: 80 }),
-      chat("databricks-meta-llama-3-1-8b-instruct", { quality: 8, cost: 3, speed: 90 }),
-    ]);
-    assert.deepEqual(classNames(buckets, ModelClass.ChatThinking), [
-      "databricks-claude-opus-4-8",
-      "databricks-claude-opus-4-7",
-    ]);
-    assert.deepEqual(classNames(buckets, ModelClass.ChatBalanced), [
-      "databricks-claude-sonnet-4-6",
-      "databricks-gpt-5-5",
-    ]);
-    assert.deepEqual(classNames(buckets, ModelClass.ChatFast), [
-      "databricks-claude-haiku-4-5",
-      "databricks-meta-llama-3-1-8b-instruct",
-    ]);
-  });
-
-  it("breaks a scored tie (same quality/cost/speed) by parsed version", () => {
-    // All identical except the trailing version: only versionTuple can
-    // order them. This is the live `q=46` Opus case.
-    const buckets = classifyEndpoints([
-      chat("databricks-claude-opus-4-6", { quality: 90, cost: 10, speed: 44 }),
-      chat("databricks-claude-opus-4-8", { quality: 90, cost: 10, speed: 44 }),
-      chat("databricks-claude-opus-4-7", { quality: 90, cost: 10, speed: 44 }),
-    ]);
-    assert.deepEqual(classNames(buckets, ModelClass.ChatThinking), [
-      "databricks-claude-opus-4-8",
-      "databricks-claude-opus-4-7",
-      "databricks-claude-opus-4-6",
-    ]);
-  });
-
-  it("orders a double-digit point release above a single-digit one", () => {
-    const buckets = classifyEndpoints([
-      chat("databricks-claude-opus-4-9", { quality: 90, cost: 10, speed: 44 }),
-      chat("databricks-claude-opus-4-10", { quality: 90, cost: 10, speed: 44 }),
-    ]);
-    assert.deepEqual(classNames(buckets, ModelClass.ChatThinking), [
-      "databricks-claude-opus-4-10",
-      "databricks-claude-opus-4-9",
-    ]);
-  });
-
-  it("places unscored but recognizable chat endpoints by family heuristic", () => {
-    const buckets = classifyEndpoints([
-      chat("databricks-claude-opus-4-1"),
-      chat("databricks-claude-sonnet-4-0"),
-      chat("databricks-claude-haiku-3-5"),
-    ]);
-    assert.deepEqual(classNames(buckets, ModelClass.ChatThinking), [
-      "databricks-claude-opus-4-1",
-    ]);
-    assert.deepEqual(classNames(buckets, ModelClass.ChatBalanced), [
-      "databricks-claude-sonnet-4-0",
-    ]);
-    assert.deepEqual(classNames(buckets, ModelClass.ChatFast), [
-      "databricks-claude-haiku-3-5",
-    ]);
-  });
-
-  it("buckets embedding endpoints by task, regardless of name or score", () => {
-    const buckets = classifyEndpoints([
-      chat("databricks-claude-opus-4-1"),
-      embedding("databricks-gte-large-en"),
-      embedding("databricks-bge-large-en"),
-    ]);
-    assert.deepEqual(classNames(buckets, ModelClass.Embedding), [
-      "databricks-gte-large-en",
-      "databricks-bge-large-en",
-    ]);
-    // Embeddings never leak into a chat band.
-    assert.deepEqual(classNames(buckets, ModelClass.ChatThinking), [
-      "databricks-claude-opus-4-1",
-    ]);
-  });
-
-  it("omits unrecognized unscored chat endpoints from every chat band", () => {
-    const buckets = classifyEndpoints([
-      chat("databricks-claude-opus-4-1"),
-      chat("databricks-some-custom-thing"),
-    ]);
-    const chatNames = [
-      ...buckets[ModelClass.ChatThinking],
-      ...buckets[ModelClass.ChatBalanced],
-      ...buckets[ModelClass.ChatFast],
-    ].map((e) => e.name);
-    assert.deepEqual(chatNames, ["databricks-claude-opus-4-1"]);
-  });
-});
-
-describe("classifyByFamily", () => {
-  it("maps well-known variants to chat classes and returns null for unknowns", () => {
-    assert.equal(classifyByFamily("databricks-claude-opus-4-8")?.class, ModelClass.ChatThinking);
-    assert.equal(classifyByFamily("databricks-claude-sonnet-4-6")?.class, ModelClass.ChatBalanced);
-    assert.equal(classifyByFamily("databricks-claude-haiku-4-5")?.class, ModelClass.ChatFast);
-    assert.equal(classifyByFamily("databricks-gpt-5-nano")?.class, ModelClass.ChatFast);
-    assert.equal(classifyByFamily("databricks-some-custom-thing"), null);
-  });
-});

package/test/display.test.ts

@@ -1,45 +0,0 @@
-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

@@ -1,80 +0,0 @@
-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

@@ -1,312 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import type { ChatMessage } from "../src/openai-chat";
-import {
-  chatToResponse,
-  createResponsesStreamTranslator,
-  readResponsesOutput,
-  responsesToChat,
-  sanitizeOpenResponsesRequest,
-} 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: [] });
-  });
-});
-
-describe("sanitizeOpenResponsesRequest", () => {
-  it("rewrites output_text content parts to input_text", () => {
-    const out = sanitizeOpenResponsesRequest({
-      input: [
-        {
-          type: "message",
-          role: "assistant",
-          content: [{ type: "output_text", text: "hi" }],
-        },
-      ],
-    });
-    assert.deepEqual(out.input, [
-      {
-        type: "message",
-        role: "assistant",
-        content: [{ type: "input_text", text: "hi" }],
-      },
-    ]);
-  });
-
-  it("strips redacted_thinking / thinking content parts and reasoning items", () => {
-    const out = sanitizeOpenResponsesRequest({
-      input: [
-        { type: "reasoning", summary: [{ type: "summary_text", text: "plan" }] },
-        {
-          type: "message",
-          role: "assistant",
-          content: [
-            { type: "redacted_thinking", data: "not-a-valid-blob" },
-            { type: "thinking", thinking: "secret" },
-            { type: "output_text", text: "visible" },
-          ],
-        },
-      ],
-    });
-    assert.deepEqual(out.input, [
-      {
-        type: "message",
-        role: "assistant",
-        content: [{ type: "input_text", text: "visible" }],
-      },
-    ]);
-  });
-
-  it("drops assistant turns that only carried thinking", () => {
-    const out = sanitizeOpenResponsesRequest({
-      input: [
-        {
-          type: "message",
-          role: "assistant",
-          content: [{ type: "redacted_thinking", data: "x" }],
-        },
-        { type: "message", role: "user", content: [{ type: "input_text", text: "next" }] },
-      ],
-    });
-    assert.deepEqual(out.input, [
-      { type: "message", role: "user", content: [{ type: "input_text", text: "next" }] },
-    ]);
-  });
-
-  it("strips non-function tools", () => {
-    const out = sanitizeOpenResponsesRequest({
-      input: [],
-      tools: [{ type: "web_search" }, { type: "function", name: "f", parameters: {} }],
-    });
-    assert.deepEqual(out.tools, [{ type: "function", name: "f", parameters: {} }]);
-  });
-});

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,40 +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",
-      "WebWorker"
-    ],
-    "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": [],
-    "moduleResolution": "bundler",
-    "skipLibCheck": true
-  },
-  "include": [
-    "src/**/*.ts"
-  ],
-  "exclude": [
-    "node_modules"
-  ]
-}