@illuma-ai/agents 1.0.90 → 1.0.93

package/src/messages/cache.test.js

@@ -0,0 +1,1167 @@
+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