@librechat/agents 3.1.57 → 3.1.61

package/src/specs/summarization-unit.test.ts

@@ -0,0 +1,868 @@
+import { HumanMessage, AIMessage, ToolMessage } from '@langchain/core/messages';
+import type { BaseMessage } from '@langchain/core/messages';
+import {
+  calculateMaxToolResultChars,
+  truncateToolResultContent,
+  truncateToolInput,
+  HARD_MAX_TOOL_RESULT_CHARS,
+} from '@/utils/truncation';
+import {
+  preFlightTruncateToolResults,
+  preFlightTruncateToolCallInputs,
+  createPruneMessages,
+} from '@/messages/prune';
+import { shouldTriggerSummarization } from '@/summarization/index';
+import { Providers } from '@/common';
+import { SummarizationTrigger } from '@/types';
+
+// ---------------------------------------------------------------------------
+// Shared helpers
+// ---------------------------------------------------------------------------
+
+function tokenCounter(msg: { content: unknown }): number {
+  const content =
+    typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content);
+  return Math.ceil(content.length / 4);
+}
+
+// ---------------------------------------------------------------------------
+// calculateMaxToolResultChars
+// ---------------------------------------------------------------------------
+
+describe('calculateMaxToolResultChars', () => {
+  it('returns 30% of context window in chars (×4 ratio)', () => {
+    // 1000 tokens × 0.3 = 300; 300 × 4 = 1200 chars
+    expect(calculateMaxToolResultChars(1000)).toBe(1200);
+  });
+
+  it('caps at HARD_MAX_TOOL_RESULT_CHARS for large contexts', () => {
+    expect(calculateMaxToolResultChars(10_000_000)).toBe(
+      HARD_MAX_TOOL_RESULT_CHARS
+    );
+  });
+
+  it('returns hard max when contextWindowTokens is undefined', () => {
+    expect(calculateMaxToolResultChars(undefined)).toBe(
+      HARD_MAX_TOOL_RESULT_CHARS
+    );
+  });
+
+  it('returns hard max when contextWindowTokens is 0 or negative', () => {
+    expect(calculateMaxToolResultChars(0)).toBe(HARD_MAX_TOOL_RESULT_CHARS);
+    expect(calculateMaxToolResultChars(-100)).toBe(HARD_MAX_TOOL_RESULT_CHARS);
+  });
+
+  it('handles small context windows', () => {
+    // 50 tokens × 0.3 = 15; 15 × 4 = 60
+    expect(calculateMaxToolResultChars(50)).toBe(60);
+    // 10 tokens × 0.3 = 3; 3 × 4 = 12
+    expect(calculateMaxToolResultChars(10)).toBe(12);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// truncateToolResultContent
+// ---------------------------------------------------------------------------
+
+describe('truncateToolResultContent', () => {
+  it('returns content unchanged when within budget', () => {
+    const content = 'Short result';
+    expect(truncateToolResultContent(content, 100)).toBe(content);
+  });
+
+  it('returns content unchanged when exactly at budget', () => {
+    const content = 'x'.repeat(50);
+    expect(truncateToolResultContent(content, 50)).toBe(content);
+  });
+
+  it('truncates with head+tail when budget is large enough', () => {
+    // Need available >= 200 for head+tail. With 1000-char content and budget=500,
+    // indicator ≈ 42 chars, available ≈ 458 — well above the 200 threshold.
+    const content = 'A'.repeat(400) + 'B'.repeat(200) + 'C'.repeat(400);
+    const result = truncateToolResultContent(content, 500);
+
+    expect(result.length).toBeLessThanOrEqual(510); // some slack for indicator
+    expect(result).toContain('truncated');
+    expect(result).toContain('1000'); // original length
+    expect(result).toContain('500'); // limit
+    // Head preserved (starts with As)
+    expect(result.startsWith('A')).toBe(true);
+    // Tail preserved (ends with Cs)
+    expect(result.endsWith('C')).toBe(true);
+  });
+
+  it('falls back to head-only when budget is very small', () => {
+    // With 1000-char content and budget=235, indicator ≈ 37 chars,
+    // available ≈ 198 < 200 threshold → head-only path.
+    const content = 'A'.repeat(500) + 'B'.repeat(500);
+    const result = truncateToolResultContent(content, 235);
+
+    expect(result).toContain('truncated');
+    expect(result.startsWith('A')).toBe(true);
+    expect(result).not.toMatch(/B/);
+  });
+
+  it('returns head-only slice when budget is smaller than indicator', () => {
+    // When budget is so small the indicator doesn't fit, just returns head slice
+    const content = 'Error: ENOENT: no such file or directory';
+    const result = truncateToolResultContent(content, 30);
+
+    expect(result).toBe(content.slice(0, 30));
+  });
+
+  it('preserves the truncation indicator format', () => {
+    const content = 'x'.repeat(500);
+    const result = truncateToolResultContent(content, 300);
+    // Format: [truncated: N chars exceeded M limit]
+    expect(result).toMatch(/\[truncated: 500 chars exceeded 300 limit\]/);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// truncateToolInput
+// ---------------------------------------------------------------------------
+
+describe('truncateToolInput', () => {
+  it('returns unchanged string when within budget', () => {
+    const result = truncateToolInput('short input', 100);
+    expect(result._truncated).toBe('short input');
+    expect(result._originalChars).toBe(11);
+  });
+
+  it('serializes objects to JSON before truncating', () => {
+    const input = { key: 'value', nested: { a: 1 } };
+    const result = truncateToolInput(input, 10);
+    expect(result._originalChars).toBe(JSON.stringify(input).length);
+    expect(result._truncated).toContain('truncated');
+  });
+
+  it('truncates long strings with indicator', () => {
+    const input = 'x'.repeat(500);
+    const result = truncateToolInput(input, 200);
+    expect(result._truncated).toContain('truncated');
+    expect(result._truncated).toContain('500');
+    expect(result._originalChars).toBe(500);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// preFlightTruncateToolResults
+// ---------------------------------------------------------------------------
+
+describe('preFlightTruncateToolResults', () => {
+  it('truncates oversized tool results and updates token counts', () => {
+    const toolMsg = new ToolMessage({
+      content: 'x'.repeat(500),
+      tool_call_id: 'tc1',
+      name: 'big_tool',
+    });
+    const messages: BaseMessage[] = [
+      new HumanMessage('run it'),
+      new AIMessage({
+        content: '',
+        tool_calls: [{ id: 'tc1', name: 'big_tool', args: {} }],
+      }),
+      toolMsg,
+    ];
+
+    const indexTokenCountMap: Record<string, number | undefined> = {
+      0: 5,
+      1: 10,
+      2: tokenCounter(toolMsg),
+    };
+    const originalTokenCount = indexTokenCountMap[2]!;
+
+    const count = preFlightTruncateToolResults({
+      messages,
+      maxContextTokens: 200, // calculateMaxToolResultChars(200) = 240 chars
+      indexTokenCountMap,
+      tokenCounter,
+    });
+
+    expect(count).toBe(1);
+    // Content was mutated in place
+    const truncatedContent = messages[2].content as string;
+    expect(truncatedContent.length).toBeLessThan(500);
+    expect(truncatedContent).toContain('truncated');
+    // Token count was updated
+    expect(indexTokenCountMap[2]).toBeLessThan(originalTokenCount);
+  });
+
+  it('does not truncate results that fit within budget', () => {
+    const toolMsg = new ToolMessage({
+      content: 'OK',
+      tool_call_id: 'tc1',
+      name: 'small_tool',
+    });
+    const messages: BaseMessage[] = [toolMsg];
+    const indexTokenCountMap: Record<string, number | undefined> = {
+      0: 2,
+    };
+
+    const count = preFlightTruncateToolResults({
+      messages,
+      maxContextTokens: 1000,
+      indexTokenCountMap,
+      tokenCounter,
+    });
+
+    expect(count).toBe(0);
+    expect(messages[0].content).toBe('OK');
+    expect(indexTokenCountMap[0]).toBe(2);
+  });
+
+  it('skips non-tool messages', () => {
+    const messages: BaseMessage[] = [
+      new HumanMessage('x'.repeat(500)),
+      new AIMessage('y'.repeat(500)),
+    ];
+    const indexTokenCountMap: Record<string, number | undefined> = {
+      0: 125,
+      1: 125,
+    };
+
+    const count = preFlightTruncateToolResults({
+      messages,
+      maxContextTokens: 10, // very tight budget
+      indexTokenCountMap,
+      tokenCounter,
+    });
+
+    expect(count).toBe(0);
+    expect((messages[0].content as string).length).toBe(500);
+  });
+
+  it('uses raw maxContextTokens (not effective budget) for threshold', () => {
+    // This verifies the bug fix: with maxContextTokens=50,
+    // calculateMaxToolResultChars(50) = 60 chars.
+    // A 60-char tool result should NOT be truncated.
+    const content =
+      'Error: ENOENT: no such file or directory, open /src/index.ts'; // 60 chars
+    const toolMsg = new ToolMessage({
+      content,
+      tool_call_id: 'tc1',
+      name: 'run_linter',
+      status: 'error',
+    });
+    const messages: BaseMessage[] = [toolMsg];
+    const indexTokenCountMap: Record<string, number | undefined> = {
+      0: tokenCounter(toolMsg),
+    };
+
+    const count = preFlightTruncateToolResults({
+      messages,
+      maxContextTokens: 50,
+      indexTokenCountMap,
+      tokenCounter,
+    });
+
+    expect(count).toBe(0);
+    expect(messages[0].content).toBe(content);
+    expect(messages[0].content).toContain('ENOENT');
+  });
+
+  it('handles multiple tool messages, truncating only oversized ones', () => {
+    const smallTool = new ToolMessage({
+      content: 'ok',
+      tool_call_id: 'tc1',
+      name: 'tool_a',
+    });
+    const bigTool = new ToolMessage({
+      content: 'x'.repeat(2000),
+      tool_call_id: 'tc2',
+      name: 'tool_b',
+    });
+    const messages: BaseMessage[] = [smallTool, bigTool];
+    const indexTokenCountMap: Record<string, number | undefined> = {
+      0: tokenCounter(smallTool),
+      1: tokenCounter(bigTool),
+    };
+
+    const count = preFlightTruncateToolResults({
+      messages,
+      maxContextTokens: 500, // maxChars = 600
+      indexTokenCountMap,
+      tokenCounter,
+    });
+
+    expect(count).toBe(1);
+    expect(messages[0].content).toBe('ok');
+    expect((messages[1].content as string).length).toBeLessThan(2000);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// preFlightTruncateToolResults uses raw maxTokens in pruner
+// ---------------------------------------------------------------------------
+
+describe('pre-flight truncation in pruner uses raw maxContextTokens', () => {
+  it('preserves small tool results even with tight effective budget', () => {
+    // Simulate: maxContextTokens=50, high instruction overhead.
+    // Pre-flight should use raw 50 (maxChars=60), not effectiveMaxTokens.
+    const content =
+      'Error: ENOENT: no such file or directory, open /src/index.ts'; // 60 chars
+    const toolMsg = new ToolMessage({
+      content,
+      tool_call_id: 'tc1',
+      name: 'run_linter',
+      status: 'error',
+    });
+    const aiMsg = new AIMessage({
+      content: [
+        { type: 'text' as const, text: 'Running linter.' },
+        {
+          type: 'tool_use' as const,
+          id: 'tc1',
+          name: 'run_linter',
+          input: '{"path":"/src"}',
+        },
+      ],
+      tool_calls: [{ id: 'tc1', name: 'run_linter', args: { path: '/src' } }],
+    });
+    const messages: BaseMessage[] = [
+      new HumanMessage('Run the linter.'),
+      aiMsg,
+      toolMsg,
+      new AIMessage('The linter failed.'),
+    ];
+
+    const indexTokenCountMap: Record<string, number | undefined> = {};
+    for (let i = 0; i < messages.length; i++) {
+      indexTokenCountMap[i] = tokenCounter(messages[i]);
+    }
+
+    const pruneMessages = createPruneMessages({
+      provider: Providers.OPENAI,
+      maxTokens: 50,
+      startIndex: messages.length,
+      tokenCounter,
+      indexTokenCountMap,
+      getInstructionTokens: () => 15,
+    });
+
+    pruneMessages({ messages });
+
+    // The 60-char tool result must survive pre-flight truncation.
+    // With raw maxTokens=50: calculateMaxToolResultChars(50) = 60, so 60 <= 60 → not truncated.
+    // The old bug used effectiveMaxTokens (~32), which gave maxChars=40 and truncated ENOENT.
+    expect(toolMsg.content).toBe(content);
+    expect(toolMsg.content).toContain('ENOENT');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// shouldTriggerSummarization
+// ---------------------------------------------------------------------------
+
+describe('shouldTriggerSummarization', () => {
+  describe('no trigger configured (default)', () => {
+    it('returns true when messagesToRefineCount > 0', () => {
+      expect(shouldTriggerSummarization({ messagesToRefineCount: 1 })).toBe(
+        true
+      );
+      expect(shouldTriggerSummarization({ messagesToRefineCount: 100 })).toBe(
+        true
+      );
+    });
+
+    it('returns false when messagesToRefineCount is 0', () => {
+      expect(shouldTriggerSummarization({ messagesToRefineCount: 0 })).toBe(
+        false
+      );
+    });
+  });
+
+  describe('token_ratio trigger', () => {
+    it('fires when used ratio exceeds threshold', () => {
+      expect(
+        shouldTriggerSummarization({
+          trigger: { type: 'token_ratio', value: 0.8 },
+          maxContextTokens: 1000,
+          prePruneContextTokens: 900, // 90% used
+          messagesToRefineCount: 5,
+        })
+      ).toBe(true);
+    });
+
+    it('does not fire when used ratio is below threshold', () => {
+      expect(
+        shouldTriggerSummarization({
+          trigger: { type: 'token_ratio', value: 0.8 },
+          maxContextTokens: 1000,
+          prePruneContextTokens: 500, // 50% used
+          messagesToRefineCount: 5,
+        })
+      ).toBe(false);
+    });
+
+    it('fires at exact boundary', () => {
+      expect(
+        shouldTriggerSummarization({
+          trigger: { type: 'token_ratio', value: 0.8 },
+          maxContextTokens: 1000,
+          prePruneContextTokens: 800, // exactly 80%
+          messagesToRefineCount: 5,
+        })
+      ).toBe(true);
+    });
+
+    it('does not fire when maxContextTokens is missing', () => {
+      expect(
+        shouldTriggerSummarization({
+          trigger: { type: 'token_ratio', value: 0.8 },
+          prePruneContextTokens: 900,
+          messagesToRefineCount: 5,
+        })
+      ).toBe(false);
+    });
+
+    it('falls back to remainingContextTokens when prePruneContextTokens is missing', () => {
+      expect(
+        shouldTriggerSummarization({
+          trigger: { type: 'token_ratio', value: 0.8 },
+          maxContextTokens: 1000,
+          remainingContextTokens: 100, // 90% used
+          messagesToRefineCount: 5,
+        })
+      ).toBe(true);
+    });
+  });
+
+  describe('remaining_tokens trigger', () => {
+    it('fires when remaining tokens are at or below threshold', () => {
+      expect(
+        shouldTriggerSummarization({
+          trigger: { type: 'remaining_tokens', value: 200 },
+          maxContextTokens: 1000,
+          prePruneContextTokens: 850, // remaining = 150
+          messagesToRefineCount: 3,
+        })
+      ).toBe(true);
+    });
+
+    it('does not fire when remaining tokens exceed threshold', () => {
+      expect(
+        shouldTriggerSummarization({
+          trigger: { type: 'remaining_tokens', value: 200 },
+          maxContextTokens: 1000,
+          prePruneContextTokens: 500, // remaining = 500
+          messagesToRefineCount: 3,
+        })
+      ).toBe(false);
+    });
+
+    it('does not fire when remaining tokens data is missing', () => {
+      expect(
+        shouldTriggerSummarization({
+          trigger: { type: 'remaining_tokens', value: 200 },
+          messagesToRefineCount: 3,
+        })
+      ).toBe(false);
+    });
+  });
+
+  describe('messages_to_refine trigger', () => {
+    it('fires when messagesToRefineCount meets threshold', () => {
+      expect(
+        shouldTriggerSummarization({
+          trigger: { type: 'messages_to_refine', value: 5 },
+          messagesToRefineCount: 5,
+        })
+      ).toBe(true);
+      expect(
+        shouldTriggerSummarization({
+          trigger: { type: 'messages_to_refine', value: 5 },
+          messagesToRefineCount: 10,
+        })
+      ).toBe(true);
+    });
+
+    it('does not fire when messagesToRefineCount is below threshold', () => {
+      expect(
+        shouldTriggerSummarization({
+          trigger: { type: 'messages_to_refine', value: 5 },
+          messagesToRefineCount: 3,
+        })
+      ).toBe(false);
+    });
+  });
+
+  describe('edge cases', () => {
+    it('returns false for unrecognized trigger type', () => {
+      expect(
+        shouldTriggerSummarization({
+          trigger: {
+            type: 'unknown_type' as SummarizationTrigger['type'],
+            value: 1,
+          },
+          messagesToRefineCount: 10,
+        })
+      ).toBe(false);
+    });
+
+    it('returns false when trigger value is invalid', () => {
+      expect(
+        shouldTriggerSummarization({
+          trigger: { type: 'token_ratio', value: NaN },
+          maxContextTokens: 1000,
+          prePruneContextTokens: 900,
+          messagesToRefineCount: 5,
+        })
+      ).toBe(false);
+    });
+
+    it('returns false when messagesToRefineCount is 0 regardless of trigger', () => {
+      expect(
+        shouldTriggerSummarization({
+          trigger: { type: 'messages_to_refine', value: 0 },
+          messagesToRefineCount: 0,
+        })
+      ).toBe(false);
+    });
+  });
+});
+
+// ---------------------------------------------------------------------------
+// preFlightTruncateToolCallInputs
+// ---------------------------------------------------------------------------
+
+describe('preFlightTruncateToolCallInputs', () => {
+  it('truncates oversized tool_use input fields', () => {
+    const bigInput = JSON.stringify({ code: 'x'.repeat(5000) });
+    const aiMsg = new AIMessage({
+      content: [
+        { type: 'text' as const, text: 'Running code.' },
+        {
+          type: 'tool_use' as const,
+          id: 'tc1',
+          name: 'execute',
+          input: bigInput,
+        },
+      ],
+      tool_calls: [
+        { id: 'tc1', name: 'execute', args: { code: 'x'.repeat(5000) } },
+      ],
+    });
+    const messages: BaseMessage[] = [aiMsg];
+    const indexTokenCountMap: Record<string, number | undefined> = {
+      0: tokenCounter(aiMsg),
+    };
+
+    const count = preFlightTruncateToolCallInputs({
+      messages,
+      maxContextTokens: 200, // maxInputChars = floor(200*0.15)*4 = 120
+      indexTokenCountMap,
+      tokenCounter,
+    });
+
+    expect(count).toBe(1);
+  });
+
+  it('does not truncate small inputs', () => {
+    const aiMsg = new AIMessage({
+      content: [
+        {
+          type: 'tool_use' as const,
+          id: 'tc1',
+          name: 'calc',
+          input: '{"a":1}',
+        },
+      ],
+      tool_calls: [{ id: 'tc1', name: 'calc', args: { a: 1 } }],
+    });
+    const messages: BaseMessage[] = [aiMsg];
+    const indexTokenCountMap: Record<string, number | undefined> = {
+      0: tokenCounter(aiMsg),
+    };
+    const originalCount = indexTokenCountMap[0];
+
+    const count = preFlightTruncateToolCallInputs({
+      messages,
+      maxContextTokens: 10000,
+      indexTokenCountMap,
+      tokenCounter,
+    });
+
+    expect(count).toBe(0);
+    expect(indexTokenCountMap[0]).toBe(originalCount);
+  });
+
+  it('skips non-AI messages', () => {
+    const messages: BaseMessage[] = [
+      new HumanMessage('hello'),
+      new ToolMessage({
+        content: 'x'.repeat(5000),
+        tool_call_id: 'tc1',
+        name: 'big',
+      }),
+    ];
+    const indexTokenCountMap: Record<string, number | undefined> = {
+      0: 3,
+      1: 1250,
+    };
+
+    const count = preFlightTruncateToolCallInputs({
+      messages,
+      maxContextTokens: 10,
+      indexTokenCountMap,
+      tokenCounter,
+    });
+
+    expect(count).toBe(0);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Pruner → summarization routing: messagesToRefine populated correctly
+// ---------------------------------------------------------------------------
+
+describe('pruner messagesToRefine for summarization', () => {
+  it('populates messagesToRefine with pruned messages when over budget', () => {
+    const messages: BaseMessage[] = [];
+    for (let i = 0; i < 20; i++) {
+      messages.push(new HumanMessage(`Question ${i}: ${'detail '.repeat(20)}`));
+      messages.push(new AIMessage(`Answer ${i}: ${'explanation '.repeat(20)}`));
+    }
+
+    const indexTokenCountMap: Record<string, number | undefined> = {};
+    for (let i = 0; i < messages.length; i++) {
+      indexTokenCountMap[i] = tokenCounter(messages[i]);
+    }
+
+    const pruneMessages = createPruneMessages({
+      provider: Providers.OPENAI,
+      maxTokens: 200,
+      startIndex: messages.length,
+      tokenCounter,
+      indexTokenCountMap,
+    });
+
+    const result = pruneMessages({ messages });
+
+    expect(result.messagesToRefine!.length).toBeGreaterThan(0);
+    expect(result.context.length).toBeGreaterThan(0);
+    expect(result.context.length + result.messagesToRefine!.length).toBe(
+      messages.length
+    );
+    expect(typeof result.remainingContextTokens).toBe('number');
+  });
+
+  it('returns empty messagesToRefine when everything fits', () => {
+    const messages: BaseMessage[] = [
+      new HumanMessage('Hi'),
+      new AIMessage('Hello'),
+    ];
+
+    const indexTokenCountMap: Record<string, number | undefined> = {};
+    for (let i = 0; i < messages.length; i++) {
+      indexTokenCountMap[i] = tokenCounter(messages[i]);
+    }
+
+    const pruneMessages = createPruneMessages({
+      provider: Providers.OPENAI,
+      maxTokens: 10000,
+      startIndex: messages.length,
+      tokenCounter,
+      indexTokenCountMap,
+    });
+
+    const result = pruneMessages({ messages });
+
+    expect(result.messagesToRefine!).toHaveLength(0);
+    expect(result.context).toEqual(messages);
+  });
+
+  it('messagesToRefine contains the oldest messages (chronological order)', () => {
+    const messages: BaseMessage[] = [
+      new HumanMessage('First question - oldest'),
+      new AIMessage('First answer - oldest'),
+      new HumanMessage('Second question'),
+      new AIMessage('Second answer'),
+      new HumanMessage(
+        'Third question with much more detail to push token count up significantly'
+      ),
+      new AIMessage(
+        'Third answer with extensive explanation that uses many tokens in the response'
+      ),
+    ];
+
+    const indexTokenCountMap: Record<string, number | undefined> = {};
+    for (let i = 0; i < messages.length; i++) {
+      indexTokenCountMap[i] = tokenCounter(messages[i]);
+    }
+
+    const totalTokens = Object.values(indexTokenCountMap).reduce(
+      (a = 0, b = 0) => a! + b!,
+      0
+    ) as number;
+
+    const pruneMessages = createPruneMessages({
+      provider: Providers.OPENAI,
+      maxTokens: Math.floor(totalTokens * 0.5),
+      startIndex: messages.length,
+      tokenCounter,
+      indexTokenCountMap,
+    });
+
+    const result = pruneMessages({ messages });
+
+    expect(result.messagesToRefine!.length).toBeGreaterThan(0);
+    // The oldest messages should be in messagesToRefine
+    const refinedContent = result.messagesToRefine!.map((m) => m.content);
+    expect(refinedContent[0]).toContain('First question');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Emergency truncation in pruner
+// ---------------------------------------------------------------------------
+
+describe('emergency truncation when pruning produces empty context', () => {
+  it('recovers from empty context by truncating tool results', () => {
+    // Single large tool result that exceeds the entire budget
+    const bigToolMsg = new ToolMessage({
+      content: 'x'.repeat(10_000),
+      tool_call_id: 'tc1',
+      name: 'big_result',
+    });
+    const aiMsg = new AIMessage({
+      content: [
+        { type: 'text' as const, text: 'Calling tool.' },
+        {
+          type: 'tool_use' as const,
+          id: 'tc1',
+          name: 'big_result',
+          input: '{}',
+        },
+      ],
+      tool_calls: [{ id: 'tc1', name: 'big_result', args: {} }],
+    });
+    const messages: BaseMessage[] = [
+      new HumanMessage('Run it'),
+      aiMsg,
+      bigToolMsg,
+      new AIMessage('Done.'),
+      new HumanMessage('What happened?'),
+    ];
+
+    const indexTokenCountMap: Record<string, number | undefined> = {};
+    for (let i = 0; i < messages.length; i++) {
+      indexTokenCountMap[i] = tokenCounter(messages[i]);
+    }
+
+    const pruneMessages = createPruneMessages({
+      provider: Providers.OPENAI,
+      maxTokens: 100, // Very tight — forces emergency path
+      startIndex: messages.length,
+      tokenCounter,
+      indexTokenCountMap,
+    });
+
+    const result = pruneMessages({ messages });
+
+    // Emergency truncation should produce a non-empty context
+    // (or at minimum, non-empty messagesToRefine)
+    const totalReturned =
+      result.context.length + (result.messagesToRefine?.length ?? 0);
+    expect(totalReturned).toBeGreaterThan(0);
+  });
+
+  it('recovers via emergency truncation after fallback fading when summarizationEnabled=true', () => {
+    const bigToolMsg = new ToolMessage({
+      content: 'y'.repeat(20_000),
+      tool_call_id: 'tc1',
+      name: 'huge_result',
+    });
+    const aiMsg = new AIMessage({
+      content: [
+        { type: 'text' as const, text: 'Running.' },
+        {
+          type: 'tool_use' as const,
+          id: 'tc1',
+          name: 'huge_result',
+          input: '{}',
+        },
+      ],
+      tool_calls: [{ id: 'tc1', name: 'huge_result', args: {} }],
+    });
+    const messages: BaseMessage[] = [
+      new HumanMessage('Do it'),
+      aiMsg,
+      bigToolMsg,
+      new AIMessage('Complete.'),
+      new HumanMessage('Status?'),
+    ];
+
+    const indexTokenCountMap: Record<string, number | undefined> = {};
+    for (let i = 0; i < messages.length; i++) {
+      indexTokenCountMap[i] = tokenCounter(messages[i]);
+    }
+
+    const pruneMessages = createPruneMessages({
+      provider: Providers.OPENAI,
+      maxTokens: 100,
+      startIndex: messages.length,
+      tokenCounter,
+      indexTokenCountMap,
+      summarizationEnabled: true,
+    });
+
+    const result = pruneMessages({ messages });
+
+    const totalReturned =
+      result.context.length + (result.messagesToRefine?.length ?? 0);
+    expect(totalReturned).toBeGreaterThan(0);
+
+    if (result.context.length > 0) {
+      const toolMsgs = result.context.filter((m) => m.getType() === 'tool');
+      for (const tm of toolMsgs) {
+        const content = typeof tm.content === 'string' ? tm.content : '';
+        expect(content.length).toBeLessThan(20_000);
+      }
+    }
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Interaction: pre-flight truncation does not destroy enrichment data
+// ---------------------------------------------------------------------------
+
+describe('pre-flight + enrichment interaction', () => {
+  it('tool error content survives pre-flight with raw maxContextTokens', () => {
+    // Simulate the exact scenario from the bug:
+    // maxContextTokens=50, tool message with 60-char error content.
+    // Pre-flight should NOT truncate since calculateMaxToolResultChars(50) = 60.
+    const errorContent =
+      'Error: ENOENT: no such file or directory, open /src/index.ts';
+    expect(errorContent.length).toBe(60);
+
+    const toolMsg = new ToolMessage({
+      content: errorContent,
+      tool_call_id: 'tc1',
+      name: 'run_linter',
+      status: 'error',
+    });
+
+    const messages: BaseMessage[] = [toolMsg];
+    const indexTokenCountMap: Record<string, number | undefined> = {
+      0: tokenCounter(toolMsg),
+    };
+
+    // Pre-flight with maxContextTokens=50 → maxChars = 60
+    const count = preFlightTruncateToolResults({
+      messages,
+      maxContextTokens: 50,
+      indexTokenCountMap,
+      tokenCounter,
+    });
+
+    expect(count).toBe(0);
+    expect(messages[0].content).toContain('ENOENT');
+
+    // Verify: if we had used effectiveMaxTokens (e.g., 37),
+    // it WOULD have truncated (maxChars=44 < 60)
+    const wouldTruncateMaxChars = calculateMaxToolResultChars(37);
+    expect(wouldTruncateMaxChars).toBe(44);
+    expect(errorContent.length).toBeGreaterThan(wouldTruncateMaxChars);
+  });
+});