@velum-labs/routekit-gateway 0.9.8 → 0.9.10

package/dist/provider-backends.js

@@ -1,5 +1,6 @@
 import { randomId } from "@velum-labs/routekit-runtime";
 import { joinPath } from "./backend.js";
+import { droppedField } from "./adapters/dropped.js";
 import { SseDecoder, SseParseError } from "./sse/parse.js";
 import { ANTHROPIC_MESSAGE_CONTENT, ANTHROPIC_REQUEST_METADATA, anthropicReasoningDetailsOf, reasoningSelectionOf } from "./adapters/openai-chat-wire.js";
 class HttpProviderBackend {
@@ -135,6 +136,70 @@ function mapSse(response, mapper) {
         headers: { "content-type": "text/event-stream; charset=utf-8" }
     });
 }
+// Stands in for a closing turn that translated to nothing. Anthropic rejects
+// empty and whitespace-only text, so the stand-in has to say something.
+const BLANK_TURN_PLACEHOLDER = "(continue)";
+function anthropicContentIsEmpty(message) {
+    return Array.isArray(message?.content) && message.content.length === 0;
+}
+function anthropicImageBlock(part) {
+    const imageUrl = part.image_url;
+    const url = typeof imageUrl === "string"
+        ? imageUrl
+        : typeof imageUrl === "object" &&
+            imageUrl !== null &&
+            typeof imageUrl.url === "string"
+            ? imageUrl.url
+            : undefined;
+    if (url === undefined)
+        return undefined;
+    const dataUrl = /^data:([^;,]+);base64,(.+)$/s.exec(url);
+    if (dataUrl !== null) {
+        return {
+            type: "image",
+            source: { type: "base64", media_type: dataUrl[1], data: dataUrl[2] }
+        };
+    }
+    if (/^https?:\/\//i.test(url))
+        return { type: "image", source: { type: "url", url } };
+    return undefined;
+}
+/**
+ * Translate OpenAI chat content into Anthropic content blocks.
+ *
+ * Anthropic rejects text blocks that are empty or whitespace-only, so those are
+ * skipped here rather than sent upstream. Callers must handle the resulting
+ * empty block list; see {@link anthropicMessages}.
+ */
+function anthropicContentBlocks(content, context) {
+    if (typeof content === "string") {
+        return content.trim().length > 0 ? [{ type: "text", text: content }] : [];
+    }
+    if (!Array.isArray(content))
+        return [];
+    const blocks = [];
+    for (const part of content) {
+        if (typeof part !== "object" || part === null)
+            continue;
+        const record = part;
+        if (record.type === "image_url") {
+            const image = anthropicImageBlock(record);
+            if (image !== undefined)
+                blocks.push(image);
+            else
+                droppedField("anthropic", "image_url", context);
+            continue;
+        }
+        if (typeof record.text === "string") {
+            if (record.text.trim().length > 0)
+                blocks.push({ type: "text", text: record.text });
+            continue;
+        }
+        if (typeof record.type === "string")
+            droppedField("anthropic", record.type, context);
+    }
+    return blocks;
+}
 function anthropicNativeContent(message) {
     const content = message[ANTHROPIC_MESSAGE_CONTENT];
     if (Array.isArray(content))
@@ -155,7 +220,7 @@ function anthropicNativeContent(message) {
             signature: detail.signature ?? ""
         });
     const text = textContent(message.content);
-    if (text.length > 0)
+    if (text.trim().length > 0)
         native.push({ type: "text", text });
     for (const call of message.tool_calls ?? []) {
         let input = {};
@@ -219,10 +284,7 @@ function anthropicMessages(body, model) {
                 }
             ];
         }
-        const content = [];
-        const text = textContent(message.content);
-        if (text.length > 0)
-            content.push({ type: "text", text });
+        const content = anthropicContentBlocks(message.content, `${message.role ?? "user"}_message`);
         for (const call of message.tool_calls ?? []) {
             let input = {};
             try {
@@ -240,6 +302,14 @@ function anthropicMessages(body, model) {
         }
         return [{ role: message.role === "assistant" ? "assistant" : "user", content }];
     });
+    // Anthropic rejects any user turn whose content list is empty, and OpenAI
+    // clients legitimately send blank turns. Adjacent turns of the same role are
+    // coalesced upstream, so dropping a blank turn loses nothing — except when it
+    // was the closing turn, which models that forbid assistant prefill require.
+    const kept = messages.filter((message) => !anthropicContentIsEmpty(message));
+    if (anthropicContentIsEmpty(messages.at(-1)) && kept.at(-1)?.role !== "user") {
+        kept.push({ role: "user", content: [{ type: "text", text: BLANK_TURN_PLACEHOLDER }] });
+    }
     const maxTokens = body.max_completion_tokens ?? body.max_tokens ?? 4096;
     const metadata = anthropicMetadata(body);
     const selection = reasoningSelectionOf(body);
@@ -255,10 +325,10 @@ function anthropicMessages(body, model) {
     const toolChoice = anthropicToolChoice(body.tool_choice, body.parallel_tool_calls);
     return {
         model,
-        messages,
+        messages: kept,
         max_tokens: maxTokens,
         stream: body.stream === true,
-        ...(system.length > 0 ? { system } : {}),
+        ...(system.trim().length > 0 ? { system } : {}),
         ...(body.temperature !== undefined ? { temperature: body.temperature } : {}),
         ...(body.top_p !== undefined ? { top_p: body.top_p } : {}),
         ...(body.top_k !== undefined ? { top_k: body.top_k } : {}),

package/dist/test/provider-backends.test.js

@@ -58,6 +58,122 @@ test("Anthropic egress preserves tools and normalizes the response", async () =>
         globalThis.fetch = original;
     }
 });
