@librechat/agents 2.4.321 → 3.0.0-rc1

package/src/stream.test.ts

@@ -0,0 +1,94 @@
+import type { AIMessageChunk } from '@langchain/core/messages';
+import type { ChatOpenAIReasoningSummary } from '@langchain/openai';
+import { getChunkContent } from './stream';
+import { Providers } from '@/common';
+
+describe('getChunkContent', () => {
+  it('should handle reasoning content for OpenAI/Azure providers', () => {
+    const chunk: Partial<AIMessageChunk> = {
+      content: 'Regular content',
+      additional_kwargs: {
+        reasoning: {
+          summary: [{ text: 'Reasoning summary text' }],
+        } as Partial<ChatOpenAIReasoningSummary>,
+      },
+    };
+
+    const result = getChunkContent({
+      chunk,
+      provider: Providers.OPENAI,
+      reasoningKey: 'reasoning',
+    });
+
+    expect(result).toBe('Reasoning summary text');
+  });
+
+  it('should fallback to reasoningKey when no OpenAI reasoning summary', () => {
+    const chunk: Partial<AIMessageChunk> = {
+      content: 'Regular content',
+      additional_kwargs: {
+        reasoning_content: 'Reasoning from key',
+      },
+    };
+
+    const result = getChunkContent({
+      chunk,
+      reasoningKey: 'reasoning_content',
+    });
+
+    expect(result).toBe('Reasoning from key');
+  });
+
+  it('should fallback to chunk.content when reasoningKey value is null or undefined', () => {
+    const chunk: Partial<AIMessageChunk> = {
+      content: 'Fallback content',
+      additional_kwargs: {
+        reasoning_content: null,
+      },
+    };
+
+    const result = getChunkContent({
+      chunk,
+      reasoningKey: 'reasoning_content',
+    });
+
+    expect(result).toBe('Fallback content');
+  });
+
+  it('should fallback to chunk.content when reasoningKey value is empty string', () => {
+    const chunk: Partial<AIMessageChunk> = {
+      content: ' can',
+      additional_kwargs: {
+        reasoning_content: '',
+      },
+    };
+
+    const result = getChunkContent({
+      chunk,
+      reasoningKey: 'reasoning_content',
+    });
+
+    expect(result).toBe(' can');
+  });
+
+  it('should return undefined when no content is available', () => {
+    const chunk: Partial<AIMessageChunk> = {
+      additional_kwargs: {},
+    };
+
+    const result = getChunkContent({
+      chunk,
+      reasoningKey: 'reasoning',
+    });
+
+    expect(result).toBeUndefined();
+  });
+
+  it('should handle missing chunk gracefully', () => {
+    const result = getChunkContent({
+      reasoningKey: 'reasoning',
+    });
+
+    expect(result).toBeUndefined();
+  });
+});

package/src/stream.ts

@@ -1,10 +1,22 @@
 // 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 { AgentContext } from '@/agents/AgentContext';
+import type { StandardGraph } from '@/graphs';
 import type * as t from '@/types';
