fix(agents): truncate tool results before overflow compaction

LLagoon3 · LLagoon3 · commit 90749d75b476 · 2026-05-13T07:06:08.000+09:00
diff --git a/src/agents/pi-embedded-runner/run.overflow-compaction.loop.test.ts b/src/agents/pi-embedded-runner/run.overflow-compaction.loop.test.ts
@@ -239,15 +239,10 @@ describe("overflow compaction in run loop", () => {
     expectLogIncludes(mockedLog.warn, "auto-compaction failed");
   });
 
-  it("falls back to tool-result truncation and retries when oversized results are detected", async () => {
+  it("tries tool-result truncation before compaction and retries when oversized results are detected", async () => {
     queueOverflowAttemptWithOversizedToolOutput(mockedRunEmbeddedAttempt, makeOverflowError());
     mockedRunEmbeddedAttempt.mockResolvedValueOnce(makeAttemptResult({ promptError: null }));
 
-    mockedCompactDirect.mockResolvedValueOnce({
-      ok: false,
-      compacted: false,
-      reason: "nothing to compact",
-    });
     mockedSessionLikelyHasOversizedToolResults.mockReturnValue(true);
     mockedTruncateOversizedToolResultsInSession.mockResolvedValueOnce({
       truncated: true,
@@ -256,7 +251,7 @@ describe("overflow compaction in run loop", () => {
 
     const result = await runEmbeddedPiAgent(baseParams);
 
-    expect(mockedCompactDirect).toHaveBeenCalledTimes(1);
+    expect(mockedCompactDirect).not.toHaveBeenCalled();
     expect(
       requireMockCallArg(mockedSessionLikelyHasOversizedToolResults, 0).contextWindowTokens,
     ).toBe(200000);
@@ -268,7 +263,7 @@ describe("overflow compaction in run loop", () => {
     expect(result.meta.error).toBeUndefined();
   });
 
-  it("retries after fallback truncation for a mixed oversized-plus-aggregate tool tail", async () => {
+  it("retries after pre-compaction truncation for a mixed oversized-plus-aggregate tool tail", async () => {
     mockedRunEmbeddedAttempt
       .mockResolvedValueOnce(
         makeAttemptResult({
@@ -291,11 +286,6 @@ describe("overflow compaction in run loop", () => {
       )
       .mockResolvedValueOnce(makeAttemptResult({ promptError: null }));
 
-    mockedCompactDirect.mockResolvedValueOnce({
-      ok: false,
-      compacted: false,
-      reason: "nothing to compact",
-    });
     mockedSessionLikelyHasOversizedToolResults.mockReturnValue(true);
     mockedTruncateOversizedToolResultsInSession.mockResolvedValueOnce({
       truncated: true,
@@ -304,15 +294,42 @@ describe("overflow compaction in run loop", () => {
 
     const result = await runEmbeddedPiAgent(baseParams);
 
-    expect(mockedCompactDirect).toHaveBeenCalledTimes(1);
+    expect(mockedCompactDirect).not.toHaveBeenCalled();
     const oversizedArgs = requireMockCallArg(mockedSessionLikelyHasOversizedToolResults, 0);
     const messages = oversizedArgs.messages as Array<{ role?: string }>;
     expect(messages.filter((message) => message.role === "toolResult")).toHaveLength(3);
     expect(requireMockCallArg(mockedTruncateOversizedToolResultsInSession, 0).sessionFile).toBe(
       "/tmp/session.json",
     );
     expect(mockedRunEmbeddedAttempt).toHaveBeenCalledTimes(2);
-    expectLogIncludes(mockedLog.info, "Truncated 2 tool result(s)");
+    expect(result.meta.error).toBeUndefined();
+  });
+
+  it("retries compaction when pre-compaction tool-result truncation does not help", async () => {
+    queueOverflowAttemptWithOversizedToolOutput(mockedRunEmbeddedAttempt, makeOverflowError());
+    mockedRunEmbeddedAttempt.mockResolvedValueOnce(makeAttemptResult({ promptError: null }));
+
+    mockedSessionLikelyHasOversizedToolResults.mockReturnValue(true);
+    mockedTruncateOversizedToolResultsInSession.mockResolvedValueOnce({
+      truncated: false,
+      truncatedCount: 0,
+      reason: "no reducible tool results",
+    });
+    mockedCompactDirect.mockResolvedValueOnce(
+      makeCompactionSuccess({
+        summary: "Compacted after truncation miss",
+        firstKeptEntryId: "entry-9",
+        tokensBefore: 150000,
+      }),
+    );
+
+    const result = await runEmbeddedPiAgent(baseParams);
+
+    expect(mockedTruncateOversizedToolResultsInSession).toHaveBeenCalledTimes(1);
+    expect(mockedCompactDirect).toHaveBeenCalledTimes(1);
+    expect(mockedRunEmbeddedAttempt).toHaveBeenCalledTimes(2);
+    expectLogIncludes(mockedLog.warn, "Tool result truncation did not help before compaction");
+    expectLogIncludes(mockedLog.info, "auto-compaction succeeded");
     expect(result.meta.error).toBeUndefined();
   });
 
diff --git a/src/agents/pi-embedded-runner/run.ts b/src/agents/pi-embedded-runner/run.ts
@@ -1736,6 +1736,47 @@ export async function runEmbeddedPiAgent(
               }
               continue;
             }
+            if (!toolResultTruncationAttempted && !preflightRecovery) {
+              const contextWindowTokens = ctxInfo.tokens;
+              const toolResultMaxChars = resolveLiveToolResultMaxChars({
+                contextWindowTokens,
+                cfg: params.config,
+                agentId: sessionAgentId,
+              });
+              const hasOversized = attempt.messagesSnapshot
+                ? sessionLikelyHasOversizedToolResults({
+                    messages: attempt.messagesSnapshot,
+                    contextWindowTokens,
+                    maxCharsOverride: toolResultMaxChars,
+                  })
+                : false;
+
+              if (hasOversized) {
+                toolResultTruncationAttempted = true;
+                log.warn(
+                  `[context-overflow-recovery] Attempting tool result truncation before compaction for ${provider}/${modelId} ` +
+                    `(contextWindow=${contextWindowTokens} tokens)`,
+                );
+                const truncResult = await truncateOversizedToolResultsInSession({
+                  sessionFile: activeSessionFile,
+                  contextWindowTokens,
+                  maxCharsOverride: toolResultMaxChars,
+                  sessionId: activeSessionId,
+                  sessionKey: params.sessionKey,
+                  config: params.config,
+                });
+                if (truncResult.truncated) {
+                  log.info(
+                    `[context-overflow-recovery] Truncated ${truncResult.truncatedCount} tool result(s); retrying prompt`,
+                  );
+                  continue;
+                }
+                log.warn(
+                  `[context-overflow-recovery] Tool result truncation did not help before compaction: ${truncResult.reason ?? "unknown"}`,
+                );
+              }
+            }
+
             // Attempt explicit overflow compaction only when this attempt did not
             // already auto-compact.
             if (
