@librechat/agents 3.0.27 → 3.0.29

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

@@ -363,6 +363,78 @@ function _formatContent(message: BaseMessage) {
     return content;
   } 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.
+       */
+      if (
+        'id' in contentPart &&
+        'name' in contentPart &&
+        'input' in contentPart &&
+        contentPart.type === 'text'
+      ) {
+        const rawPart = contentPart as Record<string, unknown>;
+        const id = rawPart.id as string;
+
+        // Only correct if this is definitely a server tool (ID starts with 'srvtoolu_')
+        if (id && id.startsWith('srvtoolu_')) {
+          let input = rawPart.input;
+
+          // Ensure input is an object
+          if (typeof input === 'string') {
+            try {
+              input = JSON.parse(input);
+            } catch {
+              input = {};
+            }
+          }
+
+          const corrected: AnthropicServerToolUseBlockParam = {
+            type: 'server_tool_use',
+            id,
+            name: 'web_search',
+            input: input as Record<string, unknown>,
+          };
+
+          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 arrays - 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.
+       */
+      if (
+        'tool_use_id' in contentPart &&
+        'content' in contentPart &&
+        Array.isArray(contentPart.content) &&
+        contentPart.type === 'text'
+      ) {
+        const rawPart = contentPart as Record<string, unknown>;
+        const toolUseId = rawPart.tool_use_id as string;
+
+        // Only correct if this is definitely a server tool result (tool_use_id starts with 'srvtoolu_')
+        if (toolUseId && toolUseId.startsWith('srvtoolu_')) {
+          const corrected: AnthropicWebSearchToolResultBlockParam = {
+            type: 'web_search_tool_result',
+            tool_use_id: toolUseId,
+            content:
+              rawPart.content as AnthropicWebSearchToolResultBlockParam['content'],
+          };
+
+          return corrected;
+        }
+
+        // If it's not a server tool result, skip it (return null to filter it out)
+        return null;
+      }
+
       if (isDataContentBlock(contentPart)) {
         return convertToProviderContentBlock(
           contentPart,
@@ -459,6 +531,14 @@ function _formatContent(message: BaseMessage) {
           }
         }
 
+        /**
+         * For multi-turn conversations with citations, we must preserve ALL blocks
+         * including server_tool_use, web_search_tool_result, and web_search_result.
+         * Citations reference search results by index, so filtering changes indices and breaks references.
+         *
+         * The ToolNode already handles skipping server tool invocations via the srvtoolu_ prefix check.
+         */
+
         // TODO: Fix when SDK types are fixed
         return {
           ...contentPartCopy,
@@ -487,10 +567,14 @@ function _formatContent(message: BaseMessage) {
           input: contentPart.functionCall.args,
         };
       } else {
+        console.error(
+          'Unsupported content part:',
+          JSON.stringify(contentPart, null, 2)
+        );
         throw new Error('Unsupported message content format');
       }
     });
-    return contentBlocks;
+    return contentBlocks.filter((block) => block !== null);
   }
 }
 