-import { StepTypes, ContentTypes, GraphEvents, ToolCallTypes } from '@/common';
-import { handleToolCalls, handleToolCallChunks } from '@/tools/handlers';
+import {
+  ToolCallTypes,
+  ContentTypes,
+  GraphEvents,
+  StepTypes,
+  Providers,
+} from '@/common';
+import {
+  handleServerToolResult,
+  handleToolCallChunks,
+  handleToolCalls,
+} from '@/tools/handlers';
 import { getMessageId } from '@/messages';
 
 /**
@@ -66,13 +78,48 @@ function getNonEmptyValue(possibleValues: string[]): string | undefined {
   }
   return undefined;
 }
+
+export function getChunkContent({
+  chunk,
+  provider,
+  reasoningKey,
+}: {
+  chunk?: Partial<AIMessageChunk>;
+  provider?: Providers;
+  reasoningKey: 'reasoning_content' | 'reasoning';
+}): string | t.MessageContentComplex[] | undefined {
+  if (
+    (provider === Providers.OPENAI || provider === Providers.AZURE) &&
+    (
+      chunk?.additional_kwargs?.reasoning as
+        | Partial<ChatOpenAIReasoningSummary>
+        | undefined
+    )?.summary?.[0]?.text != null &&
+    ((
+      chunk?.additional_kwargs?.reasoning as
+        | Partial<ChatOpenAIReasoningSummary>
+        | undefined
+    )?.summary?.[0]?.text?.length ?? 0) > 0
+  ) {
+    return (
+      chunk?.additional_kwargs?.reasoning as
+        | Partial<ChatOpenAIReasoningSummary>
+        | undefined
+    )?.summary?.[0]?.text;
+  }
+  return (
+    ((chunk?.additional_kwargs?.[reasoningKey] as string | undefined) ?? '') ||
+    chunk?.content
+  );
+}
+
 export class ChatModelStreamHandler implements t.EventHandler {
-  handle(
+  async handle(
     event: string,
     data: t.StreamEventData,
     metadata?: Record<string, unknown>,
-    graph?: Graph
-  ): void {
+    graph?: StandardGraph
+  ): Promise<void> {
     if (!graph) {
       throw new Error('Graph not found');
     }
@@ -84,12 +131,24 @@ export class ChatModelStreamHandler implements t.EventHandler {
       return;
     }
 
-    const chunk = data.chunk as Partial<AIMessageChunk>;
-    const content =
-      (chunk.additional_kwargs?.[graph.reasoningKey] as string | undefined) ??
-      chunk.content;
-    this.handleReasoning(chunk, graph);
+    const agentContext = graph.getAgentContext(metadata);
 
+    const chunk = data.chunk as Partial<AIMessageChunk>;
+    const content = getChunkContent({
+      chunk,
+      reasoningKey: agentContext.reasoningKey,
+      provider: agentContext.provider,
+    });
+    const skipHandling = await handleServerToolResult({
+      graph,
+      content,
+      metadata,
+      agentContext,
+    });
+    if (skipHandling) {
+      return;
+    }
+    this.handleReasoning(chunk, agentContext);
     let hasToolCalls = false;
     if (
       chunk.tool_calls &&
@@ -97,7 +156,7 @@ export class ChatModelStreamHandler implements t.EventHandler {
       chunk.tool_calls.every((tc) => tc.id != null && tc.id !== '')
     ) {
       hasToolCalls = true;
-      handleToolCalls(chunk.tool_calls, metadata, graph);
+      await handleToolCalls(chunk.tool_calls, metadata, graph);
     }
 
     const hasToolCallChunks =
@@ -106,18 +165,16 @@ export class ChatModelStreamHandler implements t.EventHandler {
       typeof content === 'undefined' ||
       !content.length ||
       (typeof content === 'string' && !content);
-    const isEmptyChunk = isEmptyContent && !hasToolCallChunks;
-    const chunkId = chunk.id ?? '';
-    if (isEmptyChunk && chunkId && chunkId.startsWith('msg')) {
-      if (graph.messageIdsByStepKey.has(chunkId)) {
-        return;
-      } else if (graph.prelimMessageIdsByStepKey.has(chunkId)) {
-        return;
-      }
 
+    /** Set a preliminary message ID if found in empty chunk */
+    const isEmptyChunk = isEmptyContent && !hasToolCallChunks;
+    if (
+      isEmptyChunk &&
+      (chunk.id ?? '') !== '' &&
+      !graph.prelimMessageIdsByStepKey.has(chunk.id ?? '')
+    ) {
       const stepKey = graph.getStepKey(metadata);
-      graph.prelimMessageIdsByStepKey.set(stepKey, chunkId);
-      return;
+      graph.prelimMessageIdsByStepKey.set(stepKey, chunk.id ?? '');
     } else if (isEmptyChunk) {
       return;
     }
