@roj-ai/sdk 0.1.36 → 0.2.2

package/dist/plugins/context-compact/context-compactor.test.js

@@ -1,858 +0,0 @@
-import { beforeEach, describe, expect, it } from 'bun:test';
-import { agentEvents } from '../../core/agents/state.js';
-import { generateTestAgentId } from '../../core/agents/schema.js';
-import { contextCompactedEventSchema, contextEvents } from '../../core/context/state.js';
-import { withSessionId } from '../../core/events/test-helpers.js';
-import { ModelId } from '../../core/llm/schema.js';
-import { estimateMessagesTokens } from '../../core/llm/tokens.js';
-import { generateSessionId } from '../../core/sessions/schema.js';
-import { coreReducer, createSessionState } from '../../core/sessions/state.js';
-import { generateToolCallId } from '../../core/tools/schema.js';
-import { Err, Ok } from '../../lib/utils/result.js';
-import { silentLogger } from '../../lib/logger/logger.js';
-import { ContextCompactor, createContextCompactedEvent, formatMessageForSummary } from './context-compactor.js';
-// ============================================================================
-// Test Constants
-// ============================================================================
-const TEST_MODEL_ID = ModelId('test/model');
-class InferenceMock {
-    responses = [];
-    responseIndex = 0;
-    calls = [];
-    setResponses(responses) {
-        this.responses = responses;
-        this.responseIndex = 0;
-    }
-    run = async (extraMessages) => {
-        this.calls.push({ extraMessages });
-        if (this.responseIndex >= this.responses.length) {
-            return Err({ type: 'server_error', message: 'No more mock responses' });
-        }
-        return Ok(this.responses[this.responseIndex++]);
-    };
-}
-// ============================================================================
-// Tests: ContextCompactor.needsCompaction
-// ============================================================================
-describe('ContextCompactor.needsCompaction', () => {
-    let inference;
-    let compactor;
-    beforeEach(() => {
-        inference = new InferenceMock();
-        compactor = new ContextCompactor(silentLogger, {
-            model: TEST_MODEL_ID,
-            maxTokens: 100,
-            keepRecentMessages: 2,
-        });
-    });
-    it('returns false when below threshold', () => {
-        const messages = [{ role: 'user', content: 'short' }];
-        expect(compactor.needsCompaction(messages)).toBe(false);
-    });
-    it('returns true when above threshold', () => {
-        // Create messages with > 100 tokens
-        const messages = [
-            { role: 'user', content: 'a'.repeat(200) }, // ~50 tokens + overhead
-            { role: 'assistant', content: 'b'.repeat(200) }, // ~50 tokens + overhead
-            { role: 'user', content: 'c'.repeat(200) }, // ~50 tokens + overhead
-        ];
-        expect(compactor.needsCompaction(messages)).toBe(true);
-    });
-});
-// ============================================================================
-// Tests: ContextCompactor.compact
-// ============================================================================
-describe('ContextCompactor.compact', () => {
-    let inference;
-    let compactor;
-    let sessionId;
-    let agentId;
-    beforeEach(() => {
-        inference = new InferenceMock();
-        compactor = new ContextCompactor(silentLogger, {
-            model: TEST_MODEL_ID,
-            maxTokens: 100,
-            keepRecentMessages: 2,
-        });
-        sessionId = generateSessionId();
-        agentId = generateTestAgentId();
-    });
-    it('returns empty summary when no messages to compact', async () => {
-        // Only 2 messages, keepRecentMessages = 2
-        const messages = [
-            { role: 'user', content: 'message 1' },
-            { role: 'assistant', content: 'message 2' },
-        ];
-        const result = await compactor.compact(sessionId, agentId, messages, inference.run);
-        expect(result.ok).toBe(true);
-        if (!result.ok)
-            return;
-        expect(result.value.summary).toBe('');
-        expect(result.value.messagesRemoved).toBe(0);
-        expect(result.value.compactedMessages).toEqual(messages);
-    });
-    it('compacts old messages and keeps recent ones', async () => {
-        inference.setResponses([
-            {
-                content: 'Summary of the conversation',
-                toolCalls: [],
-                finishReason: 'stop',
-                metrics: {
-                    promptTokens: 50,
-                    completionTokens: 20,
-                    totalTokens: 70,
-                    latencyMs: 100,
-                    model: 'mock',
-                },
-            },
-        ]);
-        const messages = [
-            { role: 'user', content: 'old message 1' },
-            { role: 'assistant', content: 'old message 2' },
-            { role: 'user', content: 'old message 3' },
-            { role: 'user', content: 'recent message 1' },
-            { role: 'assistant', content: 'recent message 2' },
-        ];
-        const result = await compactor.compact(sessionId, agentId, messages, inference.run);
-        expect(result.ok).toBe(true);
-        if (!result.ok)
-            return;
-        expect(result.value.summary).toBe('Summary of the conversation');
-        expect(result.value.messagesRemoved).toBe(3);
-        expect(result.value.compactedMessages.length).toBe(3); // summary + 2 recent
-        // First message is the summary (user-role so it cleanly fits into chat history)
-        expect(result.value.compactedMessages[0].role).toBe('user');
-        expect(result.value.compactedMessages[0].content).toContain('[CONVERSATION SUMMARY]');
-        expect(result.value.compactedMessages[0].content).toContain('Summary of the conversation');
-        // Recent messages preserved
-        expect(result.value.compactedMessages[1].content).toBe('recent message 1');
-        expect(result.value.compactedMessages[2].content).toBe('recent message 2');
-    });
-    it('calls runInference with a single trailing summarize-instruction message', async () => {
-        inference.setResponses([
-            {
-                content: 'Summary',
-                toolCalls: [],
-                finishReason: 'stop',
-                metrics: {
-                    promptTokens: 50,
-                    completionTokens: 20,
-                    totalTokens: 70,
-                    latencyMs: 100,
-                    model: 'mock',
-                },
-            },
-        ]);
-        const messages = [
-            { role: 'user', content: 'user message' },
-            { role: 'assistant', content: 'assistant message' },
-            { role: 'user', content: 'recent' },
-            { role: 'assistant', content: 'recent too' },
-        ];
-        await compactor.compact(sessionId, agentId, messages, inference.run);
-        expect(inference.calls.length).toBe(1);
-        const call = inference.calls[0];
-        // Inline summarization sends ONE trailing user message — the host (agent)
-        // is responsible for the full prefix (preamble + history); the compactor
-        // only contributes the instruction.
-        expect(call.extraMessages.length).toBe(1);
-        expect(call.extraMessages[0].role).toBe('user');
-        expect(typeof call.extraMessages[0].content).toBe('string');
-    });
-    it('returns error when LLM fails', async () => {
-        // No responses set, so LLM will fail
-        const messages = [
-            { role: 'user', content: 'old 1' },
-            { role: 'assistant', content: 'old 2' },
-            { role: 'user', content: 'old 3' },
-            { role: 'user', content: 'recent 1' },
-            { role: 'assistant', content: 'recent 2' },
-        ];
-        const result = await compactor.compact(sessionId, agentId, messages, inference.run);
-        expect(result.ok).toBe(false);
-        if (result.ok)
-            return;
-        expect(result.error.message).toContain('Compaction failed');
-    });
-});
-// ============================================================================
-// Tests: ContextCompactor.compactIfNeeded
-// ============================================================================
-describe('ContextCompactor.compactIfNeeded', () => {
-    let inference;
-    let compactor;
-    let sessionId;
-    let agentId;
-    beforeEach(() => {
-        inference = new InferenceMock();
-        compactor = new ContextCompactor(silentLogger, {
-            model: TEST_MODEL_ID,
-            maxTokens: 50,
-            keepRecentMessages: 1,
-        });
-        sessionId = generateSessionId();
-        agentId = generateTestAgentId();
-    });
-    it('returns null when compaction not needed', async () => {
-        const messages = [{ role: 'user', content: 'short' }];
-        const result = await compactor.compactIfNeeded(sessionId, agentId, messages, inference.run);
-        expect(result.ok).toBe(true);
-        if (!result.ok)
-            return;
-        expect(result.value).toBeNull();
-        expect(inference.calls.length).toBe(0);
-    });
-    it('compacts when needed', async () => {
-        inference.setResponses([
-            {
-                content: 'Summary',
-                toolCalls: [],
-                finishReason: 'stop',
-                metrics: {
-                    promptTokens: 50,
-                    completionTokens: 20,
-                    totalTokens: 70,
-                    latencyMs: 100,
-                    model: 'mock',
-                },
-            },
-        ]);
-        // Create messages exceeding threshold
-        const messages = [
-            { role: 'user', content: 'a'.repeat(100) },
-            { role: 'assistant', content: 'b'.repeat(100) },
-            { role: 'user', content: 'c'.repeat(100) },
-        ];
-        const result = await compactor.compactIfNeeded(sessionId, agentId, messages, inference.run);
-        expect(result.ok).toBe(true);
-        if (!result.ok)
-            return;
-        expect(result.value).not.toBeNull();
-        expect(result.value.summary).toBe('Summary');
-    });
-});
-// ============================================================================
-// Tests: createContextCompactedEvent
-// ============================================================================
-describe('createContextCompactedEvent', () => {
-    it('creates event with correct fields', () => {
-        const sessionId = generateSessionId();
-        const agentId = generateTestAgentId();
-        const result = {
-            compactedMessages: [
-                { role: 'system', content: 'summary' },
-                { role: 'user', content: 'recent' },
-            ],
-            originalMessages: [{ role: 'user', content: 'old message' }],
-            summary: 'The summary',
-            originalTokens: 1000,
-            compactedTokens: 200,
-            messagesRemoved: 5,
-        };
-        const event = createContextCompactedEvent(sessionId, agentId, result);
-        expect(event.type).toBe('context_compacted');
-        expect(event.sessionId).toBe(sessionId);
-        expect(event.agentId).toBe(agentId);
-        expect(event.compactedContent).toBe('The summary');
-        expect(event.originalTokens).toBe(1000);
-        expect(event.compactedTokens).toBe(200);
-        expect(event.messagesRemoved).toBe(5);
-        expect(event.newConversationHistory.length).toBe(2);
-        expect(event.newConversationHistory[0].role).toBe('system');
-        expect(event.newConversationHistory[0].content).toBe('summary');
-        expect(event.originalMessages?.length).toBe(1);
-        expect(event.originalMessages?.[0].content).toBe('old message');
-        expect(event.timestamp).toBeDefined();
-    });
-    it('preserves assistant tool calls and tool results in history', () => {
-        const sessionId = generateSessionId();
-        const agentId = generateTestAgentId();
-        const toolCallId = generateToolCallId();
-        const result = {
-            compactedMessages: [
-                {
-                    role: 'assistant',
-                    content: 'Checking.',
-                    toolCalls: [{ id: toolCallId, name: 'read', input: { path: '/src/index.ts' } }],
-                },
-                {
-                    role: 'tool',
-                    content: 'tool result',
-                    toolCallId,
-                    toolName: 'read',
-                    isError: false,
-                    timestamp: 123,
-                },
-            ],
-            originalMessages: [],
-            summary: '',
-            originalTokens: 100,
-            compactedTokens: 50,
-            messagesRemoved: 0,
-        };
-        const event = createContextCompactedEvent(sessionId, agentId, result);
-        expect(event.newConversationHistory).toEqual(result.compactedMessages);
-    });
-    it('parses and reduces old-shape events exactly as before', () => {
-        const sessionId = generateSessionId();
-        const agentId = generateTestAgentId();
-        const oldPayload = contextCompactedEventSchema.parse({
-            agentId,
-            compactedContent: 'Old summary',
-            newConversationHistory: [
-                { role: 'user', content: 'summary' },
-                { role: 'assistant', content: 'recent response' },
-                { role: 'system', content: 'legacy context' },
-            ],
-            originalTokens: 1000,
-            compactedTokens: 100,
-            messagesRemoved: 12,
-        });
-        let state = createSessionState(sessionId, 'test', 0);
-        state = coreReducer(state, withSessionId(sessionId, agentEvents.create('agent_spawned', {
-            agentId,
-            definitionName: 'test-agent',
-            parentId: null,
-        })));
-        state = coreReducer(state, withSessionId(sessionId, contextEvents.create('context_compacted', oldPayload)));
-        expect(state.agents.get(agentId)?.conversationHistory).toEqual([
-            { role: 'user', content: 'summary', sourceMessageIds: [], cacheControl: undefined },
-            { role: 'assistant', content: 'recent response', toolCalls: undefined, cacheControl: undefined },
-            { role: 'system', content: 'legacy context', cacheControl: undefined },
-        ]);
-    });
-});
-// ============================================================================
-// Tests: Default config
-// ============================================================================
-describe('ContextCompactor with custom config', () => {
-    it('respects custom maxTokens', () => {
-        const inference = new InferenceMock();
-        const config = {
-            model: TEST_MODEL_ID,
-            maxTokens: 20,
-            keepRecentMessages: 1,
-        };
-        const compactor = new ContextCompactor(silentLogger, config);
-        const smallMessages = [{ role: 'user', content: 'hi' }];
-        expect(compactor.needsCompaction(smallMessages)).toBe(false);
-        const largeMessages = [
-            { role: 'user', content: 'a'.repeat(100) },
-        ];
-        expect(compactor.needsCompaction(largeMessages)).toBe(true);
-    });
-    it('respects custom keepRecentMessages', async () => {
-        const inference = new InferenceMock();
-        inference.setResponses([
-            {
-                content: 'Summary',
-                toolCalls: [],
-                finishReason: 'stop',
-                metrics: {
-                    promptTokens: 50,
-                    completionTokens: 20,
-                    totalTokens: 70,
-                    latencyMs: 100,
-                    model: 'mock',
-                },
-            },
-        ]);
-        const config = {
-            model: TEST_MODEL_ID,
-            maxTokens: 10,
-            keepRecentMessages: 3,
-        };
-        const compactor = new ContextCompactor(silentLogger, config);
-        const messages = [
-            { role: 'user', content: 'old 1' },
-            { role: 'assistant', content: 'old 2' },
-            { role: 'user', content: 'recent 1' },
-            { role: 'assistant', content: 'recent 2' },
-            { role: 'user', content: 'recent 3' },
-        ];
-        const result = await compactor.compact(generateSessionId(), generateTestAgentId(), messages, inference.run);
-        expect(result.ok).toBe(true);
-        if (!result.ok)
-            return;
-        // 2 old messages removed, 3 kept + 1 summary = 4 total
-        expect(result.value.messagesRemoved).toBe(2);
-        expect(result.value.compactedMessages.length).toBe(4);
-    });
-    it('uses custom summaryPrompt', async () => {
-        const inference = new InferenceMock();
-        inference.setResponses([
-            {
-                content: 'Summary',
-                toolCalls: [],
-                finishReason: 'stop',
-                metrics: {
-                    promptTokens: 50,
-                    completionTokens: 20,
-                    totalTokens: 70,
-                    latencyMs: 100,
-                    model: 'mock',
-                },
-            },
-        ]);
-        const customPrompt = 'Custom summary instructions';
-        const config = {
-            model: TEST_MODEL_ID,
-            maxTokens: 10,
-            keepRecentMessages: 1,
-            summaryPrompt: customPrompt,
-        };
-        const compactor = new ContextCompactor(silentLogger, config);
-        const messages = [
-            { role: 'user', content: 'old' },
-            { role: 'user', content: 'recent' },
-        ];
-        await compactor.compact(generateSessionId(), generateTestAgentId(), messages, inference.run);
-        expect(inference.calls.length).toBe(1);
-        // Custom prompt is sent as the content of the trailing user-role instruction.
-        expect(inference.calls[0].extraMessages[0].content).toBe(customPrompt);
-    });
-});
-// ============================================================================
-// Tests: formatMessageForSummary
-// ============================================================================
-describe('formatMessageForSummary', () => {
-    it('formats user message', () => {
-        const msg = { role: 'user', content: 'Hello world' };
-        expect(formatMessageForSummary(msg)).toBe('User: Hello world');
-    });
-    it('formats user message with multimodal content', () => {
-        const msg = {
-            role: 'user',
-            content: [{ type: 'text', text: 'Check this image' }],
-        };
-        const result = formatMessageForSummary(msg);
-        expect(result).toContain('User:');
-        expect(result).toContain('Check this image');
-    });
-    it('formats assistant message with text only', () => {
-        const msg = { role: 'assistant', content: 'Sure, I can help' };
-        expect(formatMessageForSummary(msg)).toBe('Agent: Sure, I can help');
-    });
-    it('formats assistant message with tool calls', () => {
-        const msg = {
-            role: 'assistant',
-            content: '',
-            toolCalls: [{ id: generateToolCallId(), name: 'read', input: { path: '/src/index.ts' } }],
-        };
-        const result = formatMessageForSummary(msg);
-        expect(result).toBe('Agent: [Called tools: read(path)]');
-    });
-    it('formats assistant message with text and tool calls', () => {
-        const msg = {
-            role: 'assistant',
-            content: 'Let me read that file.',
-            toolCalls: [{ id: generateToolCallId(), name: 'read', input: { path: '/src/index.ts' } }],
-        };
-        const result = formatMessageForSummary(msg);
-        expect(result).toContain('Agent: Let me read that file.');
-        expect(result).toContain('[Called tools: read(path)]');
-    });
-    it('formats assistant message with multiple tool calls', () => {
-        const msg = {
-            role: 'assistant',
-            content: '',
-            toolCalls: [
-                { id: generateToolCallId(), name: 'read', input: { path: '/a.ts' } },
-                { id: generateToolCallId(), name: 'edit', input: { path: '/b.ts', old_string: 'x', new_string: 'y' } },
-            ],
-        };
-        const result = formatMessageForSummary(msg);
-        expect(result).toBe('Agent: [Called tools: read(path), edit(path, old_string, new_string)]');
-    });
-    it('formats tool result with tool name', () => {
-        const msg = {
-            role: 'tool',
-            content: 'export function main() {}',
-            toolCallId: generateToolCallId(),
-            toolName: 'read',
-        };
-        const result = formatMessageForSummary(msg);
-        expect(result).toBe('Tool(read): export function main() {}');
-    });
-    it('formats tool result without tool name as unknown', () => {
-        const msg = {
-            role: 'tool',
-            content: 'some result',
-            toolCallId: generateToolCallId(),
-        };
-        const result = formatMessageForSummary(msg);
-        expect(result).toBe('Tool(unknown): some result');
-    });
-    it('truncates large tool results', () => {
-        const largeContent = 'x'.repeat(1000);
-        const msg = {
-            role: 'tool',
-            content: largeContent,
-            toolCallId: generateToolCallId(),
-            toolName: 'read',
-        };
-        const result = formatMessageForSummary(msg);
-        expect(result).toContain('Tool(read):');
-        expect(result).toContain('...(truncated)...');
-        expect(result.length).toBeLessThan(largeContent.length);
-    });
-    it('does not truncate small tool results', () => {
-        const smallContent = 'small result';
-        const msg = {
-            role: 'tool',
-            content: smallContent,
-            toolCallId: generateToolCallId(),
-            toolName: 'read',
-        };
-        const result = formatMessageForSummary(msg);
-        expect(result).toBe('Tool(read): small result');
-        expect(result).not.toContain('truncated');
-    });
-    it('formats system message', () => {
-        const msg = { role: 'system', content: 'You are an assistant.' };
-        expect(formatMessageForSummary(msg)).toBe('System: You are an assistant.');
-    });
-});
-// ============================================================================
-// Tests: Tool calls in compaction
-// ============================================================================
-describe('ContextCompactor with tool calls', () => {
-    let inference;
-    let compactor;
-    let sessionId;
-    let agentId;
-    beforeEach(() => {
-        inference = new InferenceMock();
-        compactor = new ContextCompactor(silentLogger, {
-            model: TEST_MODEL_ID,
-            maxTokens: 100,
-            keepRecentMessages: 1,
-        });
-        sessionId = generateSessionId();
-        agentId = generateTestAgentId();
-    });
-    it('does not leave orphaned tool results at the start of kept messages', async () => {
-        inference.setResponses([
-            {
-                content: 'Summary',
-                toolCalls: [],
-                finishReason: 'stop',
-                metrics: { promptTokens: 50, completionTokens: 20, totalTokens: 70, latencyMs: 100, model: 'mock' },
-            },
-        ]);
-        const toolCallId = generateToolCallId();
-        // keepRecentMessages=1 would split between the assistant (tool call) and tool result
-        const messages = [
-            { role: 'user', content: 'old message' },
-            { role: 'assistant', content: 'old response' },
-            { role: 'user', content: 'Read the file' },
-            {
-                role: 'assistant',
-                content: '',
-                toolCalls: [{ id: toolCallId, name: 'read', input: { path: '/src/index.ts' } }],
-            },
-            { role: 'tool', content: 'export const foo = 1', toolCallId, toolName: 'read' },
-        ];
-        const result = await compactor.compact(sessionId, agentId, messages, inference.run);
-        expect(result.ok).toBe(true);
-        if (!result.ok)
-            return;
-        // The tool result must NOT be the first kept message — it should be compacted along with its tool call
-        const keptMessages = result.value.compactedMessages.filter(m => m.role !== 'system');
-        for (const msg of keptMessages) {
-            expect(msg.role).not.toBe('tool');
-        }
-        // All 5 original messages should be compacted (none kept except summary)
-        expect(result.value.messagesRemoved).toBe(5);
-    });
-    it('round-trips a kept tool turn and accounts for its token structure', async () => {
-        inference.setResponses([
-            {
-                content: 'Short summary',
-                toolCalls: [],
-                finishReason: 'stop',
-                metrics: { promptTokens: 50, completionTokens: 20, totalTokens: 70, latencyMs: 100, model: 'mock' },
-            },
-        ]);
-        const toolCallId = generateToolCallId();
-        const toolTurn = [
-            {
-                role: 'assistant',
-                content: 'I will inspect the file.',
-                toolCalls: [{
-                        id: toolCallId,
-                        name: 'read',
-                        input: { path: '/src/index.ts', reason: 'x'.repeat(400) },
-                    }],
-            },
-            {
-                role: 'tool',
-                content: 'export const value = 1',
-                toolCallId,
-                toolName: 'read',
-                isError: false,
-                timestamp: 123,
-            },
-        ];
-        const messages = [
-            { role: 'user', content: 'old context '.repeat(1000) },
-            { role: 'assistant', content: 'old response '.repeat(1000) },
-            ...toolTurn,
-        ];
-        const preservingCompactor = new ContextCompactor(silentLogger, {
-            maxTokens: 100,
-            keepRecentMessages: 2,
-        });
-        const result = await preservingCompactor.compact(sessionId, agentId, messages, inference.run);
-        expect(result.ok).toBe(true);
-        if (!result.ok)
-            return;
-        expect(result.value.compactedMessages.slice(1)).toEqual(toolTurn);
-        expect(result.value.compactedTokens).toBeLessThan(result.value.originalTokens);
-        expect(result.value.compactedTokens).toBeGreaterThan(estimateMessagesTokens(result.value.compactedMessages));
-        const event = createContextCompactedEvent(sessionId, agentId, result.value);
-        expect(event.newConversationHistory.slice(1)).toEqual(toolTurn);
-    });
-    it('keeps an open tool declaration even when keep limits are zero', async () => {
-        inference.setResponses([
-            {
-                content: 'Summary',
-                toolCalls: [],
-                finishReason: 'stop',
-                metrics: { promptTokens: 50, completionTokens: 20, totalTokens: 70, latencyMs: 100, model: 'mock' },
-            },
-        ]);
-        const toolCallId = generateToolCallId();
-        const openToolCall = {
-            role: 'assistant',
-            content: '',
-            toolCalls: [{ id: toolCallId, name: 'read', input: { path: '/src/index.ts' } }],
-        };
-        const zeroKeepCompactor = new ContextCompactor(silentLogger, {
-            maxTokens: 100,
-            keepRecentMessages: 0,
-            keepRecentTokens: 0,
-        });
-        const result = await zeroKeepCompactor.compact(sessionId, agentId, [
-            { role: 'user', content: 'old context' },
-            openToolCall,
-        ], inference.run);
-        expect(result.ok).toBe(true);
-        if (!result.ok)
-            return;
-        expect(result.value.compactedMessages.at(-1)).toEqual(openToolCall);
-    });
-});
-// ============================================================================
-// Tests: History offloading
-// ============================================================================
-describe('ContextCompactor with history offloading', () => {
-    let inference;
-    let sessionId;
-    let agentId;
-    beforeEach(() => {
-        inference = new InferenceMock();
-        sessionId = generateSessionId();
-        agentId = generateTestAgentId();
-    });
-    it('offloads history when enabled and offloader is provided', async () => {
-        const offloadedPaths = [];
-        const mockOffloader = {
-            async offload(agentId, content, pathPrefix) {
-                offloadedPaths.push({ agentId, content, pathPrefix });
-                return `${pathPrefix}${agentId}/history.md`;
-            },
-        };
-        inference.setResponses([
-            {
-                content: 'Summary',
-                toolCalls: [],
-                finishReason: 'stop',
-                metrics: { promptTokens: 50, completionTokens: 20, totalTokens: 70, latencyMs: 100, model: 'mock' },
-            },
-        ]);
-        const compactor = new ContextCompactor(silentLogger, {
-            model: TEST_MODEL_ID,
-            maxTokens: 100,
-            keepRecentMessages: 1,
-            offloadHistory: true,
-        }, mockOffloader);
-        const messages = [
-            { role: 'user', content: 'old message 1' },
-            { role: 'assistant', content: 'old message 2' },
-            { role: 'user', content: 'recent message' },
-        ];
-        const result = await compactor.compact(sessionId, agentId, messages, inference.run);
-        expect(result.ok).toBe(true);
-        if (!result.ok)
-            return;
-        // Verify offloader was called
-        expect(offloadedPaths.length).toBe(1);
-        expect(offloadedPaths[0].agentId).toBe(agentId);
-        expect(offloadedPaths[0].content).toContain('User: old message 1');
-        expect(offloadedPaths[0].pathPrefix).toBe('/session/.history/');
-        // Verify result contains historyPath
-        expect(result.value.historyPath).toBe(`/session/.history/${agentId}/history.md`);
-        // Verify summary message contains history reference
-        expect(result.value.compactedMessages[0].content).toContain('has been saved to');
-        expect(result.value.compactedMessages[0].content).toContain(`/session/.history/${agentId}/history.md`);
-    });
-    it('does not offload history when disabled', async () => {
-        const mockOffloader = {
-            async offload() {
-                throw new Error('Should not be called');
-            },
-        };
-        inference.setResponses([
-            {
-                content: 'Summary',
-                toolCalls: [],
-                finishReason: 'stop',
-                metrics: { promptTokens: 50, completionTokens: 20, totalTokens: 70, latencyMs: 100, model: 'mock' },
-            },
-        ]);
-        const compactor = new ContextCompactor(silentLogger, {
-            model: TEST_MODEL_ID,
-            maxTokens: 100,
-            keepRecentMessages: 1,
-            offloadHistory: false, // explicitly disabled
-        }, mockOffloader);
-        const messages = [
-            { role: 'user', content: 'old' },
-            { role: 'user', content: 'recent' },
-        ];
-        const result = await compactor.compact(sessionId, agentId, messages, inference.run);
-        expect(result.ok).toBe(true);
-        if (!result.ok)
-            return;
-        expect(result.value.historyPath).toBeUndefined();
-        expect(result.value.compactedMessages[0].content).not.toContain('has been saved to');
-    });
-    it('does not offload history when offloader is not provided', async () => {
-        inference.setResponses([
-            {
-                content: 'Summary',
-                toolCalls: [],
-                finishReason: 'stop',
-                metrics: { promptTokens: 50, completionTokens: 20, totalTokens: 70, latencyMs: 100, model: 'mock' },
-            },
-        ]);
-        const compactor = new ContextCompactor(silentLogger, {
-            model: TEST_MODEL_ID,
-            maxTokens: 100,
-            keepRecentMessages: 1,
-            offloadHistory: true, // enabled but no offloader
-        });
-        const messages = [
-            { role: 'user', content: 'old' },
-            { role: 'user', content: 'recent' },
-        ];
-        const result = await compactor.compact(sessionId, agentId, messages, inference.run);
-        expect(result.ok).toBe(true);
-        if (!result.ok)
-            return;
-        expect(result.value.historyPath).toBeUndefined();
-    });
-    it('uses custom historyPathPrefix', async () => {
-        const offloadedPaths = [];
-        const mockOffloader = {
-            async offload(_agentId, _content, pathPrefix) {
-                offloadedPaths.push({ pathPrefix });
-                return `/custom/path/history.md`;
-            },
-        };
-        inference.setResponses([
-            {
-                content: 'Summary',
-                toolCalls: [],
-                finishReason: 'stop',
-                metrics: { promptTokens: 50, completionTokens: 20, totalTokens: 70, latencyMs: 100, model: 'mock' },
-            },
-        ]);
-        const compactor = new ContextCompactor(silentLogger, {
-            model: TEST_MODEL_ID,
-            maxTokens: 100,
-            keepRecentMessages: 1,
-            offloadHistory: true,
-            historyPathPrefix: '/session/.custom-history/',
-        }, mockOffloader);
-        const messages = [
-            { role: 'user', content: 'old' },
-            { role: 'user', content: 'recent' },
-        ];
-        await compactor.compact(sessionId, agentId, messages, inference.run);
-        expect(offloadedPaths.length).toBe(1);
-        expect(offloadedPaths[0].pathPrefix).toBe('/session/.custom-history/');
-    });
-    it('continues compaction even if offloading fails', async () => {
-        const mockOffloader = {
-            async offload() {
-                throw new Error('Disk full');
-            },
-        };
-        inference.setResponses([
-            {
-                content: 'Summary despite offload failure',
-                toolCalls: [],
-                finishReason: 'stop',
-                metrics: { promptTokens: 50, completionTokens: 20, totalTokens: 70, latencyMs: 100, model: 'mock' },
-            },
-        ]);
-        const compactor = new ContextCompactor(silentLogger, {
-            model: TEST_MODEL_ID,
-            maxTokens: 100,
-            keepRecentMessages: 1,
-            offloadHistory: true,
-        }, mockOffloader);
-        const messages = [
-            { role: 'user', content: 'old' },
-            { role: 'user', content: 'recent' },
-        ];
-        const result = await compactor.compact(sessionId, agentId, messages, inference.run);
-        // Compaction should succeed despite offload failure
-        expect(result.ok).toBe(true);
-        if (!result.ok)
-            return;
-        expect(result.value.summary).toBe('Summary despite offload failure');
-        expect(result.value.historyPath).toBeUndefined();
-    });
-});
-// ============================================================================
-// Tests: createContextCompactedEvent with historyPath
-// ============================================================================
-describe('createContextCompactedEvent with historyPath', () => {
-    it('includes historyPath in event when provided', () => {
-        const sessionId = generateSessionId();
-        const agentId = generateTestAgentId();
-        const result = {
-            compactedMessages: [
-                { role: 'system', content: 'summary' },
-            ],
-            originalMessages: [],
-            summary: 'The summary',
-            originalTokens: 1000,
-            compactedTokens: 200,
-            messagesRemoved: 5,
-            historyPath: '/session/.history/agent-1/history.md',
-        };
-        const event = createContextCompactedEvent(sessionId, agentId, result);
-        expect(event.historyPath).toBe('/session/.history/agent-1/history.md');
-    });
-    it('does not include historyPath when not provided', () => {
-        const sessionId = generateSessionId();
-        const agentId = generateTestAgentId();
-        const result = {
-            compactedMessages: [
-                { role: 'system', content: 'summary' },
-            ],
-            originalMessages: [],
-            summary: 'The summary',
-            originalTokens: 1000,
-            compactedTokens: 200,
-            messagesRemoved: 5,
-        };
-        const event = createContextCompactedEvent(sessionId, agentId, result);
-        expect(event.historyPath).toBeUndefined();
-    });
-});
-//# sourceMappingURL=context-compactor.test.js.map