@@ -545,14 +629,15 @@ export function _convertMessagesToAnthropicPayload(
         }
       } else {
         const { content } = message;
-        const hasMismatchedToolCalls = !message.tool_calls.every((toolCall) =>
-          content.find(
-            (contentPart) =>
-              (contentPart.type === 'tool_use' ||
-                contentPart.type === 'input_json_delta' ||
-                contentPart.type === 'server_tool_use') &&
-              contentPart.id === toolCall.id
-          )
+        const hasMismatchedToolCalls = !message.tool_calls.every(
+          (toolCall) =>
+            !!content.find(
+              (contentPart) =>
+                (contentPart.type === 'tool_use' ||
+                  contentPart.type === 'input_json_delta' ||
+                  contentPart.type === 'server_tool_use') &&
+                contentPart.id === toolCall.id
+            )
         );
         if (hasMismatchedToolCalls) {
           console.warn(

package/src/scripts/ant_web_search_edge_case.ts

@@ -0,0 +1,162 @@
+/* eslint-disable no-console */
+// 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 { Calculator } from '@/tools/Calculator';
+
+import { getArgs } from '@/scripts/args';
+import { Run } from '@/run';
+import { GraphEvents, Callback, Providers } from '@/common';
+import { getLLMConfig } from '@/utils/llmConfig';
+
+const conversationHistory: BaseMessage[] = [];
+let _contentParts: (t.MessageContentComplex | undefined)[] = [];
+async function testStandardStreaming(): Promise<void> {
+  const { userName, location, currentDate } = await getArgs();
+  const { contentParts, aggregateContent } = createContentAggregator();
+  _contentParts = contentParts;
+  const customHandlers = {
+    [GraphEvents.TOOL_END]: new ToolEndHandler(),
+    [GraphEvents.CHAT_MODEL_END]: new ModelEndHandler(),
+    [GraphEvents.CHAT_MODEL_STREAM]: new ChatModelStreamHandler(),
+    [GraphEvents.ON_RUN_STEP_COMPLETED]: {
+      handle: (
+        event: GraphEvents.ON_RUN_STEP_COMPLETED,
+        data: t.StreamEventData
+      ): void => {
+        console.log('====== ON_RUN_STEP_COMPLETED ======');
+        // console.dir(data, { depth: null });
+        aggregateContent({
+          event,
+          data: data as unknown as { result: t.ToolEndEvent },
+        });
+      },
+    },
+    [GraphEvents.ON_RUN_STEP]: {
+      handle: (
+        event: GraphEvents.ON_RUN_STEP,
+        data: t.StreamEventData
+      ): void => {
+        console.log('====== ON_RUN_STEP ======');
+        console.dir(data, { depth: null });
+        aggregateContent({ event, data: data as t.RunStep });
+      },
+    },
+    [GraphEvents.ON_RUN_STEP_DELTA]: {
+      handle: (
+        event: GraphEvents.ON_RUN_STEP_DELTA,
+        data: t.StreamEventData
+      ): void => {
+        console.log('====== ON_RUN_STEP_DELTA ======');
+        console.dir(data, { depth: null });
+        aggregateContent({ event, data: data as t.RunStepDeltaEvent });
+      },
+    },
+    [GraphEvents.ON_MESSAGE_DELTA]: {
+      handle: (
+        event: GraphEvents.ON_MESSAGE_DELTA,
+        data: t.StreamEventData
+      ): void => {
+        // console.log('====== ON_MESSAGE_DELTA ======');
+        // console.dir(data, { depth: null });
+        aggregateContent({ event, data: data as t.MessageDeltaEvent });
+      },
+    },
+    [GraphEvents.TOOL_START]: {
+      handle: (
+        _event: string,
+        data: t.StreamEventData,
+        metadata?: Record<string, unknown>
+      ): void => {
+        console.log('====== TOOL_START ======');
+        // console.dir(data, { depth: null });
+      },
+    },
+  };
+
+  const llmConfig = getLLMConfig(
+    Providers.ANTHROPIC
+  ) as t.AnthropicClientOptions & t.SharedLLMConfig;
+  llmConfig.model = 'claude-haiku-4-5';
+
+  const run = await Run.create<t.IState>({
+    runId: 'test-run-id',
+    graphConfig: {
+      type: 'standard',
+      llmConfig,
+      tools: [
+        {
+          type: 'web_search_20250305',
+          name: 'web_search',
+          max_uses: 5,
+        },
+        new Calculator(),
+      ],
+      instructions: 'You are a friendly AI assistant.',
+      // additional_instructions: `Always address the user by their name. The user's name is ${userName} and they are located in ${location}.`,
+    },
+    returnContent: true,
+    customHandlers,
+  });
+
+  const config = {
+    configurable: {
+      provider: Providers.ANTHROPIC,
+      thread_id: 'conversation-num-1',
+    },
+    streamMode: 'values',
+    version: 'v2' as const,
+  };
+
+  console.log('Test 1: Web search + calculator (simultaneous tool test)');
+
+  // const userMessage = `
+  // Make a search for the weather in ${location} today, which is ${currentDate}.
+  // Before making the search, please let me know what you're about to do, then immediately start searching without hesitation.
+  // 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 = 'Are massage guns good?';
+  // const userMessage = 'What is functional programming?';
+  // const userMessage = "Get me today's trending news.";
+  // const userMessage = "search recent italy earthquake volcano activity";
+  // const userMessage =
+  //   "use 'Trump' as the exact search query and tell me what you find.";
+  const userMessage =
+    'Can you search the web for the current population of Tokyo, and also calculate what 15% of that population would be? Do both at the same time.';
+
+  conversationHistory.push(new HumanMessage(userMessage));
+
+  const inputs = {
+    messages: conversationHistory,
+  };
+  const finalContentParts = await run.processStream(inputs, config);
+  const finalMessages = run.getRunMessages();
+  if (finalMessages) {
+    conversationHistory.push(...finalMessages);
+    console.dir(conversationHistory, { depth: null });
+  }
+  // console.dir(finalContentParts, { depth: null });
+  console.log('\n\n====================\n\n');
+  // console.dir(contentParts, { depth: null });
+}
+
+process.on('unhandledRejection', (reason, promise) => {
+  console.error('Unhandled Rejection at:', promise, 'reason:', reason);
+  console.log('Content Parts:');
+  console.dir(_contentParts, { depth: null });
+  process.exit(1);
+});
+
+testStandardStreaming().catch((err) => {
+  console.error(err);
+  console.log('Conversation history:');
+  console.dir(conversationHistory, { depth: null });
+  console.log('Content Parts:');
+  console.dir(_contentParts, { depth: null });
+  process.exit(1);
+});

package/src/specs/anthropic.simple.test.ts

@@ -306,6 +306,73 @@ describe(`${capitalizeFirstLetter(provider)} Streaming Tests`, () => {
     expect(onRunStepSpy.mock.calls.length).toBeGreaterThan(0);
   });
 
+  test(`${capitalizeFirstLetter(provider)}: should handle parallel tool usage (web search + calculator)`, async () => {
+    const llmConfig = getLLMConfig(provider);
+    const customHandlers = setupCustomHandlers();
+
+    run = await Run.create<t.IState>({
+      runId: 'test-parallel-tools',
+      graphConfig: {
+        type: 'standard',
+        llmConfig,
+        tools: [
+          {
+            type: 'web_search_20250305',
+            name: 'web_search',
+            max_uses: 5,
+          },
+          new Calculator(),
+        ],
+        instructions: 'You are a helpful AI assistant.',
+      },
+      returnContent: true,
+      customHandlers,
+    });
+
+    // Use the same query as the edge case script to test actual parallel tool usage
+    const userMessage =
+      'Can you search the web for the current population of Tokyo, and also calculate what 15% of that population would be? Do both at the same time.';
+    conversationHistory = [];
+    conversationHistory.push(new HumanMessage(userMessage));
+
+    const inputs = {
+      messages: conversationHistory,
+    };
+
+    // This should complete without errors despite using both server tools and regular tools in parallel
+    const finalContentParts = await run.processStream(inputs, config);
+    expect(finalContentParts).toBeDefined();
+
+    const finalMessages = run.getRunMessages();
+    expect(finalMessages).toBeDefined();
+    expect(finalMessages?.length).toBeGreaterThan(0);
+
+    const hasWebSearch = contentParts.some(
+      (part) =>
+        !!(
+          part.type === 'tool_call' &&
+          part.tool_call?.name === 'web_search' &&
+          part.tool_call?.id?.startsWith('srvtoolu_') === true
+        )
+    );
+    const hasCalculator = contentParts.some(
+      (part) =>
+        !!(
+          part.type === 'tool_call' &&
+          part.tool_call?.name === 'calculator' &&
+          part.tool_call?.id?.startsWith('toolu_') === true
+        )
+    );
+
+    // Both tools should have been used for this query
+    expect(hasWebSearch).toBe(true);
+    expect(hasCalculator).toBe(true);
+
+    console.log(
+      `${capitalizeFirstLetter(provider)} parallel tools test: web_search (server tool) + calculator (regular tool) both used successfully`
+    );
+  });
+
   test('should handle errors appropriately', async () => {
     // Test error scenarios
     await expect(async () => {

package/src/stream.ts

@@ -155,7 +155,10 @@ export class ChatModelStreamHandler implements t.EventHandler {
       chunk.tool_calls.length > 0 &&
       chunk.tool_calls.every(
         (tc) =>
-          tc.id != null && tc.id !== '' && tc.name != null && tc.name !== ''
+          tc.id != null &&
+          tc.id !== '' &&
+          (tc as Partial<ToolCall>).name != null &&
+          tc.name !== ''
       )
     ) {
       hasToolCalls = true;

package/src/tools/ToolNode.ts

@@ -201,7 +201,18 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
 
       outputs = await Promise.all(
         aiMessage.tool_calls
-          ?.filter((call) => call.id == null || !toolMessageIds.has(call.id))
+          ?.filter((call) => {
+            /**
+             * Filter out:
+             * 1. Already processed tool calls (present in toolMessageIds)
+             * 2. Server tool calls (e.g., web_search with IDs starting with 'srvtoolu_')
+             *    which are executed by the provider's API and don't require invocation
+             */
+            return (
+              (call.id == null || !toolMessageIds.has(call.id)) &&
+              !(call.id?.startsWith('srvtoolu_') ?? false)
+            );
+          })
           .map((call) => this.runTool(call, config)) ?? []
       );
     }