@illuma-ai/agents 1.1.21 → 1.1.23

package/src/messages/cache.test.js

@@ -1,1167 +0,0 @@
-import { AIMessage, ToolMessage, HumanMessage, } from '@langchain/core/messages';
-import { stripAnthropicCacheControl, stripBedrockCacheControl, addBedrockCacheControl, addCacheControl, } from './cache';
-import { ContentTypes } from '@/common/enum';
-describe('addCacheControl', () => {
-    test('should add cache control to the last two user messages with array content', () => {
-        const messages = [
-            { role: 'user', content: [{ type: 'text', text: 'Hello' }] },
-            { role: 'assistant', content: [{ type: 'text', text: 'Hi there' }] },
-            { role: 'user', content: [{ type: 'text', text: 'How are you?' }] },
-            {
-                role: 'assistant',
-                content: [{ type: 'text', text: 'I\'m doing well, thanks!' }],
-            },
-            { role: 'user', content: [{ type: 'text', text: 'Great!' }] },
-        ];
-        const result = addCacheControl(messages);
-        expect(result[0].content[0]).not.toHaveProperty('cache_control');
-        expect(result[2].content[0].cache_control).toEqual({ type: 'ephemeral' });
-        expect(result[4].content[0].cache_control).toEqual({ type: 'ephemeral' });
-    });
-    test('should add cache control to the last two user messages with string content', () => {
-        const messages = [
-            { role: 'user', content: 'Hello' },
-            { role: 'assistant', content: 'Hi there' },
-            { role: 'user', content: 'How are you?' },
-            { role: 'assistant', content: 'I\'m doing well, thanks!' },
-            { role: 'user', content: 'Great!' },
-        ];
-        const result = addCacheControl(messages);
-        expect(result[0].content).toBe('Hello');
-        expect(result[2].content[0]).toEqual({
-            type: 'text',
-            text: 'How are you?',
-            cache_control: { type: 'ephemeral' },
-        });
-        expect(result[4].content[0]).toEqual({
-            type: 'text',
-            text: 'Great!',
-            cache_control: { type: 'ephemeral' },
-        });
-    });
-    test('should handle mixed string and array content', () => {
-        const messages = [
-            { role: 'user', content: 'Hello' },
-            { role: 'assistant', content: 'Hi there' },
-            { role: 'user', content: [{ type: 'text', text: 'How are you?' }] },
-        ];
-        const result = addCacheControl(messages);
-        expect(result[0].content[0]).toEqual({
-            type: 'text',
-            text: 'Hello',
-            cache_control: { type: 'ephemeral' },
-        });
-        expect(result[2].content[0].cache_control).toEqual({ type: 'ephemeral' });
-    });
-    test('should handle less than two user messages', () => {
-        const messages = [
-            { role: 'user', content: 'Hello' },
-            { role: 'assistant', content: 'Hi there' },
-        ];
-        const result = addCacheControl(messages);
-        expect(result[0].content[0]).toEqual({
-            type: 'text',
-            text: 'Hello',
-            cache_control: { type: 'ephemeral' },
-        });
-        expect(result[1].content).toBe('Hi there');
-    });
-    test('should return original array if no user messages', () => {
-        const messages = [
-            { role: 'assistant', content: 'Hi there' },
-            { role: 'assistant', content: 'How can I help?' },
-        ];
-        const result = addCacheControl(messages);
-        expect(result).toEqual(messages);
-    });
-    test('should handle empty array', () => {
-        const messages = [];
-        const result = addCacheControl(messages);
-        expect(result).toEqual([]);
-    });
-    test('should handle non-array input', () => {
-        const messages = 'not an array';
-        /** @ts-expect-error - This is a test */
-        const result = addCacheControl(messages);
-        expect(result).toBe('not an array');
-    });
-    test('should not modify assistant messages', () => {
-        const messages = [
-            { role: 'user', content: 'Hello' },
-            { role: 'assistant', content: 'Hi there' },
-            { role: 'user', content: 'How are you?' },
-        ];
-        const result = addCacheControl(messages);
-        expect(result[1].content).toBe('Hi there');
-    });
-    test('should handle multiple content items in user messages', () => {
-        const messages = [
-            {
-                role: 'user',
-                content: [
-                    { type: 'text', text: 'Hello' },
-                    {
-                        type: 'image',
-                        source: { type: 'url', url: 'http://example.com/image.jpg' },
-                    },
-                    { type: 'text', text: 'This is an image' },
-                ],
-            },
-            { role: 'assistant', content: 'Hi there' },
-            { role: 'user', content: 'How are you?' },
-        ];
-        const result = addCacheControl(messages);
-        expect(result[0].content[0]).not.toHaveProperty('cache_control');
-        expect(result[0].content[1]).not.toHaveProperty('cache_control');
-        expect(result[0].content[2].cache_control).toEqual({ type: 'ephemeral' });
-        expect(result[2].content[0]).toEqual({
-            type: 'text',
-            text: 'How are you?',
-            cache_control: { type: 'ephemeral' },
-        });
-    });
-    test('should handle an array with mixed content types', () => {
-        const messages = [
-            { role: 'user', content: 'Hello' },
-            { role: 'assistant', content: 'Hi there' },
-            { role: 'user', content: [{ type: 'text', text: 'How are you?' }] },
-            { role: 'assistant', content: 'I\'m doing well, thanks!' },
-            { role: 'user', content: 'Great!' },
-        ];
-        const result = addCacheControl(messages);
-        expect(result[0].content).toEqual('Hello');
-        expect(result[2].content[0]).toEqual({
-            type: 'text',
-            text: 'How are you?',
-            cache_control: { type: 'ephemeral' },
-        });
-        expect(result[4].content).toEqual([
-            {
-                type: 'text',
-                text: 'Great!',
-                cache_control: { type: 'ephemeral' },
-            },
-        ]);
-        expect(result[1].content).toBe('Hi there');
-        expect(result[3].content).toBe('I\'m doing well, thanks!');
-    });
-    test('should handle edge case with multiple content types', () => {
-        const messages = [
-            {
-                role: 'user',
-                content: [
-                    {
-                        type: 'image',
-                        source: {
-                            type: 'base64',
-                            media_type: 'image/png',
-                            data: 'some_base64_string',
-                        },
-                    },
-                    {
-                        type: 'image',
-                        source: {
-                            type: 'base64',
-                            media_type: 'image/png',
-                            data: 'another_base64_string',
-                        },
-                    },
-                    { type: 'text', text: 'what do all these images have in common' },
-                ],
-            },
-            { role: 'assistant', content: 'I see multiple images.' },
-            { role: 'user', content: 'Correct!' },
-        ];
-        const result = addCacheControl(messages);
-        expect(result[0].content[0]).not.toHaveProperty('cache_control');
-        expect(result[0].content[1]).not.toHaveProperty('cache_control');
-        expect(result[0].content[2].cache_control).toEqual({ type: 'ephemeral' });
-        expect(result[2].content[0]).toEqual({
-            type: 'text',
-            text: 'Correct!',
-            cache_control: { type: 'ephemeral' },
-        });
-    });
-    test('should handle user message with no text block', () => {
-        const messages = [
-            {
-                role: 'user',
-                content: [
-                    {
-                        type: 'image',
-                        source: {
-                            type: 'base64',
-                            media_type: 'image/png',
-                            data: 'some_base64_string',
-                        },
-                    },
-                    {
-                        type: 'image',
-                        source: {
-                            type: 'base64',
-                            media_type: 'image/png',
-                            data: 'another_base64_string',
-                        },
-                    },
-                ],
-            },
-            { role: 'assistant', content: 'I see two images.' },
-            { role: 'user', content: 'Correct!' },
-        ];
-        const result = addCacheControl(messages);
-        expect(result[0].content[0]).not.toHaveProperty('cache_control');
-        expect(result[0].content[1]).not.toHaveProperty('cache_control');
-        expect(result[2].content[0]).toEqual({
-            type: 'text',
-            text: 'Correct!',
-            cache_control: { type: 'ephemeral' },
-        });
-    });
-});
-describe('addBedrockCacheControl (Bedrock cache checkpoints)', () => {
-    it('returns empty array unchanged but processes single message', () => {
-        const empty = [];
-        expect(addBedrockCacheControl(empty)).toEqual(empty);
-        // A single eligible message gets a cachePoint (last 2 eligible messages strategy)
-        const single = [{ role: 'user', content: 'only' }];
-        const result = addBedrockCacheControl(single);
-        const content = result[0].content;
-        expect(Array.isArray(content)).toBe(true);
-        expect(content[0]).toEqual({ type: ContentTypes.TEXT, text: 'only' });
-        expect(content[1]).toEqual({ cachePoint: { type: 'default' } });
-    });
-    it('wraps string content and appends separate cachePoint block', () => {
-        const messages = [
-            { role: 'user', content: 'Hello' },
-            { role: 'assistant', content: [{ type: ContentTypes.TEXT, text: 'Hi' }] },
-        ];
-        const result = addBedrockCacheControl(messages);
-        const last = result[1].content;
-        expect(Array.isArray(last)).toBe(true);
-        expect(last[0]).toEqual({ type: ContentTypes.TEXT, text: 'Hi' });
-        expect(last[1]).toEqual({ cachePoint: { type: 'default' } });
-    });
-    it('inserts cachePoint after the last text when multiple text blocks exist', () => {
-        const messages = [
-            {
-                role: 'user',
-                content: [
-                    { type: ContentTypes.TEXT, text: 'Intro' },
-                    { type: ContentTypes.TEXT, text: 'Details' },
-                    {
-                        type: ContentTypes.IMAGE_FILE,
-                        image_file: { file_id: 'file_123' },
-                    },
-                ],
-            },
-            {
-                role: 'assistant',
-                content: [
-                    { type: ContentTypes.TEXT, text: 'Reply A' },
-                    { type: ContentTypes.TEXT, text: 'Reply B' },
-                ],
-            },
-        ];
-        const result = addBedrockCacheControl(messages);
-        // Both messages get cachePoints (last 2 eligible messages)
-        const first = result[0].content;
-        expect(first[0]).toEqual({ type: ContentTypes.TEXT, text: 'Intro' });
-        expect(first[1]).toEqual({ type: ContentTypes.TEXT, text: 'Details' });
-        expect(first[2]).toEqual({ cachePoint: { type: 'default' } });
-        const img = first[3];
-        expect(img.type).toBe(ContentTypes.IMAGE_FILE);
-        if (img.type === ContentTypes.IMAGE_FILE) {
-            expect('image_file' in img).toBe(true);
-        }
-        const second = result[1].content;
-        expect(second[0]).toEqual({ type: ContentTypes.TEXT, text: 'Reply A' });
-        expect(second[1]).toEqual({ type: ContentTypes.TEXT, text: 'Reply B' });
-        expect(second[2]).toEqual({ cachePoint: { type: 'default' } });
-    });
-    it('skips adding cachePoint when content is an empty array', () => {
-        const messages = [
-            { role: 'user', content: [] },
-            { role: 'assistant', content: [] },
-            { role: 'user', content: 'ignored because only last two are modified' },
-        ];
-        const result = addBedrockCacheControl(messages);
-        const first = result[0].content;
-        const second = result[1].content;
-        expect(Array.isArray(first)).toBe(true);
-        expect(first.length).toBe(0);
-        expect(Array.isArray(second)).toBe(true);
-        expect(second.length).toBe(0);
-        expect(second[0]).not.toEqual({ cachePoint: { type: 'default' } });
-    });
-    it('skips adding cachePoint when content is an empty string', () => {
-        const messages = [
-            { role: 'user', content: '' },
-            { role: 'assistant', content: '' },
-            { role: 'user', content: 'ignored because only last two are modified' },
-        ];
-        const result = addBedrockCacheControl(messages);
-        expect(result[0].content).toBe('');
-        expect(result[1].content).toBe('');
-    });
-    /** (I don't think this will ever occur in actual use, but its the only branch left uncovered so I'm covering it */
-    it('skips messages with non-string, non-array content and still modifies the previous to reach two edits', () => {
-        const messages = [
-            {
-                role: 'user',
-                content: [{ type: ContentTypes.TEXT, text: 'Will be modified' }],
-            },
-            { role: 'assistant', content: undefined },
-            {
-                role: 'user',
-                content: [{ type: ContentTypes.TEXT, text: 'Also modified' }],
-            },
-        ];
-        const result = addBedrockCacheControl(messages);
-        // Last user message (index 2) gets cachePoint as the last eligible message
-        const last = result[2].content;
-        expect(last[0]).toEqual({ type: ContentTypes.TEXT, text: 'Also modified' });
-        expect(last[1]).toEqual({ cachePoint: { type: 'default' } });
-        // Undefined content is skipped
-        expect(result[1].content).toBeUndefined();
-        // First user message (index 0) gets cachePoint as the second eligible message
-        const first = result[0].content;
-        expect(first[0]).toEqual({
-            type: ContentTypes.TEXT,
-            text: 'Will be modified',
-        });
-        expect(first[1]).toEqual({ cachePoint: { type: 'default' } });
-    });
-    it('works with the example from the langchain pr (with multi-turn behavior)', () => {
-        const messages = [
-            {
-                role: 'system',
-                content: [
-                    { type: ContentTypes.TEXT, text: 'You\'re an advanced AI assistant.' },
-                ],
-            },
-            {
-                role: 'user',
-                content: [
-                    { type: ContentTypes.TEXT, text: 'What is the capital of France?' },
-                ],
-            },
-        ];
-        const result = addBedrockCacheControl(messages);
-        let system = result[0].content;
-        let user = result[1].content;
-        // Both messages get cachePoints (last 2 eligible messages)
-        expect(system[0]).toEqual({
-            type: ContentTypes.TEXT,
-            text: 'You\'re an advanced AI assistant.',
-        });
-        expect(system[1]).toEqual({ cachePoint: { type: 'default' } });
-        expect(user[0]).toEqual({
-            type: ContentTypes.TEXT,
-            text: 'What is the capital of France?',
-        });
-        expect(user[1]).toEqual({ cachePoint: { type: 'default' } });
-        // Second turn: add assistant message
-        result.push({
-            role: 'assistant',
-            content: [
-                {
-                    type: ContentTypes.TEXT,
-                    text: 'Sure! The capital of France is Paris.',
-                },
-            ],
-        });
-        const result2 = addBedrockCacheControl(result);
-        system = result2[0].content;
-        user = result2[1].content;
-        const assistant = result2[2].content;
-        // System message no longer has cachePoint (it's not in the last 2 eligible)
-        expect(system[0]).toEqual({
-            type: ContentTypes.TEXT,
-            text: 'You\'re an advanced AI assistant.',
-        });
-        expect(system.length).toBe(1);
-        // User message gets cachePoint (second-to-last eligible)
-        expect(user[0]).toEqual({
-            type: ContentTypes.TEXT,
-            text: 'What is the capital of France?',
-        });
-        expect(user[1]).toEqual({ cachePoint: { type: 'default' } });
-        // Assistant message gets cachePoint (last eligible)
-        expect(assistant[0]).toEqual({
-            type: ContentTypes.TEXT,
-            text: 'Sure! The capital of France is Paris.',
-        });
-        expect(assistant[1]).toEqual({ cachePoint: { type: 'default' } });
-    });
-    it('is idempotent - calling multiple times does not add duplicate cache points', () => {
-        const messages = [
-            {
-                role: 'user',
-                content: [{ type: ContentTypes.TEXT, text: 'First message' }],
-            },
-            {
-                role: 'assistant',
-                content: [{ type: ContentTypes.TEXT, text: 'First response' }],
-            },
-        ];
-        const result1 = addBedrockCacheControl(messages);
-        const firstContent = result1[0].content;
-        const secondContent = result1[1].content;
-        // Both messages get cachePoints (last 2 eligible)
-        expect(firstContent.length).toBe(2);
-        expect(firstContent[0]).toEqual({
-            type: ContentTypes.TEXT,
-            text: 'First message',
-        });
-        expect(firstContent[1]).toEqual({ cachePoint: { type: 'default' } });
-        expect(secondContent.length).toBe(2);
-        expect(secondContent[0]).toEqual({
-            type: ContentTypes.TEXT,
-            text: 'First response',
-        });
-        expect(secondContent[1]).toEqual({ cachePoint: { type: 'default' } });
-        // Second call should produce the same result (idempotent)
-        const result2 = addBedrockCacheControl(result1);
-        const firstContentAfter = result2[0].content;
-        const secondContentAfter = result2[1].content;
-        expect(firstContentAfter.length).toBe(2);
-        expect(firstContentAfter[0]).toEqual({
-            type: ContentTypes.TEXT,
-            text: 'First message',
-        });
-        expect(firstContentAfter[1]).toEqual({ cachePoint: { type: 'default' } });
-        expect(secondContentAfter.length).toBe(2);
-        expect(secondContentAfter[0]).toEqual({
-            type: ContentTypes.TEXT,
-            text: 'First response',
-        });
-        expect(secondContentAfter[1]).toEqual({ cachePoint: { type: 'default' } });
-    });
-    it('strips stale cache points and adds fresh ones to last 2 eligible messages', () => {
-        const messages = [
-            {
-                role: 'user',
-                content: [{ type: ContentTypes.TEXT, text: 'Hello' }],
-            },
-            {
-                role: 'assistant',
-                content: [
-                    { type: ContentTypes.TEXT, text: 'Response from agent 1' },
-                    { cachePoint: { type: 'default' } },
-                ],
-            },
-            {
-                role: 'user',
-                content: [{ type: ContentTypes.TEXT, text: 'Follow-up question' }],
-            },
-        ];
-        const result = addBedrockCacheControl(messages);
-        // Last user message gets cachePoint (last eligible)
-        const lastContent = result[2].content;
-        expect(lastContent.length).toBe(2);
-        expect(lastContent[0]).toEqual({
-            type: ContentTypes.TEXT,
-            text: 'Follow-up question',
-        });
-        expect(lastContent[1]).toEqual({ cachePoint: { type: 'default' } });
-        // The assistant message gets a fresh cachePoint (second-to-last eligible)
-        const secondLastContent = result[1].content;
-        expect(secondLastContent.length).toBe(2);
-        expect(secondLastContent[0]).toEqual({
-            type: ContentTypes.TEXT,
-            text: 'Response from agent 1',
-        });
-        expect(secondLastContent[1]).toEqual({ cachePoint: { type: 'default' } });
-    });
-    it('skips cachePoint on AI messages with only whitespace text and reasoning (tool-call scenario)', () => {
-        const messages = [
-            {
-                role: 'user',
-                content: [
-                    {
-                        type: ContentTypes.TEXT,
-                        text: 'What can you tell me about this PR?',
-                    },
-                ],
-            },
-            {
-                role: 'assistant',
-                content: [
-                    { type: ContentTypes.TEXT, text: '\n\n' },
-                    {
-                        type: 'reasoning_content',
-                        reasoningText: { text: 'Let me look into that.', signature: 'abc' },
-                    },
-                ],
-            },
-            {
-                role: 'user',
-                content: [{ type: ContentTypes.TEXT, text: 'tool result here' }],
-                getType: () => 'tool',
-            },
-        ];
-        const result = addBedrockCacheControl(messages);
-        // The assistant message has whitespace-only text + reasoning, so it gets skipped
-        const aiContent = result[1].content;
-        const hasCachePoint = aiContent.some((b) => 'cachePoint' in b);
-        expect(hasCachePoint).toBe(false);
-        // The user messages are still eligible and get cachePoints (last 2 eligible)
-        const userContent = result[0].content;
-        expect(userContent[userContent.length - 1]).toEqual({
-            cachePoint: { type: 'default' },
-        });
-    });
-});
-describe('stripAnthropicCacheControl', () => {
-    it('removes cache_control fields from content blocks', () => {
-        const messages = [
-            {
-                role: 'user',
-                content: [
-                    {
-                        type: ContentTypes.TEXT,
-                        text: 'Hello',
-                        cache_control: { type: 'ephemeral' },
-                    },
-                ],
-            },
-            {
-                role: 'assistant',
-                content: [
-                    {
-                        type: ContentTypes.TEXT,
-                        text: 'Hi there',
-                        cache_control: { type: 'ephemeral' },
-                    },
-                ],
-            },
-        ];
-        const result = stripAnthropicCacheControl(messages);
-        const firstContent = result[0].content;
-        const secondContent = result[1].content;
-        expect(firstContent[0]).toEqual({
-            type: ContentTypes.TEXT,
-            text: 'Hello',
-        });
-        expect('cache_control' in firstContent[0]).toBe(false);
-        expect(secondContent[0]).toEqual({
-            type: ContentTypes.TEXT,
-            text: 'Hi there',
-        });
-        expect('cache_control' in secondContent[0]).toBe(false);
-    });
-    it('handles messages without cache_control gracefully', () => {
-        const messages = [
-            {
-                role: 'user',
-                content: [{ type: ContentTypes.TEXT, text: 'Hello' }],
-            },
-        ];
-        const result = stripAnthropicCacheControl(messages);
-        expect(result[0].content).toEqual([
-            { type: ContentTypes.TEXT, text: 'Hello' },
-        ]);
-    });
-    it('handles string content gracefully', () => {
-        const messages = [
-            {
-                role: 'user',
-                content: 'Hello',
-            },
-        ];
-        const result = stripAnthropicCacheControl(messages);
-        expect(result[0].content).toBe('Hello');
-    });
-    it('returns non-array input unchanged', () => {
-        const notArray = 'not an array';
-        /** @ts-expect-error - Testing invalid input */
-        const result = stripAnthropicCacheControl(notArray);
-        expect(result).toBe('not an array');
-    });
-});
-describe('stripBedrockCacheControl', () => {
-    it('removes cachePoint blocks from content arrays', () => {
-        const messages = [
-            {
-                role: 'user',
-                content: [
-                    { type: ContentTypes.TEXT, text: 'Hello' },
-                    { cachePoint: { type: 'default' } },
-                ],
-            },
-            {
-                role: 'assistant',
-                content: [
-                    { type: ContentTypes.TEXT, text: 'Hi there' },
-                    { cachePoint: { type: 'default' } },
-                ],
-            },
-        ];
-        const result = stripBedrockCacheControl(messages);
-        const firstContent = result[0].content;
-        const secondContent = result[1].content;
-        expect(firstContent.length).toBe(1);
-        expect(firstContent[0]).toEqual({
-            type: ContentTypes.TEXT,
-            text: 'Hello',
-        });
-        expect(secondContent.length).toBe(1);
-        expect(secondContent[0]).toEqual({
-            type: ContentTypes.TEXT,
-            text: 'Hi there',
-        });
-    });
-    it('handles messages without cachePoint blocks gracefully', () => {
-        const messages = [
-            {
-                role: 'user',
-                content: [{ type: ContentTypes.TEXT, text: 'Hello' }],
-            },
-        ];
-        const result = stripBedrockCacheControl(messages);
-        expect(result[0].content).toEqual([
-            { type: ContentTypes.TEXT, text: 'Hello' },
-        ]);
-    });
-    it('handles string content gracefully', () => {
-        const messages = [
-            {
-                role: 'user',
-                content: 'Hello',
-            },
-        ];
-        const result = stripBedrockCacheControl(messages);
-        expect(result[0].content).toBe('Hello');
-    });
-    it('preserves content with type field', () => {
-        const messages = [
-            {
-                role: 'user',
-                content: [
-                    { type: ContentTypes.TEXT, text: 'Hello' },
-                    {
-                        type: ContentTypes.IMAGE_FILE,
-                        image_file: { file_id: 'file_123' },
-                    },
-                    { cachePoint: { type: 'default' } },
-                ],
-            },
-        ];
-        const result = stripBedrockCacheControl(messages);
-        const content = result[0].content;
-        expect(content.length).toBe(2);
-        expect(content[0]).toEqual({ type: ContentTypes.TEXT, text: 'Hello' });
-        expect(content[1]).toEqual({
-            type: ContentTypes.IMAGE_FILE,
-            image_file: { file_id: 'file_123' },
-        });
-    });
-    it('returns non-array input unchanged', () => {
-        const notArray = 'not an array';
-        /** @ts-expect-error - Testing invalid input */
-        const result = stripBedrockCacheControl(notArray);
-        expect(result).toBe('not an array');
-    });
-});
-describe('Multi-agent provider interoperability', () => {
-    it('strips Bedrock cache before applying Anthropic cache (single pass)', () => {
-        const messages = [
-            {
-                role: 'user',
-                content: [
-                    { type: ContentTypes.TEXT, text: 'First message' },
-                    { cachePoint: { type: 'default' } },
-                ],
-            },
-            {
-                role: 'assistant',
-                content: [
-                    { type: ContentTypes.TEXT, text: 'Response' },
-                    { cachePoint: { type: 'default' } },
-                ],
-            },
-        ];
-        /** @ts-expect-error - Testing cross-provider compatibility */
-        const result = addCacheControl(messages);
-        const firstContent = result[0].content;
-        expect(firstContent.some((b) => 'cachePoint' in b)).toBe(false);
-        expect('cache_control' in firstContent[0]).toBe(true);
-    });
-    it('strips Anthropic cache before applying Bedrock cache (single pass)', () => {
-        const messages = [
-            {
-                role: 'user',
-                content: [
-                    {
-                        type: ContentTypes.TEXT,
-                        text: 'First message',
-                        cache_control: { type: 'ephemeral' },
-                    },
-                ],
-            },
-            {
-                role: 'assistant',
-                content: [
-                    {
-                        type: ContentTypes.TEXT,
-                        text: 'Response',
-                        cache_control: { type: 'ephemeral' },
-                    },
-                ],
-            },
-        ];
-        const result = addBedrockCacheControl(messages);
-        const firstContent = result[0].content;
-        const secondContent = result[1].content;
-        // Anthropic cache_control should be stripped from both
-        expect('cache_control' in firstContent[0]).toBe(false);
-        expect('cache_control' in secondContent[0]).toBe(false);
-        // Both messages get Bedrock cachePoints (last 2 eligible)
-        expect(firstContent.some((b) => 'cachePoint' in b)).toBe(true);
-        expect(secondContent.some((b) => 'cachePoint' in b)).toBe(true);
-    });
-    it('strips Bedrock cache using separate function (backwards compat)', () => {
-        const messages = [
-            {
-                role: 'user',
-                content: [
-                    { type: ContentTypes.TEXT, text: 'First message' },
-                    { cachePoint: { type: 'default' } },
-                ],
-            },
-        ];
-        const stripped = stripBedrockCacheControl(messages);
-        const firstContent = stripped[0].content;
-        expect(firstContent.some((b) => 'cachePoint' in b)).toBe(false);
-        expect(firstContent.length).toBe(1);
-    });
-    it('strips Anthropic cache using separate function (backwards compat)', () => {
-        const messages = [
-            {
-                role: 'user',
-                content: [
-                    {
-                        type: ContentTypes.TEXT,
-                        text: 'First message',
-                        cache_control: { type: 'ephemeral' },
-                    },
-                ],
-            },
-        ];
-        const stripped = stripAnthropicCacheControl(messages);
-        const firstContent = stripped[0].content;
-        expect('cache_control' in firstContent[0]).toBe(false);
-    });
-});
-describe('Immutability - addCacheControl does not mutate original messages', () => {
-    it('should not mutate original messages when adding cache control to string content', () => {
-        const originalMessages = [
-            { role: 'user', content: 'Hello' },
-            { role: 'assistant', content: 'Hi there' },
-            { role: 'user', content: 'How are you?' },
-        ];
-        const originalFirstContent = originalMessages[0].content;
-        const originalThirdContent = originalMessages[2].content;
-        const result = addCacheControl(originalMessages);
-        expect(originalMessages[0].content).toBe(originalFirstContent);
-        expect(originalMessages[2].content).toBe(originalThirdContent);
-        expect(typeof originalMessages[0].content).toBe('string');
-        expect(typeof originalMessages[2].content).toBe('string');
-        expect(Array.isArray(result[0].content)).toBe(true);
-        expect(Array.isArray(result[2].content)).toBe(true);
-    });
-    it('should not mutate original messages when adding cache control to array content', () => {
-        const originalMessages = [
-            {
-                role: 'user',
-                content: [{ type: ContentTypes.TEXT, text: 'Hello' }],
-            },
-            { role: 'assistant', content: 'Hi there' },
-            {
-                role: 'user',
-                content: [{ type: ContentTypes.TEXT, text: 'How are you?' }],
-            },
-        ];
-        const originalFirstBlock = {
-            ...originalMessages[0].content[0],
-        };
-        const originalThirdBlock = {
-            ...originalMessages[2].content[0],
-        };
-        const result = addCacheControl(originalMessages);
-        const firstContent = originalMessages[0].content;
-        const thirdContent = originalMessages[2].content;
-        expect('cache_control' in firstContent[0]).toBe(false);
-        expect('cache_control' in thirdContent[0]).toBe(false);
-        expect(firstContent[0]).toEqual(originalFirstBlock);
-        expect(thirdContent[0]).toEqual(originalThirdBlock);
-        const resultFirstContent = result[0].content;
-        const resultThirdContent = result[2].content;
-        expect('cache_control' in resultFirstContent[0]).toBe(true);
-        expect('cache_control' in resultThirdContent[0]).toBe(true);
-    });
-    it('should not mutate original messages when stripping existing cache control', () => {
-        const originalMessages = [
-            {
-                role: 'user',
-                content: [
-                    {
-                        type: ContentTypes.TEXT,
-                        text: 'Hello',
-                        cache_control: { type: 'ephemeral' },
-                    },
-                ],
-            },
-            { role: 'assistant', content: 'Hi there' },
-            {
-                role: 'user',
-                content: [{ type: ContentTypes.TEXT, text: 'How are you?' }],
-            },
-        ];
-        const originalFirstBlock = originalMessages[0].content[0];
-        addCacheControl(originalMessages);
-        expect('cache_control' in originalFirstBlock).toBe(true);
-    });
-    it('should sync lc_kwargs.content with new content for LangChain messages', () => {
-        const messagesWithLcKwargs = [
-            {
-                role: 'user',
-                content: [{ type: ContentTypes.TEXT, text: 'First user message' }],
-                lc_kwargs: {
-                    content: [{ type: ContentTypes.TEXT, text: 'First user message' }],
-                },
-            },
-            {
-                role: 'assistant',
-                content: [{ type: ContentTypes.TEXT, text: 'Assistant response' }],
-                lc_kwargs: {
-                    content: [{ type: ContentTypes.TEXT, text: 'Assistant response' }],
-                },
-            },
-            {
-                role: 'user',
-                content: [{ type: ContentTypes.TEXT, text: 'Second user message' }],
-                lc_kwargs: {
-                    content: [{ type: ContentTypes.TEXT, text: 'Second user message' }],
-                },
-            },
-        ];
-        const result = addCacheControl(messagesWithLcKwargs);
-        const resultFirst = result[0];
-        const resultThird = result[2];
-        // lc_kwargs should be synced with new content (not removed)
-        expect(resultFirst.lc_kwargs).toBeDefined();
-        expect(resultThird.lc_kwargs).toBeDefined();
-        const firstContent = resultFirst.content;
-        expect('cache_control' in firstContent[0]).toBe(true);
-        // Original messages should not be mutated
-        const originalFirst = messagesWithLcKwargs[0];
-        const originalContent = originalFirst.content;
-        const originalLcContent = originalFirst.lc_kwargs
-            ?.content;
-        expect('cache_control' in originalContent[0]).toBe(false);
-        expect('cache_control' in originalLcContent[0]).toBe(false);
-    });
-});
-describe('Immutability - addBedrockCacheControl does not mutate original messages', () => {
-    it('should not mutate original messages when adding cache points to string content', () => {
-        const originalMessages = [
-            { role: 'user', content: 'Hello' },
-            { role: 'assistant', content: 'Hi there' },
-        ];
-        const originalFirstContent = originalMessages[0].content;
-        const originalSecondContent = originalMessages[1].content;
-        const result = addBedrockCacheControl(originalMessages);
-        // Originals should not be mutated
-        expect(originalMessages[0].content).toBe(originalFirstContent);
-        expect(originalMessages[1].content).toBe(originalSecondContent);
-        expect(typeof originalMessages[0].content).toBe('string');
-        expect(typeof originalMessages[1].content).toBe('string');
-        // Both messages get converted to arrays with cachePoints (last 2 eligible)
-        expect(Array.isArray(result[0].content)).toBe(true);
-        expect(Array.isArray(result[1].content)).toBe(true);
-    });
-    it('should not mutate original messages when adding cache points to array content', () => {
-        const originalMessages = [
-            {
-                role: 'user',
-                content: [{ type: ContentTypes.TEXT, text: 'Hello' }],
-            },
-            {
-                role: 'assistant',
-                content: [{ type: ContentTypes.TEXT, text: 'Hi there' }],
-            },
-        ];
-        const originalFirstContentLength = originalMessages[0].content.length;
-        const originalSecondContentLength = originalMessages[1].content.length;
-        const result = addBedrockCacheControl(originalMessages);
-        // Original messages should not be mutated
-        const firstContent = originalMessages[0].content;
-        const secondContent = originalMessages[1]
-            .content;
-        expect(firstContent.length).toBe(originalFirstContentLength);
-        expect(secondContent.length).toBe(originalSecondContentLength);
-        expect(firstContent.some((b) => 'cachePoint' in b)).toBe(false);
-        expect(secondContent.some((b) => 'cachePoint' in b)).toBe(false);
-        // Both messages get cachePoints (last 2 eligible)
-        const resultFirstContent = result[0].content;
-        expect(resultFirstContent.length).toBe(originalFirstContentLength + 1);
-        expect(resultFirstContent.some((b) => 'cachePoint' in b)).toBe(true);
-        const resultSecondContent = result[1].content;
-        expect(resultSecondContent.length).toBe(originalSecondContentLength + 1);
-        expect(resultSecondContent.some((b) => 'cachePoint' in b)).toBe(true);
-    });
-    it('should not mutate original messages when stripping existing cache control', () => {
-        const originalMessages = [
-            {
-                role: 'user',
-                content: [
-                    {
-                        type: ContentTypes.TEXT,
-                        text: 'Hello',
-                        cache_control: { type: 'ephemeral' },
-                    },
-                ],
-            },
-            {
-                role: 'assistant',
-                content: [
-                    { type: ContentTypes.TEXT, text: 'Hi there' },
-                    { cachePoint: { type: 'default' } },
-                ],
-            },
-        ];
-        const originalFirstBlock = originalMessages[0].content[0];
-        const originalSecondContentLength = originalMessages[1].content.length;
-        addBedrockCacheControl(originalMessages);
-        expect('cache_control' in originalFirstBlock).toBe(true);
-        expect(originalMessages[1].content.length).toBe(originalSecondContentLength);
-    });
-    it('should allow different providers to process same messages without cross-contamination', () => {
-        const sharedMessages = [
-            {
-                role: 'user',
-                content: [{ type: ContentTypes.TEXT, text: 'Shared message 1' }],
-            },
-            {
-                role: 'assistant',
-                content: [{ type: ContentTypes.TEXT, text: 'Shared response 1' }],
-            },
-        ];
-        const bedrockResult = addBedrockCacheControl(sharedMessages);
-        const anthropicResult = addCacheControl(sharedMessages);
-        // Originals should not be mutated
-        const originalFirstContent = sharedMessages[0]
-            .content;
-        expect(originalFirstContent.some((b) => 'cachePoint' in b)).toBe(false);
-        expect('cache_control' in originalFirstContent[0]).toBe(false);
-        // Bedrock: both messages get cachePoints (last 2 eligible)
-        const bedrockFirstContent = bedrockResult[0]
-            .content;
-        expect(bedrockFirstContent.some((b) => 'cachePoint' in b)).toBe(true);
-        expect('cache_control' in bedrockFirstContent[0]).toBe(false);
-        // Anthropic: user message gets cache_control
-        const anthropicFirstContent = anthropicResult[0]
-            .content;
-        expect(anthropicFirstContent.some((b) => 'cachePoint' in b)).toBe(false);
-        expect('cache_control' in anthropicFirstContent[0]).toBe(true);
-    });
-    it('should sync lc_kwargs.content with new content for LangChain messages', () => {
-        const messagesWithLcKwargs = [
-            {
-                role: 'user',
-                content: [{ type: ContentTypes.TEXT, text: 'User message' }],
-                lc_kwargs: {
-                    content: [{ type: ContentTypes.TEXT, text: 'User message' }],
-                },
-            },
-            {
-                role: 'assistant',
-                content: [{ type: ContentTypes.TEXT, text: 'Assistant response' }],
-                lc_kwargs: {
-                    content: [{ type: ContentTypes.TEXT, text: 'Assistant response' }],
-                },
-            },
-        ];
-        const bedrockResult = addBedrockCacheControl(messagesWithLcKwargs);
-        const resultFirst = bedrockResult[0];
-        const resultSecond = bedrockResult[1];
-        // lc_kwargs should be synced with new content (not removed)
-        expect(resultFirst.lc_kwargs).toBeDefined();
-        expect(resultSecond.lc_kwargs).toBeDefined();
-        // Both messages get cachePoints (last 2 eligible)
-        const firstContent = resultFirst.content;
-        expect(firstContent.some((b) => 'cachePoint' in b)).toBe(true);
-        const secondContent = resultSecond.content;
-        expect(secondContent.some((b) => 'cachePoint' in b)).toBe(true);
-        // Original messages should not be mutated
-        const originalFirst = messagesWithLcKwargs[0];
-        const originalContent = originalFirst.content;
-        const originalLcContent = originalFirst.lc_kwargs
-            ?.content;
-        expect(originalContent.some((b) => 'cachePoint' in b)).toBe(false);
-        expect(originalLcContent.some((b) => 'cachePoint' in b)).toBe(false);
-    });
-});
-describe('Multi-turn cache cleanup', () => {
-    it('strips stale Bedrock cache points from previous turns before applying new ones', () => {
-        const messages = [
-            {
-                role: 'user',
-                content: [
-                    { type: ContentTypes.TEXT, text: 'Turn 1 message 1' },
-                    { cachePoint: { type: 'default' } },
-                ],
-            },
-            {
-                role: 'assistant',
-                content: [
-                    { type: ContentTypes.TEXT, text: 'Turn 1 response 1' },
-                    { cachePoint: { type: 'default' } },
-                ],
-            },
-            {
-                role: 'user',
-                content: [{ type: ContentTypes.TEXT, text: 'Turn 2 message 2' }],
-            },
-            {
-                role: 'assistant',
-                content: [{ type: ContentTypes.TEXT, text: 'Turn 2 response 2' }],
-            },
-        ];
-        const result = addBedrockCacheControl(messages);
-        // 2 cachePoints total on the last 2 eligible messages
-        const cachePointCount = result.reduce((count, msg) => {
-            if (Array.isArray(msg.content)) {
-                return (count +
-                    msg.content.filter((block) => 'cachePoint' in block && !('type' in block)).length);
-            }
-            return count;
-        }, 0);
-        expect(cachePointCount).toBe(2);
-        // Last 2 messages (indices 2 and 3) get cachePoints
-        const lastContent = result[3].content;
-        const secondLastContent = result[2].content;
-        expect(lastContent.some((b) => 'cachePoint' in b)).toBe(true);
-        expect(secondLastContent.some((b) => 'cachePoint' in b)).toBe(true);
-        // First 2 messages should NOT have cachePoints (stale ones stripped)
-        const firstContent = result[0].content;
-        const secondContent = result[1].content;
-        expect(firstContent.some((b) => 'cachePoint' in b)).toBe(false);
-        expect(secondContent.some((b) => 'cachePoint' in b)).toBe(false);
-    });
-    it('strips stale Anthropic cache_control from previous turns before applying new ones', () => {
-        const messages = [
-            {
-                role: 'user',
-                content: [
-                    {
-                        type: ContentTypes.TEXT,
-                        text: 'Turn 1 message 1',
-                        cache_control: { type: 'ephemeral' },
-                    },
-                ],
-            },
-            {
-                role: 'assistant',
-                content: [{ type: ContentTypes.TEXT, text: 'Turn 1 response 1' }],
-            },
-            {
-                role: 'user',
-                content: [
-                    {
-                        type: ContentTypes.TEXT,
-                        text: 'Turn 2 message 2',
-                        cache_control: { type: 'ephemeral' },
-                    },
-                ],
-            },
-            {
-                role: 'assistant',
-                content: [{ type: ContentTypes.TEXT, text: 'Turn 2 response 2' }],
-            },
-            {
-                role: 'user',
-                content: [{ type: ContentTypes.TEXT, text: 'Turn 3 message 3' }],
-            },
-        ];
-        /** @ts-expect-error - Testing cross-provider compatibility */
-        const result = addCacheControl(messages);
-        const cacheControlCount = result.reduce((count, msg) => {
-            if (Array.isArray(msg.content)) {
-                return (count +
-                    msg.content.filter((block) => 'cache_control' in block && 'type' in block).length);
-            }
-            return count;
-        }, 0);
-        expect(cacheControlCount).toBe(2);
-        const lastContent = result[4].content;
-        const thirdContent = result[2].content;
-        expect('cache_control' in lastContent[0]).toBe(true);
-        expect('cache_control' in thirdContent[0]).toBe(true);
-        const firstContent = result[0].content;
-        expect('cache_control' in firstContent[0]).toBe(false);
-    });
-});
-describe('LangChain message type preservation', () => {
-    it('should preserve instanceof for LangChain messages after addCacheControl', () => {
-        const messages = [
-            new HumanMessage({ content: [{ type: 'text', text: 'Hello' }] }),
-            new AIMessage({
-                content: [{ type: 'text', text: 'Using a tool' }],
-                tool_calls: [
-                    { id: 'call_1', name: 'test', args: {}, type: 'tool_call' },
-                ],
-            }),
-            new ToolMessage({ content: 'result', tool_call_id: 'call_1' }),
-            new HumanMessage({ content: [{ type: 'text', text: 'Thanks' }] }),
-            new AIMessage({ content: [{ type: 'text', text: 'No problem' }] }),
-        ];
-        const result = addCacheControl(messages);
-        expect(result[0]).toBeInstanceOf(HumanMessage);
-        expect(result[1]).toBeInstanceOf(AIMessage);
-        expect(result[2]).toBeInstanceOf(ToolMessage);
-        expect(result[3]).toBeInstanceOf(HumanMessage);
-        expect(result[4]).toBeInstanceOf(AIMessage);
-        // Verify tool_calls are preserved on the AIMessage
-        expect(result[1].tool_calls).toHaveLength(1);
-        expect(result[1].tool_calls[0].name).toBe('test');
-        // Verify tool_call_id is preserved on the ToolMessage
-        expect(result[2].tool_call_id).toBe('call_1');
-    });
-    it('should preserve instanceof for LangChain messages after addBedrockCacheControl', () => {
-        const messages = [
-            new HumanMessage({ content: [{ type: 'text', text: 'Hello' }] }),
-            new AIMessage({
-                content: [
-                    { type: 'text', text: '\n\n' },
-                    { type: 'reasoning_content', reasoningText: { text: 'thinking...' } },
-                    { type: 'text', text: 'Using a tool' },
-                ],
-                tool_calls: [
-                    {
-                        id: 'call_1',
-                        name: 'navigate',
-                        args: { url: 'test' },
-                        type: 'tool_call',
-                    },
-                ],
-            }),
-            new ToolMessage({ content: 'navigated', tool_call_id: 'call_1' }),
-            new HumanMessage({ content: [{ type: 'text', text: 'Now what?' }] }),
-        ];
-        const result = addBedrockCacheControl(messages);
-        expect(result[0]).toBeInstanceOf(HumanMessage);
-        expect(result[1]).toBeInstanceOf(AIMessage);
-        expect(result[2]).toBeInstanceOf(ToolMessage);
-        expect(result[3]).toBeInstanceOf(HumanMessage);
-        // Verify reasoning content is preserved
-        const aiContent = result[1]
-            .content;
-        expect(aiContent.some((c) => c.type === 'reasoning_content')).toBe(true);
-        // Verify tool_calls are preserved
-        expect(result[1].tool_calls).toHaveLength(1);
-        expect(result[1].tool_calls[0].name).toBe('navigate');
-    });
-});
-//# sourceMappingURL=cache.test.js.map