fix(anthropic): guard against empty text content blocks (400 rejection)

Anthropic rejects requests containing { type: 'text', text: '' } blocks
with 'text content blocks must be non-empty'. This surfaces when Codex
replays history with empty user messages, empty assistant text parts
(e.g. tool-call-only turns with a zero-length text prefix), or tool
results with empty output.

- user/developer: empty string -> '(empty)' placeholder; empty text
  parts filtered from content arrays (fallback to '(empty)' if all gone)
- assistant: empty text parts silently dropped (tool_use blocks suffice)
- tool_result: empty string content -> '(empty tool output)' placeholder
- tests: 5 cases covering each path

Author: lidge-jun

src/adapters/anthropic.ts

@@ -331,9 +331,16 @@ function buildToolNameTransforms(provider: OcxProviderConfig): { toWire: (name:
 function toAnthropicToolResult(msg: OcxToolResultMessage): Record<string, unknown> {
   // Anthropic tool_result accepts a string OR content blocks — render images natively
   // (e.g. Codex view_image output) instead of dropping them.
-  const content = typeof msg.content === "string"
-    ? msg.content
-    : (msg.content as OcxContentPart[]).map(toAnthropicContentPart);
+  let content: string | unknown[];
+  if (typeof msg.content === "string") {
+    // Anthropic rejects tool_result with empty text content blocks.
+    content = msg.content || "(empty tool output)";
+  } else {
+    const parts = (msg.content as OcxContentPart[])
+      .map(toAnthropicContentPart)
+      .filter(p => !((p as { type?: string }).type === "text" && !(p as { text?: string }).text));
+    content = parts.length > 0 ? parts : "(empty tool output)";
+  }
   return {
     type: "tool_result",
     tool_use_id: msg.toolCallId,
@@ -370,9 +377,16 @@ function messagesToAnthropicFormat(
     switch (msg.role) {
       case "user":
       case "developer": {
-        const content = typeof msg.content === "string"
-          ? msg.content
-          : (msg.content as OcxContentPart[]).map(toAnthropicContentPart);
+        let content: string | unknown[];
+        if (typeof msg.content === "string") {
+          // Anthropic rejects empty string text content blocks.
+          content = msg.content || "(empty)";
+        } else {
+          const parts = (msg.content as OcxContentPart[])
+            .map(toAnthropicContentPart)
+            .filter(p => !((p as { type?: string }).type === "text" && !(p as { text?: string }).text));
+          content = parts.length > 0 ? parts : "(empty)";
+        }
         messages.push({ role: "user", content });
         break;
       }
@@ -382,7 +396,8 @@ function messagesToAnthropicFormat(
         const toolUseIds: string[] = [];
         for (const part of aMsg.content) {
           if (part.type === "text") {
-            content.push({ type: "text", text: (part as OcxTextContent).text });
+            const text = (part as OcxTextContent).text;
+            if (text) content.push({ type: "text", text });
           } else if (part.type === "thinking") {
             const t = part as OcxThinkingContent;
             // Redacted blocks replay verbatim FIRST (they preceded the visible thinking block

tests/anthropic-empty-content.test.ts

@@ -0,0 +1,69 @@
+import { describe, expect, test } from "bun:test";
+import { createAnthropicAdapter } from "../src/adapters/anthropic";
+import type { OcxMessage, OcxParsedRequest, OcxProviderConfig } from "../src/types";
+
+const provider = { adapter: "anthropic", baseUrl: "https://api.anthropic.com", apiKey: "sk-x", authMode: "apiKey" } as unknown as OcxProviderConfig;
+
+function parsed(messages: OcxMessage[]): OcxParsedRequest {
+  return {
+    modelId: "anthropic/claude-sonnet-4.5",
+    stream: false,
+    options: {},
+    context: { messages },
+  };
+}
+
+function bodyOf(p: OcxParsedRequest): { messages: Array<{ role: string; content: unknown }> } {
+  const { body } = createAnthropicAdapter(provider).buildRequest(p);
+  return JSON.parse(typeof body === "string" ? body : JSON.stringify(body)) as { messages: Array<{ role: string; content: unknown }> };
+}
+
+describe("anthropic empty content block guard", () => {
+  test("user message with empty string content is replaced with placeholder", () => {
+    const body = bodyOf(parsed([
+      { role: "user", content: "", timestamp: 0 },
+    ]));
+    const msg = body.messages[0] as { role: string; content: string };
+    expect(msg.content).toBe("(empty)");
+  });
+
+  test("user message with empty text part is filtered out", () => {
+    const body = bodyOf(parsed([
+      { role: "user", content: [{ type: "text", text: "" }], timestamp: 0 },
+    ]));
+    const msg = body.messages[0] as { role: string; content: string };
+    // Empty part filtered -> falls back to placeholder string
+    expect(msg.content).toBe("(empty)");
+  });
+
+  test("user message with mixed empty and non-empty parts keeps only non-empty", () => {
+    const body = bodyOf(parsed([
+      { role: "user", content: [{ type: "text", text: "" }, { type: "text", text: "hello" }], timestamp: 0 },
+    ]));
+    const msg = body.messages[0] as { role: string; content: Array<{ type: string; text: string }> };
+    expect(msg.content).toEqual([{ type: "text", text: "hello" }]);
+  });
+
+  test("assistant message with empty text part is dropped silently", () => {
+    const body = bodyOf(parsed([
+      { role: "user", content: "start", timestamp: 0 },
+      { role: "assistant", content: [{ type: "text", text: "" }, { type: "text", text: "visible" }], model: "claude", timestamp: 0 },
+    ]));
+    const assistantMsg = body.messages.find(m => (m as { role: string }).role === "assistant") as { content: Array<{ type: string; text?: string }> };
+    expect(assistantMsg.content).toEqual([{ type: "text", text: "visible" }]);
+  });
+
+  test("tool result with empty string content gets a placeholder", () => {
+    const body = bodyOf(parsed([
+      { role: "user", content: "start", timestamp: 0 },
+      { role: "assistant", content: [{ type: "toolCall", id: "tc1", name: "run", arguments: {} }], model: "claude", timestamp: 0 },
+      { role: "toolResult", toolCallId: "tc1", toolName: "run", content: "", isError: false, timestamp: 0 },
+    ]));
+    const toolResultMsg = body.messages.find(m => {
+      const content = (m as { content?: unknown[] }).content;
+      return Array.isArray(content) && content.some((c: { type?: string }) => c.type === "tool_result");
+    }) as { content: Array<{ type: string; content?: string }> };
+    const toolResult = toolResultMsg.content.find((c: { type: string }) => c.type === "tool_result") as { content: string };
+    expect(toolResult.content).toBe("(empty tool output)");
+  });
+});