@librechat/agents 3.2.2 → 3.2.31

package/src/specs/summarization-unit.test.ts

@@ -12,8 +12,8 @@ import {
   createPruneMessages,
 } from '@/messages/prune';
 import { shouldTriggerSummarization } from '@/summarization/index';
-import { Providers } from '@/common';
 import { SummarizationTrigger } from '@/types';
+import { Providers } from '@/common';
 
 // ---------------------------------------------------------------------------
 // Shared helpers

package/src/specs/thinking-handoff.test.ts

@@ -1,7 +1,7 @@
 // src/specs/thinking-handoff.test.ts
 import { HumanMessage, ToolMessage } from '@langchain/core/messages';
-import type { ToolCall } from '@langchain/core/messages/tool';
 import type { RunnableConfig } from '@langchain/core/runnables';
+import type { ToolCall } from '@langchain/core/messages/tool';
 import type * as t from '@/types';
 import { Providers, Constants } from '@/common';
 import { StandardGraph } from '@/graphs/Graph';

package/src/splitStream.test.ts

@@ -225,6 +225,54 @@ describe('ContentAggregator empty deltas', () => {
   });
 });
 
+describe('ContentAggregator provider-specific parts', () => {
+  it('should preserve Gemini server-side tool content blocks', () => {
+    const { contentParts, aggregateContent } = createContentAggregator();
+    const toolCallPart: t.MessageContentComplex = {
+      type: 'toolCall',
+      toolCall: {
+        id: 'server-search-1',
+        name: 'google_search',
+        args: {},
+      },
+    };
+    const toolResponsePart: t.MessageContentComplex = {
+      type: 'toolResponse',
+      toolResponse: {
+        id: 'server-search-1',
+        name: 'google_search',
+        response: { results: [] },
+      },
+    };
+
+    aggregateContent({
+      event: GraphEvents.ON_RUN_STEP,
+      data: createRunStep('step_tool_call'),
+    });
+    aggregateContent({
+      event: GraphEvents.ON_MESSAGE_DELTA,
+      data: {
+        id: 'step_tool_call',
+        delta: { content: [toolCallPart] },
+      },
+    });
+    aggregateContent({
+      event: GraphEvents.ON_RUN_STEP,
+      data: { ...createRunStep('step_tool_response'), index: 1 },
+    });
+    aggregateContent({
+      event: GraphEvents.ON_MESSAGE_DELTA,
+      data: {
+        id: 'step_tool_response',
+        delta: { content: [toolResponsePart] },
+      },
+    });
+
+    expect(contentParts[0]).toEqual(toolCallPart);
+    expect(contentParts[1]).toEqual(toolResponsePart);
+  });
+});
+
 describe('ContentAggregator with SplitStreamHandler', () => {
   it('should aggregate content from multiple message blocks', async () => {
     const runId = nanoid();

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',