@@ -130,7 +187,7 @@ export class ChatModelStreamHandler implements t.EventHandler {
       chunk.tool_call_chunks.length &&
       typeof chunk.tool_call_chunks[0]?.index === 'number'
     ) {
-      handleToolCallChunks({
+      await handleToolCallChunks({
         graph,
         stepKey,
         toolCallChunks: chunk.tool_call_chunks,
@@ -143,7 +200,7 @@ export class ChatModelStreamHandler implements t.EventHandler {
 
     const message_id = getMessageId(stepKey, graph) ?? '';
     if (message_id) {
-      graph.dispatchRunStep(stepKey, {
+      await graph.dispatchRunStep(stepKey, {
         type: StepTypes.MESSAGE_CREATION,
         message_creation: {
           message_id,
@@ -181,8 +238,8 @@ hasToolCallChunks: ${hasToolCallChunks}
     ) {
       return;
     } else if (typeof content === 'string') {
-      if (graph.currentTokenType === ContentTypes.TEXT) {
-        graph.dispatchMessageDelta(stepId, {
+      if (agentContext.currentTokenType === ContentTypes.TEXT) {
+        await graph.dispatchMessageDelta(stepId, {
           content: [
             {
               type: ContentTypes.TEXT,
@@ -190,10 +247,10 @@ hasToolCallChunks: ${hasToolCallChunks}
             },
           ],
         });
-      } else if (graph.currentTokenType === 'think_and_text') {
+      } else if (agentContext.currentTokenType === 'think_and_text') {
         const { text, thinking } = parseThinkingContent(content);
         if (thinking) {
-          graph.dispatchReasoningDelta(stepId, {
+          await graph.dispatchReasoningDelta(stepId, {
             content: [
               {
                 type: ContentTypes.THINK,
@@ -203,11 +260,11 @@ hasToolCallChunks: ${hasToolCallChunks}
           });
         }
         if (text) {
-          graph.currentTokenType = ContentTypes.TEXT;
-          graph.tokenTypeSwitch = 'content';
+          agentContext.currentTokenType = ContentTypes.TEXT;
+          agentContext.tokenTypeSwitch = 'content';
           const newStepKey = graph.getStepKey(metadata);
           const message_id = getMessageId(newStepKey, graph) ?? '';
-          graph.dispatchRunStep(newStepKey, {
+          await graph.dispatchRunStep(newStepKey, {
             type: StepTypes.MESSAGE_CREATION,
             message_creation: {
               message_id,
@@ -215,7 +272,7 @@ hasToolCallChunks: ${hasToolCallChunks}
           });
 
           const newStepId = graph.getStepIdByKey(newStepKey);
-          graph.dispatchMessageDelta(newStepId, {
+          await graph.dispatchMessageDelta(newStepId, {
             content: [
               {
                 type: ContentTypes.TEXT,
@@ -225,7 +282,7 @@ hasToolCallChunks: ${hasToolCallChunks}
           });
         }
       } else {
-        graph.dispatchReasoningDelta(stepId, {
+        await graph.dispatchReasoningDelta(stepId, {
           content: [
             {
               type: ContentTypes.THINK,
@@ -237,82 +294,97 @@ hasToolCallChunks: ${hasToolCallChunks}
     } else if (
       content.every((c) => c.type?.startsWith(ContentTypes.TEXT) ?? false)
     ) {
-      graph.dispatchMessageDelta(stepId, {
+      await graph.dispatchMessageDelta(stepId, {
         content,
       });
     } else if (
       content.every(
         (c) =>
           (c.type?.startsWith(ContentTypes.THINKING) ?? false) ||
+          (c.type?.startsWith(ContentTypes.REASONING) ?? false) ||
           (c.type?.startsWith(ContentTypes.REASONING_CONTENT) ?? false)
       )
     ) {
-      graph.dispatchReasoningDelta(stepId, {
+      await graph.dispatchReasoningDelta(stepId, {
         content: content.map((c) => ({
           type: ContentTypes.THINK,
           think:
             (c as t.ThinkingContentText).thinking ??
+            (c as Partial<t.GoogleReasoningContentText>).reasoning ??
             (c as Partial<t.BedrockReasoningContentText>).reasoningText?.text ??
             '',
         })),
       });
     }
   }
-  handleReasoning(chunk: Partial<AIMessageChunk>, graph: Graph): void {
-    let reasoning_content = chunk.additional_kwargs?.[graph.reasoningKey] as
-      | string
-      | undefined;
+  handleReasoning(
+    chunk: Partial<AIMessageChunk>,
+    agentContext: AgentContext
+  ): void {
+    let reasoning_content = chunk.additional_kwargs?.[
+      agentContext.reasoningKey
+    ] as string | Partial<ChatOpenAIReasoningSummary> | undefined;
     if (
       Array.isArray(chunk.content) &&
-      (chunk.content[0]?.type === 'thinking' ||
-        chunk.content[0]?.type === 'reasoning_content')
+      (chunk.content[0]?.type === ContentTypes.THINKING ||
+        chunk.content[0]?.type === ContentTypes.REASONING ||
+        chunk.content[0]?.type === ContentTypes.REASONING_CONTENT)
+    ) {
+      reasoning_content = 'valid';
+    } else if (
+      (agentContext.provider === Providers.OPENAI ||
+        agentContext.provider === Providers.AZURE) &&
+      reasoning_content != null &&
+      typeof reasoning_content !== 'string' &&
+      reasoning_content.summary?.[0]?.text != null &&
+      reasoning_content.summary[0].text
     ) {
       reasoning_content = 'valid';
     }
     if (
       reasoning_content != null &&
-      reasoning_content &&
+      reasoning_content !== '' &&
       (chunk.content == null ||
         chunk.content === '' ||
         reasoning_content === 'valid')
     ) {
-      graph.currentTokenType = ContentTypes.THINK;
-      graph.tokenTypeSwitch = 'reasoning';
+      agentContext.currentTokenType = ContentTypes.THINK;
+      agentContext.tokenTypeSwitch = 'reasoning';
       return;
     } else if (
-      graph.tokenTypeSwitch === 'reasoning' &&
-      graph.currentTokenType !== ContentTypes.TEXT &&
-      chunk.content != null &&
-      chunk.content !== ''
+      agentContext.tokenTypeSwitch === 'reasoning' &&
+      agentContext.currentTokenType !== ContentTypes.TEXT &&
+      ((chunk.content != null && chunk.content !== '') ||
+        (chunk.tool_calls?.length ?? 0) > 0)
     ) {
-      graph.currentTokenType = ContentTypes.TEXT;
-      graph.tokenTypeSwitch = 'content';
+      agentContext.currentTokenType = ContentTypes.TEXT;
+      agentContext.tokenTypeSwitch = 'content';
     } else if (
       chunk.content != null &&
       typeof chunk.content === 'string' &&
       chunk.content.includes('<think>') &&
       chunk.content.includes('</think>')
     ) {
-      graph.currentTokenType = 'think_and_text';
-      graph.tokenTypeSwitch = 'content';
+      agentContext.currentTokenType = 'think_and_text';
+      agentContext.tokenTypeSwitch = 'content';
     } else if (
       chunk.content != null &&
       typeof chunk.content === 'string' &&
       chunk.content.includes('<think>')
     ) {
-      graph.currentTokenType = ContentTypes.THINK;
-      graph.tokenTypeSwitch = 'content';
+      agentContext.currentTokenType = ContentTypes.THINK;
+      agentContext.tokenTypeSwitch = 'content';
     } else if (
-      graph.lastToken != null &&
-      graph.lastToken.includes('</think>')
+      agentContext.lastToken != null &&
+      agentContext.lastToken.includes('</think>')
     ) {
-      graph.currentTokenType = ContentTypes.TEXT;
-      graph.tokenTypeSwitch = 'content';
+      agentContext.currentTokenType = ContentTypes.TEXT;
+      agentContext.tokenTypeSwitch = 'content';
     }
     if (typeof chunk.content !== 'string') {
       return;
     }
-    graph.lastToken = chunk.content;
+    agentContext.lastToken = chunk.content;
   }
 }
 
@@ -402,12 +474,19 @@ export function createContentAggregator(): t.ContentAggregatorResult {
 
       const toolCallArgs = (contentPart.tool_call as t.ToolCallPart).args;
       /** When args are a valid object, they are likely already invoked */
-      const args =
+      let args =
         finalUpdate ||
         typeof existingContent?.tool_call?.args === 'object' ||
         typeof toolCallArgs === 'object'
           ? contentPart.tool_call.args
           : (existingContent?.tool_call?.args ?? '') + (toolCallArgs ?? '');
+      if (
+        finalUpdate &&
+        args == null &&
+        existingContent?.tool_call?.args != null
+      ) {
+        args = existingContent.tool_call.args;
+      }
 
       const id =
         getNonEmptyValue([

package/src/tools/ToolNode.ts

@@ -13,7 +13,6 @@ import type { BaseMessage, AIMessage } from '@langchain/core/messages';
 import type { StructuredToolInterface } from '@langchain/core/tools';
 import type * as t from '@/types';
 import { RunnableCallable } from '@/utils';
-import { GraphNodeKeys } from '@/common';
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export class ToolNode<T = any> extends RunnableCallable<T, T> {
@@ -138,18 +137,33 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
   }
 }
 
-export function toolsCondition(
-  state: BaseMessage[] | typeof MessagesAnnotation.State
-): 'tools' | typeof END {
-  const message = Array.isArray(state)
+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<T extends string>(
+  state: BaseMessage[] | typeof MessagesAnnotation.State,
+  toolNode: T,
+  invokedToolIds?: Set<string>
+): T | typeof END {
+  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;
+    return toolNode;
   } else {
     return END;
   }