@librechat/agents 2.2.4 → 2.2.6

package/src/messages/formatAgentMessages.tools.test.ts

@@ -0,0 +1,349 @@
+import { HumanMessage, AIMessage, SystemMessage, ToolMessage } from '@langchain/core/messages';
+import type { TPayload } from '@/types';
+import { formatAgentMessages } from './format';
+import { ContentTypes } from '@/common';
+
+describe('formatAgentMessages with tools parameter', () => {
+  it('should process messages normally when tools is not provided', () => {
+    const payload: TPayload = [
+      { role: 'user', content: 'Hello' },
+      {
+        role: 'assistant',
+        content: [
+          {
+            type: ContentTypes.TEXT,
+            [ContentTypes.TEXT]: 'Let me check that for you.',
+            tool_call_ids: ['123'],
+          },
+          {
+            type: ContentTypes.TOOL_CALL,
+            tool_call: {
+              id: '123',
+              name: 'search',
+              args: '{"query":"weather"}',
+              output: 'The weather is sunny.',
+            },
+          },
+        ],
+      },
+    ];
+    
+    const result = formatAgentMessages(payload);
+    
+    expect(result.messages).toHaveLength(3);
+    expect(result.messages[0]).toBeInstanceOf(HumanMessage);
+    expect(result.messages[1]).toBeInstanceOf(AIMessage);
+    expect(result.messages[2]).toBeInstanceOf(ToolMessage);
+    expect((result.messages[1] as AIMessage).tool_calls).toHaveLength(1);
+    expect((result.messages[2] as ToolMessage).tool_call_id).toBe('123');
+  });
+
+  it('should treat an empty tools set the same as disallowing all tools', () => {
+    const payload: TPayload = [
+      { role: 'user', content: 'What\'s the weather?' },
+      {
+        role: 'assistant',
+        content: [
+          {
+            type: ContentTypes.TEXT,
+            [ContentTypes.TEXT]: 'Let me check the weather for you.',
+            tool_call_ids: ['weather_1'],
+          },
+          {
+            type: ContentTypes.TOOL_CALL,
+            tool_call: {
+              id: 'weather_1',
+              name: 'check_weather',
+              args: '{"location":"New York"}',
+              output: 'Sunny, 75°F',
+            },
+          },
+        ],
+      },
+    ];
+    
+    // Provide an empty set of allowed tools
+    const allowedTools = new Set<string>();
+    
+    const result = formatAgentMessages(payload, undefined, allowedTools);
+    
+    // Should convert to a single AIMessage with string content
+    expect(result.messages).toHaveLength(2);
+    expect(result.messages[0]).toBeInstanceOf(HumanMessage);
+    expect(result.messages[1]).toBeInstanceOf(AIMessage);
+    
+    // The content should be a string representation of both messages
+    expect(typeof result.messages[1].content).toBe('string');
+    expect(result.messages[1].content).toEqual('AI: Let me check the weather for you.\nTool: check_weather, Sunny, 75°F');
+  });
+
+  it('should convert tool messages to string when tool is not in the allowed set', () => {
+    const payload: TPayload = [
+      { role: 'user', content: 'What\'s the weather?' },
+      {
+        role: 'assistant',
+        content: [
+          {
+            type: ContentTypes.TEXT,
+            [ContentTypes.TEXT]: 'Let me check the weather for you.',
+            tool_call_ids: ['weather_1'],
+          },
+          {
+            type: ContentTypes.TOOL_CALL,
+            tool_call: {
+              id: 'weather_1',
+              name: 'check_weather',
+              args: '{"location":"New York"}',
+              output: 'Sunny, 75°F',
+            },
+          },
+        ],
+      },
+    ];
+    
+    // Provide a set of allowed tools that doesn't include 'check_weather'
+    const allowedTools = new Set(['search', 'calculator']);
+    
+    const result = formatAgentMessages(payload, undefined, allowedTools);
+    
+    // Should convert to a single AIMessage with string content
+    expect(result.messages).toHaveLength(2);
+    expect(result.messages[0]).toBeInstanceOf(HumanMessage);
+    expect(result.messages[1]).toBeInstanceOf(AIMessage);
+    
+    // The content should be a string representation of both messages
+    expect(typeof result.messages[1].content).toBe('string');
+    expect(result.messages[1].content).toEqual('AI: Let me check the weather for you.\nTool: check_weather, Sunny, 75°F');
+  });
+
+  it('should not convert tool messages when tool is in the allowed set', () => {
+    const payload: TPayload = [
+      { role: 'user', content: 'What\'s the weather?' },
+      {
+        role: 'assistant',
+        content: [
+          {
+            type: ContentTypes.TEXT,
+            [ContentTypes.TEXT]: 'Let me check the weather for you.',
+            tool_call_ids: ['weather_1'],
+          },
+          {
+            type: ContentTypes.TOOL_CALL,
+            tool_call: {
+              id: 'weather_1',
+              name: 'check_weather',
+              args: '{"location":"New York"}',
+              output: 'Sunny, 75°F',
+            },
+          },
+        ],
+      },
+    ];
+    
+    // Provide a set of allowed tools that includes 'check_weather'
+    const allowedTools = new Set(['check_weather', 'search']);
+    
+    const result = formatAgentMessages(payload, undefined, allowedTools);
+    
+    // Should keep the original structure
+    expect(result.messages).toHaveLength(3);
+    expect(result.messages[0]).toBeInstanceOf(HumanMessage);
+    expect(result.messages[1]).toBeInstanceOf(AIMessage);
+    expect(result.messages[2]).toBeInstanceOf(ToolMessage);
+  });
+
+  it('should handle multiple tool calls with mixed allowed/disallowed tools', () => {
+    const payload: TPayload = [
+      { role: 'user', content: 'Tell me about the weather and calculate something' },
+      {
+        role: 'assistant',
+        content: [
+          {
+            type: ContentTypes.TEXT,
+            [ContentTypes.TEXT]: 'Let me check the weather first.',
+            tool_call_ids: ['weather_1'],
+          },
+          {
+            type: ContentTypes.TOOL_CALL,
+            tool_call: {
+              id: 'weather_1',
+              name: 'check_weather',
+              args: '{"location":"New York"}',
+              output: 'Sunny, 75°F',
+            },
+          },
+          {
+            type: ContentTypes.TEXT,
+            [ContentTypes.TEXT]: 'Now let me calculate something for you.',
+            tool_call_ids: ['calc_1'],
+          },
+          {
+            type: ContentTypes.TOOL_CALL,
+            tool_call: {
+              id: 'calc_1',
+              name: 'calculator',
+              args: '{"expression":"1+1"}',
+              output: '2',
+            },
+          },
+        ],
+      },
+    ];
+    
+    // Allow calculator but not check_weather
+    const allowedTools = new Set(['calculator', 'search']);
+    
+    const result = formatAgentMessages(payload, undefined, allowedTools);
+    
+    // Should convert the entire sequence to a single AIMessage
+    expect(result.messages).toHaveLength(2);
+    expect(result.messages[0]).toBeInstanceOf(HumanMessage);
+    expect(result.messages[1]).toBeInstanceOf(AIMessage);
+    
+    // The content should include all parts
+    expect(typeof result.messages[1].content).toBe('string');
+    expect(result.messages[1].content).toContain('Let me check the weather first.');
+    expect(result.messages[1].content).toContain('Sunny, 75°F');
+    expect(result.messages[1].content).toContain('Now let me calculate something for you.');
+    expect(result.messages[1].content).toContain('2');
+  });
+
+  it('should update indexTokenCountMap correctly when converting tool messages', () => {
+    const payload: TPayload = [
+      { role: 'user', content: 'What\'s the weather?' },
+      {
+        role: 'assistant',
+        content: [
+          {
+            type: ContentTypes.TEXT,
+            [ContentTypes.TEXT]: 'Let me check the weather for you.',
+            tool_call_ids: ['weather_1'],
+          },
+          {
+            type: ContentTypes.TOOL_CALL,
+            tool_call: {
+              id: 'weather_1',
+              name: 'check_weather',
+              args: '{"location":"New York"}',
+              output: 'Sunny, 75°F',
+            },
+          },
+        ],
+      },
+    ];
+    
+    const indexTokenCountMap = {
+      0: 10,  // 10 tokens for user message
+      1: 40,  // 40 tokens for assistant message with tool call
+    };
+    
+    // Provide a set of allowed tools that doesn't include 'check_weather'
+    const allowedTools = new Set(['search', 'calculator']);
+    
+    const result = formatAgentMessages(payload, indexTokenCountMap, allowedTools);
+    
+    // Should have 2 messages and 2 entries in the token count map
+    expect(result.messages).toHaveLength(2);
+    expect(Object.keys(result.indexTokenCountMap || {}).length).toBe(2);
+    
+    // User message token count should be unchanged
+    expect(result.indexTokenCountMap?.[0]).toBe(10);
+    
+    // All assistant message tokens should be assigned to the single AIMessage
+    expect(result.indexTokenCountMap?.[1]).toBe(40);
+  });
+
+  it('should handle complex sequences with multiple tool calls', () => {
+    const payload: TPayload = [
+      { role: 'user', content: 'Help me with a complex task' },
+      {
+        role: 'assistant',
+        content: [
+          {
+            type: ContentTypes.TEXT,
+            [ContentTypes.TEXT]: 'I\'ll search for information first.',
+            tool_call_ids: ['search_1'],
+          },
+          {
+            type: ContentTypes.TOOL_CALL,
+            tool_call: {
+              id: 'search_1',
+              name: 'search',
+              args: '{"query":"complex task"}',
+              output: 'Found information about complex tasks.',
+            },
+          },
+        ],
+      },
+      {
+        role: 'assistant',
+        content: [
+          {
+            type: ContentTypes.TEXT,
+            [ContentTypes.TEXT]: 'Now I\'ll check the weather.',
+            tool_call_ids: ['weather_1'],
+          },
+          {
+            type: ContentTypes.TOOL_CALL,
+            tool_call: {
+              id: 'weather_1',
+              name: 'check_weather',
+              args: '{"location":"New York"}',
+              output: 'Sunny, 75°F',
+            },
+          },
+        ],
+      },
+      {
+        role: 'assistant',
+        content: [
+          {
+            type: ContentTypes.TEXT,
+            [ContentTypes.TEXT]: 'Finally, I\'ll calculate something.',
+            tool_call_ids: ['calc_1'],
+          },
+          {
+            type: ContentTypes.TOOL_CALL,
+            tool_call: {
+              id: 'calc_1',
+              name: 'calculator',
+              args: '{"expression":"1+1"}',
+              output: '2',
+            },
+          },
+        ],
+      },
+      { role: 'assistant', content: 'Here\'s your answer based on all that information.' },
+    ];
+    
+    // Allow search and calculator but not check_weather
+    const allowedTools = new Set(['search', 'calculator']);
+    
+    const result = formatAgentMessages(payload, undefined, allowedTools);
+    
+    // Should have the user message, search tool sequence (2 messages),
+    // a combined message for weather and calculator (since one has an invalid tool),
+    // and final message
+    expect(result.messages).toHaveLength(5);
+    
+    // Check the types of messages
+    expect(result.messages[0]).toBeInstanceOf(HumanMessage);
+    expect(result.messages[1]).toBeInstanceOf(AIMessage);  // Search message
+    expect(result.messages[2]).toBeInstanceOf(ToolMessage); // Search tool response
+    expect(result.messages[3]).toBeInstanceOf(AIMessage); // Converted weather+calculator message
+    expect(result.messages[4]).toBeInstanceOf(AIMessage); // Final message
+    
+    // Check that the combined message was converted to a string
+    expect(typeof result.messages[3].content).toBe('string');
+    
+    // The format might vary based on the getBufferString implementation
+    // but we should check that all the key information is present
+    const content = result.messages[3].content as string;
+    expect(content).toContain('Now I\'ll check the weather');
+    expect(content).toContain('Sunny');
+    expect(content).toContain('75');
+    expect(content).toContain('Finally');
+    expect(content).toContain('calculate');
+    expect(content).toContain('2');
+  });
+});

