@librechat/agents 3.0.13 → 3.0.15

package/src/messages/cache.ts

@@ -83,8 +83,21 @@ export function addBedrockCacheControl<
     i--
   ) {
     const message = updatedMessages[i];
+
+    if (
+      'getType' in message &&
+      typeof message.getType === 'function' &&
+      message.getType() === 'tool'
+    ) {
+      continue;
+    }
+
     const content = message.content;
 
+    if (typeof content === 'string' && content === '') {
+      continue;
+    }
+
     if (typeof content === 'string') {
       message.content = [
         { type: ContentTypes.TEXT, text: content },
@@ -95,11 +108,29 @@ export function addBedrockCacheControl<
     }
 
     if (Array.isArray(content)) {
+      let hasCacheableContent = false;
+      for (const block of content) {
+        if (block.type === ContentTypes.TEXT) {
+          if (typeof block.text === 'string' && block.text !== '') {
+            hasCacheableContent = true;
+            break;
+          }
+        }
+      }
+
+      if (!hasCacheableContent) {
+        continue;
+      }
+
       let inserted = false;
       for (let j = content.length - 1; j >= 0; j--) {
         const block = content[j] as MessageContentComplex;
         const type = (block as { type?: string }).type;
         if (type === ContentTypes.TEXT || type === 'text') {
+          const text = (block as { text?: string }).text;
+          if (text === '' || text === undefined) {
+            continue;
+          }
           content.splice(j + 1, 0, {
             cachePoint: { type: 'default' },
           } as MessageContentComplex);

package/src/messages/format.ts

@@ -310,18 +310,24 @@ function formatAssistantMessage(
         });
         formattedMessages.push(lastAIMessage);
       } else if (part.type === ContentTypes.TOOL_CALL) {
-        if (!lastAIMessage) {
-          // "Heal" the payload by creating an AIMessage to precede the tool call
-          lastAIMessage = new AIMessage({ content: '' });
-          formattedMessages.push(lastAIMessage);
-        }
-
         // Note: `tool_calls` list is defined when constructed by `AIMessage` class, and outputs should be excluded from it
         const {
           output,
           args: _args,
           ..._tool_call
         } = part.tool_call as ToolCallPart;
+
+        // Skip invalid tool calls that have no name AND no output
+        if (!_tool_call.name && (output == null || output === '')) {
+          continue;
+        }
+
+        if (!lastAIMessage) {
+          // "Heal" the payload by creating an AIMessage to precede the tool call
+          lastAIMessage = new AIMessage({ content: '' });
+          formattedMessages.push(lastAIMessage);
+        }
+
         const tool_call: ToolCallPart = _tool_call;
         // TODO: investigate; args as dictionary may need to be providers-or-tool-specific
         let args: any = _args;

package/src/messages/formatAgentMessages.test.ts

@@ -914,4 +914,171 @@ describe('formatAgentMessages', () => {
 
     expect(totalTokens).toBe(10);
   });
+
+  it('should skip invalid tool calls with no name AND no output', () => {
+    const payload = [
+      {
+        role: 'assistant',
+        content: [
+          {
+            type: ContentTypes.TEXT,
+            [ContentTypes.TEXT]: 'Let me help you with that.',
+            tool_call_ids: ['valid_tool_1'],
+          },
+          {
+            type: ContentTypes.TOOL_CALL,
+            tool_call: {
+              id: 'invalid_tool_1',
+              name: '',
+              args: '{"query":"test"}',
+              output: '',
+            },
+          },
+          {
+            type: ContentTypes.TOOL_CALL,
+            tool_call: {
+              id: 'valid_tool_1',
+              name: 'search',
+              args: '{"query":"weather"}',
+              output: 'The weather is sunny.',
+            },
+          },
+        ],
+      },
+    ];
+
+    const result = formatAgentMessages(payload);
+
+    // Should have 2 messages: AIMessage and ToolMessage (invalid tool call is skipped)
+    expect(result.messages).toHaveLength(2);
+    expect(result.messages[0]).toBeInstanceOf(AIMessage);
+    expect(result.messages[1]).toBeInstanceOf(ToolMessage);
+
+    // The AIMessage should only have 1 tool call (the valid one)
+    expect((result.messages[0] as AIMessage).tool_calls).toHaveLength(1);
+    expect((result.messages[0] as AIMessage).tool_calls?.[0].name).toBe(
+      'search'
+    );
+    expect((result.messages[0] as AIMessage).tool_calls?.[0].id).toBe(
+      'valid_tool_1'
+    );
+
+    // The ToolMessage should be for the valid tool call
+    expect((result.messages[1] as ToolMessage).tool_call_id).toBe(
+      'valid_tool_1'
+    );
+    expect(result.messages[1].name).toBe('search');
+    expect(result.messages[1].content).toBe('The weather is sunny.');
+  });
+
+  it('should skip tool calls with no name AND null output', () => {
+    const payload = [
+      {
+        role: 'assistant',
+        content: [
+          {
+            type: ContentTypes.TOOL_CALL,
+            tool_call: {
+              id: 'invalid_tool_1',
+              name: '',
+              args: '{"query":"test"}',
+              output: null,
+            },
+          },
+          {
+            type: ContentTypes.TEXT,
+            [ContentTypes.TEXT]: 'Here is the information.',
+          },
+        ],
+      },
+    ];
+
+    const result = formatAgentMessages(payload);
+
+    // Should have 1 message: AIMessage (invalid tool call is skipped)
+    expect(result.messages).toHaveLength(1);
+    expect(result.messages[0]).toBeInstanceOf(AIMessage);
+
+    // The AIMessage should have no tool calls or an empty array
+    const toolCalls = (result.messages[0] as AIMessage).tool_calls;
+    expect(toolCalls === undefined || toolCalls.length === 0).toBe(true);
+    expect(result.messages[0].content).toStrictEqual([
+      {
+        type: ContentTypes.TEXT,
+        [ContentTypes.TEXT]: 'Here is the information.',
+      },
+    ]);
+  });
+
+  it('should NOT skip tool calls with no name but valid output', () => {
+    const payload = [
+      {
+        role: 'assistant',
+        content: [
+          {
+            type: ContentTypes.TOOL_CALL,
+            tool_call: {
+              id: 'tool_1',
+              name: '',
+              args: '{"query":"test"}',
+              output: 'Valid output despite missing name',
+            },
+          },
+        ],
+      },
+    ];
+
+    const result = formatAgentMessages(payload);
+
+    // Should have 2 messages: AIMessage and ToolMessage
+    expect(result.messages).toHaveLength(2);
+    expect(result.messages[0]).toBeInstanceOf(AIMessage);
+    expect(result.messages[1]).toBeInstanceOf(ToolMessage);
+
+    // The AIMessage should have 1 tool call
+    expect((result.messages[0] as AIMessage).tool_calls).toHaveLength(1);
+
+    // The ToolMessage should have the output
+    expect((result.messages[1] as ToolMessage).tool_call_id).toBe('tool_1');
+    expect(result.messages[1].content).toBe(
+      'Valid output despite missing name'
+    );
+  });
+
+  it('should NOT skip tool calls with valid name but no output', () => {
+    const payload = [
+      {
+        role: 'assistant',
+        content: [
+          {
+            type: ContentTypes.TOOL_CALL,
+            tool_call: {
+              id: 'tool_1',
+              name: 'search',
+              args: '{"query":"test"}',
+              output: '',
+            },
+          },
+        ],
+      },
+    ];
+
+    const result = formatAgentMessages(payload);
+
+    // Should have 2 messages: AIMessage and ToolMessage
+    expect(result.messages).toHaveLength(2);
+    expect(result.messages[0]).toBeInstanceOf(AIMessage);
+    expect(result.messages[1]).toBeInstanceOf(ToolMessage);
+
+    // The AIMessage should have 1 tool call
+    expect((result.messages[0] as AIMessage).tool_calls).toHaveLength(1);
+    expect((result.messages[0] as AIMessage).tool_calls?.[0].name).toBe(
+      'search'
+    );
+
+    // The ToolMessage should have empty content
+    expect((result.messages[1] as ToolMessage).tool_call_id).toBe('tool_1');
+    expect(result.messages[1].name).toBe('search');
+    expect(result.messages[1].content).toBe('');
+  });
 });

package/src/scripts/search.ts

@@ -10,7 +10,7 @@ import { createSearchTool } from '@/tools/search';
 
 import { getArgs } from '@/scripts/args';
 import { Run } from '@/run';
-import { GraphEvents, Callback } from '@/common';
+import { GraphEvents, Callback, Providers } from '@/common';
 import { getLLMConfig } from '@/utils/llmConfig';
 
 const conversationHistory: BaseMessage[] = [];
@@ -72,6 +72,10 @@ async function testStandardStreaming(): Promise<void> {
 
   const llmConfig = getLLMConfig(provider);
 
+  if (llmConfig.provider === Providers.BEDROCK) {
+    (llmConfig as t.BedrockAnthropicInput).promptCache = true;
+  }
+
   const run = await Run.create<t.IState>({
     runId: 'test-run-id',
     graphConfig: {

package/src/scripts/tools.ts

@@ -2,15 +2,16 @@
 // src/scripts/cli.ts
 import { config } from 'dotenv';
 config();
+
 import { HumanMessage, BaseMessage } from '@langchain/core/messages';
 import type * as t from '@/types';
 import { ChatModelStreamHandler, createContentAggregator } from '@/stream';
 import { ToolEndHandler, ModelEndHandler } from '@/events';
-
+import { GraphEvents, Providers } from '@/common';
+import { getLLMConfig } from '@/utils/llmConfig';
+import { Calculator } from '@/tools/Calculator';
 import { getArgs } from '@/scripts/args';
 import { Run } from '@/run';
-import { GraphEvents, Callback } from '@/common';
-import { getLLMConfig } from '@/utils/llmConfig';
 
 const conversationHistory: BaseMessage[] = [];
 async function testStandardStreaming(): Promise<void> {
@@ -89,12 +90,16 @@ async function testStandardStreaming(): Promise<void> {
 
   const llmConfig = getLLMConfig(provider);
 
+  if (llmConfig.provider === Providers.BEDROCK) {
+    (llmConfig as t.BedrockAnthropicInput).promptCache = true;
+  }
+
   const run = await Run.create<t.IState>({
     runId: 'test-run-id',
     graphConfig: {
       type: 'standard',
       llmConfig,
-      tools: [],
+      tools: [new Calculator()],
       instructions:
         'You are a friendly AI assistant. Always address the user by their name.',
       additional_instructions: `The user's name is ${userName} and they are located in ${location}.`,
@@ -114,13 +119,9 @@ async function testStandardStreaming(): Promise<void> {
     version: 'v2' as const,
   };
 
-  console.log('Test 1: Weather query (content parts test)');
+  console.log('Test 1: Calculation query');
 
-  const userMessage = `
-  Make a search for the weather in ${location} today, which is ${currentDate}.
-  Make sure to always refer to me by name, which is ${userName}.
-  After giving me a thorough summary, tell me a joke about the weather forecast we went over.
-  `;
+  const userMessage = `What is 1123123 + 123123 / 20348?`;
 
   conversationHistory.push(new HumanMessage(userMessage));