+test("Anthropic egress drops blank turns and translates image parts", async () => {
+    const original = globalThis.fetch;
+    let request;
+    globalThis.fetch = async (input, init) => {
+        request = new Request(input, init);
+        return Response.json({
+            id: "msg_blank",
+            content: [{ type: "text", text: "ok" }],
+            usage: { input_tokens: 1, output_tokens: 1 }
+        });
+    };
+    try {
+        const backend = new AnthropicBackend({
+            baseUrl: "https://api.anthropic.test/v1",
+            apiKey: "secret",
+            defaultModel: "claude-test"
+        });
+        await backend.chat({
+            messages: [
+                { role: "system", content: "be brief" },
+                { role: "user", content: "first" },
+                { role: "assistant", content: "reply" },
+                { role: "user", content: "" },
+                { role: "user", content: [] },
+                { role: "user", content: null },
+                { role: "user", content: "   " },
+                {
+                    role: "user",
+                    content: [
+                        { type: "image_url", image_url: { url: "data:image/png;base64,AAAB" } }
+                    ]
+                }
+            ]
+        });
+        const outbound = (await request?.json());
+        assert.equal(outbound.system, "be brief");
+        assert.deepEqual(outbound.messages.map((message) => message.role), ["user", "assistant", "user"]);
+        assert.ok(outbound.messages.every((message) => message.content.length > 0));
+        assert.deepEqual(outbound.messages[2]?.content, [
+            { type: "image", source: { type: "base64", media_type: "image/png", data: "AAAB" } }
+        ]);
+    }
+    finally {
+        globalThis.fetch = original;
+    }
+});
+test("Anthropic egress keeps a closing user turn when the caller's is blank", async () => {
+    const original = globalThis.fetch;
+    let request;
+    globalThis.fetch = async (input, init) => {
+        request = new Request(input, init);
+        return Response.json({
+            id: "msg_closing",
+            content: [{ type: "text", text: "ok" }],
+            usage: { input_tokens: 1, output_tokens: 1 }
+        });
+    };
+    try {
+        const backend = new AnthropicBackend({
+            baseUrl: "https://api.anthropic.test/v1",
+            apiKey: "secret",
+            defaultModel: "claude-test"
+        });
+        await backend.chat({
+            messages: [
+                { role: "user", content: "first" },
+                { role: "assistant", content: "reply" },
+                { role: "user", content: "" }
+            ]
+        });
+        const outbound = (await request?.json());
+        assert.deepEqual(outbound.messages.map((message) => message.role), ["user", "assistant", "user"]);
+        assert.equal(outbound.messages[2]?.content[0]?.type, "text");
+        assert.ok(String(outbound.messages[2]?.content[0]?.text).trim().length > 0);
+    }
+    finally {
+        globalThis.fetch = original;
+    }
+});
+test("Anthropic egress keeps tool calls on assistant turns without text", async () => {
+    const original = globalThis.fetch;
+    let request;
+    globalThis.fetch = async (input, init) => {
+        request = new Request(input, init);
+        return Response.json({
+            id: "msg_tools",
+            content: [{ type: "text", text: "ok" }],
+            usage: { input_tokens: 1, output_tokens: 1 }
+        });
+    };
+    try {
+        const backend = new AnthropicBackend({
+            baseUrl: "https://api.anthropic.test/v1",
+            apiKey: "secret",
+            defaultModel: "claude-test"
+        });
+        await backend.chat({
+            messages: [
+                { role: "user", content: "read a.ts" },
+                {
+                    role: "assistant",
+                    content: null,
+                    tool_calls: [
+                        { id: "call_1", function: { name: "read", arguments: "{\"path\":\"a.ts\"}" } }
+                    ]
+                },
+                { role: "tool", tool_call_id: "call_1", content: "" }
+            ]
+        });
+        const outbound = (await request?.json());
+        assert.deepEqual(outbound.messages.map((message) => message.content[0]?.type), ["text", "tool_use", "tool_result"]);
+    }
+    finally {
+        globalThis.fetch = original;
+    }
+});
 test("Anthropic egress preserves native thinking controls, signed history, and buffered blocks", async () => {
     const original = globalThis.fetch;
     let request;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@velum-labs/routekit-gateway",
   "private": false,
-  "version": "0.9.8",
+  "version": "0.9.10",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/velum-labs/handoffkit.git",
@@ -27,10 +27,10 @@
   },
   "dependencies": {
     "zod": "4.4.3",
-    "@velum-labs/routekit-registry": "0.9.8",
-    "@velum-labs/routekit-tracing": "0.9.8",
-    "@velum-labs/routekit-runtime": "0.9.8",
-    "@velum-labs/routekit-contracts": "0.9.8"
+    "@velum-labs/routekit-tracing": "0.9.10",
+    "@velum-labs/routekit-runtime": "0.9.10",
+    "@velum-labs/routekit-registry": "0.9.10",
+    "@velum-labs/routekit-contracts": "0.9.10"
   },
   "keywords": [
     "routekit",