fix(agent): drop rawOutput for non-MCP tool results

packages/agent/src/adapters/claude/conversion/sdk-to-acp.test.ts

@@ -5,6 +5,7 @@ import type {
 import type {
   SDKAssistantMessage,
   SDKPartialAssistantMessage,
+  SDKUserMessage,
 } from "@anthropic-ai/claude-agent-sdk";
 import { describe, expect, it } from "vitest";
 import { Logger } from "../../../utils/logger";
@@ -260,3 +261,101 @@ describe("assembled assistant text fallback", () => {
     expect(chunkTexts(updates, "agent_message_chunk")).toEqual([]);
   });
 });
+
+async function registerToolUse(
+  context: MessageHandlerContext,
+  toolUseId: string,
+  name: string,
+  input: Record<string, unknown> = {},
+): Promise<void> {
+  await handleUserAssistantMessage(
+    assistantMessage("msg_tool", [
+      { type: "tool_use", id: toolUseId, name, input },
+    ]),
+    context,
+  );
+}
+
+function userToolResult(
+  toolUseId: string,
+  content: unknown,
+  toolUseResult?: Record<string, unknown>,
+): SDKUserMessage {
+  return {
+    type: "user",
+    parent_tool_use_id: null,
+    uuid: "00000000-0000-0000-0000-000000000003",
+    session_id: "test-session",
+    message: {
+      role: "user",
+      content: [{ type: "tool_result", tool_use_id: toolUseId, content }],
+    },
+    ...(toolUseResult ? { tool_use_result: toolUseResult } : {}),
+  } as unknown as SDKUserMessage;
+}
+
+function toolUpdate(updates: SessionNotification[]) {
+  return updates.find((u) => u.update.sessionUpdate === "tool_call_update")
+    ?.update as
+    | (Extract<
+        SessionNotification["update"],
+        { sessionUpdate: "tool_call_update" }
+      > & { rawOutput?: unknown })
+    | undefined;
+}
+
+describe("tool_call_update rawOutput", () => {
+  it.each([
+    {
+      name: "omits rawOutput for standard tool results so content is not duplicated",
+      toolName: "Read",
+      toolUseId: "tool_read",
+      content: "line one\nline two",
+      toolUseResult: undefined,
+      expectedRawOutput: false,
+    },
+    {
+      name: "forwards rawOutput for MCP tool results consumed by the App bridge",
+      toolName: "mcp__srv__do",
+      toolUseId: "tool_mcp",
+      content: "ignored",
+      toolUseResult: {
+        content: [{ type: "text", text: "mcp payload" }],
+        structuredContent: { ok: true },
+      },
+      expectedRawOutput: {
+        content: [{ type: "text", text: "mcp payload" }],
+        structuredContent: { ok: true },
+        isError: false,
+      },
+    },
+  ])(
+    "$name",
+    async ({
+      toolName,
+      toolUseId,
+      content,
+      toolUseResult,
+      expectedRawOutput,
+    }) => {
+      const { context, updates } = createHandlerContext();
+      await registerToolUse(context, toolUseId, toolName);
+      updates.length = 0;
+      await handleUserAssistantMessage(
+        userToolResult(
+          toolUseId,
+          content,
+          toolUseResult as Record<string, unknown> | undefined,
+        ),
+        context,
+      );
+      const update = toolUpdate(updates);
+      expect(update?.status).toBe("completed");
+      if (expectedRawOutput === false) {
+        expect(update && "rawOutput" in update).toBe(false);
+      } else {
+        expect(update?.rawOutput).toEqual(expectedRawOutput);
+      }
+    },
+  );
+});

packages/agent/src/adapters/claude/conversion/sdk-to-acp.ts

@@ -439,16 +439,17 @@ function handleToolResultChunk(
     toolCallId: chunk.tool_use_id,
     sessionUpdate: "tool_call_update",
     status: chunk.is_error ? "failed" : "completed",
-    rawOutput: ctx.mcpToolUseResult
-      ? { ...ctx.mcpToolUseResult, isError: chunk.is_error ?? false }
-      : {
-          content: Array.isArray(chunk.content)
-            ? chunk.content
-            : typeof chunk.content === "string"
-              ? [{ type: "text" as const, text: chunk.content }]
-              : [],
-          isError: chunk.is_error ?? false,
-        },
+    // Only MCP tools need rawOutput: their App bridge replays it. Standard
+    // tools (Read, Bash, ...) render from `content`, so forwarding the full
+    // result here would duplicate large payloads to the renderer.
+    ...(ctx.mcpToolUseResult
+      ? {
+          rawOutput: {
+            ...ctx.mcpToolUseResult,
+            isError: chunk.is_error ?? false,
+          },
+        }
+      : {}),
     ...toolUpdate,
   });