fix(anthropic): normalize the messages baseUrl and harden stream quirks (#765)

Four defects an Anthropic-compatible relay exposes, all in the same
adapter.

A `baseUrl` pasted as `https://host/v1/messages` -- which is what the
provider's own docs show -- got `/v1/messages` appended again. The URL is
now normalized so both the bare-origin and full-endpoint forms resolve to
one request path.

`input_json_delta` was accepted regardless of the open block, so a relay
emitting JSON deltas outside a `tool_use` block corrupted the assembled
arguments; the delta is now scoped to `tool_use`. A `tool_use` block
arriving without an `id` was forwarded with an empty one, which downstream
treats as unpaired -- a `toolu_` id is synthesized instead. And a stream
that reached EOF carrying a `message_delta.stop_reason` but no
`message_stop` now settles from that stop reason rather than hanging.

Two changes on top of the contributed patch:

`toolUseArguments` re-encoded an unparseable string input as a JSON
*string*, so `"not json at all"` arrived where the tool contract requires
an object. That is the double-encoding half of #765 and it survived the
original fix. It degrades to `{}` now, which still fails -- but inside the
tool's own argument validation instead of as a type error. A test pins it.

`sawContent` was assigned in six places and read in none; removed.

The contributed branch also swapped three `/api/logs` test files onto a
`logsFromApiBody` helper that accepts both the bare array and a `{logs}`
envelope. That helper is not brought across: it would pre-accept the
response-shape change this round has not decided on, and a matcher that
tolerates both shapes cannot fail when the shape regresses. Only the
adapter and its own test come over.

#765 stays open -- it asks for broader relay quirk tolerance than these
four fixes.

Note for whoever runs the suite: `tests/claude-messages-endpoint.test.ts`
and `tests/claude-native-passthrough.test.ts` already fail together on an
unmodified tree ("unmapped claude model + sk-ant credential passes through
verbatim"), and pass individually. That interference predates this commit.

Co-authored-by: bitkyc08-arch <bitkyc08@gmail.com>

Author: Wibias

src/adapters/anthropic.ts

@@ -250,6 +250,40 @@ function usesNativeAnthropicEndpoint(provider: OcxProviderConfig): boolean {
   }
 }
 
+/** Normalize provider baseUrl paths ending in `/`, `/v1`, or `/v1/messages` to `{origin}/v1/messages`. */
+export function anthropicMessagesUrl(baseUrl: string): string {
+  try {
+    new URL(baseUrl);
+  } catch {
+    throw new Error(`anthropic provider has malformed baseUrl: ${baseUrl}`);
+  }
+  const trimmed = baseUrl.trim().replace(/\/+$/, "");
+  const root = trimmed.replace(/\/v1\/messages\/?$/i, "").replace(/\/v1\/?$/i, "").replace(/\/+$/, "");
+  return `${root}/v1/messages`;
+}
+
+function synthesizeToolUseId(): string {
+  return `toolu_${crypto.randomUUID().replace(/-/g, "").slice(0, 24)}`;
+}
+
+function toolUseArguments(input: unknown): string {
+  if (typeof input === "string") {
+    const trimmed = input.trim();
+    if (!trimmed) return "{}";
+    try {
+      JSON.parse(trimmed);
+      return trimmed;
+    } catch {
+      // A tool call's arguments must be a JSON object. Re-encoding an unparseable string as a
+      // JSON *string* is the double-encoding #765 reports: the caller then receives
+      // `"get weather"` where an object was required and the tool call is unusable either way.
+      // An empty object at least fails in the tool's own argument validation.
+      return "{}";
+    }
+  }
+  return JSON.stringify(input ?? {});
+}
+
 function anthropicKeyUsesBearer(provider: OcxProviderConfig): boolean {
   return provider.apiKeyTransport === "bearer";
 }
@@ -680,8 +714,7 @@ export function createAnthropicAdapter(provider: OcxProviderConfig, cacheRetenti
         else if (typeof tc === "object" && "name" in tc) body.tool_choice = { type: "tool", name: toolNames.toWire(resolveToolChoiceWireName(parsed.context.tools, tc.name)) };
       }
 
-      const base = provider.baseUrl.replace(/\/v1\/?$/, "");
-      const url = `${base}/v1/messages`;
+      const url = anthropicMessagesUrl(provider.baseUrl);
       const unresolvedPlaceholder = url.match(/\{[^}]*\}/)?.[0];
       if (unresolvedPlaceholder) {
         throw new Error(`anthropic baseUrl contains unresolved ${unresolvedPlaceholder}`);
@@ -773,7 +806,7 @@ export function createAnthropicAdapter(provider: OcxProviderConfig, cacheRetenti
                 if (!block) break;
                 currentBlockType = block.type;
                 if (block.type === "tool_use") {
-                  currentToolCallId = block.id ?? "";
+                  currentToolCallId = block.id ?? synthesizeToolUseId();
                   currentToolCallName = toolNames.fromWire(block.name ?? "");
                   yield { type: "tool_call_start", id: currentToolCallId, name: currentToolCallName };
                 }
@@ -799,7 +832,7 @@ export function createAnthropicAdapter(provider: OcxProviderConfig, cacheRetenti
                   // Arrives once, just before the thinking block's content_block_stop; block-scoped
                   // so a stray signature on a non-thinking block can never be captured.
                   yield { type: "thinking_signature", signature: delta.signature };
-                } else if (delta.type === "input_json_delta" && typeof delta.partial_json === "string") {
+                } else if (delta.type === "input_json_delta" && typeof delta.partial_json === "string" && currentBlockType === "tool_use") {
                   yield { type: "tool_call_delta", arguments: delta.partial_json };
                 }
                 break;
@@ -831,12 +864,13 @@ export function createAnthropicAdapter(provider: OcxProviderConfig, cacheRetenti
         }
       }
       if (!emittedDone) {
+        // Fail closed on transport EOF. Compatible providers may omit message_stop after message_delta.stop_reason.
         if (pendingStopReason !== undefined) {
           const stopReason = pendingStopReason === "max_tokens"
             ? "max_tokens"
             : pendingStopReason === "refusal" || pendingStopReason === "content_filter"
               ? "content_filter"
-              : undefined;
+              : pendingStopReason;
           emittedDone = true;
           yield {
             type: "done",
@@ -867,8 +901,9 @@ export function createAnthropicAdapter(provider: OcxProviderConfig, cacheRetenti
           } else if (block.type === "redacted_thinking" && typeof block.data === "string") {
             events.push({ type: "redacted_thinking", data: block.data });
           } else if (block.type === "tool_use") {
-            events.push({ type: "tool_call_start", id: block.id ?? "", name: toolNames.fromWire(block.name ?? "") });
-            events.push({ type: "tool_call_delta", arguments: JSON.stringify(block.input ?? {}) });
+            const id = block.id ?? synthesizeToolUseId();
+            events.push({ type: "tool_call_start", id, name: toolNames.fromWire(block.name ?? "") });
+            events.push({ type: "tool_call_delta", arguments: toolUseArguments(block.input) });
             events.push({ type: "tool_call_end" });
           }
         }

tests/anthropic-stream-hardening.test.ts

@@ -0,0 +1,106 @@
+import { describe, expect, test } from "bun:test";
+import { anthropicMessagesUrl, createAnthropicAdapter } from "../src/adapters/anthropic";
+import type { AdapterEvent } from "../src/types";
+
+const provider = { adapter: "anthropic", baseUrl: "https://example.test", apiKey: "key" };
+
+async function collect(gen: AsyncGenerator<AdapterEvent>): Promise<AdapterEvent[]> {
+  const out: AdapterEvent[] = [];
+  for await (const e of gen) out.push(e);
+  return out;
+}
+
+describe("anthropicMessagesUrl", () => {
+  test.each([
+    ["https://example.test", "https://example.test/v1/messages"],
+    ["https://example.test/", "https://example.test/v1/messages"],
+    ["https://example.test/v1", "https://example.test/v1/messages"],
+    ["https://example.test/v1/", "https://example.test/v1/messages"],
+    ["https://example.test/v1/messages", "https://example.test/v1/messages"],
+    ["https://example.test/v1/messages/", "https://example.test/v1/messages"],
+  ] as const)("normalizes %s", (input, expected) => {
+    expect(anthropicMessagesUrl(input)).toBe(expected);
+  });
+});
+
+describe("anthropic stream hardening", () => {
+  test("EOF after content without message_stop fails closed", async () => {
+    const response = new Response([
+      "event: content_block_start\n",
+      'data: {"type":"content_block_start","content_block":{"type":"text","text":""}}\n\n',
+      "event: content_block_delta\n",
+      'data: {"type":"content_block_delta","delta":{"type":"text_delta","text":"hi"}}\n\n',
+    ].join(""));
+    const events = await collect(createAnthropicAdapter(provider).parseStream(response));
+    expect(events.at(-1)?.type).toBe("error");
+    expect(events.some(e => e.type === "done")).toBe(false);
+  });
+
+  test("input_json_delta outside tool_use is ignored", async () => {
+    const response = new Response([
+      "event: content_block_start\n",
+      'data: {"type":"content_block_start","content_block":{"type":"text","text":""}}\n\n',
+      "event: content_block_delta\n",
+      'data: {"type":"content_block_delta","delta":{"type":"input_json_delta","partial_json":"{\\"x\\":1}"}}\n\n',
+      "event: message_stop\n",
+      'data: {"type":"message_stop"}\n\n',
+    ].join(""));
+    const events = await collect(createAnthropicAdapter(provider).parseStream(response));
+    expect(events.some(e => e.type === "tool_call_delta")).toBe(false);
+    expect(events.at(-1)?.type).toBe("done");
+  });
+
+  test("tool_use without id synthesizes a toolu_ id", async () => {
+    const response = new Response([
+      "event: content_block_start\n",
+      'data: {"type":"content_block_start","content_block":{"type":"tool_use","name":"get_weather"}}\n\n',
+      "event: content_block_delta\n",
+      'data: {"type":"content_block_delta","delta":{"type":"input_json_delta","partial_json":"{}"}}\n\n',
+      "event: content_block_stop\n",
+      'data: {"type":"content_block_stop"}\n\n',
+      "event: message_stop\n",
+      'data: {"type":"message_stop"}\n\n',
+    ].join(""));
+    const events = await collect(createAnthropicAdapter(provider).parseStream(response));
+    const start = events.find(e => e.type === "tool_call_start");
+    expect(start).toMatchObject({ type: "tool_call_start", name: "get_weather" });
+    expect(start && "id" in start && start.id.startsWith("toolu_")).toBe(true);
+  });
+
+  test("empty EOF without content still errors", async () => {
+    const response = new Response("");
+    const events = await collect(createAnthropicAdapter(provider).parseStream(response));
+    expect(events.at(-1)?.type).toBe("error");
+    expect(events.some(e => e.type === "done")).toBe(false);
+  });
+});
+
+describe("anthropic non-stream tool_use input", () => {
+  test("parses string tool_use.input", async () => {
+    const adapter = createAnthropicAdapter(provider);
+    const events = await adapter.parseResponse!(new Response(JSON.stringify({
+      content: [{ type: "tool_use", id: "toolu_1", name: "get_weather", input: "{\"city\":\"Paris\"}" }],
+      stop_reason: "tool_use",
+    })));
+    expect(events.find(e => e.type === "tool_call_delta")).toMatchObject({
+      type: "tool_call_delta",
+      arguments: "{\"city\":\"Paris\"}",
+    });
+    expect(events.at(-1)?.type).toBe("done");
+  });
+
+  test("unparseable string tool_use.input degrades to {} instead of double-encoding", async () => {
+    // Re-encoding the raw text as a JSON string produces `"not json at all"` where the tool
+    // contract requires an object -- that is the double-encoding half of #765. `{}` is still
+    // wrong input, but it fails in the tool's own argument validation rather than as a type error.
+    const adapter = createAnthropicAdapter(provider);
+    const events = await adapter.parseResponse!(new Response(JSON.stringify({
+      content: [{ type: "tool_use", id: "toolu_2", name: "get_weather", input: "not json at all" }],
+      stop_reason: "tool_use",
+    })));
+    expect(events.find(e => e.type === "tool_call_delta")).toMatchObject({
+      type: "tool_call_delta",
+      arguments: "{}",
+    });
+  });
+});