@librechat/agents 3.0.0-rc11 → 3.0.0-rc12

package/src/messages/cache.test.ts

@@ -0,0 +1,262 @@
+import type Anthropic from '@anthropic-ai/sdk';
+import type { AnthropicMessages } from '@/types/messages';
+import { addCacheControl } from './cache';
+
+describe('addCacheControl', () => {
+  test('should add cache control to the last two user messages with array content', () => {
+    const messages: AnthropicMessages = [
+      { 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] as Anthropic.TextBlockParam).cache_control
+    ).toEqual({ type: 'ephemeral' });
+    expect(
+      (result[4].content[0] as Anthropic.TextBlockParam).cache_control
+    ).toEqual({ type: 'ephemeral' });
+  });
+
+  test('should add cache control to the last two user messages with string content', () => {
+    const messages: AnthropicMessages = [
+      { 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: AnthropicMessages = [
+      { 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] as Anthropic.TextBlockParam).cache_control
+    ).toEqual({ type: 'ephemeral' });
+  });
+
+  test('should handle less than two user messages', () => {
+    const messages: AnthropicMessages = [
+      { 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: AnthropicMessages = [
+      { 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: AnthropicMessages = [];
+    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: AnthropicMessages = [
+      { 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: AnthropicMessages = [
+      {
+        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] as Anthropic.TextBlockParam).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: AnthropicMessages = [
+      { 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: AnthropicMessages = [
+      {
+        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] as Anthropic.ImageBlockParam).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: AnthropicMessages = [
+      {
+        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' },
+    });
+  });
+});

package/src/messages/cache.ts

@@ -0,0 +1,56 @@
+import type { AnthropicMessage } from '@/types/messages';
+import type Anthropic from '@anthropic-ai/sdk';
+import { BaseMessage } from '@langchain/core/messages';
+
+/**
+ * Anthropic API: Adds cache control to the appropriate user messages in the payload.
+ * @param messages - The array of message objects.
+ * @returns - The updated array of message objects with cache control added.
+ */
+export function addCacheControl<T extends AnthropicMessage | BaseMessage>(
+  messages: T[]
+): T[] {
+  if (!Array.isArray(messages) || messages.length < 2) {
+    return messages;
+  }
+
+  const updatedMessages = [...messages];
+  let userMessagesModified = 0;
+
+  for (
+    let i = updatedMessages.length - 1;
+    i >= 0 && userMessagesModified < 2;
+    i--
+  ) {
+    const message = updatedMessages[i];
+    if ('getType' in message && message.getType() !== 'human') {
+      continue;
+    } else if ('role' in message && message.role !== 'user') {
+      continue;
+    }
+
+    if (typeof message.content === 'string') {
+      message.content = [
+        {
+          type: 'text',
+          text: message.content,
+          cache_control: { type: 'ephemeral' },
+        },
+      ];
+      userMessagesModified++;
+    } else if (Array.isArray(message.content)) {
+      for (let j = message.content.length - 1; j >= 0; j--) {
+        const contentPart = message.content[j];
+        if ('type' in contentPart && contentPart.type === 'text') {
+          (contentPart as Anthropic.TextBlockParam).cache_control = {
+            type: 'ephemeral',
+          };
+          userMessagesModified++;
+          break;
+        }
+      }
+    }
+  }
+
+  return updatedMessages;
+}

package/src/messages/content.test.ts

@@ -0,0 +1,362 @@
+import {
+  HumanMessage,
+  AIMessage,
+  SystemMessage,
+} from '@langchain/core/messages';
+import { formatContentStrings } from './content';
+import { ContentTypes } from '@/common';
+
+describe('formatContentStrings', () => {
+  describe('Human messages', () => {
+    it('should convert human message with all text blocks to string', () => {
+      const messages = [
+        new HumanMessage({
+          content: [
+            { type: ContentTypes.TEXT, [ContentTypes.TEXT]: 'Hello' },
+            { type: ContentTypes.TEXT, [ContentTypes.TEXT]: 'World' },
+          ],
+        }),
+      ];
+
+      const result = formatContentStrings(messages);
+
+      expect(result).toHaveLength(1);
+      expect(result[0].content).toBe('Hello\nWorld');
+    });
+
+    it('should not convert human message with mixed content types (text + image)', () => {
+      const messages = [
+        new HumanMessage({
+          content: [
+            { type: ContentTypes.TEXT, text: 'what do you see' },
+            {
+              type: 'image_url',
+              image_url: {
+                url: 'data:image/png;base64,iVBO_SOME_BASE64_DATA=',
+                detail: 'auto',
+              },
+            },
+          ],
+        }),
+      ];
+
+      const result = formatContentStrings(messages);
+
+      expect(result).toHaveLength(1);
+      expect(result[0].content).toEqual([
+        { type: ContentTypes.TEXT, text: 'what do you see' },
+        {
+          type: 'image_url',
+          image_url: {
+            url: 'data:image/png;base64,iVBO_SOME_BASE64_DATA=',
+            detail: 'auto',
+          },
+        },
+      ]);
+    });
+
+    it('should leave string content unchanged', () => {
+      const messages = [
+        new HumanMessage({
+          content: 'Hello World',
+        }),
+      ];
+
+      const result = formatContentStrings(messages);
+
+      expect(result).toHaveLength(1);
+      expect(result[0].content).toBe('Hello World');
+    });
+
+    it('should handle empty text blocks', () => {
+      const messages = [
+        new HumanMessage({
+          content: [
+            { type: ContentTypes.TEXT, [ContentTypes.TEXT]: 'Hello' },
+            { type: ContentTypes.TEXT, [ContentTypes.TEXT]: '' },
+            { type: ContentTypes.TEXT, [ContentTypes.TEXT]: 'World' },
+          ],
+        }),
+      ];
+
+      const result = formatContentStrings(messages);
+
+      expect(result).toHaveLength(1);
+      expect(result[0].content).toBe('Hello\n\nWorld');
+    });
+
+    it('should handle null/undefined text values', () => {
+      const messages = [
+        new HumanMessage({
+          content: [
+            { type: ContentTypes.TEXT, [ContentTypes.TEXT]: 'Hello' },
+            { type: ContentTypes.TEXT, [ContentTypes.TEXT]: null },
+            { type: ContentTypes.TEXT, [ContentTypes.TEXT]: undefined },
+            { type: ContentTypes.TEXT, [ContentTypes.TEXT]: 'World' },
+          ],
+        }),
+      ];
+
+      const result = formatContentStrings(messages);
+
+      expect(result).toHaveLength(1);
+      expect(result[0].content).toBe('Hello\n\n\nWorld');
+    });
+  });
+
+  describe('AI messages', () => {
+    it('should convert AI message with all text blocks to string', () => {
+      const messages = [
+        new AIMessage({
+          content: [
+            { type: ContentTypes.TEXT, [ContentTypes.TEXT]: 'Hello' },
+            { type: ContentTypes.TEXT, [ContentTypes.TEXT]: 'World' },
+          ],
+        }),
+      ];
+
+      const result = formatContentStrings(messages);
+
+      expect(result).toHaveLength(1);
+      expect(result[0].content).toBe('Hello\nWorld');
+      expect(result[0].getType()).toBe('ai');
+    });
+
+    it('should not convert AI message with mixed content types', () => {
+      const messages = [
+        new AIMessage({
+          content: [
+            {
+              type: ContentTypes.TEXT,
+              [ContentTypes.TEXT]: 'Here is an image',
+            },
+            {
+              type: ContentTypes.TOOL_CALL,
+              tool_call: { name: 'generate_image' },
+            },
+          ],
+        }),
+      ];
+
+      const result = formatContentStrings(messages);
+
+      expect(result).toHaveLength(1);
+      expect(result[0].content).toEqual([
+        { type: ContentTypes.TEXT, [ContentTypes.TEXT]: 'Here is an image' },
+        { type: ContentTypes.TOOL_CALL, tool_call: { name: 'generate_image' } },
+      ]);
+    });
+  });
+
+  describe('System messages', () => {
+    it('should convert System message with all text blocks to string', () => {
+      const messages = [
+        new SystemMessage({
+          content: [
+            { type: ContentTypes.TEXT, [ContentTypes.TEXT]: 'System' },
+            { type: ContentTypes.TEXT, [ContentTypes.TEXT]: 'Message' },
+          ],
+        }),
+      ];
+
+      const result = formatContentStrings(messages);
+
+      expect(result).toHaveLength(1);
+      expect(result[0].content).toBe('System\nMessage');
+      expect(result[0].getType()).toBe('system');
+    });
+  });
+
+  describe('Mixed message types', () => {
+    it('should process all valid message types in mixed array', () => {
+      const messages = [
+        new HumanMessage({
+          content: [
+            { type: ContentTypes.TEXT, [ContentTypes.TEXT]: 'Human' },
+            { type: ContentTypes.TEXT, [ContentTypes.TEXT]: 'Message' },
+          ],
+        }),
+        new AIMessage({
+          content: [
+            { type: ContentTypes.TEXT, [ContentTypes.TEXT]: 'AI' },
+            { type: ContentTypes.TEXT, [ContentTypes.TEXT]: 'Response' },
+          ],
+        }),
+        new SystemMessage({
+          content: [
+            { type: ContentTypes.TEXT, [ContentTypes.TEXT]: 'System' },
+            { type: ContentTypes.TEXT, [ContentTypes.TEXT]: 'Prompt' },
+          ],
+        }),
+      ];
+
+      const result = formatContentStrings(messages);
+
+      expect(result).toHaveLength(3);
+      // All messages should be converted
+      expect(result[0].content).toBe('Human\nMessage');
+      expect(result[0].getType()).toBe('human');
+
+      expect(result[1].content).toBe('AI\nResponse');
+      expect(result[1].getType()).toBe('ai');
+
+      expect(result[2].content).toBe('System\nPrompt');
+      expect(result[2].getType()).toBe('system');
+    });
+  });
+
+  describe('Edge cases', () => {
+    it('should handle empty array', () => {
+      const result = formatContentStrings([]);
+      expect(result).toEqual([]);
+    });
+
+    it('should handle messages with non-array content', () => {
+      const messages = [
+        new HumanMessage({
+          content: 'This is a string content',
+        }),
+      ];
+
+      const result = formatContentStrings(messages);
+
+      expect(result).toHaveLength(1);
+      expect(result[0].content).toBe('This is a string content');
+    });
+
+    it('should trim the final concatenated string', () => {
+      const messages = [
+        new HumanMessage({
+          content: [
+            { type: ContentTypes.TEXT, [ContentTypes.TEXT]: '  Hello  ' },
+            { type: ContentTypes.TEXT, [ContentTypes.TEXT]: '  World  ' },
+          ],
+        }),
+      ];
+
+      const result = formatContentStrings(messages);
+
+      expect(result).toHaveLength(1);
+      expect(result[0].content).toBe('Hello  \n  World');
+    });
+  });
+
+  describe('Real-world scenarios', () => {
+    it('should handle the exact scenario from the issue', () => {
+      const messages = [
+        new HumanMessage({
+          content: [
+            {
+              type: 'text',
+              text: 'hi there',
+            },
+          ],
+        }),
+        new AIMessage({
+          content: [
+            {
+              type: 'text',
+              text: 'Hi Danny! How can I help you today?',
+            },
+          ],
+        }),
+        new HumanMessage({
+          content: [
+            {
+              type: 'text',
+              text: 'what do you see',
+            },
+            {
+              type: 'image_url',
+              image_url: {
+                url: 'data:image/png;base64,iVBO_SOME_BASE64_DATA=',
+                detail: 'auto',
+              },
+            },
+          ],
+        }),
+      ];
+
+      const result = formatContentStrings(messages);
+
+      expect(result).toHaveLength(3);
+
+      // First human message (all text) should be converted
+      expect(result[0].content).toBe('hi there');
+      expect(result[0].getType()).toBe('human');
+
+      // AI message (all text) should now also be converted
+      expect(result[1].content).toBe('Hi Danny! How can I help you today?');
+      expect(result[1].getType()).toBe('ai');
+
+      // Third message (mixed content) should remain unchanged
+      expect(result[2].content).toEqual([
+        {
+          type: 'text',
+          text: 'what do you see',
+        },
+        {
+          type: 'image_url',
+          image_url: {
+            url: 'data:image/png;base64,iVBO_SOME_BASE64_DATA=',
+            detail: 'auto',
+          },
+        },
+      ]);
+    });
+
+    it('should handle messages with tool calls', () => {
+      const messages = [
+        new HumanMessage({
+          content: [
+            {
+              type: ContentTypes.TEXT,
+              [ContentTypes.TEXT]: 'Please use the calculator',
+            },
+            {
+              type: ContentTypes.TOOL_CALL,
+              tool_call: { name: 'calculator', args: '{"a": 1, "b": 2}' },
+            },
+          ],
+        }),
+        new AIMessage({
+          content: [
+            {
+              type: ContentTypes.TEXT,
+              [ContentTypes.TEXT]: 'I will calculate that for you',
+            },
+            {
+              type: ContentTypes.TOOL_CALL,
+              tool_call: { name: 'calculator', args: '{"a": 1, "b": 2}' },
+            },
+          ],
+        }),
+      ];
+
+      const result = formatContentStrings(messages);
+
+      expect(result).toHaveLength(2);
+      // Should not convert because not all blocks are text
+      expect(result[0].content).toEqual([
+        {
+          type: ContentTypes.TEXT,
+          [ContentTypes.TEXT]: 'Please use the calculator',
+        },
+        {
+          type: ContentTypes.TOOL_CALL,
+          tool_call: { name: 'calculator', args: '{"a": 1, "b": 2}' },
+        },
+      ]);
+      expect(result[1].content).toEqual([
+        {
+          type: ContentTypes.TEXT,
+          [ContentTypes.TEXT]: 'I will calculate that for you',
+        },
+        {
+          type: ContentTypes.TOOL_CALL,
+          tool_call: { name: 'calculator', args: '{"a": 1, "b": 2}' },
+        },
+      ]);
+    });
+  });
+});