skimpyclaw 0.3.14 → 0.4.0

package/dist/__tests__/context-manager.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { estimateTokens, compactAnthropicMessages, compactOpenAIMessages, compactCodexMessages, serializeAnthropicMessages, serializeOpenAIMessages, serializeCodexMessages, } from '../providers/context-manager.js';
+import { estimateTokens, compactMessages, compactAnthropicMessages, compactOpenAIMessages, compactCodexMessages, anthropicFormatHelper, openaiFormatHelper, codexFormatHelper, serializeAnthropicMessages, serializeOpenAIMessages, serializeCodexMessages, } from '../providers/context-manager.js';
 // Mock the chat function used for LLM summarization
 vi.mock('../providers/index.js', () => ({
     chat: vi.fn().mockResolvedValue('Summary of the conversation: the user asked to list files and the assistant ran ls.'),
@@ -51,6 +51,14 @@ function openaiExchange(toolResult) {
         { role: 'tool', tool_call_id: 'tc_1', content: toolResult },
     ];
 }
+// Helper: build many items for compaction tests
+function manyItems(factory, content, count = 30) {
+    const items = [];
+    for (let i = 0; i < count; i++) {
+        items.push(...factory(content));
+    }
+    return items;
+}
 describe('estimateTokens', () => {
     it('returns a positive number for non-empty data', () => {
         expect(estimateTokens([{ role: 'user', content: 'hello' }])).toBeGreaterThan(0);
@@ -64,25 +72,119 @@ describe('estimateTokens', () => {
         expect(large).toBeGreaterThan(small);
     });
 });
-describe('compactAnthropicMessages', () => {
-    it('passes through unchanged when under threshold', async () => {
+// =====================================================================
+// MessageFormatHelper unit tests
+// =====================================================================
+describe('anthropicFormatHelper', () => {
+    it('isToolResult returns true for tool_result content blocks', () => {
+        const msg = { role: 'user', content: [{ type: 'tool_result', tool_use_id: 'tu_1', content: 'result' }] };
+        expect(anthropicFormatHelper.isToolResult(msg)).toBe(true);
+    });
+    it('isToolResult returns false for text messages', () => {
+        const msg = { role: 'user', content: [{ type: 'text', text: 'hello' }] };
+        expect(anthropicFormatHelper.isToolResult(msg)).toBe(false);
+    });
+    it('isToolResult returns false for string content', () => {
+        expect(anthropicFormatHelper.isToolResult({ role: 'user', content: 'hi' })).toBe(false);
+    });
+    it('truncateToolResult truncates long tool_result content', () => {
+        const msg = {
+            role: 'user',
+            content: [{ type: 'tool_result', tool_use_id: 'tu_1', content: 'x'.repeat(1000) }],
+        };
+        const truncated = anthropicFormatHelper.truncateToolResult(msg, 100);
+        expect(truncated.content[0].content).toContain('[truncated]');
+        expect(truncated.content[0].content.length).toBeLessThan(200);
+    });
+    it('truncateToolResult leaves short content unchanged', () => {
+        const msg = {
+            role: 'user',
+            content: [{ type: 'tool_result', tool_use_id: 'tu_1', content: 'short' }],
+        };
+        const result = anthropicFormatHelper.truncateToolResult(msg, 500);
+        expect(result).toBe(msg); // same reference (no change)
+    });
+    it('buildSummaryMessage returns Anthropic-format summary', () => {
+        const summary = anthropicFormatHelper.buildSummaryMessage('test summary');
+        expect(summary.role).toBe('user');
+        expect(summary.content[0].type).toBe('text');
+        expect(summary.content[0].text).toContain('[Conversation Summary]');
+        expect(summary.content[0].text).toContain('test summary');
+    });
+});
+describe('openaiFormatHelper', () => {
+    it('isToolResult returns true for tool role messages', () => {
+        expect(openaiFormatHelper.isToolResult({ role: 'tool', content: 'result' })).toBe(true);
+    });
+    it('isToolResult returns false for non-tool messages', () => {
+        expect(openaiFormatHelper.isToolResult({ role: 'assistant', content: 'hi' })).toBe(false);
+    });
+    it('truncateToolResult truncates long content', () => {
+        const msg = { role: 'tool', tool_call_id: 'tc_1', content: 'x'.repeat(1000) };
+        const truncated = openaiFormatHelper.truncateToolResult(msg, 100);
+        expect(truncated.content).toContain('[truncated]');
+        expect(truncated.content.length).toBeLessThan(200);
+    });
+    it('truncateToolResult leaves short content unchanged', () => {
+        const msg = { role: 'tool', tool_call_id: 'tc_1', content: 'short' };
+        const result = openaiFormatHelper.truncateToolResult(msg, 500);
+        expect(result).toBe(msg);
+    });
+    it('buildSummaryMessage returns OpenAI-format summary', () => {
+        const summary = openaiFormatHelper.buildSummaryMessage('test summary');
+        expect(summary.role).toBe('user');
+        expect(summary.content).toContain('[Conversation Summary]');
+        expect(summary.content).toContain('test summary');
+    });
+});
+describe('codexFormatHelper', () => {
+    it('isToolResult returns true for function_call_output items', () => {
+        expect(codexFormatHelper.isToolResult({ type: 'function_call_output', output: 'result' })).toBe(true);
+    });
+    it('isToolResult returns false for function_call items', () => {
+        expect(codexFormatHelper.isToolResult({ type: 'function_call', name: 'Bash' })).toBe(false);
+    });
+    it('isToolResult returns false for message items', () => {
+        expect(codexFormatHelper.isToolResult({ type: 'message', role: 'user' })).toBe(false);
+    });
+    it('truncateToolResult truncates long output', () => {
+        const item = { type: 'function_call_output', call_id: 'fc_1', output: 'x'.repeat(1000) };
+        const truncated = codexFormatHelper.truncateToolResult(item, 100);
+        expect(truncated.output).toContain('[truncated]');
+        expect(truncated.output.length).toBeLessThan(200);
+    });
+    it('truncateToolResult leaves short output unchanged', () => {
+        const item = { type: 'function_call_output', call_id: 'fc_1', output: 'short' };
+        const result = codexFormatHelper.truncateToolResult(item, 500);
+        expect(result).toBe(item);
+    });
+    it('buildSummaryMessage returns Codex-format summary', () => {
+        const summary = codexFormatHelper.buildSummaryMessage('test summary');
+        expect(summary.type).toBe('message');
+        expect(summary.role).toBe('user');
+        expect(summary.content).toContain('[Conversation Summary]');
+        expect(summary.content).toContain('test summary');
+    });
+});
+// =====================================================================
+// Generic compactMessages() tests
+// =====================================================================
+describe('compactMessages (generic)', () => {
+    it('passes through when under threshold', async () => {
         const messages = anthropicExchange('short result');
-        const result = await compactAnthropicMessages(messages, { maxContextTokens: 100_000 });
-        expect(result.messages).toEqual(messages);
+        const result = await compactMessages(messages, anthropicFormatHelper, { maxContextTokens: 100_000 });
+        expect(result.messages).toBe(messages);
         expect(result.compacted).toBe(false);
     });
-    it('returns same reference when no compaction needed', async () => {
-        const messages = anthropicExchange('short result');
-        const result = await compactAnthropicMessages(messages, { maxContextTokens: 100_000 });
+    it('passes through when disabled', async () => {
+        const messages = manyItems(anthropicExchange, 'x'.repeat(10_000));
+        const result = await compactMessages(messages, anthropicFormatHelper, { enabled: false, maxContextTokens: 1 });
         expect(result.messages).toBe(messages);
+        expect(result.compacted).toBe(false);
     });
-    it('uses LLM summarization when fullConfig is provided', async () => {
-        const longResult = 'x'.repeat(10_000);
-        const messages = [];
-        for (let i = 0; i < 30; i++) {
-            messages.push(...anthropicExchange(longResult));
-        }
-        const result = await compactAnthropicMessages(messages, { maxContextTokens: 1_000 }, 1, fullConfig);
+    it('uses LLM summarization with Anthropic helper', async () => {
+        const messages = manyItems(anthropicExchange, 'x'.repeat(10_000));
+        const result = await compactMessages(messages, anthropicFormatHelper, { maxContextTokens: 1_000 }, 1, fullConfig);
         expect(result.compacted).toBe(true);
         expect(result.method).toBe('llm');
         expect(result.summary).toBeTruthy();
@@ -90,86 +192,157 @@ describe('compactAnthropicMessages', () => {
         expect(result.tokensAfter).toBeGreaterThan(0);
         expect(result.tokensAfter).toBeLessThan(result.tokensBefore);
         expect(mockChat).toHaveBeenCalledOnce();
-        // First message should be the summary
+        // First message should be the summary in Anthropic format
         expect(result.messages[0].role).toBe('user');
         expect(result.messages[0].content[0].text).toContain('[Conversation Summary]');
         // Last 8 should be preserved
         expect(result.messages.slice(-8)).toEqual(messages.slice(-8));
     });
-    it('falls back to truncation when LLM fails', async () => {
+    it('uses LLM summarization with OpenAI helper', async () => {
+        const messages = manyItems(openaiExchange, 'x'.repeat(10_000));
+        const result = await compactMessages(messages, openaiFormatHelper, { maxContextTokens: 1_000 }, 1, fullConfig);
+        expect(result.compacted).toBe(true);
+        expect(result.method).toBe('llm');
+        expect(result.messages[0].role).toBe('user');
+        expect(result.messages[0].content).toContain('[Conversation Summary]');
+    });
+    it('uses LLM summarization with Codex helper', async () => {
+        const messages = manyItems(codexExchange, 'x'.repeat(10_000));
+        const result = await compactMessages(messages, codexFormatHelper, { maxContextTokens: 1_000 }, 1, fullConfig);
+        expect(result.compacted).toBe(true);
+        expect(result.method).toBe('llm');
+        expect(result.messages[0].type).toBe('message');
+        expect(result.messages[0].content).toContain('[Conversation Summary]');
+    });
+    it('falls back to truncation when LLM fails (Anthropic)', async () => {
         mockChat.mockRejectedValueOnce(new Error('API error'));
-        const longResult = 'x'.repeat(10_000);
-        const messages = [];
-        for (let i = 0; i < 30; i++) {
-            messages.push(...anthropicExchange(longResult));
-        }
-        const result = await compactAnthropicMessages(messages, { maxContextTokens: 1_000 }, 1, fullConfig);
+        const messages = manyItems(anthropicExchange, 'x'.repeat(10_000));
+        const result = await compactMessages(messages, anthropicFormatHelper, { maxContextTokens: 1_000 }, 1, fullConfig);
         expect(result.compacted).toBe(true);
         expect(result.method).toBe('truncation');
-        // Head messages should have truncated tool results
         const headMessages = result.messages.slice(0, -8);
         const toolResultMessages = headMessages.filter((m) => Array.isArray(m.content) && m.content.some((b) => b.type === 'tool_result'));
         for (const msg of toolResultMessages) {
             const block = msg.content.find((b) => b.type === 'tool_result');
             expect(block.content).toContain('[truncated]');
-            expect(block.content.length).toBeLessThan(longResult.length);
         }
     });
-    it('falls back to truncation without fullConfig', async () => {
-        const longResult = 'x'.repeat(10_000);
-        const messages = [];
-        for (let i = 0; i < 30; i++) {
-            messages.push(...anthropicExchange(longResult));
+    it('falls back to truncation when LLM fails (OpenAI)', async () => {
+        mockChat.mockRejectedValueOnce(new Error('API error'));
+        const messages = manyItems(openaiExchange, 'x'.repeat(10_000));
+        const result = await compactMessages(messages, openaiFormatHelper, { maxContextTokens: 1_000 }, 1, fullConfig);
+        expect(result.method).toBe('truncation');
+        const toolMessages = result.messages.slice(0, -8).filter((m) => m.role === 'tool');
+        for (const msg of toolMessages) {
+            expect(msg.content).toContain('[truncated]');
+        }
+    });
+    it('falls back to truncation when LLM fails (Codex)', async () => {
+        mockChat.mockRejectedValueOnce(new Error('API error'));
+        const messages = manyItems(codexExchange, 'x'.repeat(10_000));
+        const result = await compactMessages(messages, codexFormatHelper, { maxContextTokens: 1_000 }, 1, fullConfig);
+        expect(result.method).toBe('truncation');
+        const outputItems = result.messages.slice(0, -8).filter((item) => item.type === 'function_call_output');
+        for (const item of outputItems) {
+            expect(item.output).toContain('[truncated]');
         }
-        const result = await compactAnthropicMessages(messages, { maxContextTokens: 1_000 });
+    });
+    it('falls back to truncation without fullConfig', async () => {
+        const messages = manyItems(anthropicExchange, 'x'.repeat(10_000));
+        const result = await compactMessages(messages, anthropicFormatHelper, { maxContextTokens: 1_000 });
         expect(result.compacted).toBe(true);
         expect(result.method).toBe('truncation');
         expect(mockChat).not.toHaveBeenCalled();
     });
-    it('keeps last 8 messages intact when compacting', async () => {
-        const longResult = 'x'.repeat(10_000);
-        const messages = [];
-        for (let i = 0; i < 30; i++) {
-            messages.push(...anthropicExchange(longResult));
+    it('keeps last 8 items intact across all formats', async () => {
+        for (const [factory, helper] of [
+            [anthropicExchange, anthropicFormatHelper],
+            [openaiExchange, openaiFormatHelper],
+            [codexExchange, codexFormatHelper],
+        ]) {
+            const items = manyItems(factory, 'x'.repeat(10_000));
+            const result = await compactMessages(items, helper, { maxContextTokens: 1_000 }, 1, fullConfig);
+            expect(result.messages.slice(-8)).toEqual(items.slice(-8));
+            mockChat.mockClear();
+            mockChat.mockResolvedValue('Summary of the conversation.');
         }
-        const result = await compactAnthropicMessages(messages, { maxContextTokens: 1_000 }, 1, fullConfig);
-        // Last 8 messages should be untouched
-        const tail = result.messages.slice(-8);
-        const originalTail = messages.slice(-8);
-        expect(tail).toEqual(originalTail);
     });
     it('does not mutate the input array', async () => {
-        const longResult = 'x'.repeat(10_000);
-        const messages = [];
-        for (let i = 0; i < 30; i++) {
-            messages.push(...anthropicExchange(longResult));
-        }
+        const messages = manyItems(anthropicExchange, 'x'.repeat(10_000));
         const originalJson = JSON.stringify(messages);
-        await compactAnthropicMessages(messages, { maxContextTokens: 1_000 }, 1, fullConfig);
+        await compactMessages(messages, anthropicFormatHelper, { maxContextTokens: 1_000 }, 1, fullConfig);
         expect(JSON.stringify(messages)).toBe(originalJson);
     });
-    it('passes through unchanged when disabled', async () => {
-        const longResult = 'x'.repeat(10_000);
-        const messages = [];
-        for (let i = 0; i < 30; i++) {
-            messages.push(...anthropicExchange(longResult));
+    it('includes token counts in result', async () => {
+        const messages = manyItems(anthropicExchange, 'x'.repeat(10_000));
+        const result = await compactMessages(messages, anthropicFormatHelper, { maxContextTokens: 1_000 }, 1, fullConfig);
+        expect(result.tokensBefore).toBeGreaterThan(1_000);
+        expect(result.tokensAfter).toBeDefined();
+    });
+    it('preserves non-tool-result items during truncation', async () => {
+        mockChat.mockRejectedValueOnce(new Error('fail'));
+        const items = manyItems(codexExchange, 'x'.repeat(10_000));
+        const result = await compactMessages(items, codexFormatHelper, { maxContextTokens: 1_000 }, 1, fullConfig);
+        const callItems = result.messages.filter((item) => item.type === 'function_call');
+        for (const item of callItems) {
+            expect(item.name).toBe('Bash');
         }
-        const result = await compactAnthropicMessages(messages, { enabled: false, maxContextTokens: 1 });
-        expect(result.messages).toBe(messages);
-        expect(result.compacted).toBe(false);
     });
-    it('includes token counts in result', async () => {
-        const longResult = 'x'.repeat(10_000);
-        const messages = [];
+    it('works with a custom MessageFormatHelper', async () => {
+        // Demonstrate that any format helper works with the generic function
+        const customHelper = {
+            isToolResult: (item) => item.kind === 'result',
+            truncateToolResult: (item, maxChars) => ({
+                ...item,
+                data: item.data.slice(0, maxChars) + ' [truncated]',
+            }),
+            serialize: (items) => items.map(i => JSON.stringify(i)).join('\n'),
+            buildSummaryMessage: (summary) => ({ kind: 'summary', data: summary }),
+        };
+        const items = [];
         for (let i = 0; i < 30; i++) {
-            messages.push(...anthropicExchange(longResult));
+            items.push({ kind: 'call', name: 'test' });
+            items.push({ kind: 'result', data: 'x'.repeat(10_000) });
         }
+        const result = await compactMessages(items, customHelper, { maxContextTokens: 1_000 }, 1, fullConfig);
+        expect(result.compacted).toBe(true);
+        expect(result.method).toBe('llm');
+        expect(result.messages[0].kind).toBe('summary');
+    });
+});
+// =====================================================================
+// Legacy wrapper tests (verify backward compatibility)
+// =====================================================================
+describe('compactAnthropicMessages (legacy wrapper)', () => {
+    it('passes through unchanged when under threshold', async () => {
+        const messages = anthropicExchange('short result');
+        const result = await compactAnthropicMessages(messages, { maxContextTokens: 100_000 });
+        expect(result.messages).toEqual(messages);
+        expect(result.compacted).toBe(false);
+    });
+    it('returns same reference when no compaction needed', async () => {
+        const messages = anthropicExchange('short result');
+        const result = await compactAnthropicMessages(messages, { maxContextTokens: 100_000 });
+        expect(result.messages).toBe(messages);
+    });
+    it('uses LLM summarization when fullConfig is provided', async () => {
+        const messages = manyItems(anthropicExchange, 'x'.repeat(10_000));
         const result = await compactAnthropicMessages(messages, { maxContextTokens: 1_000 }, 1, fullConfig);
-        expect(result.tokensBefore).toBeGreaterThan(1_000);
-        expect(result.tokensAfter).toBeDefined();
+        expect(result.compacted).toBe(true);
+        expect(result.method).toBe('llm');
+        expect(result.summary).toBeTruthy();
+        expect(result.messages[0].role).toBe('user');
+        expect(result.messages[0].content[0].text).toContain('[Conversation Summary]');
+        expect(result.messages.slice(-8)).toEqual(messages.slice(-8));
+    });
+    it('passes through unchanged when disabled', async () => {
+        const messages = manyItems(anthropicExchange, 'x'.repeat(10_000));
+        const result = await compactAnthropicMessages(messages, { enabled: false, maxContextTokens: 1 });
+        expect(result.messages).toBe(messages);
+        expect(result.compacted).toBe(false);
     });
 });
-describe('compactOpenAIMessages', () => {
+describe('compactOpenAIMessages (legacy wrapper)', () => {
     it('passes through unchanged when under threshold', async () => {
         const messages = openaiExchange('short result');
         const result = await compactOpenAIMessages(messages, { maxContextTokens: 100_000 });
@@ -177,63 +350,21 @@ describe('compactOpenAIMessages', () => {
         expect(result.compacted).toBe(false);
     });
     it('uses LLM summarization when fullConfig is provided', async () => {
-        const longResult = 'x'.repeat(10_000);
-        const messages = [];
-        for (let i = 0; i < 30; i++) {
-            messages.push(...openaiExchange(longResult));
-        }
+        const messages = manyItems(openaiExchange, 'x'.repeat(10_000));
         const result = await compactOpenAIMessages(messages, { maxContextTokens: 1_000 }, 1, fullConfig);
         expect(result.compacted).toBe(true);
         expect(result.method).toBe('llm');
         expect(result.messages[0].role).toBe('user');
         expect(result.messages[0].content).toContain('[Conversation Summary]');
     });
-    it('falls back to truncation when LLM fails', async () => {
-        mockChat.mockRejectedValueOnce(new Error('API error'));
-        const longResult = 'x'.repeat(10_000);
-        const messages = [];
-        for (let i = 0; i < 30; i++) {
-            messages.push(...openaiExchange(longResult));
-        }
-        const result = await compactOpenAIMessages(messages, { maxContextTokens: 1_000 }, 1, fullConfig);
-        expect(result.method).toBe('truncation');
-        const headItems = result.messages.slice(0, -8);
-        const toolMessages = headItems.filter((m) => m.role === 'tool');
-        for (const msg of toolMessages) {
-            expect(msg.content).toContain('[truncated]');
-        }
-    });
-    it('keeps last 8 messages intact', async () => {
-        const longResult = 'x'.repeat(10_000);
-        const messages = [];
-        for (let i = 0; i < 30; i++) {
-            messages.push(...openaiExchange(longResult));
-        }
-        const result = await compactOpenAIMessages(messages, { maxContextTokens: 1_000 }, 1, fullConfig);
-        expect(result.messages.slice(-8)).toEqual(messages.slice(-8));
-    });
-    it('does not mutate the input array', async () => {
-        const longResult = 'x'.repeat(10_000);
-        const messages = [];
-        for (let i = 0; i < 30; i++) {
-            messages.push(...openaiExchange(longResult));
-        }
-        const original = JSON.stringify(messages);
-        await compactOpenAIMessages(messages, { maxContextTokens: 1_000 }, 1, fullConfig);
-        expect(JSON.stringify(messages)).toBe(original);
-    });
     it('passes through unchanged when disabled', async () => {
-        const longResult = 'x'.repeat(10_000);
-        const messages = [];
-        for (let i = 0; i < 30; i++) {
-            messages.push(...openaiExchange(longResult));
-        }
+        const messages = manyItems(openaiExchange, 'x'.repeat(10_000));
         const result = await compactOpenAIMessages(messages, { enabled: false, maxContextTokens: 1 });
         expect(result.messages).toBe(messages);
         expect(result.compacted).toBe(false);
     });
 });
-describe('compactCodexMessages', () => {
+describe('compactCodexMessages (legacy wrapper)', () => {
     it('passes through unchanged when under threshold', async () => {
         const items = codexExchange('short result');
         const result = await compactCodexMessages(items, { maxContextTokens: 100_000 });
@@ -241,75 +372,23 @@ describe('compactCodexMessages', () => {
         expect(result.compacted).toBe(false);
     });
     it('uses LLM summarization when fullConfig is provided', async () => {
-        const longOutput = 'x'.repeat(10_000);
-        const items = [];
-        for (let i = 0; i < 30; i++) {
-            items.push(...codexExchange(longOutput));
-        }
+        const items = manyItems(codexExchange, 'x'.repeat(10_000));
         const result = await compactCodexMessages(items, { maxContextTokens: 1_000 }, 1, fullConfig);
         expect(result.compacted).toBe(true);
         expect(result.method).toBe('llm');
         expect(result.messages[0].type).toBe('message');
         expect(result.messages[0].content).toContain('[Conversation Summary]');
     });
-    it('falls back to truncation when LLM fails', async () => {
-        mockChat.mockRejectedValueOnce(new Error('API error'));
-        const longOutput = 'x'.repeat(10_000);
-        const items = [];
-        for (let i = 0; i < 30; i++) {
-            items.push(...codexExchange(longOutput));
-        }
-        const result = await compactCodexMessages(items, { maxContextTokens: 1_000 }, 1, fullConfig);
-        expect(result.method).toBe('truncation');
-        const headItems = result.messages.slice(0, -8);
-        const outputItems = headItems.filter((item) => item.type === 'function_call_output');
-        for (const item of outputItems) {
-            expect(item.output).toContain('[truncated]');
-        }
-    });
-    it('keeps last 8 items intact when compacting', async () => {
-        const longOutput = 'x'.repeat(10_000);
-        const items = [];
-        for (let i = 0; i < 30; i++) {
-            items.push(...codexExchange(longOutput));
-        }
-        const result = await compactCodexMessages(items, { maxContextTokens: 1_000 }, 1, fullConfig);
-        expect(result.messages.slice(-8)).toEqual(items.slice(-8));
-    });
-    it('does not mutate the input array', async () => {
-        const longOutput = 'x'.repeat(10_000);
-        const items = [];
-        for (let i = 0; i < 30; i++) {
-            items.push(...codexExchange(longOutput));
-        }
-        const originalJson = JSON.stringify(items);
-        await compactCodexMessages(items, { maxContextTokens: 1_000 }, 1, fullConfig);
-        expect(JSON.stringify(items)).toBe(originalJson);
-    });
-    it('preserves function_call items unchanged', async () => {
-        mockChat.mockRejectedValueOnce(new Error('fail')); // force truncation
-        const longOutput = 'x'.repeat(10_000);
-        const items = [];
-        for (let i = 0; i < 30; i++) {
-            items.push(...codexExchange(longOutput));
-        }
-        const result = await compactCodexMessages(items, { maxContextTokens: 1_000 }, 1, fullConfig);
-        const callItems = result.messages.filter((item) => item.type === 'function_call');
-        for (const item of callItems) {
-            expect(item.name).toBe('Bash');
-        }
-    });
     it('passes through unchanged when disabled', async () => {
-        const longOutput = 'x'.repeat(10_000);
-        const items = [];
-        for (let i = 0; i < 30; i++) {
-            items.push(...codexExchange(longOutput));
-        }
+        const items = manyItems(codexExchange, 'x'.repeat(10_000));
         const result = await compactCodexMessages(items, { enabled: false, maxContextTokens: 1 });
         expect(result.messages).toBe(items);
         expect(result.compacted).toBe(false);
     });
 });
+// =====================================================================
+// Serializer tests (unchanged — these test the format helpers indirectly)
+// =====================================================================
 describe('serializers', () => {
     it('serializeAnthropicMessages produces readable transcript', () => {
         const messages = [