@librechat/agents 3.2.21 → 3.2.31

package/src/stream.test.ts

@@ -1,5 +1,5 @@
-import type { AIMessageChunk } from '@langchain/core/messages';
 import type { ChatOpenAIReasoningSummary } from '@langchain/openai';
+import type { AIMessageChunk } from '@langchain/core/messages';
 import { getChunkContent } from './stream';
 import { Providers } from '@/common';
 
@@ -23,9 +23,9 @@ describe('getChunkContent', () => {
     expect(result).toBe('Reasoning summary text');
   });
 
-  it('should fallback to reasoningKey when no OpenAI reasoning summary', () => {
+  it('should fallback to reasoningKey when no visible content is present', () => {
     const chunk: Partial<AIMessageChunk> = {
-      content: 'Regular content',
+      content: '',
       additional_kwargs: {
         reasoning_content: 'Reasoning from key',
       },
@@ -39,6 +39,56 @@ describe('getChunkContent', () => {
     expect(result).toBe('Reasoning from key');
   });
 
+  it('should use OpenRouter reasoning_content when no visible content is present', () => {
+    const chunk: Partial<AIMessageChunk> = {
+      content: '',
+      additional_kwargs: {
+        reasoning_content: 'OpenRouter reasoning delta',
+      },
+    };
+
+    const result = getChunkContent({
+      chunk,
+      provider: Providers.OPENROUTER,
+      reasoningKey: 'reasoning',
+    });
+
+    expect(result).toBe('OpenRouter reasoning delta');
+  });
+
+  it('should prefer visible content when hidden reasoning is present on the same chunk', () => {
+    const chunk: Partial<AIMessageChunk> = {
+      content: 'Regular content',
+      additional_kwargs: {
+        reasoning_content: 'Reasoning from key',
+      },
+    };
+
+    const result = getChunkContent({
+      chunk,
+      reasoningKey: 'reasoning_content',
+    });
+
+    expect(result).toBe('Regular content');
+  });
+
+  it('should prefer visible OpenRouter content over reasoning_content on the same chunk', () => {
+    const chunk: Partial<AIMessageChunk> = {
+      content: 'Regular content',
+      additional_kwargs: {
+        reasoning_content: 'OpenRouter reasoning delta',
+      },
+    };
+
+    const result = getChunkContent({
+      chunk,
+      provider: Providers.OPENROUTER,
+      reasoningKey: 'reasoning',
+    });
+
+    expect(result).toBe('Regular content');
+  });
+
   it('should fallback to chunk.content when reasoningKey value is null or undefined', () => {
     const chunk: Partial<AIMessageChunk> = {
       content: 'Fallback content',

package/src/stream.ts

@@ -1,7 +1,7 @@
 // src/stream.ts
+import type { ToolCall, ToolCallChunk } from '@langchain/core/messages/tool';
 import type { ChatOpenAIReasoningSummary } from '@langchain/openai';
 import type { AIMessageChunk } from '@langchain/core/messages';
-import type { ToolCall, ToolCallChunk } from '@langchain/core/messages/tool';
 import type { AgentContext } from '@/agents/AgentContext';
 import type { StandardGraph } from '@/graphs';
 import type * as t from '@/types';
@@ -16,32 +16,37 @@ import {
   LOCAL_CODING_BUNDLE_NAMES,
 } from '@/common';
 import {
-  handleServerToolResult,
-  handleToolCallChunks,
-  handleToolCalls,
-} from '@/tools/handlers';
-import { getMessageId } from '@/messages';
-import { safeDispatchCustomEvent } from '@/utils/events';
+  getStreamedToolCallSeal,
+  getStreamedToolCallAdapter,
+  type StreamedToolCallSeal,
+} from '@/tools/streamedToolCallSeals';
 import {
   buildToolExecutionRequestPlan,
   coerceRecordArgs,
   normalizeError,
 } from '@/tools/eagerEventExecution';
+import {
+  handleServerToolResult,
+  handleToolCallChunks,
+  handleToolCalls,
+} from '@/tools/handlers';
 import {
   calculateMaxToolResultChars,
   truncateToolResultContent,
 } from '@/utils/truncation';
-import {
-  getStreamedToolCallSeal,
-  getStreamedToolCallAdapter,
-  type StreamedToolCallSeal,
-} from '@/tools/streamedToolCallSeals';
 import { TOOL_OUTPUT_REF_PATTERN } from '@/tools/toolOutputReferences';
+import { safeDispatchCustomEvent } from '@/utils/events';
+import { isGoogleLike } from '@/utils/llm';
+import { getMessageId } from '@/messages';
 
 const LOCAL_CODING_BUNDLE_NAME_SET: ReadonlySet<string> = new Set(
   LOCAL_CODING_BUNDLE_NAMES
 );
 
+type ReasoningSummaryLike = {
+  summary?: Array<{ text?: string }>;
+};
+
 /**
  * Parses content to extract thinking sections enclosed in <think> tags using string operations
  * @param content The content to parse
@@ -329,6 +334,230 @@ function hasDirectToolCallChunkStateInStep(args: {
   return false;
 }
 
+function isGoogleServerSideToolContentPart(
+  contentPart: t.MessageContentComplex
+): boolean {
+  return contentPart.type === 'toolCall' || contentPart.type === 'toolResponse';
+}
+
+function isTextContentPart(contentPart: t.MessageContentComplex): boolean {
+  return contentPart.type?.startsWith(ContentTypes.TEXT) ?? false;
+}
+
+function isReasoningContentPart(contentPart: t.MessageContentComplex): boolean {
+  return (
+    (contentPart.type?.startsWith(ContentTypes.THINKING) ?? false) ||
+    (contentPart.type?.startsWith(ContentTypes.REASONING) ?? false) ||
+    (contentPart.type?.startsWith(ContentTypes.REASONING_CONTENT) ?? false) ||
+    contentPart.type === 'redacted_thinking'
+  );
+}
+
+function getReasoningTextFromContentPart(
+  contentPart: t.MessageContentComplex
+): string {
+  return (
+    (contentPart as t.ThinkingContentText).thinking ??
+    (contentPart as Partial<t.GoogleReasoningContentText>).reasoning ??
+    (contentPart as Partial<t.BedrockReasoningContentText>).reasoningText
+      ?.text ??
+    ''
+  );
+}
+
+function getReasoningTextFromChunk(
+  chunk: Partial<AIMessageChunk>,
+  agentContext: AgentContext
+): string {
+  const reasoning = chunk.additional_kwargs?.[agentContext.reasoningKey] as
+    | string
+    | Partial<ChatOpenAIReasoningSummary>
+    | undefined;
+  if (typeof reasoning === 'string') {
+    return reasoning;
+  }
+  return reasoning?.summary?.[0]?.text ?? '';
+}
+
+const googleServerSideToolStepIdsByGraph = new WeakMap<
+  StandardGraph,
+  Set<string>
+>();
+
+function markGoogleServerSideToolMessageStep(
+  graph: StandardGraph,
+  stepId: string
+): void {
+  const stepIds = googleServerSideToolStepIdsByGraph.get(graph) ?? new Set();
+  stepIds.add(stepId);
+  googleServerSideToolStepIdsByGraph.set(graph, stepIds);
+}
+
+function isGoogleServerSideToolMessageStep(
+  graph: StandardGraph,
+  stepId: string
+): boolean {
+  return googleServerSideToolStepIdsByGraph.get(graph)?.has(stepId) === true;
+}
+
+function shouldStartFreshMessageStepAfterGoogleServerSideTool({
+  graph,
+  stepId,
+  runStep,
+  content,
+}: {
+  graph: StandardGraph;
+  stepId: string;
+  runStep?: t.RunStep;
+  content: string | t.MessageContentComplex[];
+}): boolean {
+  if (
+    runStep?.type !== StepTypes.MESSAGE_CREATION ||
+    !isGoogleServerSideToolMessageStep(graph, stepId)
+  ) {
+    return false;
+  }
+  if (typeof content === 'string') {
+    return true;
+  }
+  return (
+    content.every((c) => isTextContentPart(c)) ||
+    content.every((c) => isReasoningContentPart(c))
+  );
+}
+
+async function dispatchMessageCreationStep({
+  graph,
+  stepKey,
+  metadata,
+}: {
+  graph: StandardGraph;
+  stepKey: string;
+  metadata?: Record<string, unknown>;
+}): Promise<string> {
+  const messageId = getMessageId(stepKey, graph, true) ?? '';
+  return graph.dispatchRunStep(
+    stepKey,
+    {
+      type: StepTypes.MESSAGE_CREATION,
+      message_creation: {
+        message_id: messageId,
+      },
+    },
+    metadata
+  );
+}
+
+async function dispatchMessageContentParts({
+  graph,
+  stepKey,
+  content,
+  metadata,
+}: {
+  graph: StandardGraph;
+  stepKey: string;
+  content: t.MessageContentComplex[];
+  metadata?: Record<string, unknown>;
+}): Promise<void> {
+  for (const contentPart of content) {
+    const currentStepId = await dispatchMessageCreationStep({
+      graph,
+      stepKey,
+      metadata,
+    });
+    if (isGoogleServerSideToolContentPart(contentPart)) {
+      markGoogleServerSideToolMessageStep(graph, currentStepId);
+    }
+    await graph.dispatchMessageDelta(
+      currentStepId,
+      {
+        content: [contentPart],
+      },
+      metadata
+    );
+  }
+}
+
+async function dispatchReasoningContentParts({
+  graph,
+  stepKey,
+  content,
+  metadata,
+}: {
+  graph: StandardGraph;
+  stepKey: string;
+  content: t.MessageContentComplex[];
+  metadata?: Record<string, unknown>;
+}): Promise<void> {
+  if (content.length === 0) {
+    return;
+  }
+  const currentStepId = await dispatchMessageCreationStep({
+    graph,
+    stepKey,
+    metadata,
+  });
+  await graph.dispatchReasoningDelta(
+    currentStepId,
+    {
+      content,
+    },
+    metadata
+  );
+}
+
+async function dispatchGoogleServerSideToolStreamContent({
+  graph,
+  stepKey,
+  chunk,
+  agentContext,
+  content,
+  metadata,
+}: {
+  graph: StandardGraph;
+  stepKey: string;
+  chunk: Partial<AIMessageChunk>;
+  agentContext: AgentContext;
+  content: t.MessageContentComplex[];
+  metadata?: Record<string, unknown>;
+}): Promise<void> {
+  const reasoningContent: t.MessageContentComplex[] = [];
+  const reasoningText = getReasoningTextFromChunk(chunk, agentContext);
+  if (reasoningText !== '') {
+    reasoningContent.push({
+      type: ContentTypes.THINK,
+      think: reasoningText,
+    });
+  }
+  reasoningContent.push(
+    ...content
+      .filter((contentPart) => isReasoningContentPart(contentPart))
+      .map((contentPart) => ({
+        type: ContentTypes.THINK,
+        think: getReasoningTextFromContentPart(contentPart),
+      }))
+      .filter((contentPart) => contentPart.think !== '')
+  );
+  await dispatchReasoningContentParts({
+    graph,
+    stepKey,
+    content: reasoningContent,
+    metadata,
+  });
+
+  const messageContent = content.filter(
+    (contentPart) =>
+      isTextContentPart(contentPart) ||
+      isGoogleServerSideToolContentPart(contentPart)
+  );
+  await dispatchMessageContentParts({
+    graph,
+    stepKey,
+    content: messageContent,
+    metadata,
+  });
+}
+
 type EagerToolExecutionEntry = {
   id: string;
   toolName: string;
@@ -890,6 +1119,14 @@ export function getChunkContent({
   provider?: Providers;
   reasoningKey: 'reasoning_content' | 'reasoning';
 }): string | t.MessageContentComplex[] | undefined {
+  if (
+    isGoogleLike(provider) &&
+    Array.isArray(chunk?.content) &&
+    chunk.content.some((c) => isGoogleServerSideToolContentPart(c))
+  ) {
+    return chunk.content;
+  }
+
   if (
     (provider === Providers.OPENAI || provider === Providers.AZURE) &&
     (
@@ -909,16 +1146,6 @@ export function getChunkContent({
         | undefined
     )?.summary?.[0]?.text;
   }
-  /**
-   * For OpenRouter, reasoning is stored in additional_kwargs.reasoning (not reasoning_content).
-   * NOTE: We intentionally do NOT extract text from reasoning_details here.
-   * The reasoning_details array contains the FULL accumulated reasoning text (set only on final chunk),
-   * but individual reasoning tokens are already streamed via additional_kwargs.reasoning.
-   * Extracting from reasoning_details would cause duplication.
-   * The reasoning_details is only used for:
-   * 1. Detecting reasoning mode in handleReasoning()
-   * 2. Final message storage (for thought signatures)
-   */
   if (provider === Providers.OPENROUTER) {
     // Content presence signals end of reasoning phase - prefer content over reasoning
     // This handles transitional chunks that may have both reasoning and content
@@ -929,11 +1156,158 @@ export function getChunkContent({
     if (reasoning != null && reasoning !== '') {
       return reasoning;
     }
+    const reasoningContent = chunk?.additional_kwargs?.reasoning_content as
+      | string
+      | undefined;
+    if (reasoningContent != null && reasoningContent !== '') {
+      return reasoningContent;
+    }
     return chunk?.content;
   }
+  const keyedReasoning = chunk?.additional_kwargs?.[reasoningKey] as
+    | string
+    | undefined;
+  if (
+    typeof chunk?.content === 'string' &&
+    chunk.content !== '' &&
+    keyedReasoning != null &&
+    keyedReasoning !== ''
+  ) {
+    return chunk.content;
+  }
+  return ((keyedReasoning as string | undefined) ?? '') || chunk?.content;
+}
+
+function isDisableStreamingEnabled(
+  clientOptions: t.ClientOptions | undefined
+): boolean {
+  return (
+    clientOptions != null &&
+    'disableStreaming' in clientOptions &&
+    clientOptions.disableStreaming === true
+  );
+}
+
+function hasReasoningContent(
+  value: string | ReasoningSummaryLike | object[] | null | undefined
+): boolean {
+  if (typeof value === 'string') {
+    return value !== '';
+  }
+  if (Array.isArray(value)) {
+    return value.length > 0;
+  }
+  if (value == null) {
+    return false;
+  }
+  return (
+    value.summary?.some(
+      (summary) => summary.text != null && summary.text.length > 0
+    ) === true
+  );
+}
+
+function shouldDeferMixedFinalReasoningChunk({
+  chunk,
+  agentContext,
+}: {
+  chunk: Partial<AIMessageChunk>;
+  agentContext: AgentContext;
+}): boolean {
+  if (
+    (chunk.tool_calls?.length ?? 0) > 0 ||
+    (chunk.tool_call_chunks?.length ?? 0) > 0 ||
+    typeof chunk.content !== 'string' ||
+    chunk.content === ''
+  ) {
+    return false;
+  }
+  const additionalKwargs = chunk.additional_kwargs;
+  if (
+    agentContext.provider === Providers.OPENROUTER &&
+    hasReasoningContent(additionalKwargs?.reasoning_details as object[])
+  ) {
+    return true;
+  }
+  if (!isDisableStreamingEnabled(agentContext.clientOptions)) {
+    return false;
+  }
+  return (
+    hasReasoningContent(
+      additionalKwargs?.[agentContext.reasoningKey] as
+        | string
+        | ReasoningSummaryLike
+        | null
+        | undefined
+    ) ||
+    hasReasoningContent(
+      additionalKwargs?.reasoning_content as
+        | string
+        | ReasoningSummaryLike
+        | null
+        | undefined
+    ) ||
+    hasReasoningContent(
+      additionalKwargs?.reasoning as
+        | string
+        | ReasoningSummaryLike
+        | null
+        | undefined
+    ) ||
+    hasReasoningContent(additionalKwargs?.reasoning_details as object[])
+  );
+}
+
+function hasCurrentTextDeltaStep({
+  graph,
+  metadata,
+}: {
+  graph: StandardGraph;
+  metadata?: Record<string, unknown>;
+}): boolean {
+  if (metadata == null) {
+    return false;
+  }
+  const baseStepKey = graph.getStepBaseKey(metadata);
+  for (const [stepKey, stepIds] of graph.stepKeyIds) {
+    if (stepKey !== baseStepKey && !stepKey.startsWith(`${baseStepKey}_`)) {
+      continue;
+    }
+    if (stepIds.some((stepId) => graph.messageStepHasTextDeltas.has(stepId))) {
+      return true;
+    }
+  }
+  return false;
+}
+
+function shouldSkipLateOpenRouterReasoningChunk({
+  chunk,
+  agentContext,
+  graph,
+  metadata,
+}: {
+  chunk: Partial<AIMessageChunk>;
+  agentContext: AgentContext;
+  graph: StandardGraph;
+  metadata?: Record<string, unknown>;
+}): boolean {
+  if (
+    agentContext.provider !== Providers.OPENROUTER ||
+    (chunk.tool_calls?.length ?? 0) > 0 ||
+    (chunk.tool_call_chunks?.length ?? 0) > 0 ||
+    (chunk.content != null && chunk.content !== '')
+  ) {
+    return false;
+  }
   return (
-    ((chunk?.additional_kwargs?.[reasoningKey] as string | undefined) ?? '') ||
-    chunk?.content
+    (hasReasoningContent(chunk.additional_kwargs?.reasoning as string) ||
+      hasReasoningContent(
+        chunk.additional_kwargs?.reasoning_content as string
+      ) ||
+      hasReasoningContent(
+        chunk.additional_kwargs?.reasoning_details as object[]
+      )) &&
+    hasCurrentTextDeltaStep({ graph, metadata })
   );
 }
 
@@ -974,11 +1348,39 @@ export class ChatModelStreamHandler implements t.EventHandler {
     if (skipHandling) {
       return;
     }
+    if (shouldDeferMixedFinalReasoningChunk({ chunk, agentContext })) {
+      return;
+    }
+    if (
+      shouldSkipLateOpenRouterReasoningChunk({
+        chunk,
+        agentContext,
+        graph,
+        metadata,
+      })
+    ) {
+      return;
+    }
     this.handleReasoning(chunk, agentContext);
     const stepKey = graph.getStepKey(metadata);
     let hasToolCalls = false;
     const hasToolCallChunks =
       (chunk.tool_call_chunks && chunk.tool_call_chunks.length > 0) ?? false;
+    const hasGoogleServerSideToolContent =
+      isGoogleLike(agentContext.provider) &&
+      Array.isArray(content) &&
+      content.some((c) => isGoogleServerSideToolContentPart(c));
+    if (hasGoogleServerSideToolContent && Array.isArray(content)) {
+      await dispatchGoogleServerSideToolStreamContent({
+        graph,
+        stepKey,
+        chunk,
+        agentContext,
+        content,
+        metadata,
+      });
+    }
+
     if (
       chunk.tool_calls &&
       chunk.tool_calls.length > 0 &&
@@ -1069,6 +1471,10 @@ export class ChatModelStreamHandler implements t.EventHandler {
       return;
     }
 
+    if (hasGoogleServerSideToolContent) {
+      return;
+    }
+
     const message_id = getMessageId(stepKey, graph) ?? '';
     if (message_id) {
       await graph.dispatchRunStep(
@@ -1083,8 +1489,19 @@ export class ChatModelStreamHandler implements t.EventHandler {
       );
     }
 
-    const stepId = graph.getStepIdByKey(stepKey);
-    const runStep = graph.getRunStep(stepId);
+    let stepId = graph.getStepIdByKey(stepKey);
+    let runStep = graph.getRunStep(stepId);
+    if (
+      shouldStartFreshMessageStepAfterGoogleServerSideTool({
+        graph,
+        stepId,
+        runStep,
+        content,
+      })
+    ) {
+      stepId = await dispatchMessageCreationStep({ graph, stepKey, metadata });
+      runStep = graph.getRunStep(stepId);
+    }
     if (!runStep) {
       console.warn(`\n
 ==============================================================
@@ -1186,9 +1603,7 @@ hasToolCallChunks: ${hasToolCallChunks}
           metadata
         );
       }
-    } else if (
-      content.every((c) => c.type?.startsWith(ContentTypes.TEXT) ?? false)
-    ) {
+    } else if (content.every((c) => isTextContentPart(c))) {
       await graph.dispatchMessageDelta(
         stepId,
         {
@@ -1196,15 +1611,7 @@ hasToolCallChunks: ${hasToolCallChunks}
         },
         metadata
       );
-    } else if (
-      content.every(
-        (c) =>
-          (c.type?.startsWith(ContentTypes.THINKING) ?? false) ||
-          (c.type?.startsWith(ContentTypes.REASONING) ?? false) ||
-          (c.type?.startsWith(ContentTypes.REASONING_CONTENT) ?? false) ||
-          c.type === 'redacted_thinking'
-      )
-    ) {
+    } else if (content.every((c) => isReasoningContentPart(c))) {
       await graph.dispatchReasoningDelta(
         stepId,
         {
@@ -1255,7 +1662,9 @@ hasToolCallChunks: ${hasToolCallChunks}
         Array.isArray(chunk.additional_kwargs.reasoning_details) &&
         chunk.additional_kwargs.reasoning_details.length > 0) ||
         (typeof chunk.additional_kwargs?.reasoning === 'string' &&
-          chunk.additional_kwargs.reasoning !== ''))
+          chunk.additional_kwargs.reasoning !== '') ||
+        (typeof chunk.additional_kwargs?.reasoning_content === 'string' &&
+          chunk.additional_kwargs.reasoning_content !== ''))
     ) {
       reasoning_content = 'valid';
     }
@@ -1388,6 +1797,8 @@ export function createContentAggregator(): t.ContentAggregatorResult {
       };
 
       contentParts[index] = update;
+    } else if (partType === 'toolCall' || partType === 'toolResponse') {
+      contentParts[index] = contentPart;
     } else if (partType === ContentTypes.SUMMARY) {
       const currentSummary = contentParts[index] as
         | t.SummaryContentBlock

package/src/summarization/__tests__/aggregator.test.ts

@@ -1,6 +1,6 @@
-import { createContentAggregator } from '@/stream';
-import { ContentTypes, GraphEvents, StepTypes } from '@/common';
 import type * as t from '@/types';
+import { ContentTypes, GraphEvents, StepTypes } from '@/common';
+import { createContentAggregator } from '@/stream';
 
 describe('createContentAggregator – SUMMARY accumulation', () => {
   it('accumulates text from multiple ON_SUMMARIZE_DELTA events', () => {

package/src/summarization/__tests__/node.test.ts

@@ -1,15 +1,15 @@
 import { AIMessage, HumanMessage, ToolMessage } from '@langchain/core/messages';
 import type { RunnableConfig } from '@langchain/core/runnables';
 import type * as t from '@/types';
-import { GraphEvents, Providers } from '@/common';
 import {
   createSummarizeNode,
   DEFAULT_SUMMARIZATION_PROMPT,
   DEFAULT_UPDATE_SUMMARIZATION_PROMPT,
 } from '@/summarization/node';
+import { AgentContext } from '@/agents/AgentContext';
+import { GraphEvents, Providers } from '@/common';
 import * as providers from '@/llm/providers';
 import * as eventUtils from '@/utils/events';
-import { AgentContext } from '@/agents/AgentContext';
 
 // ---------------------------------------------------------------------------
 // Helpers

package/src/summarization/node.ts

@@ -4,8 +4,8 @@ import {
   HumanMessage,
   SystemMessage,
 } from '@langchain/core/messages';
-import type { RunnableConfig } from '@langchain/core/runnables';
 import type { UsageMetadata, BaseMessage } from '@langchain/core/messages';
+import type { RunnableConfig } from '@langchain/core/runnables';
 import type { AgentContext } from '@/agents/AgentContext';
 import type { HookRegistry } from '@/hooks';
 import type { OnChunk } from '@/llm/invoke';