@librechat/agents 2.4.52 → 2.4.54

package/src/llm/anthropic/types.ts

@@ -49,6 +49,8 @@ export type AnthropicWebSearchToolResultBlockParam =
   Anthropic.Messages.WebSearchToolResultBlockParam;
 export type AnthropicWebSearchResultBlockParam =
   Anthropic.Messages.WebSearchResultBlockParam;
+export type AnthropicSearchResultBlockParam =
+  Anthropic.Beta.BetaSearchResultBlockParam;
 
 // Union of all possible content block types including server tool use
 export type AnthropicContentBlock =
@@ -63,6 +65,20 @@ export type AnthropicContentBlock =
   | AnthropicWebSearchToolResultBlockParam
   | AnthropicWebSearchResultBlockParam;
 
+// Union of all possible content block types including server tool use
+export type ChatAnthropicContentBlock =
+  | AnthropicTextBlockParam
+  | AnthropicImageBlockParam
+  | AnthropicToolUseBlockParam
+  | AnthropicToolResultBlockParam
+  | AnthropicDocumentBlockParam
+  | AnthropicThinkingBlockParam
+  | AnthropicRedactedThinkingBlockParam
+  | AnthropicServerToolUseBlockParam
+  | AnthropicWebSearchToolResultBlockParam
+  | AnthropicWebSearchResultBlockParam
+  | AnthropicSearchResultBlockParam;
+
 export function isAnthropicImageBlockParam(
   block: unknown
 ): block is AnthropicImageBlockParam {

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

@@ -25,7 +25,6 @@ import {
   AnthropicImageBlockParam,
   AnthropicMessageCreateParams,
   AnthropicTextBlockParam,
-  AnthropicToolResponse,
   AnthropicToolResultBlockParam,
   AnthropicToolUseBlockParam,
   AnthropicDocumentBlockParam,
@@ -34,7 +33,9 @@ import {
   AnthropicServerToolUseBlockParam,
   AnthropicWebSearchToolResultBlockParam,
   isAnthropicImageBlockParam,
-} from '@/llm/anthropic/types';
+  AnthropicSearchResultBlockParam,
+  AnthropicToolResponse,
+} from '../types';
 
 function _formatImage(imageUrl: string) {
   const parsed = parseBase64DataUrl({ dataUrl: imageUrl });
@@ -407,6 +408,20 @@ function _formatContent(content: MessageContent) {
           ...(cacheControl ? { cache_control: cacheControl } : {}),
         };
         return block;
+      } else if (contentPart.type === 'search_result') {
+        const block: AnthropicSearchResultBlockParam = {
+          type: 'search_result' as const, // Explicitly setting the type as "search_result"
+          title: contentPart.title,
+          source: contentPart.source,
+          ...('cache_control' in contentPart && contentPart.cache_control
+            ? { cache_control: contentPart.cache_control }
+            : {}),
+          ...('citations' in contentPart && contentPart.citations
+            ? { citations: contentPart.citations }
+            : {}),
+          content: contentPart.content,
+        };
+        return block;
       } else if (
         textTypes.find((t) => t === contentPart.type) &&
         'text' in contentPart

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

@@ -4,17 +4,17 @@ import {
   BaseLLMOutputParser,
   OutputParserException,
 } from '@langchain/core/output_parsers';
-import { JsonOutputKeyToolsParserParams } from '@langchain/core/output_parsers/openai_tools';
+import { JsonOutputKeyToolsParserParamsInterop } from '@langchain/core/output_parsers/openai_tools';
+import { ChatGeneration } from '@langchain/core/outputs';
+import { ToolCall } from '@langchain/core/messages/tool';
 import {
   interopSafeParseAsync,
   InteropZodType,
 } from '@langchain/core/utils/types';
-import { ChatGeneration } from '@langchain/core/outputs';
-import { ToolCall } from '@langchain/core/messages/tool';
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 interface AnthropicToolsOutputParserParams<T extends Record<string, any>>
-  extends JsonOutputKeyToolsParserParams<T> {}
+  extends JsonOutputKeyToolsParserParamsInterop<T> {}
 
 export class AnthropicToolsOutputParser<
   // eslint-disable-next-line @typescript-eslint/no-explicit-any

package/src/scripts/ant_web_search.ts

@@ -0,0 +1,158 @@
+/* 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 { 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-3-5-sonnet-latest';
+
+  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,
+        },
+      ],
+      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: Search query (search 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.";
+
+  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/stream.ts

@@ -1,17 +1,21 @@
 // src/stream.ts
+import type { ChatOpenAIReasoningSummary } from '@langchain/openai';
 import type { AIMessageChunk } from '@langchain/core/messages';
 import type { ToolCall } from '@langchain/core/messages/tool';
 import type { Graph } from '@/graphs';
-import type { ChatOpenAIReasoningSummary } from '@langchain/openai';
 import type * as t from '@/types';
 import {
-  StepTypes,
+  ToolCallTypes,
   ContentTypes,
   GraphEvents,
-  ToolCallTypes,
+  StepTypes,
   Providers,
 } from '@/common';
-import { handleToolCalls, handleToolCallChunks } from '@/tools/handlers';
+import {
+  handleServerToolResult,
+  handleToolCallChunks,
+  handleToolCalls,
+} from '@/tools/handlers';
 import { getMessageId } from '@/messages';
 
 /**
@@ -132,8 +136,15 @@ export class ChatModelStreamHandler implements t.EventHandler {
       reasoningKey: graph.reasoningKey,
       provider: metadata?.provider as Providers,
     });
+    const skipHandling = handleServerToolResult({
+      content,
+      metadata,
+      graph,
+    });
+    if (skipHandling) {
+      return;
+    }
     this.handleReasoning(chunk, graph, metadata?.provider as Providers);
-
     let hasToolCalls = false;
     if (
       chunk.tool_calls &&

package/src/tools/ToolNode.ts

@@ -138,16 +138,30 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
   }
 }
 
+function areToolCallsInvoked(
+  message: AIMessage,
+  invokedToolIds?: Set<string>
+): boolean {
+  if (!invokedToolIds || invokedToolIds.size === 0) return false;
+  return (
+    message.tool_calls?.every(
+      (toolCall) => toolCall.id != null && invokedToolIds.has(toolCall.id)
+    ) ?? false
+  );
+}
+
 export function toolsCondition(
-  state: BaseMessage[] | typeof MessagesAnnotation.State
+  state: BaseMessage[] | typeof MessagesAnnotation.State,
+  invokedToolIds?: Set<string>
 ): 'tools' | typeof END {
-  const message = Array.isArray(state)
+  const message: AIMessage = Array.isArray(state)
     ? state[state.length - 1]
     : state.messages[state.messages.length - 1];
 
   if (
     'tool_calls' in message &&
-    ((message as AIMessage).tool_calls?.length ?? 0) > 0
+    (message.tool_calls?.length ?? 0) > 0 &&
+    !areToolCallsInvoked(message, invokedToolIds)
   ) {
     return GraphNodeKeys.TOOLS;
   } else {

package/src/tools/handlers.ts

@@ -1,10 +1,24 @@
 /* eslint-disable no-console */
 // src/tools/handlers.ts
 import { nanoid } from 'nanoid';
+import { ToolMessage } from '@langchain/core/messages';
+import type { AnthropicWebSearchResultBlockParam } from '@/llm/anthropic/types';
 import type { ToolCall, ToolCallChunk } from '@langchain/core/messages/tool';
 import type { Graph } from '@/graphs';
 import type * as t from '@/types';
-import { StepTypes, ContentTypes, ToolCallTypes } from '@/common';
+import {
+  ToolCallTypes,
+  ContentTypes,
+  GraphEvents,
+  StepTypes,
+  Providers,
+  Constants,
+} from '@/common';
+import {
+  coerceAnthropicSearchResults,
+  isAnthropicWebSearchResult,
+} from '@/tools/search/anthropic';
+import { formatResultsForLLM } from '@/tools/search/format';
 import { getMessageId } from '@/messages';
 
 export function handleToolCallChunks({
@@ -165,3 +179,158 @@ export const handleToolCalls = (
     });
   }
 };
+
+export const toolResultTypes = new Set([
+  // 'tool_use',
+  // 'server_tool_use',
+  // 'input_json_delta',
+  'tool_result',
+  'web_search_result',
+  'web_search_tool_result',
+]);
+
+/**
+ * Handles the result of a server tool call; in other words, a provider's built-in tool.
+ * As of 2025-07-06, only Anthropic handles server tool calls with this pattern.
+ */
+export function handleServerToolResult({
+  content,
+  metadata,
+  graph,
+}: {
+  content?: string | t.MessageContentComplex[];
+  metadata?: Record<string, unknown>;
+  graph: Graph;
+}): boolean {
+  let skipHandling = false;
+  if (metadata?.provider !== Providers.ANTHROPIC) {
+    return skipHandling;
+  }
+  if (
+    typeof content === 'string' ||
+    content == null ||
+    content.length === 0 ||
+    (content.length === 1 &&
+      (content[0] as t.ToolResultContent).tool_use_id == null)
+  ) {
+    return skipHandling;
+  }
+
+  for (const contentPart of content) {
+    const toolUseId = (contentPart as t.ToolResultContent).tool_use_id;
+    if (toolUseId == null || toolUseId === '') {
+      continue;
+    }
+    const stepId = graph.toolCallStepIds.get(toolUseId);
+    if (stepId == null || stepId === '') {
+      console.warn(
+        `Tool use ID ${toolUseId} not found in graph, cannot dispatch tool result.`
+      );
+      continue;
+    }
+    const runStep = graph.getRunStep(stepId);
+    if (!runStep) {
+      console.warn(
+        `Run step for ${stepId} does not exist, cannot dispatch tool result.`
+      );
+      continue;
+    } else if (runStep.type !== StepTypes.TOOL_CALLS) {
+      console.warn(
+        `Run step for ${stepId} is not a tool call step, cannot dispatch tool result.`
+      );
+      continue;
+    }
+
+    const toolCall =
+      runStep.stepDetails.type === StepTypes.TOOL_CALLS
+        ? (runStep.stepDetails.tool_calls?.find(
+          (toolCall) => toolCall.id === toolUseId
+        ) as ToolCall)
+        : undefined;
+
+    if (!toolCall) {
+      continue;
+    }
+
+    if (
+      contentPart.type === 'web_search_result' ||
+      contentPart.type === 'web_search_tool_result'
+    ) {
+      handleAnthropicSearchResults({
+        contentPart: contentPart as t.ToolResultContent,
+        toolCall,
+        metadata,
+        graph,
+      });
+    }
+
+    if (!skipHandling) {
+      skipHandling = true;
+    }
+  }
+
+  return skipHandling;
+}
+
+function handleAnthropicSearchResults({
+  contentPart,
+  toolCall,
+  metadata,
+  graph,
+}: {
+  contentPart: t.ToolResultContent;
+  toolCall: ToolCall;
+  metadata?: Record<string, unknown>;
+  graph: Graph;
+}): void {
+  if (!Array.isArray(contentPart.content)) {
+    console.warn(
+      `Expected content to be an array, got ${typeof contentPart.content}`
+    );
+    return;
+  }
+
+  if (!isAnthropicWebSearchResult(contentPart.content[0])) {
+    console.warn(
+      `Expected content to be an Anthropic web search result, got ${JSON.stringify(
+        contentPart.content
+      )}`
+    );
+    return;
+  }
+
+  const turn = graph.invokedToolIds?.size ?? 0;
+  const searchResultData = coerceAnthropicSearchResults({
+    turn,
+    results: contentPart.content as AnthropicWebSearchResultBlockParam[],
+  });
+
+  const name = toolCall.name;
+  const input = toolCall.args;
+  const artifact = {
+    [Constants.WEB_SEARCH]: searchResultData,
+  };
+  const { output: formattedOutput } = formatResultsForLLM(
+    turn,
+    searchResultData
+  );
+  const output = new ToolMessage({
+    name,
+    artifact,
+    content: formattedOutput,
+    tool_call_id: toolCall.id!,
+  });
+  const toolEndData: t.ToolEndData = {
+    input,
+    output,
+  };
+  graph.handlerRegistry
+    ?.getHandler(GraphEvents.TOOL_END)
+    ?.handle(GraphEvents.TOOL_END, toolEndData, metadata, graph);
+
+  if (graph.invokedToolIds == null) {
+    graph.invokedToolIds = new Set<string>();
+  }
+
+  graph.invokedToolIds.add(toolCall.id!);
+}

package/src/tools/search/anthropic.ts

@@ -0,0 +1,51 @@
+import type {
+  AnthropicTextBlockParam,
+  AnthropicWebSearchResultBlockParam,
+} from '@/llm/anthropic/types';
+import type { SearchResultData, ProcessedOrganic } from './types';
+import { getAttribution } from './utils';
+
+/**
+ * Coerces Anthropic web search results to the SearchResultData format
+ * @param results - Array of Anthropic web search results
+ * @param turn - The turn number to associate with these results
+ * @returns SearchResultData with minimal ProcessedOrganic items
+ */
+export function coerceAnthropicSearchResults({
+  results,
+  turn = 0,
+}: {
+  results: (AnthropicTextBlockParam | AnthropicWebSearchResultBlockParam)[];
+  turn?: number;
+}): SearchResultData {
+  const organic: ProcessedOrganic[] = results
+    .filter((result) => result.type === 'web_search_result')
+    .map((result, index) => ({
+      link: result.url,
+      position: index + 1,
+      title: result.title,
+      date: result.page_age ?? undefined,
+      attribution: getAttribution(result.url),
+    }));
+
+  return {
+    turn,
+    organic,
+  };
+}
+
+/**
+ * Helper function to check if an object is an Anthropic web search result
+ */
+export function isAnthropicWebSearchResult(
+  obj: unknown
+): obj is AnthropicWebSearchResultBlockParam {
+  return (
+    typeof obj === 'object' &&
+    obj !== null &&
+    'type' in obj &&
+    obj.type === 'web_search_result' &&
+    'url' in obj &&
+    typeof (obj as Record<string, unknown>).url === 'string'
+  );
+}

package/src/tools/search/search.ts

@@ -233,6 +233,7 @@ const createSearXNGAPI = (
   const getSources = async ({
     query,
     numResults = 8,
+    safeSearch,
     type,
   }: t.GetSourcesParams): Promise<t.SearchResult> => {
     if (!query.trim()) {
@@ -267,7 +268,7 @@ const createSearXNGAPI = (
         pageno: 1,
         categories: category,
         language: 'all',
-        safesearch: 0,
+        safesearch: safeSearch,
         engines: 'google,bing,duckduckgo',
       };
 

package/src/types/llm.ts

@@ -91,9 +91,11 @@ export type ClientOptions =
   | DeepSeekClientOptions
   | XAIClientOptions;
 
-export type LLMConfig = {
+export type SharedLLMConfig = {
   provider: Providers;
-} & ClientOptions;
+};
+
+export type LLMConfig = SharedLLMConfig & ClientOptions;
 
 export type ProviderOptionsMap = {
   [Providers.AZURE]: AzureClientOptions;

package/src/types/stream.ts

@@ -8,6 +8,7 @@ import type {
 } from '@langchain/core/messages';
 import type { ToolCall, ToolCallChunk } from '@langchain/core/messages/tool';
 import type { LLMResult, Generation } from '@langchain/core/outputs';
+import type { AnthropicContentBlock } from '@/llm/anthropic/types';
 import type { ToolEndEvent } from '@/types/tools';
 import { StepTypes, ContentTypes, GraphEvents } from '@/common/enum';
 
@@ -299,7 +300,20 @@ export type ToolCallContent = {
   tool_call?: ToolCallPart;
 };
 
+export type ToolResultContent = {
+  content:
+    | string
+    | Record<string, unknown>
+    | Array<string | Record<string, unknown>>
+    | AnthropicContentBlock[];
+  type: 'tool_result' | 'web_search_result' | 'web_search_tool_result';
+  tool_use_id?: string;
+  input?: string | Record<string, unknown>;
+  index?: number;
+};
+
 export type MessageContentComplex = (
+  | ToolResultContent
   | ThinkingContentText
   | AgentUpdate
   | ToolCallContent