@librechat/agents 3.2.0 → 3.2.2

package/src/index.ts

@@ -74,6 +74,7 @@ export type {
   ChatOpenRouterCallOptions,
 } from './llm/openrouter';
 export { getChatModelClass } from './llm/providers';
+export { FakeChatModel, createFakeStreamingLLM } from './llm/fake';
 export { initializeModel } from './llm/init';
 export { attemptInvoke, tryFallbackProviders } from './llm/invoke';
 export { isThinkingEnabled, getMaxOutputTokensKey } from './llm/request';

package/src/messages/core.ts

@@ -8,9 +8,17 @@ import {
 } from '@langchain/core/messages';
 import type { ToolCall } from '@langchain/core/messages/tool';
 import type * as t from '@/types';
-import { Providers } from '@/common';
+import { ContentTypes, Providers } from '@/common';
 import { toLangChainContent } from './langchain';
 
+type ReasoningSummary = { summary?: Array<{ text?: string }> };
+type ReasoningDetail = { type?: string; text?: string };
+type ReasoningAdditionalKwargs = {
+  reasoning_content?: string | Partial<ReasoningSummary> | null;
+  reasoning?: string | Partial<ReasoningSummary> | null;
+  reasoning_details?: ReasoningDetail[] | null;
+};
+
 export function getConverseOverrideMessage({
   userMessage,
   lastMessageX,
@@ -143,6 +151,75 @@ function reduceBlocks(blocks: ContentBlock[]): ContentBlock[] {
   return reduced;
 }
 
+function getReasoningText(
+  value: string | Partial<ReasoningSummary> | null | undefined
+): string | undefined {
+  if (typeof value === 'string') {
+    return value !== '' ? value : undefined;
+  }
+  const summaryText = value?.summary
+    ?.map((summary) => summary.text ?? '')
+    .filter((text) => text !== '')
+    .join('');
+  return summaryText != null && summaryText !== '' ? summaryText : undefined;
+}
+
+function getReasoningDetailsText(
+  value: ReasoningDetail[] | null | undefined
+): string | undefined {
+  if (!Array.isArray(value)) {
+    return undefined;
+  }
+  const reasoningText = value
+    .filter((detail) => detail.type === 'reasoning.text')
+    .map((detail) => detail.text ?? '')
+    .filter((text) => text !== '')
+    .join('');
+  return reasoningText !== '' ? reasoningText : undefined;
+}
+
+function getAdditionalReasoningContent(
+  message: BaseMessage
+): string | undefined {
+  const additionalKwargs =
+    message.additional_kwargs as ReasoningAdditionalKwargs | undefined;
+  if (additionalKwargs == null) {
+    return undefined;
+  }
+
+  const reasoningContent = getReasoningText(
+    additionalKwargs.reasoning_content
+  );
+  if (reasoningContent != null) {
+    return reasoningContent;
+  }
+
+  const reasoning = getReasoningText(additionalKwargs.reasoning);
+  if (reasoning != null) {
+    return reasoning;
+  }
+
+  return getReasoningDetailsText(additionalKwargs.reasoning_details);
+}
+
+function hasReasoningContent(content: BaseMessage['content']): boolean {
+  if (!Array.isArray(content)) {
+    return false;
+  }
+  return content.some((item) => {
+    if (typeof item !== 'object' || !('type' in item)) {
+      return false;
+    }
+    return (
+      item.type === ContentTypes.THINK ||
+      item.type === ContentTypes.THINKING ||
+      item.type === ContentTypes.REASONING ||
+      item.type === ContentTypes.REASONING_CONTENT ||
+      item.type === 'redacted_thinking'
+    );
+  });
+}
+
 export function modifyDeltaProperties(
   provider: Providers,
   obj?: AIMessageChunk
@@ -287,25 +364,52 @@ export function convertMessagesToContent(
 ): t.MessageContentComplex[] {
   const processedContent: t.MessageContentComplex[] = [];
 
-  const addContentPart = (message: BaseMessage | null): void => {
+  const addToolCallBoundary = (): number => {
+    processedContent.push({ type: ContentTypes.TEXT, text: '' });
+    return processedContent.length - 1;
+  };
+
+  const addContentPart = (message: BaseMessage | null): number | undefined => {
     const content =
       message?.lc_kwargs.content != null
         ? message.lc_kwargs.content
         : message?.content;
     if (content === undefined) {
-      return;
+      return undefined;
+    }
+    const reasoningContent =
+      message?._getType() === 'ai' && !hasReasoningContent(content)
+        ? getAdditionalReasoningContent(message)
+        : undefined;
+    if (reasoningContent != null) {
+      processedContent.push({
+        type: ContentTypes.THINK,
+        think: reasoningContent,
+      });
     }
     if (typeof content === 'string') {
+      if (content === '') {
+        return undefined;
+      }
       processedContent.push({
-        type: 'text',
+        type: ContentTypes.TEXT,
         text: content,
       });
+      return processedContent.length - 1;
     } else if (Array.isArray(content)) {
-      const filteredContent = content.filter(
-        (item) => item != null && item.type !== 'tool_use'
-      );
-      processedContent.push(...filteredContent);
+      let textContentIndex: number | undefined;
+      for (const item of content) {
+        if (item == null || item.type === 'tool_use') {
+          continue;
+        }
+        processedContent.push(item);
+        if (item.type === ContentTypes.TEXT) {
+          textContentIndex = processedContent.length - 1;
+        }
+      }
+      return textContentIndex;
     }
+    return undefined;
   };
 
   let currentAIMessageIndex = -1;
@@ -328,8 +432,8 @@ export function convertMessagesToContent(
         toolCallMap.set(tool_call.id, tool_call);
       }
 
-      addContentPart(message);
-      currentAIMessageIndex = processedContent.length - 1;
+      currentAIMessageIndex =
+        addContentPart(message) ?? addToolCallBoundary();
       continue;
     } else if (
       messageType === 'tool' &&
@@ -361,6 +465,12 @@ export function convertMessagesToContent(
   return processedContent;
 }
 
+function stringifyToolMessageContent(
+  content: ToolMessage['content'] | null | undefined
+): string {
+  return content == null ? '' : String(content);
+}
+
 export function formatAnthropicArtifactContent(messages: BaseMessage[]): void {
   const lastMessage = messages[messages.length - 1];
   if (!(lastMessage instanceof ToolMessage)) return;
@@ -398,7 +508,12 @@ export function formatAnthropicArtifactContent(messages: BaseMessage[]): void {
     ) {
       const base = Array.isArray(msg.content)
         ? msg.content
-        : [{ type: 'text' as const, text: String(msg.content ?? '') }];
+        : [
+          {
+            type: ContentTypes.TEXT,
+            text: stringifyToolMessageContent(msg.content),
+          },
+        ];
       msg.content = base.concat(msg.artifact.content);
     }
   }

package/src/messages/formatAgentMessages.test.ts

@@ -1,11 +1,16 @@
 import {
   HumanMessage,
   AIMessage,
+  AIMessageChunk,
   SystemMessage,
   ToolMessage,
 } from '@langchain/core/messages';
 import type { MessageContentComplex, TPayload } from '@/types';
 import { formatAgentMessages } from './format';
+import {
+  convertMessagesToContent,
+  formatAnthropicArtifactContent,
+} from './core';
 import { _convertMessagesToAnthropicPayload } from '@/llm/anthropic/utils/message_inputs';
 import { Constants, ContentTypes, Providers } from '@/common';
 
@@ -619,6 +624,123 @@ describe('formatAgentMessages', () => {
     ]);
   });
 
+  it('preserves tool-only assistant turn boundaries when converting messages to content', () => {
+    const messages = [
+      new AIMessage({
+        content: '',
+        tool_calls: [
+          {
+            id: 'call_1',
+            name: 'lookup',
+            args: { step: 1 },
+            type: 'tool_call' as const,
+          },
+        ],
+      }),
+      new ToolMessage({
+        content: 'first result',
+        tool_call_id: 'call_1',
+        name: 'lookup',
+      }),
+      new AIMessage({
+        content: '',
+        tool_calls: [
+          {
+            id: 'call_2',
+            name: 'lookup',
+            args: { step: 2 },
+            type: 'tool_call' as const,
+          },
+        ],
+      }),
+      new ToolMessage({
+        content: 'second result',
+        tool_call_id: 'call_2',
+        name: 'lookup',
+      }),
+    ];
+
+    const content = convertMessagesToContent(messages);
+    expect(content).toHaveLength(4);
+    expect(content[0]).toMatchObject({
+      type: ContentTypes.TEXT,
+      text: '',
+      tool_call_ids: ['call_1'],
+    });
+    expect(content[1]).toMatchObject({
+      type: ContentTypes.TOOL_CALL,
+      tool_call: {
+        id: 'call_1',
+        name: 'lookup',
+        output: 'first result',
+      },
+    });
+    expect(content[2]).toMatchObject({
+      type: ContentTypes.TEXT,
+      text: '',
+      tool_call_ids: ['call_2'],
+    });
+    expect(content[3]).toMatchObject({
+      type: ContentTypes.TOOL_CALL,
+      tool_call: {
+        id: 'call_2',
+        name: 'lookup',
+        output: 'second result',
+      },
+    });
+
+    const result = formatAgentMessages([{ role: 'assistant', content }]);
+    expect(result.messages).toHaveLength(4);
+    expect(result.messages[0]).toBeInstanceOf(AIMessage);
+    expect(result.messages[1]).toBeInstanceOf(ToolMessage);
+    expect(result.messages[2]).toBeInstanceOf(AIMessage);
+    expect(result.messages[3]).toBeInstanceOf(ToolMessage);
+    expect((result.messages[0] as AIMessage).tool_calls?.[0].id).toBe(
+      'call_1'
+    );
+    expect((result.messages[1] as ToolMessage).tool_call_id).toBe('call_1');
+    expect((result.messages[2] as AIMessage).tool_calls?.[0].id).toBe(
+      'call_2'
+    );
+    expect((result.messages[3] as ToolMessage).tool_call_id).toBe('call_2');
+  });
+
+  it('keeps absent tool content empty when merging Anthropic artifacts', () => {
+    const toolMessage = new ToolMessage({
+      content: '',
+      tool_call_id: 'call_artifact',
+      name: 'render',
+      artifact: {
+        content: [{ type: ContentTypes.TEXT, text: 'artifact text' }],
+      },
+    });
+    Object.defineProperty(toolMessage, 'content', {
+      value: undefined,
+      writable: true,
+      configurable: true,
+    });
+
+    formatAnthropicArtifactContent([
+      new AIMessageChunk({
+        content: '',
+        tool_calls: [
+          {
+            id: 'call_artifact',
+            name: 'render',
+            args: {},
+            type: 'tool_call' as const,
+          },
+        ],
+      }),
+      toolMessage,
+    ]);
+
+    expect(toolMessage.content).toEqual([
+      { type: ContentTypes.TEXT, text: '' },
+      { type: ContentTypes.TEXT, text: 'artifact text' },
+    ]);
+  });
+
   it('should dynamically discover tools from tool_search output and keep their tool calls', () => {
     const tools = new Set(['tool_search', 'calculator']);
     const payload = [

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

@@ -265,10 +265,15 @@ const skipTests = process.env.DEEPSEEK_API_KEY == null;
       const finalContentParts = await run.processStream(inputs, testConfig);
       expect(finalContentParts).toBeDefined();
 
-      const allTextParts = finalContentParts?.every(
-        (part) => part.type === ContentTypes.TEXT
+      const supportedContentParts = finalContentParts?.every(
+        (part) =>
+          part.type === ContentTypes.TEXT || part.type === ContentTypes.THINK
       );
-      expect(allTextParts).toBe(true);
+      expect(supportedContentParts).toBe(true);
+      const textParts =
+        finalContentParts?.filter((part) => part.type === ContentTypes.TEXT) ??
+        [];
+      expect(textParts.length).toBeGreaterThan(0);
 
       expect(collectedUsage.length).toBeGreaterThan(0);
       expect(collectedUsage[0].input_tokens).toBeGreaterThan(0);

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

@@ -283,10 +283,15 @@ const skipTests = process.env.MOONSHOT_API_KEY == null;
       const finalContentParts = await run.processStream(inputs, testConfig);
       expect(finalContentParts).toBeDefined();
 
-      const allTextParts = finalContentParts?.every(
-        (part) => part.type === ContentTypes.TEXT
+      const supportedContentParts = finalContentParts?.every(
+        (part) =>
+          part.type === ContentTypes.TEXT || part.type === ContentTypes.THINK
       );
-      expect(allTextParts).toBe(true);
+      expect(supportedContentParts).toBe(true);
+      const textParts =
+        finalContentParts?.filter((part) => part.type === ContentTypes.TEXT) ??
+        [];
+      expect(textParts.length).toBeGreaterThan(0);
 
       expect(collectedUsage.length).toBeGreaterThan(0);
       expect(collectedUsage[0].input_tokens).toBeGreaterThan(0);

package/src/splitStream.test.ts

@@ -11,6 +11,18 @@ jest.mock('@/utils', () => ({
   sleep: (): Promise<void> => Promise.resolve(),
 }));
 
+const createRunStep = (id: string): t.RunStep => ({
+  id,
+  stepIndex: 0,
+  type: StepTypes.MESSAGE_CREATION,
+  index: 0,
+  stepDetails: {
+    type: StepTypes.MESSAGE_CREATION,
+    message_creation: { message_id: id },
+  },
+  usage: null,
+});
+
 describe('Stream Generation and Handling', () => {
   let mockHandlers: {
     [GraphEvents.ON_RUN_STEP]: jest.Mock;
@@ -161,6 +173,58 @@ End code.`;
   });
 });
 
+describe('ContentAggregator empty deltas', () => {
+  it('should ignore empty message delta content arrays', () => {
+    const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+    const { contentParts, aggregateContent } = createContentAggregator();
+
+    try {
+      aggregateContent({
+        event: GraphEvents.ON_RUN_STEP,
+        data: createRunStep('step_empty_message'),
+      });
+
+      aggregateContent({
+        event: GraphEvents.ON_MESSAGE_DELTA,
+        data: {
+          id: 'step_empty_message',
+          delta: { content: [] },
+        },
+      });
+
+      expect(warnSpy).not.toHaveBeenCalled();
+      expect(contentParts).toEqual([]);
+    } finally {
+      warnSpy.mockRestore();
+    }
+  });
+
+  it('should ignore empty reasoning delta content arrays', () => {
+    const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+    const { contentParts, aggregateContent } = createContentAggregator();
+
+    try {
+      aggregateContent({
+        event: GraphEvents.ON_RUN_STEP,
+        data: createRunStep('step_empty_reasoning'),
+      });
+
+      aggregateContent({
+        event: GraphEvents.ON_REASONING_DELTA,
+        data: {
+          id: 'step_empty_reasoning',
+          delta: { content: [] },
+        },
+      });
+
+      expect(warnSpy).not.toHaveBeenCalled();
+      expect(contentParts).toEqual([]);
+    } finally {
+      warnSpy.mockRestore();
+    }
+  });
+});
+
 describe('ContentAggregator with SplitStreamHandler', () => {
   it('should aggregate content from multiple message blocks', async () => {
     const runId = nanoid();

package/src/stream.ts

@@ -1317,6 +1317,14 @@ export function createContentAggregator(): t.ContentAggregatorResult {
     number,
     { agentId?: string; groupId?: number }
   >();
+  const getFirstContentPart = (
+    content?: t.MessageDelta['content'] | t.MessageContentComplex
+  ): t.MessageContentComplex | undefined => {
+    if (content == null) {
+      return undefined;
+    }
+    return Array.isArray(content) ? content[0] : content;
+  };
 
   const updateContent = (
     index: number,
@@ -1588,11 +1596,8 @@ export function createContentAggregator(): t.ContentAggregatorResult {
         return;
       }
 
-      if (messageDelta.delta.content) {
-        const contentPart = Array.isArray(messageDelta.delta.content)
-          ? messageDelta.delta.content[0]
-          : messageDelta.delta.content;
-
+      const contentPart = getFirstContentPart(messageDelta.delta.content);
+      if (contentPart != null) {
         updateContent(runStep.index, contentPart);
       }
     } else if (
@@ -1612,11 +1617,8 @@ export function createContentAggregator(): t.ContentAggregatorResult {
         return;
       }
 
-      if (reasoningDelta.delta.content) {
-        const contentPart = Array.isArray(reasoningDelta.delta.content)
-          ? reasoningDelta.delta.content[0]
-          : reasoningDelta.delta.content;
-
+      const contentPart = getFirstContentPart(reasoningDelta.delta.content);
+      if (contentPart != null) {
         updateContent(runStep.index, contentPart);
       }
     } else if (event === GraphEvents.ON_RUN_STEP_DELTA) {