fix(compaction): preserve safe text around session sends

mushuiyu886 · mushuiyu886 · commit 69fa892b99fa · 2026-06-29T13:54:05.000+08:00
diff --git a/src/agents/agent-hooks/compaction-safeguard.test.ts b/src/agents/agent-hooks/compaction-safeguard.test.ts
@@ -2611,6 +2611,95 @@ describe("compaction-safeguard double-compaction guard", () => {
     expect(JSON.stringify(messages)).not.toContain("sessions_send");
   });
 
+  it("preserves assistant text while filtering sessions_send tool calls as fallback history", async () => {
+    mockSummarizeInStages.mockReset();
+    mockSummarizeInStages.mockResolvedValue("mixed branch summary");
+
+    const now = Date.now();
+    const sessionManager = {
+      ...stubSessionManager(),
+      getBranch: () => [
+        {
+          type: "message",
+          id: "user-1",
+          parentId: null,
+          timestamp: new Date(now).toISOString(),
+          message: {
+            role: "user",
+            content: "ask the bee session to respond",
+            timestamp: now,
+          },
+        },
+        {
+          type: "message",
+          id: "assistant-1",
+          parentId: "user-1",
+          timestamp: new Date(now + 1).toISOString(),
+          message: {
+            role: "assistant",
+            content: [
+              { type: "text", text: "I will ask the bee session and keep context." },
+              {
+                type: "toolCall",
+                id: "call-1",
+                name: "sessions_send",
+                arguments: { sessionKey: "agent:bee", message: "say bee" },
+              },
+            ],
+            timestamp: now + 1,
+          },
+        },
+        {
+          type: "message",
+          id: "tool-1",
+          parentId: "assistant-1",
+          timestamp: new Date(now + 2).toISOString(),
+          message: {
+            role: "toolResult",
+            toolCallId: "call-1",
+            toolName: "sessions_send",
+            content: [{ type: "text", text: "delivered" }],
+            timestamp: now + 2,
+          },
+        },
+      ],
+    } as ExtensionContext["sessionManager"];
+    const model = createAnthropicModelFixture();
+    setCompactionSafeguardRuntime(sessionManager, { model, recentTurnsPreserve: 0 });
+
+    const mockEvent = {
+      preparation: {
+        messagesToSummarize: [] as AgentMessage[],
+        turnPrefixMessages: [] as AgentMessage[],
+        firstKeptEntryId: "entry-9",
+        tokensBefore: 38085,
+        fileOps: { read: [], edited: [], written: [] },
+        settings: { reserveTokens: 4000 },
+        isSplitTurn: true,
+      },
+      customInstructions: "",
+      signal: new AbortController().signal,
+    };
+    const { result } = await runCompactionScenario({
+      sessionManager,
+      event: mockEvent,
+      apiKey: "test-key",
+    });
+
+    const compaction = expectCompactionResult(result);
+    expect(compaction.summary).toContain("mixed branch summary");
+    expect(mockSummarizeInStages).toHaveBeenCalledTimes(1);
+    const summarizeCall = requireRecord(mockCallArg(mockSummarizeInStages));
+    const messages = requireArray(summarizeCall.messages);
+    expect(messages.map((message) => requireRecord(message).role)).toEqual(["user", "assistant"]);
+    const assistantMessage = requireRecord(messages[1]);
+    expect(assistantMessage.content).toEqual([
+      { type: "text", text: "I will ask the bee session and keep context." },
+    ]);
+    expect(JSON.stringify(messages)).not.toContain("sessions_send");
+    expect(JSON.stringify(messages)).not.toContain("delivered");
+  });
+
   it("recovers user and assistant branch turns when compaction preparation has only tool output", async () => {
     mockSummarizeInStages.mockReset();
     mockSummarizeInStages.mockResolvedValue("branch summary with visible turns");
diff --git a/src/agents/agent-hooks/compaction-safeguard.ts b/src/agents/agent-hooks/compaction-safeguard.ts
@@ -193,21 +193,18 @@ function recordOrEmpty(value: unknown): Record<string, unknown> {
     : {};
 }
 
-type ReplayUnsafeToolCalls = {
-  found: boolean;
-  ids: Set<string>;
-};
-
-function collectReplayUnsafeMessagingToolCalls(message: AgentMessage): ReplayUnsafeToolCalls {
+function filterReplayUnsafeMessagingToolCalls(
+  message: AgentMessage,
+  replayUnsafeToolCallIds: Set<string>,
+): AgentMessage | undefined {
   const content = (message as { content?: unknown }).content;
-  const ids = new Set<string>();
-  let found = false;
   if (!Array.isArray(content)) {
-    return { found, ids };
+    return message;
   }
-  for (const block of content) {
+  let removed = false;
+  const filteredContent = content.filter((block) => {
     if (!block || typeof block !== "object") {
-      continue;
+      return true;
     }
     const record = block as {
       type?: unknown;
@@ -217,21 +214,27 @@ function collectReplayUnsafeMessagingToolCalls(message: AgentMessage): ReplayUns
       input?: unknown;
     };
     if (typeof record.type !== "string" || !TOOL_CALL_BLOCK_TYPES.has(record.type)) {
-      continue;
+      return true;
     }
     if (typeof record.name !== "string" || !record.name.trim()) {
-      continue;
+      return true;
     }
     const args = recordOrEmpty(record.arguments ?? record.input);
     if (!isMessagingToolSendAction(record.name, args)) {
-      continue;
+      return true;
     }
-    found = true;
+    removed = true;
     if (typeof record.id === "string" && record.id.trim()) {
-      ids.add(record.id.trim());
+      replayUnsafeToolCallIds.add(record.id.trim());
     }
+    return false;
+  });
+  if (!removed) {
+    return message;
   }
-  return { found, ids };
+  return filteredContent.length > 0
+    ? ({ ...message, content: filteredContent } as AgentMessage)
+    : undefined;
 }
 
 function isReplayUnsafeMessagingToolResult(
@@ -267,13 +270,15 @@ function filterReplayUnsafeSessionBranchMessages(messages: AgentMessage[]): Agen
       skippingInterSessionReply = false;
     }
     if (role === "assistant") {
-      const replayUnsafeToolCalls = collectReplayUnsafeMessagingToolCalls(message);
-      if (replayUnsafeToolCalls.found) {
-        for (const id of replayUnsafeToolCalls.ids) {
-          replayUnsafeToolCallIds.add(id);
-        }
+      const filteredMessage = filterReplayUnsafeMessagingToolCalls(
+        message,
+        replayUnsafeToolCallIds,
+      );
+      if (!filteredMessage) {
         continue;
       }
+      filtered.push(filteredMessage);
+      continue;
     }
     if (isReplayUnsafeMessagingToolResult(message, replayUnsafeToolCallIds)) {
       continue;
