@strands-agents/sdk 1.0.0 → 1.2.0

package/dist/src/conversation-manager/__tests__/sliding-window-conversation-manager.test.js

@@ -1,7 +1,7 @@
 import { describe, it, expect, vi } from 'vitest';
 import { SlidingWindowConversationManager } from '../sliding-window-conversation-manager.js';
-import { ContextWindowOverflowError, Message, TextBlock, ToolUseBlock, ToolResultBlock, } from '../../index.js';
-import { AfterInvocationEvent, AfterModelCallEvent } from '../../hooks/events.js';
+import { ContextWindowOverflowError, DocumentBlock, ImageBlock, JsonBlock, Message, TextBlock, ToolUseBlock, ToolResultBlock, VideoBlock, } from '../../index.js';
+import { AfterInvocationEvent, AfterModelCallEvent, BeforeModelCallEvent } from '../../hooks/events.js';
 import { createMockAgent, invokeTrackedHook } from '../../__fixtures__/agent-helpers.js';
 async function triggerSlidingWindow(manager, agent) {
     const pluginAgent = createMockAgent();
@@ -12,7 +12,7 @@ async function triggerSlidingWindow(manager, agent) {
 async function triggerContextOverflow(manager, agent, error) {
     const pluginAgent = createMockAgent();
     manager.initAgent(pluginAgent);
-    const event = new AfterModelCallEvent({ agent, model: {}, error, invocationState: {} });
+    const event = new AfterModelCallEvent({ agent, model: {}, attemptCount: 1, error, invocationState: {} });
     await invokeTrackedHook(pluginAgent, event);
     return event;
 }
@@ -46,7 +46,7 @@ describe('SlidingWindowConversationManager', () => {
                         new ToolResultBlock({
                             toolUseId: 'tool-1',
                             status: 'success',
-                            content: [new TextBlock('Large tool result content')],
+                            content: [new TextBlock('x'.repeat(500))],
                         }),
                     ],
                 }),
@@ -123,8 +123,10 @@ describe('SlidingWindowConversationManager', () => {
         });
     });
     describe('reduceContext - tool result truncation', () => {
-        it('truncates tool results when shouldTruncateResults is true', async () => {
+        it('partially truncates large tool results preserving first and last 200 chars', async () => {
             const manager = new SlidingWindowConversationManager({ shouldTruncateResults: true });
+            const middle = 'MIDDLE_CONTENT_TO_REMOVE'.repeat(10); // 240 chars, safely above MIN_TRUNCATION_GAIN
+            const original = 'A'.repeat(200) + middle + 'B'.repeat(200);
             const messages = [
                 new Message({
                     role: 'user',
@@ -132,19 +134,41 @@ describe('SlidingWindowConversationManager', () => {
                         new ToolResultBlock({
                             toolUseId: 'tool-1',
                             status: 'success',
-                            content: [new TextBlock('Large tool result content')],
+                            content: [new TextBlock(original)],
                         }),
                     ],
                 }),
             ];
             const mockAgent = createMockAgent({ messages });
             await triggerContextOverflow(manager, mockAgent, new ContextWindowOverflowError('Context overflow'));
-            const toolResult = messages[0].content[0];
-            expect(toolResult.status).toBe('error');
-            expect(toolResult.content[0]).toEqual({ type: 'textBlock', text: 'The tool result was too large!' });
+            const expectedText = `${'A'.repeat(200)}\n<truncated chars="${middle.length}"/>\n${'B'.repeat(200)}`;
+            expect(messages[0].content[0]).toEqual(new ToolResultBlock({
+                toolUseId: 'tool-1',
+                status: 'success',
+                content: [new TextBlock(expectedText)],
+            }));
         });
-        it('finds last message with tool results', async () => {
+        it('leaves small tool results unchanged', () => {
             const manager = new SlidingWindowConversationManager({ shouldTruncateResults: true });
+            const messages = [
+                new Message({
+                    role: 'user',
+                    content: [
+                        new ToolResultBlock({
+                            toolUseId: 'tool-1',
+                            status: 'success',
+                            content: [new TextBlock('Small result')],
+                        }),
+                    ],
+                }),
+            ];
+            const result = manager._truncateToolResults(messages, 0);
+            expect(result).toBe(false);
+        });
+        it('finds oldest message with tool results', async () => {
+            const manager = new SlidingWindowConversationManager({ shouldTruncateResults: true });
+            const firstOriginal = 'F'.repeat(500);
+            const secondOriginal = 'S'.repeat(500);
             const messages = [
                 new Message({ role: 'user', content: [new TextBlock('Message 1')] }),
                 new Message({
@@ -153,7 +177,7 @@ describe('SlidingWindowConversationManager', () => {
                         new ToolResultBlock({
                             toolUseId: 'tool-1',
                             status: 'success',
-                            content: [new TextBlock('First result')],
+                            content: [new TextBlock(firstOriginal)],
                         }),
                     ],
                 }),
@@ -164,21 +188,25 @@ describe('SlidingWindowConversationManager', () => {
                         new ToolResultBlock({
                             toolUseId: 'tool-2',
                             status: 'success',
-                            content: [new TextBlock('Second result')],
+                            content: [new TextBlock(secondOriginal)],
                         }),
                     ],
                 }),
             ];
             const mockAgent = createMockAgent({ messages });
             await triggerContextOverflow(manager, mockAgent, new ContextWindowOverflowError('Context overflow'));
-            // Should truncate the last message with tool results (index 3)
-            const lastToolResult = messages[3].content[0];
-            expect(lastToolResult.status).toBe('error');
-            expect(lastToolResult.content[0]).toEqual({ type: 'textBlock', text: 'The tool result was too large!' });
-            // Earlier tool result should remain unchanged
-            const firstToolResult = messages[1].content[0];
-            expect(firstToolResult.status).toBe('success');
-            expect(firstToolResult.content[0]).toEqual({ type: 'textBlock', text: 'First result' });
+            // Oldest tool-result message is truncated; newer one is untouched.
+            const expectedTruncated = `${'F'.repeat(200)}\n<truncated chars="100"/>\n${'F'.repeat(200)}`;
+            expect(messages[1].content[0]).toEqual(new ToolResultBlock({
+                toolUseId: 'tool-1',
+                status: 'success',
+                content: [new TextBlock(expectedTruncated)],
+            }));
+            expect(messages[3].content[0]).toEqual(new ToolResultBlock({
+                toolUseId: 'tool-2',
+                status: 'success',
+                content: [new TextBlock(secondOriginal)],
+            }));
         });
         it('returns after successful truncation without trimming messages', async () => {
             const manager = new SlidingWindowConversationManager({ windowSize: 2, shouldTruncateResults: true });
@@ -191,7 +219,7 @@ describe('SlidingWindowConversationManager', () => {
                         new ToolResultBlock({
                             toolUseId: 'tool-1',
                             status: 'success',
-                            content: [new TextBlock('Large result')],
+                            content: [new TextBlock('L'.repeat(500))],
                         }),
                     ],
                 }),
@@ -217,7 +245,7 @@ describe('SlidingWindowConversationManager', () => {
                         new ToolResultBlock({
                             toolUseId: 'tool-1',
                             status: 'success',
-                            content: [new TextBlock('Large result')],
+                            content: [new TextBlock('L'.repeat(500))],
                         }),
                     ],
                 }),
@@ -228,24 +256,30 @@ describe('SlidingWindowConversationManager', () => {
             expect(mockAgent.messages).toHaveLength(3);
             expect(mockAgent.messages[0].role).toBe('user');
             // Tool result should not be truncated
-            const toolResult = mockAgent.messages[2].content[0];
-            expect(toolResult.status).toBe('success');
+            expect(mockAgent.messages[2].content[0]).toEqual(new ToolResultBlock({
+                toolUseId: 'tool-1',
+                status: 'success',
+                content: [new TextBlock('L'.repeat(500))],
+            }));
         });
-        it('does not truncate already-truncated results', async () => {
+        it('does not re-truncate already-truncated results', async () => {
             const manager = new SlidingWindowConversationManager({ shouldTruncateResults: true });
+            // Produced by an earlier run: 200 chars + marker + 200 chars = well under the 450-char
+            // threshold below which truncation is not worth running.
+            const alreadyTruncated = 'A'.repeat(200) + '\n<truncated chars="1000"/>\n' + 'B'.repeat(200);
             const messages = [
                 new Message({
                     role: 'user',
                     content: [
                         new ToolResultBlock({
                             toolUseId: 'tool-1',
-                            status: 'error',
-                            content: [new TextBlock('The tool result was too large!')],
+                            status: 'success',
+                            content: [new TextBlock(alreadyTruncated)],
                         }),
                     ],
                 }),
             ];
-            // First call should return false (already truncated)
+            // First call should return false (too short to gain anything from re-truncating)
             const result = manager._truncateToolResults(messages, 0);
             expect(result).toBe(false);
             // reduceContext should fall through to message trimming
@@ -255,19 +289,316 @@ describe('SlidingWindowConversationManager', () => {
                     content: [
                         new ToolResultBlock({
                             toolUseId: 'tool-1',
-                            status: 'error',
-                            content: [new TextBlock('The tool result was too large!')],
+                            status: 'success',
+                            content: [new TextBlock(alreadyTruncated)],
                         }),
                     ],
                 }),
                 new Message({ role: 'assistant', content: [new TextBlock('Response')] }),
                 new Message({ role: 'user', content: [new TextBlock('Message')] }),
             ];
-            const mockAgent = { messages: messages2 };
+            const mockAgent = createMockAgent({ messages: messages2 });
             await triggerContextOverflow(manager, mockAgent, new ContextWindowOverflowError('Context overflow'));
             // Should have trimmed messages since truncation was skipped
             expect(mockAgent.messages.length).toBeLessThan(3);
         });
+        it('replaces image blocks nested in tool results with descriptive placeholders', () => {
+            const manager = new SlidingWindowConversationManager({ shouldTruncateResults: true });
+            const bytes = new Uint8Array(1234);
+            const messages = [
+                new Message({
+                    role: 'user',
+                    content: [
+                        new ToolResultBlock({
+                            toolUseId: 'tool-1',
+                            status: 'success',
+                            content: [new ImageBlock({ format: 'png', source: { bytes } }), new TextBlock('tail')],
+                        }),
+                    ],
+                }),
+            ];
+            const changed = manager._truncateToolResults(messages, 0);
+            expect(changed).toBe(true);
+            expect(messages[0].content[0]).toEqual(new ToolResultBlock({
+                toolUseId: 'tool-1',
+                status: 'success',
+                content: [new TextBlock('[image: png, source: bytes, 1234 bytes]'), new TextBlock('tail')],
+            }));
+        });
+        it('preserves the error field on truncated tool results', () => {
+            const manager = new SlidingWindowConversationManager({ shouldTruncateResults: true });
+            const originalError = new Error('tool blew up');
+            const messages = [
+                new Message({
+                    role: 'user',
+                    content: [
+                        new ToolResultBlock({
+                            toolUseId: 'tool-1',
+                            status: 'error',
+                            content: [new TextBlock('x'.repeat(500))],
+                            error: originalError,
+                        }),
+                    ],
+                }),
+            ];
+            const changed = manager._truncateToolResults(messages, 0);
+            expect(changed).toBe(true);
+            const expectedText = `${'x'.repeat(200)}\n<truncated chars="100"/>\n${'x'.repeat(200)}`;
+            expect(messages[0].content[0]).toEqual(new ToolResultBlock({
+                toolUseId: 'tool-1',
+                status: 'error',
+                content: [new TextBlock(expectedText)],
+                error: originalError,
+            }));
+        });
+        it('image placeholder reflects non-bytes source kinds honestly', () => {
+            const manager = new SlidingWindowConversationManager({ shouldTruncateResults: true });
+            const messages = [
+                new Message({
+                    role: 'user',
+                    content: [
+                        new ToolResultBlock({
+                            toolUseId: 'tool-1',
+                            status: 'success',
+                            content: [
+                                new ImageBlock({ format: 'jpeg', source: { url: 'https://example.com/x.jpg' } }),
+                                new ImageBlock({ format: 'png', source: { location: { type: 's3', uri: 's3://bucket/key' } } }),
+                            ],
+                        }),
+                    ],
+                }),
+            ];
+            manager._truncateToolResults(messages, 0);
+            expect(messages[0].content[0]).toEqual(new ToolResultBlock({
+                toolUseId: 'tool-1',
+                status: 'success',
+                content: [new TextBlock('[image: jpeg, source: url]'), new TextBlock('[image: png, source: s3]')],
+            }));
+        });
+        it('replaces video bytes blocks with a descriptive placeholder', () => {
+            const manager = new SlidingWindowConversationManager({ shouldTruncateResults: true });
+            const messages = [
+                new Message({
+                    role: 'user',
+                    content: [
+                        new ToolResultBlock({
+                            toolUseId: 'tool-1',
+                            status: 'success',
+                            content: [new VideoBlock({ format: 'mp4', source: { bytes: new Uint8Array(4096) } })],
+                        }),
+                    ],
+                }),
+            ];
+            const changed = manager._truncateToolResults(messages, 0);
+            expect(changed).toBe(true);
+            expect(messages[0].content[0]).toEqual(new ToolResultBlock({
+                toolUseId: 'tool-1',
+                status: 'success',
+                content: [new TextBlock('[video: mp4, source: bytes, 4096 bytes]')],
+            }));
+        });
+        it('replaces video s3 blocks with a descriptive placeholder', () => {
+            const manager = new SlidingWindowConversationManager({ shouldTruncateResults: true });
+            const messages = [
+                new Message({
+                    role: 'user',
+                    content: [
+                        new ToolResultBlock({
+                            toolUseId: 'tool-1',
+                            status: 'success',
+                            content: [
+                                new VideoBlock({
+                                    format: 'mp4',
+                                    source: { location: { type: 's3', uri: 's3://bucket/key' } },
+                                }),
+                            ],
+                        }),
+                    ],
+                }),
+            ];
+            const changed = manager._truncateToolResults(messages, 0);
+            expect(changed).toBe(true);
+            expect(messages[0].content[0]).toEqual(new ToolResultBlock({
+                toolUseId: 'tool-1',
+                status: 'success',
+                content: [new TextBlock('[video: mp4, source: s3]')],
+            }));
+        });
+        it('replaces document bytes blocks with a descriptive placeholder', () => {
+            const manager = new SlidingWindowConversationManager({ shouldTruncateResults: true });
+            const messages = [
+                new Message({
+                    role: 'user',
+                    content: [
+                        new ToolResultBlock({
+                            toolUseId: 'tool-1',
+                            status: 'success',
+                            content: [
+                                new DocumentBlock({
+                                    name: 'report',
+                                    format: 'pdf',
+                                    source: { bytes: new Uint8Array(8192) },
+                                }),
+                            ],
+                        }),
+                    ],
+                }),
+            ];
+            const changed = manager._truncateToolResults(messages, 0);
+            expect(changed).toBe(true);
+            expect(messages[0].content[0]).toEqual(new ToolResultBlock({
+                toolUseId: 'tool-1',
+                status: 'success',
+                content: [new TextBlock('[document: report, pdf, source: bytes, 8192 bytes]')],
+            }));
+        });
+        it('replaces document s3 blocks with a descriptive placeholder', () => {
+            const manager = new SlidingWindowConversationManager({ shouldTruncateResults: true });
+            const messages = [
+                new Message({
+                    role: 'user',
+                    content: [
+                        new ToolResultBlock({
+                            toolUseId: 'tool-1',
+                            status: 'success',
+                            content: [
+                                new DocumentBlock({
+                                    name: 'spec',
+                                    format: 'pdf',
+                                    source: { location: { type: 's3', uri: 's3://b/k' } },
+                                }),
+                            ],
+                        }),
+                    ],
+                }),
+            ];
+            const changed = manager._truncateToolResults(messages, 0);
+            expect(changed).toBe(true);
+            expect(messages[0].content[0]).toEqual(new ToolResultBlock({
+                toolUseId: 'tool-1',
+                status: 'success',
+                content: [new TextBlock('[document: spec, pdf, source: s3]')],
+            }));
+        });
+        it('partially truncates large text inside a document text source', () => {
+            const manager = new SlidingWindowConversationManager({ shouldTruncateResults: true });
+            const middle = 'M'.repeat(240);
+            const originalText = 'A'.repeat(200) + middle + 'B'.repeat(200);
+            const messages = [
+                new Message({
+                    role: 'user',
+                    content: [
+                        new ToolResultBlock({
+                            toolUseId: 'tool-1',
+                            status: 'success',
+                            content: [new DocumentBlock({ name: 'report', format: 'txt', source: { text: originalText } })],
+                        }),
+                    ],
+                }),
+            ];
+            const changed = manager._truncateToolResults(messages, 0);
+            expect(changed).toBe(true);
+            const expectedText = `${'A'.repeat(200)}\n<truncated chars="${middle.length}"/>\n${'B'.repeat(200)}`;
+            expect(messages[0].content[0]).toEqual(new ToolResultBlock({
+                toolUseId: 'tool-1',
+                status: 'success',
+                content: [new DocumentBlock({ name: 'report', format: 'txt', source: { text: expectedText } })],
+            }));
+        });
+        it('leaves small text inside a document text source unchanged', () => {
+            const manager = new SlidingWindowConversationManager({ shouldTruncateResults: true });
+            const messages = [
+                new Message({
+                    role: 'user',
+                    content: [
+                        new ToolResultBlock({
+                            toolUseId: 'tool-1',
+                            status: 'success',
+                            content: [new DocumentBlock({ name: 'short', format: 'txt', source: { text: 'hello' } })],
+                        }),
+                    ],
+                }),
+            ];
+            const changed = manager._truncateToolResults(messages, 0);
+            expect(changed).toBe(false);
+        });
+        it('truncates long nested text blocks inside a document content source', () => {
+            const manager = new SlidingWindowConversationManager({ shouldTruncateResults: true });
+            const longText = 'A'.repeat(200) + 'M'.repeat(240) + 'B'.repeat(200);
+            const messages = [
+                new Message({
+                    role: 'user',
+                    content: [
+                        new ToolResultBlock({
+                            toolUseId: 'tool-1',
+                            status: 'success',
+                            content: [
+                                new DocumentBlock({
+                                    name: 'pages',
+                                    format: 'txt',
+                                    source: { content: [new TextBlock(longText), new TextBlock('short')] },
+                                }),
+                            ],
+                        }),
+                    ],
+                }),
+            ];
+            const changed = manager._truncateToolResults(messages, 0);
+            expect(changed).toBe(true);
+            const expectedText = `${'A'.repeat(200)}\n<truncated chars="240"/>\n${'B'.repeat(200)}`;
+            expect(messages[0].content[0]).toEqual(new ToolResultBlock({
+                toolUseId: 'tool-1',
+                status: 'success',
+                content: [
+                    new DocumentBlock({
+                        name: 'pages',
+                        format: 'txt',
+                        source: { content: [new TextBlock(expectedText), new TextBlock('short')] },
+                    }),
+                ],
+            }));
+        });
+        it('replaces large json blocks with a size placeholder', () => {
+            const manager = new SlidingWindowConversationManager({ shouldTruncateResults: true });
+            const big = { payload: 'x'.repeat(1000) };
+            const size = JSON.stringify(big).length;
+            const messages = [
+                new Message({
+                    role: 'user',
+                    content: [
+                        new ToolResultBlock({
+                            toolUseId: 'tool-1',
+                            status: 'success',
+                            content: [new JsonBlock({ json: big })],
+                        }),
+                    ],
+                }),
+            ];
+            const changed = manager._truncateToolResults(messages, 0);
+            expect(changed).toBe(true);
+            expect(messages[0].content[0]).toEqual(new ToolResultBlock({
+                toolUseId: 'tool-1',
+                status: 'success',
+                content: [new TextBlock(`[json: ${size} chars]`)],
+            }));
+        });
+        it('leaves small json blocks unchanged', () => {
+            const manager = new SlidingWindowConversationManager({ shouldTruncateResults: true });
+            const messages = [
+                new Message({
+                    role: 'user',
+                    content: [
+                        new ToolResultBlock({
+                            toolUseId: 'tool-1',
+                            status: 'success',
+                            content: [new JsonBlock({ json: { ok: true } })],
+                        }),
+                    ],
+                }),
+            ];
+            const changed = manager._truncateToolResults(messages, 0);
+            expect(changed).toBe(false);
+        });
         it('does not call truncateToolResults unless an error is passed in', async () => {
             const manager = new SlidingWindowConversationManager({ windowSize: 2, shouldTruncateResults: true });
             const messages = [
@@ -534,6 +865,7 @@ describe('SlidingWindowConversationManager', () => {
             const event = new AfterModelCallEvent({
                 agent: mockAgent,
                 model: {},
+                attemptCount: 1,
                 error: originalError,
                 invocationState: {},
             });
@@ -544,7 +876,7 @@ describe('SlidingWindowConversationManager', () => {
         });
     });
     describe('helper methods', () => {
-        describe('findLastMessageWithToolResults', () => {
+        describe('findOldestMessageWithToolResults', () => {
             it('returns correct index when tool results exist', () => {
                 const manager = new SlidingWindowConversationManager();
                 const messages = [
@@ -561,7 +893,7 @@ describe('SlidingWindowConversationManager', () => {
                     }),
                     new Message({ role: 'assistant', content: [new TextBlock('Response')] }),
                 ];
-                const index = manager._findLastMessageWithToolResults(messages);
+                const index = manager._findOldestMessageWithToolResults(messages);
                 expect(index).toBe(1);
             });
             it('returns undefined when no tool results exist', () => {
@@ -570,10 +902,10 @@ describe('SlidingWindowConversationManager', () => {
                     new Message({ role: 'user', content: [new TextBlock('Message 1')] }),
                     new Message({ role: 'assistant', content: [new TextBlock('Response 1')] }),
                 ];
-                const index = manager._findLastMessageWithToolResults(messages);
+                const index = manager._findOldestMessageWithToolResults(messages);
                 expect(index).toBeUndefined();
             });
-            it('iterates backwards from end', () => {
+            it('iterates forward from start', () => {
                 const manager = new SlidingWindowConversationManager();
                 const messages = [
                     new Message({
@@ -598,9 +930,9 @@ describe('SlidingWindowConversationManager', () => {
                         ],
                     }),
                 ];
-                const index = manager._findLastMessageWithToolResults(messages);
-                // Should find the last one (index 2), not the first one (index 0)
-                expect(index).toBe(2);
+                const index = manager._findOldestMessageWithToolResults(messages);
+                // Should find the first one (index 0), not the last (index 2)
+                expect(index).toBe(0);
             });
         });
         describe('truncateToolResults', () => {
@@ -613,7 +945,7 @@ describe('SlidingWindowConversationManager', () => {
                             new ToolResultBlock({
                                 toolUseId: 'id-1',
                                 status: 'success',
-                                content: [new TextBlock('Large result')],
+                                content: [new TextBlock('x'.repeat(500))],
                             }),
                         ],
                     }),
@@ -623,14 +955,15 @@ describe('SlidingWindowConversationManager', () => {
             });
             it('returns false when already truncated', () => {
                 const manager = new SlidingWindowConversationManager();
+                const alreadyTruncated = 'A'.repeat(200) + '\n<truncated chars="1000"/>\n' + 'B'.repeat(200);
                 const messages = [
                     new Message({
                         role: 'user',
                         content: [
                             new ToolResultBlock({
                                 toolUseId: 'id-1',
-                                status: 'error',
-                                content: [new TextBlock('The tool result was too large!')],
+                                status: 'success',
+                                content: [new TextBlock(alreadyTruncated)],
                             }),
                         ],
                     }),
@@ -646,5 +979,53 @@ describe('SlidingWindowConversationManager', () => {
             });
         });
     });
+    describe('reduceOnThreshold', () => {
+        it('trims oldest messages when compressionThreshold is exceeded', async () => {
+            const manager = new SlidingWindowConversationManager({
+                windowSize: 4,
+                proactiveCompression: { compressionThreshold: 0.7 },
+            });
+            const messages = [
+                new Message({ role: 'user', content: [new TextBlock('Message 1')] }),
+                new Message({ role: 'assistant', content: [new TextBlock('Response 1')] }),
+                new Message({ role: 'user', content: [new TextBlock('Message 2')] }),
+                new Message({ role: 'assistant', content: [new TextBlock('Response 2')] }),
+                new Message({ role: 'user', content: [new TextBlock('Message 3')] }),
+                new Message({ role: 'assistant', content: [new TextBlock('Response 3')] }),
+            ];
+            const mockModel = { getConfig: () => ({ contextWindowLimit: 1000 }) };
+            const mockAgent = createMockAgent({ messages });
+            manager.initAgent(mockAgent);
+            const event = new BeforeModelCallEvent({
+                agent: mockAgent,
+                model: mockModel,
+                invocationState: {},
+                projectedInputTokens: 800,
+            });
+            await invokeTrackedHook(mockAgent, event);
+            expect(mockAgent.messages.length).toBe(4);
+        });
+        it('does not trim when below compressionThreshold', async () => {
+            const manager = new SlidingWindowConversationManager({
+                windowSize: 4,
+                proactiveCompression: { compressionThreshold: 0.7 },
+            });
+            const messages = [
+                new Message({ role: 'user', content: [new TextBlock('Message 1')] }),
+                new Message({ role: 'assistant', content: [new TextBlock('Response 1')] }),
+            ];
+            const mockModel = { getConfig: () => ({ contextWindowLimit: 1000 }) };
+            const mockAgent = createMockAgent({ messages });
+            manager.initAgent(mockAgent);
+            const event = new BeforeModelCallEvent({
+                agent: mockAgent,
+                model: mockModel,
+                invocationState: {},
+                projectedInputTokens: 500,
+            });
+            await invokeTrackedHook(mockAgent, event);
+            expect(mockAgent.messages).toHaveLength(2);
+        });
+    });
 });
 //# sourceMappingURL=sliding-window-conversation-manager.test.js.map