package/src/messages/prune.ts

@@ -9,6 +9,7 @@ export type PruneMessagesFactoryParams = {
 export type PruneMessagesParams = {
   messages: BaseMessage[];
   usageMetadata?: Partial<UsageMetadata>;
+  startOnMessageType?: ReturnType<BaseMessage['getType']>;
 }
 
 /**
@@ -43,10 +44,12 @@ function getMessagesWithinTokenLimit({
   messages: _messages,
   maxContextTokens,
   indexTokenCountMap,
+  startOnMessageType,
 }: {
   messages: BaseMessage[];
   maxContextTokens: number;
   indexTokenCountMap: Record<string, number>;
+  startOnMessageType?: string;
 }): {
   context: BaseMessage[];
   remainingContextTokens: number;
@@ -61,7 +64,7 @@ function getMessagesWithinTokenLimit({
   const instructionsTokenCount = instructions != null ? indexTokenCountMap[0] : 0;
   let remainingContextTokens = maxContextTokens - instructionsTokenCount;
   const messages = [..._messages];
-  const context: BaseMessage[] = [];
+  let context: BaseMessage[] = [];
 
   if (currentTokenCount < remainingContextTokens) {
     let currentIndex = messages.length;
@@ -83,6 +86,14 @@ function getMessagesWithinTokenLimit({
         break;
       }
     }
+    
+    if (startOnMessageType && context.length > 0) {
+      const requiredTypeIndex = context.findIndex(msg => msg.getType() === startOnMessageType);
+      
+      if (requiredTypeIndex > 0) {
+        context = context.slice(requiredTypeIndex);
+      }
+    }
   }
 
   if (instructions && _messages.length > 0) {
@@ -160,8 +171,9 @@ export function createPruneMessages(factoryParams: PruneMessagesFactoryParams) {
       maxContextTokens: factoryParams.maxTokens,
       messages: params.messages,
       indexTokenCountMap,
+      startOnMessageType: params.startOnMessageType,
     });
 
     return { context, indexTokenCountMap };
   }
-}
+}

package/src/specs/prune.test.ts

@@ -65,10 +65,12 @@ function getMessagesWithinTokenLimit({
   messages: _messages,
   maxContextTokens,
   indexTokenCountMap,
+  startOnMessageType,
 }: {
   messages: BaseMessage[];
   maxContextTokens: number;
   indexTokenCountMap: Record<string, number>;
+  startOnMessageType?: string;
 }): {
   context: BaseMessage[];
   remainingContextTokens: number;
@@ -105,6 +107,18 @@ function getMessagesWithinTokenLimit({
         break;
       }
     }
+    
+    // If startOnMessageType is specified, discard messages until we find one of the required type
+    if (startOnMessageType && context.length > 0) {
+      const requiredTypeIndex = context.findIndex(msg => msg.getType() === startOnMessageType);
+      
+      if (requiredTypeIndex > 0) {
+        // If we found a message of the required type, discard all messages before it
+        const remainingMessages = context.slice(requiredTypeIndex);
+        context.length = 0; // Clear the array
+        context.push(...remainingMessages);
+      }
+    }
   }
 
   if (instructions && _messages.length > 0) {
@@ -262,6 +276,73 @@ describe('Prune Messages Tests', () => {
       
       expect(result.messagesToRefine.length).toBe(2);
     });
+
+    it('should start context with a specific message type when startOnMessageType is specified', () => {
+      const messages = [
+        new SystemMessage('System instruction'),
+        new AIMessage('AI message 1'),
+        new HumanMessage('Human message 1'),
+        new AIMessage('AI message 2'),
+        new HumanMessage('Human message 2')
+      ];
+      
+      const indexTokenCountMap = {
+        0: 17, // "System instruction"
+        1: 12, // "AI message 1"
+        2: 15, // "Human message 1"
+        3: 12, // "AI message 2"
+        4: 15  // "Human message 2"
+      };
+      
+      // Set a limit that can fit all messages
+      const result = getMessagesWithinTokenLimit({
+        messages,
+        maxContextTokens: 100,
+        indexTokenCountMap,
+        startOnMessageType: 'human'
+      });
+      
+      // All messages should be included since we're under the token limit
+      expect(result.context.length).toBe(5);
+      expect(result.context[0]).toBe(messages[0]); // System message
+      expect(result.context[1]).toBe(messages[1]); // AI message 1
+      expect(result.context[2]).toBe(messages[2]); // Human message 1
+      expect(result.context[3]).toBe(messages[3]); // AI message 2
+      expect(result.context[4]).toBe(messages[4]); // Human message 2
+      
+      // All messages should be included since we're under the token limit
+      expect(result.messagesToRefine.length).toBe(0);
+    });
+
+    it('should keep all messages if no message of required type is found', () => {
+      const messages = [
+        new SystemMessage('System instruction'),
+        new AIMessage('AI message 1'),
+        new AIMessage('AI message 2')
+      ];
+      
+      const indexTokenCountMap = {
+        0: 17, // "System instruction"
+        1: 12, // "AI message 1"
+        2: 12  // "AI message 2"
+      };
+      
+      // Set a limit that can fit all messages
+      const result = getMessagesWithinTokenLimit({
+        messages,
+        maxContextTokens: 100,
+        indexTokenCountMap,
+        startOnMessageType: 'human'
+      });
+      
+      // Should include all messages since no human messages exist to start from
+      expect(result.context.length).toBe(3);
+      expect(result.context[0]).toBe(messages[0]); // System message
+      expect(result.context[1]).toBe(messages[1]); // AI message 1
+      expect(result.context[2]).toBe(messages[2]); // AI message 2
+      
+      expect(result.messagesToRefine.length).toBe(0);
+    });
   });
   
   describe('checkValidNumber', () => {
@@ -348,6 +429,46 @@ describe('Prune Messages Tests', () => {
       expect(result.context[1]).toBe(messages[3]); // Message 2
       expect(result.context[2]).toBe(messages[4]); // Response 2
     });
+
+    it('should respect startOnMessageType parameter', () => {
+      const tokenCounter = createTestTokenCounter();
+      const messages = [
+        new SystemMessage('System instruction'),
+        new AIMessage('AI message 1'),
+        new HumanMessage('Human message 1'),
+        new AIMessage('AI message 2'),
+        new HumanMessage('Human message 2')
+      ];
+      
+      const indexTokenCountMap = {
+        0: tokenCounter(messages[0]),
+        1: tokenCounter(messages[1]),
+        2: tokenCounter(messages[2]),
+        3: tokenCounter(messages[3]),
+        4: tokenCounter(messages[4])
+      };
+      
+      // Set a limit that can fit all messages
+      const pruneMessages = createPruneMessages({
+        maxTokens: 100,
+        startIndex: 0,
+        tokenCounter,
+        indexTokenCountMap: { ...indexTokenCountMap }
+      });
+      
+      const result = pruneMessages({ 
+        messages,
+        startOnMessageType: 'human'
+      });
+      
+      // All messages should be included since we're under the token limit
+      expect(result.context.length).toBe(5);
+      expect(result.context[0]).toBe(messages[0]); // System message
+      expect(result.context[1]).toBe(messages[1]); // AI message 1
+      expect(result.context[2]).toBe(messages[2]); // Human message 1
+      expect(result.context[3]).toBe(messages[3]); // AI message 2
+      expect(result.context[4]).toBe(messages[4]); // Human message 2
+    });
     
     it('should update token counts when usage metadata is provided', () => {
       const tokenCounter = createTestTokenCounter();

package/src/types/stream.ts

@@ -240,8 +240,35 @@ export type BedrockReasoningContentText = {
   reasoningText: { text?: string; signature?: string; }
 };
 
+/**
+ * A call to a tool.
+ */
+export type ToolCallPart = {
+  /** Type ("tool_call") according to Assistants Tool Call Structure */
+  type: ContentTypes.TOOL_CALL;
+  /** The name of the tool to be called */
+  name: string;
+  /** The arguments to the tool call */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  args?: string | Record<string, any>;
+
+  /** If provided, an identifier associated with the tool call */
+  id?: string;
+  /** If provided, the output of the tool call */
+  output?: string;
+  /** Auth URL */
+  auth?: string;
+  /** Expiration time */
+  expires_at?: number;
+};
+
+export type ToolCallContent = {
+  type: ContentTypes.TOOL_CALL;
+  tool_call?: ToolCallPart;
+};
+
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-export type MessageContentComplex = (ThinkingContentText | AgentUpdate | ReasoningContentText | MessageContentText | MessageContentImageUrl | (Record<string, any> & {
+export type MessageContentComplex = (ThinkingContentText | AgentUpdate | ToolCallContent | ReasoningContentText | MessageContentText | MessageContentImageUrl | (Record<string, any> & {
   type?: 'text' | 'image_url' | 'think' | 'thinking' | string;
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 }) | (Record<string, any> & {
@@ -249,7 +276,14 @@ export type MessageContentComplex = (ThinkingContentText | AgentUpdate | Reasoni
 })) & {
   tool_call_ids?: string[];
 };
-// #new
+
+export interface TMessage {
+  role?: string;
+  content?: MessageContentComplex[] | string;
+  [key: string]: any;
+}
+
+export type TPayload = Array<Partial<TMessage>>;
 
 export type CustomChunk = Partial<OpenAITypes.ChatCompletionChunk> & {
   choices?: Partial<Array<Partial<OpenAITypes.Chat.Completions.ChatCompletionChunk.Choice> & {

package/src/types/tools.ts

@@ -42,11 +42,6 @@ export type ToolEndEvent = {
   index: number;
 };
 
-export type ToolCallContent = {
-  type: ContentTypes.TOOL_CALL;
-  tool_call: ToolCall;
-};
-
 export type CodeEnvFile = {
   id: string;
   name: string;