fix: Anthropic request errors when using parallel tool calls (#16359)

The cache marker algorithm in the Anthropic language model was
incorrectly removing content blocks, causing invalid requests when
using parallel tool calls or other multi-content-block scenarios.

Update the algorithm to preserve all content blocks while applying
cache markers, ensuring message integrity for complex requests.

Fixes #16355

Author: sdirix

packages/ai-anthropic/src/node/anthropic-language-model.spec.ts

@@ -15,7 +15,7 @@
 // *****************************************************************************
 
 import { expect } from 'chai';
-import { AnthropicModel, DEFAULT_MAX_TOKENS } from './anthropic-language-model';
+import { AnthropicModel, DEFAULT_MAX_TOKENS, addCacheControlToLastMessage } from './anthropic-language-model';
 
 describe('AnthropicModel', () => {
 
@@ -75,4 +75,93 @@ describe('AnthropicModel', () => {
             expect(model.maxRetries).to.equal(5);
         });
     });
+
+    describe('addCacheControlToLastMessage', () => {
+        it('should preserve all content blocks when adding cache control to parallel tool calls', () => {
+            const messages = [
+                {
+                    role: 'user' as const,
+                    content: [
+                        { type: 'tool_result' as const, tool_use_id: 'tool1', content: 'result1' },
+                        { type: 'tool_result' as const, tool_use_id: 'tool2', content: 'result2' },
+                        { type: 'tool_result' as const, tool_use_id: 'tool3', content: 'result3' }
+                    ]
+                }
+            ];
+
+            const result = addCacheControlToLastMessage(messages);
+
+            expect(result).to.have.lengthOf(1);
+            expect(result[0].content).to.be.an('array').with.lengthOf(3);
+            expect(result[0].content[0]).to.deep.equal({ type: 'tool_result', tool_use_id: 'tool1', content: 'result1' });
+            expect(result[0].content[1]).to.deep.equal({ type: 'tool_result', tool_use_id: 'tool2', content: 'result2' });
+            expect(result[0].content[2]).to.deep.equal({
+                type: 'tool_result',
+                tool_use_id: 'tool3',
+                content: 'result3',
+                cache_control: { type: 'ephemeral' }
+            });
+        });
+
+        it('should add cache control to last non-thinking block in mixed content', () => {
+            const messages = [
+                {
+                    role: 'assistant' as const,
+                    content: [
+                        { type: 'text' as const, text: 'Some text' },
+                        { type: 'tool_use' as const, id: 'tool1', name: 'getTool', input: {} },
+                        { type: 'thinking' as const, thinking: 'thinking content', signature: 'signature' }
+                    ]
+                }
+            ];
+
+            const result = addCacheControlToLastMessage(messages);
+
+            expect(result).to.have.lengthOf(1);
+            expect(result[0].content).to.be.an('array').with.lengthOf(3);
+            expect(result[0].content[0]).to.deep.equal({ type: 'text', text: 'Some text' });
+            expect(result[0].content[1]).to.deep.equal({
+                type: 'tool_use',
+                id: 'tool1',
+                name: 'getTool',
+                input: {},
+                cache_control: { type: 'ephemeral' }
+            });
+            expect(result[0].content[2]).to.deep.equal({ type: 'thinking', thinking: 'thinking content', signature: 'signature' });
+        });
+
+        it('should handle string content by converting to content block', () => {
+            const messages = [
+                {
+                    role: 'user' as const,
+                    content: 'Simple text message'
+                }
+            ];
+
+            const result = addCacheControlToLastMessage(messages);
+
+            expect(result).to.have.lengthOf(1);
+            expect(result[0].content).to.be.an('array').with.lengthOf(1);
+            expect(result[0].content[0]).to.deep.equal({
+                type: 'text',
+                text: 'Simple text message',
+                cache_control: { type: 'ephemeral' }
+            });
+        });
+
+        it('should not modify original messages', () => {
+            const originalMessages = [
+                {
+                    role: 'user' as const,
+                    content: [
+                        { type: 'tool_result' as const, tool_use_id: 'tool1', content: 'result1' }
+                    ]
+                }
+            ];
+
+            addCacheControlToLastMessage(originalMessages);
+
+            expect(originalMessages[0].content[0]).to.not.have.property('cache_control');
+        });
+    });
 });

packages/ai-anthropic/src/node/anthropic-language-model.ts

@@ -119,24 +119,31 @@ function transformToAnthropicParams(
  * @returns A new messages array with the last message adapted to include cache control. If no cache control can be added, the original messages are returned.
  * In any case, the original messages are not modified
  */
-function addCacheControlToLastMessage(messages: Anthropic.Messages.MessageParam[]): Anthropic.Messages.MessageParam[] {
+export function addCacheControlToLastMessage(messages: Anthropic.Messages.MessageParam[]): Anthropic.Messages.MessageParam[] {
     const clonedMessages = [...messages];
     const latestMessage = clonedMessages.pop();
     if (latestMessage) {
-        let content: NonThinkingParam | undefined = undefined;
         if (typeof latestMessage.content === 'string') {
-            content = { type: 'text', text: latestMessage.content };
+            // Wrap the string content into a content block with cache control
+            const cachedContent: NonThinkingParam = {
+                type: 'text',
+                text: latestMessage.content,
+                cache_control: { type: 'ephemeral' }
+            };
+            return [...clonedMessages, { ...latestMessage, content: [cachedContent] }];
         } else if (Array.isArray(latestMessage.content)) {
-            // we can't set cache control on thinking messages, so we only set it on the last non-thinking block
-            const filteredContent = latestMessage.content.filter(isNonThinkingParam);
-            if (filteredContent.length) {
-                content = filteredContent[filteredContent.length - 1];
+            // Update the last non-thinking content block to include cache control
+            const updatedContent = [...latestMessage.content];
+            for (let i = updatedContent.length - 1; i >= 0; i--) {
+                if (isNonThinkingParam(updatedContent[i])) {
+                    updatedContent[i] = {
+                        ...updatedContent[i],
+                        cache_control: { type: 'ephemeral' }
+                    } as NonThinkingParam;
+                    return [...clonedMessages, { ...latestMessage, content: updatedContent }];
+                }
             }
         }
-        if (content) {
-            const cachedContent: NonThinkingParam = { ...content, cache_control: { type: 'ephemeral' } };
-            return [...clonedMessages, { ...latestMessage, content: [cachedContent] }];
-        }
     }
     return messages;
 }