@librechat/agents 3.1.64 → 3.1.65

package/src/llm/anthropic/utils/message_inputs.ts

@@ -144,7 +144,9 @@ export function _convertLangChainToolCallToAnthropic(
     throw new Error('Anthropic requires all tool calls to have an "id".');
   }
   return {
-    type: 'tool_use',
+    type: toolCall.id.startsWith(Constants.ANTHROPIC_SERVER_TOOL_PREFIX)
+      ? 'server_tool_use'
+      : 'tool_use',
     id: toolCall.id,
     name: toolCall.name,
     input: toolCall.args,
@@ -364,87 +366,90 @@ function _formatContent(message: BaseMessage) {
   } else {
     const contentBlocks = content.map((contentPart) => {
       /**
-       * Handle malformed blocks that have server tool fields mixed with text type.
-       * These can occur when server_tool_use blocks get mislabeled during aggregation.
-       * Correct their type ONLY if we can confirm it's a server tool by checking the ID prefix.
-       * Anthropic needs both server_tool_use and web_search_tool_result blocks for citations to work.
+       * Normalize server_tool_use blocks into a clean shape the API accepts.
+       * These blocks may arrive with the correct type (server_tool_use) or mislabeled
+       * as text/tool_use after chunk concatenation or state serialization.
+       * Regardless of current type, if the id starts with 'srvtoolu_' we rebuild
+       * a clean block with only the properties the API expects.
        */
       if (
         'id' in contentPart &&
-        'name' in contentPart &&
-        'input' in contentPart &&
-        contentPart.type === 'text'
+        typeof (contentPart as Record<string, unknown>).id === 'string' &&
+        ((contentPart as Record<string, unknown>).id as string).startsWith(
+          Constants.ANTHROPIC_SERVER_TOOL_PREFIX
+        ) &&
+        'name' in contentPart
       ) {
         const rawPart = contentPart as Record<string, unknown>;
-        const id = rawPart.id as string;
-
-        if (id && id.startsWith(Constants.ANTHROPIC_SERVER_TOOL_PREFIX)) {
-          let input = rawPart.input;
-
-          // Ensure input is an object
-          if (typeof input === 'string') {
-            try {
-              input = JSON.parse(input);
-            } catch {
-              input = {};
-            }
+        let input = rawPart.input;
+        if (typeof input === 'string') {
+          try {
+            input = JSON.parse(input);
+          } catch {
+            input = {};
           }
+        }
+        const corrected: AnthropicServerToolUseBlockParam = {
+          type: 'server_tool_use',
+          id: rawPart.id as string,
+          name: (rawPart.name ?? 'web_search') as 'web_search',
+          input: (input ?? {}) as Record<string, unknown>,
+        };
+        return corrected;
+      }
 
-          const corrected: AnthropicServerToolUseBlockParam = {
-            type: 'server_tool_use',
-            id,
-            name: 'web_search',
-            input: input as Record<string, unknown>,
+      /**
+       * Normalize web_search_tool_result blocks into a clean shape.
+       * Same rationale as above — the block may carry extra properties from
+       * streaming (input, index, etc.) that the API rejects. Rebuild cleanly.
+       */
+      if (
+        'tool_use_id' in contentPart &&
+        typeof (contentPart as Record<string, unknown>).tool_use_id ===
+          'string' &&
+        (
+          (contentPart as Record<string, unknown>).tool_use_id as string
+        ).startsWith(Constants.ANTHROPIC_SERVER_TOOL_PREFIX) &&
+        'content' in contentPart
+      ) {
+        const rawPart = contentPart as Record<string, unknown>;
+        const content = rawPart.content;
+        const isValidContent =
+          Array.isArray(content) ||
+          (content != null &&
+            typeof content === 'object' &&
+            'type' in content &&
+            (content as Record<string, unknown>).type ===
+              'web_search_tool_result_error');
+
+        if (isValidContent) {
+          const corrected: AnthropicWebSearchToolResultBlockParam = {
+            type: 'web_search_tool_result',
+            tool_use_id: rawPart.tool_use_id as string,
+            content:
+              content as AnthropicWebSearchToolResultBlockParam['content'],
           };
-
           return corrected;
         }
-
-        // If it's not a server tool, skip it (return null to filter it out)
         return null;
       }
 
       /**
-       * Handle malformed web_search_tool_result blocks marked as text.
-       * These have tool_use_id and nested content - fix their type instead of filtering.
-       * Only correct if we can confirm it's a web search result by checking the tool_use_id prefix.
-       *
-       * Handles both success results (array content) and error results (object with error_code).
+       * Skip non-server malformed blocks that have tool fields mixed with text type.
        */
+      if (
+        'id' in contentPart &&
+        'name' in contentPart &&
+        'input' in contentPart &&
+        contentPart.type === 'text'
+      ) {
+        return null;
+      }
       if (
         'tool_use_id' in contentPart &&
         'content' in contentPart &&
         contentPart.type === 'text'
       ) {
-        const rawPart = contentPart as Record<string, unknown>;
-        const toolUseId = rawPart.tool_use_id as string;
-        const content = rawPart.content;
-
-        if (
-          toolUseId &&
-          toolUseId.startsWith(Constants.ANTHROPIC_SERVER_TOOL_PREFIX)
-        ) {
-          // Verify content is either an array (success) or error object
-          const isValidContent =
-            Array.isArray(content) ||
-            (content != null &&
-              typeof content === 'object' &&
-              'type' in content &&
-              (content as Record<string, unknown>).type ===
-                'web_search_tool_result_error');
-
-          if (isValidContent) {
-            const corrected: AnthropicWebSearchToolResultBlockParam = {
-              type: 'web_search_tool_result',
-              tool_use_id: toolUseId,
-              content:
-                content as AnthropicWebSearchToolResultBlockParam['content'],
-            };
-            return corrected;
-          }
-        }
-
-        // If it's not a recognized server tool result format, skip it (return null to filter it out)
         return null;
       }
 
@@ -540,6 +545,15 @@ function _formatContent(message: BaseMessage) {
           contentPartCopy.type = 'tool_use';
         }
 
+        if (
+          contentPartCopy.type === 'tool_use' &&
+          'id' in contentPartCopy &&
+          typeof contentPartCopy.id === 'string' &&
+          contentPartCopy.id.startsWith(Constants.ANTHROPIC_SERVER_TOOL_PREFIX)
+        ) {
+          contentPartCopy.type = 'server_tool_use';
+        }
+
         if ('input' in contentPartCopy) {
           // Anthropic tool use inputs should be valid objects, when applicable.
           if (typeof contentPartCopy.input === 'string') {
@@ -594,7 +608,11 @@ function _formatContent(message: BaseMessage) {
         throw new Error('Unsupported message content format');
       }
     });
-    return contentBlocks.filter((block) => block !== null);
+    return contentBlocks.filter(
+      (block) =>
+        block !== null &&
+        !(block.type === 'text' && 'text' in block && block.text === '')
+    );
   }
 }
 
@@ -631,19 +649,26 @@ export function _convertMessagesToAnthropicPayload(
     }
     if (isAIMessage(message) && !!message.tool_calls?.length) {
       if (typeof message.content === 'string') {
+        const clientToolCalls = message.tool_calls.filter(
+          (tc) =>
+            !(
+              tc.id?.startsWith(Constants.ANTHROPIC_SERVER_TOOL_PREFIX) ?? false
+            )
+        );
         if (message.content === '') {
           return {
             role,
-            content: message.tool_calls.map(
-              _convertLangChainToolCallToAnthropic
-            ),
+            content:
+              clientToolCalls.length > 0
+                ? clientToolCalls.map(_convertLangChainToolCallToAnthropic)
+                : [{ type: 'text' as const, text: ' ' }],
           };
         } else {
           return {
             role,
             content: [
-              { type: 'text', text: message.content },
-              ...message.tool_calls.map(_convertLangChainToolCallToAnthropic),
+              { type: 'text' as const, text: message.content },
+              ...clientToolCalls.map(_convertLangChainToolCallToAnthropic),
             ],
           };
         }

package/src/llm/anthropic/utils/server-tool-inputs.test.ts

@@ -0,0 +1,349 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { AIMessage, HumanMessage, ToolMessage } from '@langchain/core/messages';
+import type { BaseMessage } from '@langchain/core/messages';
+import { _convertMessagesToAnthropicPayload } from './message_inputs';
+
+describe('_convertMessagesToAnthropicPayload — server tool use (web search) multi-turn', () => {
+  it('corrects tool_use blocks with srvtoolu_ IDs to server_tool_use', () => {
+    const messageHistory: BaseMessage[] = [
+      new HumanMessage('search for X and Y'),
+      new AIMessage({
+        content: [
+          { type: 'text', text: 'I will search for that.' },
+          {
+            type: 'tool_use',
+            id: 'srvtoolu_1',
+            name: 'web_search',
+            input: { query: 'X' },
+          },
+          {
+            type: 'web_search_tool_result',
+            tool_use_id: 'srvtoolu_1',
+            content: [
+              {
+                type: 'web_search_result',
+                url: 'https://example.com',
+                title: 'Result',
+                encrypted_content: 'abc',
+                page_age: '1d',
+              },
+            ],
+          },
+          {
+            type: 'tool_use',
+            id: 'srvtoolu_2',
+            name: 'web_search',
+            input: { query: 'Y' },
+          },
+          {
+            type: 'web_search_tool_result',
+            tool_use_id: 'srvtoolu_2',
+            content: [
+              {
+                type: 'web_search_result',
+                url: 'https://example2.com',
+                title: 'Result 2',
+                encrypted_content: 'def',
+                page_age: '2d',
+              },
+            ],
+          },
+          { type: 'text', text: 'Here are the results.' },
+        ],
+        tool_calls: [
+          {
+            id: 'srvtoolu_1',
+            name: 'web_search',
+            args: { query: 'X' },
+            type: 'tool_call',
+          },
+          {
+            id: 'srvtoolu_2',
+            name: 'web_search',
+            args: { query: 'Y' },
+            type: 'tool_call',
+          },
+        ],
+      }),
+      new HumanMessage('follow up question'),
+    ];
+
+    const { messages } = _convertMessagesToAnthropicPayload(messageHistory);
+    expect(messages).toHaveLength(3);
+
+    const assistantContent = messages[1].content as any[];
+    const serverToolBlocks = assistantContent.filter(
+      (b: any) => b.type === 'server_tool_use'
+    );
+    const searchResultBlocks = assistantContent.filter(
+      (b: any) => b.type === 'web_search_tool_result'
+    );
+    const regularToolUseBlocks = assistantContent.filter(
+      (b: any) => b.type === 'tool_use' && b.id?.startsWith('srvtoolu_')
+    );
+
+    expect(serverToolBlocks).toHaveLength(2);
+    expect(searchResultBlocks).toHaveLength(2);
+    expect(regularToolUseBlocks).toHaveLength(0);
+
+    // Verify blocks are clean (no extra streaming properties)
+    for (const b of serverToolBlocks) {
+      expect(Object.keys(b).sort()).toEqual(
+        ['id', 'input', 'name', 'type'].sort()
+      );
+    }
+    for (const b of searchResultBlocks) {
+      expect(Object.keys(b).sort()).toEqual(
+        ['content', 'tool_use_id', 'type'].sort()
+      );
+    }
+  });
+
+  it('corrects text-typed server tool blocks back to correct types', () => {
+    const messageHistory: BaseMessage[] = [
+      new HumanMessage('search for X'),
+      new AIMessage({
+        content: [
+          {
+            type: 'text',
+            id: 'srvtoolu_1',
+            name: 'web_search',
+            input: '{"query":"X"}',
+          },
+          {
+            type: 'text',
+            tool_use_id: 'srvtoolu_1',
+            content: [
+              {
+                type: 'web_search_result',
+                url: 'https://example.com',
+                title: 'Result',
+                encrypted_content: 'abc',
+                page_age: '1d',
+              },
+            ],
+          },
+          { type: 'text', text: 'Found results.' },
+        ],
+        tool_calls: [
+          {
+            id: 'srvtoolu_1',
+            name: 'web_search',
+            args: { query: 'X' },
+            type: 'tool_call',
+          },
+        ],
+      }),
+      new HumanMessage('follow up'),
+    ];
+
+    const { messages } = _convertMessagesToAnthropicPayload(messageHistory);
+    const assistantContent = messages[1].content as any[];
+
+    expect(assistantContent[0]).toEqual({
+      type: 'server_tool_use',
+      id: 'srvtoolu_1',
+      name: 'web_search',
+      input: { query: 'X' },
+    });
+    expect(assistantContent[1].type).toBe('web_search_tool_result');
+    expect(assistantContent[1].tool_use_id).toBe('srvtoolu_1');
+    expect(assistantContent[2]).toEqual({
+      type: 'text',
+      text: 'Found results.',
+    });
+  });
+
+  it('filters server tool calls when content is a string', () => {
+    const messageHistory: BaseMessage[] = [
+      new HumanMessage('search for X'),
+      new AIMessage({
+        content: 'I searched and found results.',
+        tool_calls: [
+          {
+            id: 'srvtoolu_1',
+            name: 'web_search',
+            args: { query: 'X' },
+            type: 'tool_call',
+          },
+          {
+            id: 'toolu_regular',
+            name: 'calculator',
+            args: { expr: '2+2' },
+            type: 'tool_call',
+          },
+        ],
+      }),
+      new ToolMessage({
+        content: '4',
+        tool_call_id: 'toolu_regular',
+      }),
+      new HumanMessage('follow up'),
+    ];
+
+    const { messages } = _convertMessagesToAnthropicPayload(messageHistory);
+    const assistantContent = messages[1].content as any[];
+
+    const toolUseBlocks = assistantContent.filter(
+      (b: any) => b.type === 'tool_use'
+    );
+    expect(toolUseBlocks).toHaveLength(1);
+    expect(toolUseBlocks[0].id).toBe('toolu_regular');
+
+    const serverToolBlocks = assistantContent.filter((b: any) =>
+      b.id?.startsWith('srvtoolu_')
+    );
+    expect(serverToolBlocks).toHaveLength(0);
+  });
+
+  it('handles empty string content with only server tool calls', () => {
+    const messageHistory: BaseMessage[] = [
+      new HumanMessage('search for X'),
+      new AIMessage({
+        content: '',
+        tool_calls: [
+          {
+            id: 'srvtoolu_1',
+            name: 'web_search',
+            args: { query: 'X' },
+            type: 'tool_call',
+          },
+        ],
+      }),
+      new HumanMessage('follow up'),
+    ];
+
+    const { messages } = _convertMessagesToAnthropicPayload(messageHistory);
+    const assistantContent = messages[1].content as any[];
+    expect(assistantContent).toHaveLength(1);
+    expect(assistantContent[0].type).toBe('text');
+    expect(assistantContent[0].text).toBe(' ');
+  });
+
+  it('preserves regular tool_use blocks alongside corrected server tool blocks', () => {
+    const messageHistory: BaseMessage[] = [
+      new HumanMessage('search for X and calculate 2+2'),
+      new AIMessage({
+        content: [
+          { type: 'text', text: 'Let me help.' },
+          {
+            type: 'tool_use',
+            id: 'srvtoolu_1',
+            name: 'web_search',
+            input: { query: 'X' },
+          },
+          {
+            type: 'web_search_tool_result',
+            tool_use_id: 'srvtoolu_1',
+            content: [
+              {
+                type: 'web_search_result',
+                url: 'https://example.com',
+                title: 'Result',
+                encrypted_content: 'abc',
+                page_age: '1d',
+              },
+            ],
+          },
+          {
+            type: 'tool_use',
+            id: 'toolu_calc',
+            name: 'calculator',
+            input: { expr: '2+2' },
+          },
+        ],
+        tool_calls: [
+          {
+            id: 'srvtoolu_1',
+            name: 'web_search',
+            args: { query: 'X' },
+            type: 'tool_call',
+          },
+          {
+            id: 'toolu_calc',
+            name: 'calculator',
+            args: { expr: '2+2' },
+            type: 'tool_call',
+          },
+        ],
+      }),
+      new ToolMessage({
+        content: '4',
+        tool_call_id: 'toolu_calc',
+      }),
+      new HumanMessage('follow up'),
+    ];
+
+    const { messages } = _convertMessagesToAnthropicPayload(messageHistory);
+    const assistantContent = messages[1].content as any[];
+
+    const serverToolUse = assistantContent.filter(
+      (b: any) => b.type === 'server_tool_use'
+    );
+    const webSearchResult = assistantContent.filter(
+      (b: any) => b.type === 'web_search_tool_result'
+    );
+    const regularToolUse = assistantContent.filter(
+      (b: any) => b.type === 'tool_use' && !b.id?.startsWith('srvtoolu_')
+    );
+
+    expect(serverToolUse).toHaveLength(1);
+    expect(serverToolUse[0].id).toBe('srvtoolu_1');
+    expect(webSearchResult).toHaveLength(1);
+    expect(regularToolUse).toHaveLength(1);
+    expect(regularToolUse[0].id).toBe('toolu_calc');
+  });
+
+  it('filters out empty text blocks from array content', () => {
+    const messageHistory: BaseMessage[] = [
+      new HumanMessage('search for X'),
+      new AIMessage({
+        content: [
+          { type: 'text', text: '' },
+          {
+            type: 'server_tool_use',
+            id: 'srvtoolu_1',
+            name: 'web_search',
+            input: { query: 'X' },
+          },
+          {
+            type: 'web_search_tool_result',
+            tool_use_id: 'srvtoolu_1',
+            content: [
+              {
+                type: 'web_search_result',
+                url: 'https://example.com',
+                title: 'Result',
+                encrypted_content: 'abc',
+                page_age: '1d',
+              },
+            ],
+          },
+          { type: 'text', text: '' },
+          { type: 'text', text: 'Here are the results.' },
+        ],
+        tool_calls: [
+          {
+            id: 'srvtoolu_1',
+            name: 'web_search',
+            args: { query: 'X' },
+            type: 'tool_call',
+          },
+        ],
+      }),
+      new HumanMessage('follow up'),
+    ];
+
+    const { messages } = _convertMessagesToAnthropicPayload(messageHistory);
+    const assistantContent = messages[1].content as any[];
+
+    const emptyTextBlocks = assistantContent.filter(
+      (b: any) => b.type === 'text' && b.text === ''
+    );
+    expect(emptyTextBlocks).toHaveLength(0);
+
+    const textBlocks = assistantContent.filter((b: any) => b.type === 'text');
+    expect(textBlocks).toHaveLength(1);
+    expect(textBlocks[0].text).toBe('Here are the results.');
+  });
+});

package/src/messages/core.ts

@@ -41,7 +41,14 @@ User: ${userMessage[1]}
 const _allowedTypes = ['image_url', 'text', 'tool_use', 'tool_result'];
 const allowedTypesByProvider: Record<string, string[]> = {
   default: _allowedTypes,
-  [Providers.ANTHROPIC]: [..._allowedTypes, 'thinking', 'redacted_thinking'],
+  [Providers.ANTHROPIC]: [
+    ..._allowedTypes,
+    'thinking',
+    'redacted_thinking',
+    'server_tool_use',
+    'web_search_tool_result',
+    'web_search_result',
+  ],
   [Providers.BEDROCK]: [..._allowedTypes, 'reasoning_content'],
   [Providers.OPENAI]: _allowedTypes,
 };