fix: self-heal empty ModelMessages at request-build time

Add defensive filter after convertToModelMessages to catch any
empty assistant messages that slip through. This is a final safety
net - if corrupted history produces empty ModelMessages, they are
filtered out before sending to the API.

Also adds integration tests that seed corrupted history and verify
the system self-heals.

Author: ammar-agent

src/node/services/aiService.ts

@@ -1202,11 +1202,26 @@ export class AIService extends EventEmitter {
       // Convert MuxMessage to ModelMessage format using Vercel AI SDK utility
       // Type assertion needed because MuxMessage has custom tool parts for interrupted tools
       // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument
-      const modelMessages = convertToModelMessages(sanitizedMessages as any, {
+      const rawModelMessages = convertToModelMessages(sanitizedMessages as any, {
         // Drop unfinished tool calls (input-streaming/input-available) so downstream
         // transforms only see tool calls that actually produced outputs.
         ignoreIncompleteToolCalls: true,
       });
+
+      // Self-healing: Filter out any empty ModelMessages that could brick the request.
+      // The SDK's ignoreIncompleteToolCalls can drop all parts from a message, leaving
+      // an assistant with empty content array. The API rejects these with "all messages
+      // must have non-empty content except for the optional final assistant message".
+      const modelMessages = rawModelMessages.filter((msg) => {
+        if (msg.role !== "assistant") return true;
+        if (typeof msg.content === "string") return msg.content.length > 0;
+        return Array.isArray(msg.content) && msg.content.length > 0;
+      });
+      if (modelMessages.length < rawModelMessages.length) {
+        log.debug(
+          `Self-healing: Filtered ${rawModelMessages.length - modelMessages.length} empty ModelMessage(s)`
+        );
+      }
       log.debug_obj(`${workspaceId}/2_model_messages.json`, modelMessages);
 
       // Apply ModelMessage transforms based on provider requirements

tests/ipc/emptyAssistantMessage.test.ts

@@ -0,0 +1,156 @@
+/**
+ * Test that corrupted chat history with empty assistant messages
+ * does not brick the workspace (self-healing behavior).
+ *
+ * Reproduction of: "messages.95: all messages must have non-empty content
+ * except for the optional final assistant message"
+ */
+import { setupWorkspace, shouldRunIntegrationTests, validateApiKeys } from "./setup";
+import {
+  sendMessageWithModel,
+  createStreamCollector,
+  modelString,
+  HAIKU_MODEL,
+} from "./helpers";
+import { HistoryService } from "../../src/node/services/historyService";
+import { createMuxMessage } from "../../src/common/types/message";
+
+// Skip all tests if TEST_INTEGRATION is not set
+const describeIntegration = shouldRunIntegrationTests() ? describe : describe.skip;
+
+// Validate API keys before running tests
+if (shouldRunIntegrationTests()) {
+  validateApiKeys(["ANTHROPIC_API_KEY"]);
+}
+
+describeIntegration("empty assistant message self-healing", () => {
+  test.concurrent(
+    "should handle corrupted history with empty assistant parts array",
+    async () => {
+      const { env, workspaceId, cleanup } = await setupWorkspace("anthropic");
+      try {
+        const historyService = new HistoryService(env.config);
+
+        // Seed history that mimics a crash-corrupted chat.jsonl:
+        // 1. User message
+        // 2. Assistant message with content
+        // 3. User follow-up
+        // 4. Empty assistant message (crash during stream start - placeholder persisted)
+        const messages = [
+          createMuxMessage("msg-1", "user", "Hello", {}),
+          createMuxMessage("msg-2", "assistant", "Hi there!", {}),
+          createMuxMessage("msg-3", "user", "Follow up question", {}),
+          // Corrupted: empty parts array (placeholder message from crash)
+          {
+            id: "msg-4-corrupted",
+            role: "assistant" as const,
+            parts: [], // Empty - this is the corruption
+            metadata: {
+              timestamp: Date.now(),
+              model: "anthropic:claude-haiku-4-5",
+              mode: "exec" as const,
+              historySequence: 3,
+            },
+          },
+        ];
+
+        // Write corrupted history directly
+        for (const msg of messages) {
+          const result = await historyService.appendToHistory(workspaceId, msg as any);
+          if (!result.success) {
+            throw new Error(`Failed to seed history: ${result.error}`);
+          }
+        }
+
+        // Now try to send a new message - this should NOT fail with
+        // "all messages must have non-empty content"
+        const collector = createStreamCollector(env.orpc, workspaceId);
+        collector.start();
+
+        const sendResult = await sendMessageWithModel(
+          env,
+          workspaceId,
+          "This should work despite corrupted history",
+          HAIKU_MODEL
+        );
+
+        // The send should succeed (not fail due to corrupted history)
+        expect(sendResult.success).toBe(true);
+
+        // Wait for stream to complete successfully
+        const streamEnd = await collector.waitForEvent("stream-end", 30000);
+        expect(streamEnd).toBeDefined();
+
+        collector.stop();
+      } finally {
+        await cleanup();
+      }
+    },
+    60000
+  );
+
+  test.concurrent(
+    "should handle corrupted history with incomplete tool-only assistant message",
+    async () => {
+      const { env, workspaceId, cleanup } = await setupWorkspace("anthropic");
+      try {
+        const historyService = new HistoryService(env.config);
+
+        // Seed history with an assistant message that has only an incomplete tool call
+        // (state: "input-available" means tool was requested but never executed)
+        const messages = [
+          createMuxMessage("msg-1", "user", "Run a command", {}),
+          // Corrupted: tool-only with incomplete state
+          {
+            id: "msg-2-corrupted",
+            role: "assistant" as const,
+            parts: [
+              {
+                type: "dynamic-tool" as const,
+                toolName: "bash",
+                toolCallId: "call-123",
+                state: "input-available" as const, // Incomplete - will be dropped by SDK
+                input: { script: "echo hello" },
+              },
+            ],
+            metadata: {
+              timestamp: Date.now(),
+              model: "anthropic:claude-haiku-4-5",
+              mode: "exec" as const,
+              historySequence: 1,
+            },
+          },
+        ];
+
+        // Write corrupted history directly
+        for (const msg of messages) {
+          const result = await historyService.appendToHistory(workspaceId, msg as any);
+          if (!result.success) {
+            throw new Error(`Failed to seed history: ${result.error}`);
+          }
+        }
+
+        // Now try to send a new message
+        const collector = createStreamCollector(env.orpc, workspaceId);
+        collector.start();
+
+        const sendResult = await sendMessageWithModel(
+          env,
+          workspaceId,
+          "This should work despite corrupted tool history",
+          HAIKU_MODEL
+        );
+
+        expect(sendResult.success).toBe(true);
+
+        const streamEnd = await collector.waitForEvent("stream-end", 30000);
+        expect(streamEnd).toBeDefined();
+
+        collector.stop();
+      } finally {
+        await cleanup();
+      }
+    },
+    60000
+  );
+});