@librechat/agents 3.4.6 → 3.5.0

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

@@ -1,973 +0,0 @@
-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 { SummarizationTrigger } from '@/types';
-import { Providers } from '@/common';
-
-// ---------------------------------------------------------------------------
-// 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('truncates structured tool results and preserves message metadata', () => {
-    const toolMsg = new ToolMessage({
-      content: [
-        {
-          type: 'json',
-          rows: Array.from({ length: 20 }, (_, index) => ({
-            id: index,
-            value: `${'x'.repeat(100)}-${index}`,
-          })),
-        },
-      ],
-      tool_call_id: 'tc-structured',
-      name: 'run_select_query',
-      status: 'success',
-      artifact: { source: 'clickhouse' },
-      metadata: { requestId: 'request-1' },
-      additional_kwargs: { traceId: 'trace-1' },
-    });
-    const messages: BaseMessage[] = [toolMsg];
-    const indexTokenCountMap: Record<string, number | undefined> = { 0: 0 };
-
-    const count = preFlightTruncateToolResults({
-      messages,
-      maxContextTokens: 200,
-      indexTokenCountMap,
-      tokenCounter,
-    });
-
-    expect(count).toBe(1);
-    expect(typeof messages[0].content).toBe('string');
-    expect(messages[0].content).toContain('truncated');
-    expect(messages[0].content).toContain('"id":0');
-    const truncated = messages[0] as ToolMessage;
-    expect(truncated.tool_call_id).toBe('tc-structured');
-    expect(truncated.name).toBe('run_select_query');
-    expect(truncated.status).toBe('success');
-    expect(truncated.artifact).toEqual({ source: 'clickhouse' });
-    expect(truncated.metadata).toEqual({ requestId: 'request-1' });
-    expect(truncated.additional_kwargs).toEqual({ traceId: 'trace-1' });
-    expect(indexTokenCountMap[0]).toBe(tokenCounter(truncated));
-  });
-
-  it('does not truncate indivisible native computer screenshots', () => {
-    const screenshot = `data:image/png;base64,${'A'.repeat(2_000)}`;
-    const stringOutput = new ToolMessage({
-      content: screenshot,
-      tool_call_id: 'computer-string',
-      additional_kwargs: { type: 'computer_call_output' },
-    });
-    const structuredOutput = new ToolMessage({
-      content: [{ type: 'computer_screenshot', image_url: screenshot }],
-      tool_call_id: 'computer-structured',
-      additional_kwargs: { type: 'computer_call_output' },
-    });
-    const messages: BaseMessage[] = [stringOutput, structuredOutput];
-    const indexTokenCountMap: Record<string, number | undefined> = {
-      0: tokenCounter(stringOutput),
-      1: tokenCounter(structuredOutput),
-    };
-
-    const count = preFlightTruncateToolResults({
-      messages,
-      maxContextTokens: 50,
-      indexTokenCountMap,
-      tokenCounter,
-    });
-
-    expect(count).toBe(0);
-    expect(messages[0]).toBe(stringOutput);
-    expect(messages[0].content).toBe(screenshot);
-    expect(messages[1]).toBe(structuredOutput);
-    expect(messages[1].content).toBe(structuredOutput.content);
-  });
-
-  it('compacts text in multipart results without slicing media blocks', () => {
-    const imageBlock = {
-      type: 'image_url',
-      image_url: { url: 'data:image/png;base64,AAAA' },
-    };
-    const toolMsg = new ToolMessage({
-      content: [{ type: 'text', text: 'x'.repeat(1_000) }, imageBlock],
-      tool_call_id: 'tc-multipart',
-      name: 'screenshot',
-    });
-    const messages: BaseMessage[] = [toolMsg];
-    const indexTokenCountMap: Record<string, number | undefined> = {
-      0: tokenCounter(toolMsg),
-    };
-
-    const count = preFlightTruncateToolResults({
-      messages,
-      maxContextTokens: 200,
-      indexTokenCountMap,
-      tokenCounter,
-    });
-
-    expect(count).toBe(1);
-    expect(Array.isArray(messages[0].content)).toBe(true);
-    const content = messages[0].content as Array<Record<string, unknown>>;
-    expect(content).toHaveLength(2);
-    expect(content[0].type).toBe('text');
-    expect(content[0].text).toContain('truncated');
-    expect(content[1]).toBe(imageBlock);
-  });
-
-  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);
-  });
-});