@librechat/agents 3.1.75-dev.1 → 3.1.76

package/src/llm/openai/utils/messages.test.ts

@@ -0,0 +1,159 @@
+import { AIMessage, HumanMessage, ToolMessage } from '@langchain/core/messages';
+import { _convertMessagesToOpenAIParams } from './index';
+
+describe('_convertMessagesToOpenAIParams', () => {
+  it('includes reasoning_content for assistant messages in tool-call context when requested', () => {
+    const messages = [
+      new AIMessage({
+        content: '',
+        tool_calls: [
+          {
+            id: 'call_1',
+            name: 'calculator',
+            args: { input: '127 * 453' },
+            type: 'tool_call',
+          },
+        ],
+        additional_kwargs: {
+          reasoning_content: 'Need calculator.',
+        },
+      }),
+      new ToolMessage({
+        content: '57531',
+        tool_call_id: 'call_1',
+      }),
+      new AIMessage({
+        content: '127 * 453 = 57531.',
+        additional_kwargs: {
+          reasoning_content: 'Calculator returned 57531.',
+        },
+      }),
+    ];
+
+    const params = _convertMessagesToOpenAIParams(messages, 'deepseek-v4-pro', {
+      includeReasoningContent: true,
+    });
+
+    expect(params).toHaveLength(3);
+    expect(params[0]).toEqual(
+      expect.objectContaining({
+        role: 'assistant',
+        content: '',
+        reasoning_content: 'Need calculator.',
+      })
+    );
+    expect(params[2]).toEqual(
+      expect.objectContaining({
+        role: 'assistant',
+        reasoning_content: 'Calculator returned 57531.',
+      })
+    );
+  });
+
+  it('does not include reasoning_content for no-tool assistant messages', () => {
+    const messages = [
+      new AIMessage({
+        content: '127 * 453 = 57531.',
+        additional_kwargs: {
+          reasoning_content: 'Mental calculation.',
+        },
+      }),
+    ];
+
+    const params = _convertMessagesToOpenAIParams(messages, 'deepseek-v4-pro', {
+      includeReasoningContent: true,
+    });
+
+    expect(params).toHaveLength(1);
+    expect(params[0]).not.toHaveProperty('reasoning_content');
+  });
+
+  it('does not include reasoning_content unless explicitly requested', () => {
+    const messages = [
+      new AIMessage({
+        content: '',
+        tool_calls: [
+          {
+            id: 'call_1',
+            name: 'calculator',
+            args: { input: '127 * 453' },
+            type: 'tool_call',
+          },
+        ],
+        additional_kwargs: {
+          reasoning_content: 'Need calculator.',
+        },
+      }),
+    ];
+
+    const params = _convertMessagesToOpenAIParams(messages, 'deepseek-v4-pro');
+
+    expect(params).toHaveLength(1);
+    expect(params[0]).not.toHaveProperty('reasoning_content');
+  });
+
+  it('keeps reasoning_content latched after tool-call context is established', () => {
+    const messages = [
+      new AIMessage({
+        content: 'No tool was needed.',
+        additional_kwargs: {
+          reasoning_content: 'Initial no-tool reasoning.',
+        },
+      }),
+      new HumanMessage('Use the calculator.'),
+      new AIMessage({
+        content: '',
+        tool_calls: [
+          {
+            id: 'call_1',
+            name: 'calculator',
+            args: { input: '127 * 453' },
+            type: 'tool_call',
+          },
+        ],
+        additional_kwargs: {
+          reasoning_content: 'Need calculator.',
+        },
+      }),
+      new ToolMessage({
+        content: '57531',
+        tool_call_id: 'call_1',
+      }),
+      new AIMessage({
+        content: '127 * 453 = 57531.',
+        additional_kwargs: {
+          reasoning_content: 'Calculator returned 57531.',
+        },
+      }),
+      new HumanMessage('Was that correct?'),
+      new AIMessage({
+        content: 'Yes.',
+        additional_kwargs: {
+          reasoning_content: 'The prior calculator result is available.',
+        },
+      }),
+    ];
+
+    const params = _convertMessagesToOpenAIParams(messages, 'deepseek-v4-pro', {
+      includeReasoningContent: true,
+    });
+
+    expect(params).toHaveLength(7);
+    expect(params[0]).not.toHaveProperty('reasoning_content');
+    expect(params[2]).toEqual(
+      expect.objectContaining({
+        reasoning_content: 'Need calculator.',
+      })
+    );
+    expect(params[4]).toEqual(
+      expect.objectContaining({
+        reasoning_content: 'Calculator returned 57531.',
+      })
+    );
+    expect(params[6]).toEqual(
+      expect.objectContaining({
+        reasoning_content: 'The prior calculator result is available.',
+      })
+    );
+  });
+});

package/src/messages/format.ts

@@ -7,13 +7,19 @@ import {
   HumanMessage,
   SystemMessage,
 } from '@langchain/core/messages';
-import type { MessageContentImageUrl } from '@langchain/core/messages';
+import type {
+  MessageContent,
+  MessageContentImageUrl,
+} from '@langchain/core/messages';
 import type { ToolCall } from '@langchain/core/messages/tool';
 import type {
+  BedrockReasoningContentText,
   ExtendedMessageContent,
+  GoogleReasoningContentText,
   MessageContentComplex,
   ReasoningContentText,
   SummaryContentBlock,
+  ThinkingContentText,
   ToolCallContent,
   ToolCallPart,
   TPayload,
@@ -277,18 +283,86 @@ export const formatFromLangChain = (
   };
 };
 
+interface FormatAssistantMessageOptions {
+  preserveReasoningContent?: boolean;
+}
+
+interface FormatAgentMessagesOptions {
+  provider?: Providers;
+}
+
+function extractReasoningContent(
+  part: MessageContentComplex | undefined | null
+): string {
+  if (part == null || typeof part !== 'object') {
+    return '';
+  }
+  if (part.type === ContentTypes.THINK) {
+    const think = (part as ReasoningContentText).think;
+    return typeof think === 'string' ? think : '';
+  }
+  if (part.type === ContentTypes.THINKING) {
+    const thinking = (part as ThinkingContentText).thinking;
+    return typeof thinking === 'string' ? thinking : '';
+  }
+  if (part.type === ContentTypes.REASONING) {
+    const reasoning = (part as GoogleReasoningContentText).reasoning;
+    return typeof reasoning === 'string' ? reasoning : '';
+  }
+  if (part.type === ContentTypes.REASONING_CONTENT) {
+    const reasoningText = (part as BedrockReasoningContentText).reasoningText;
+    return typeof reasoningText.text === 'string' ? reasoningText.text : '';
+  }
+  return '';
+}
+
 /**
  * Helper function to format an assistant message
  * @param message The message to format
+ * @param options Optional formatting options
  * @returns Array of formatted messages
  */
 function formatAssistantMessage(
-  message: Partial<TMessage>
+  message: Partial<TMessage>,
+  options?: FormatAssistantMessageOptions
 ): Array<AIMessage | ToolMessage> {
   const formattedMessages: Array<AIMessage | ToolMessage> = [];
   let currentContent: MessageContentComplex[] = [];
   let lastAIMessage: AIMessage | null = null;
   let hasReasoning = false;
+  let pendingReasoningContent = '';
+  const shouldPreserveReasoningContent =
+    options?.preserveReasoningContent === true;
+
+  const takePendingReasoningContent = (): string | undefined => {
+    if (!shouldPreserveReasoningContent || !pendingReasoningContent) {
+      return undefined;
+    }
+    const reasoningContent = pendingReasoningContent;
+    pendingReasoningContent = '';
+    return reasoningContent;
+  };
+
+  const createAIMessage = (content: MessageContent): AIMessage => {
+    const reasoningContent = takePendingReasoningContent();
+    return new AIMessage({
+      content,
+      ...(reasoningContent != null && {
+        additional_kwargs: { reasoning_content: reasoningContent },
+      }),
+    });
+  };
+
+  const attachPendingReasoningContent = (aiMessage: AIMessage): void => {
+    const reasoningContent = takePendingReasoningContent();
+    if (reasoningContent == null) {
+      return;
+    }
+    aiMessage.additional_kwargs.reasoning_content =
+      typeof aiMessage.additional_kwargs.reasoning_content === 'string'
+        ? `${aiMessage.additional_kwargs.reasoning_content}${reasoningContent}`
+        : reasoningContent;
+  };
 
   if (Array.isArray(message.content)) {
     for (const part of message.content as Array<
@@ -311,15 +385,13 @@ function formatAssistantMessage(
           }, '');
           content =
             `${content}\n${part[ContentTypes.TEXT] ?? part.text ?? ''}`.trim();
-          lastAIMessage = new AIMessage({ content });
+          lastAIMessage = createAIMessage(content);
           formattedMessages.push(lastAIMessage);
           currentContent = [];
           continue;
         }
         // Create a new AIMessage with this text and prepare for tool calls
-        lastAIMessage = new AIMessage({
-          content: part.text != null ? part.text : '',
-        });
+        lastAIMessage = createAIMessage(part.text != null ? part.text : '');
         formattedMessages.push(lastAIMessage);
       } else if (part.type === ContentTypes.TOOL_CALL) {
         // Skip malformed tool call entries without tool_call property
@@ -344,8 +416,10 @@ function formatAssistantMessage(
 
         if (!lastAIMessage) {
           // "Heal" the payload by creating an AIMessage to precede the tool call
-          lastAIMessage = new AIMessage({ content: '' });
+          lastAIMessage = createAIMessage('');
           formattedMessages.push(lastAIMessage);
+        } else {
+          attachPendingReasoningContent(lastAIMessage);
         }
 
         const tool_call: ToolCallPart = _tool_call;
@@ -377,10 +451,12 @@ function formatAssistantMessage(
       } else if (
         part.type === ContentTypes.THINK ||
         part.type === ContentTypes.THINKING ||
+        part.type === ContentTypes.REASONING ||
         part.type === ContentTypes.REASONING_CONTENT ||
         part.type === 'redacted_thinking'
       ) {
         hasReasoning = true;
+        pendingReasoningContent += extractReasoningContent(part);
         continue;
       } else if (
         part.type === ContentTypes.ERROR ||
@@ -411,12 +487,10 @@ function formatAssistantMessage(
       .trim();
 
     if (content) {
-      formattedMessages.push(new AIMessage({ content }));
+      formattedMessages.push(createAIMessage(content));
     }
   } else if (currentContent.length > 0) {
-    formattedMessages.push(
-      new AIMessage({ content: toLangChainContent(currentContent) })
-    );
+    formattedMessages.push(createAIMessage(toLangChainContent(currentContent)));
   }
 
   return formattedMessages;
@@ -832,7 +906,8 @@ export const formatAgentMessages = (
   /** Pre-resolved skill bodies keyed by skill name. When present, HumanMessages
    *  are reconstructed after skill ToolMessages to restore skill instructions
    *  that were only in LangGraph state during the original run. */
-  skills?: Map<string, string>
+  skills?: Map<string, string>,
+  options?: FormatAgentMessagesOptions
 ): {
   messages: Array<HumanMessage | AIMessage | SystemMessage | ToolMessage>;
   indexTokenCountMap?: Record<number, number>;
@@ -1080,7 +1155,9 @@ export const formatAgentMessages = (
       }
     }
 
-    const formattedMessages = formatAssistantMessage(processedMessage);
+    const formattedMessages = formatAssistantMessage(processedMessage, {
+      preserveReasoningContent: options?.provider === Providers.DEEPSEEK,
+    });
     if (sourceMessageId != null && sourceMessageId !== '') {
       for (const formattedMessage of formattedMessages) {
         formattedMessage.id = sourceMessageId;

package/src/messages/formatAgentMessages.test.ts

@@ -6,7 +6,7 @@ import {
 } from '@langchain/core/messages';
 import type { MessageContentComplex, TPayload } from '@/types';
 import { formatAgentMessages } from './format';
-import { ContentTypes } from '@/common';
+import { ContentTypes, Providers } from '@/common';
 
 describe('formatAgentMessages', () => {
   it('should format simple user and AI messages', () => {
@@ -967,6 +967,171 @@ describe('formatAgentMessages', () => {
     );
   });
 
+  it('should preserve hidden reasoning_content for DeepSeek assistant messages', () => {
+    const payload: TPayload = [
+      {
+        role: 'assistant',
+        content: [
+          {
+            type: ContentTypes.THINK,
+            [ContentTypes.THINK]: 'Need calculator.',
+          },
+          {
+            type: ContentTypes.TEXT,
+            [ContentTypes.TEXT]: 'Using calculator.',
+            tool_call_ids: ['call_1'],
+          },
+          {
+            type: ContentTypes.TOOL_CALL,
+            tool_call: {
+              id: 'call_1',
+              name: 'calculator',
+              args: '{"input":"127 * 453"}',
+              output: '57531',
+            },
+          },
+          {
+            type: ContentTypes.THINK,
+            [ContentTypes.THINK]: 'Calculator returned 57531.',
+          },
+          {
+            type: ContentTypes.TEXT,
+            [ContentTypes.TEXT]: '127 * 453 = 57531.',
+          },
+        ],
+      },
+    ];
+
+    const defaultResult = formatAgentMessages(payload);
+    expect(
+      (defaultResult.messages[0] as AIMessage).additional_kwargs
+        .reasoning_content
+    ).toBeUndefined();
+
+    const result = formatAgentMessages(
+      payload,
+      undefined,
+      undefined,
+      undefined,
+      { provider: Providers.DEEPSEEK }
+    );
+
+    expect(result.messages).toHaveLength(3);
+    expect(result.messages[0]).toBeInstanceOf(AIMessage);
+    expect(result.messages[1]).toBeInstanceOf(ToolMessage);
+    expect(result.messages[2]).toBeInstanceOf(AIMessage);
+
+    const toolCallMessage = result.messages[0] as AIMessage;
+    const finalMessage = result.messages[2] as AIMessage;
+
+    expect(toolCallMessage.content).toBe('Using calculator.');
+    expect(toolCallMessage.tool_calls).toHaveLength(1);
+    expect(toolCallMessage.additional_kwargs.reasoning_content).toBe(
+      'Need calculator.'
+    );
+    expect(finalMessage.content).toBe('127 * 453 = 57531.');
+    expect(finalMessage.additional_kwargs.reasoning_content).toBe(
+      'Calculator returned 57531.'
+    );
+  });
+
+  it('should preserve DeepSeek reasoning from supported hidden content blocks', () => {
+    const payload: TPayload = [
+      {
+        role: 'assistant',
+        content: [
+          {
+            type: ContentTypes.THINK,
+            [ContentTypes.THINK]: 'Think. ',
+          },
+          {
+            type: ContentTypes.THINKING,
+            thinking: 'Thinking. ',
+          },
+          {
+            type: ContentTypes.REASONING,
+            reasoning: 'Reasoning. ',
+          },
+          {
+            type: ContentTypes.REASONING_CONTENT,
+            reasoningText: { text: 'Reasoning content.' },
+          },
+          {
+            type: ContentTypes.TEXT,
+            [ContentTypes.TEXT]: 'Done.',
+          },
+        ],
+      },
+    ];
+
+    const result = formatAgentMessages(
+      payload,
+      undefined,
+      undefined,
+      undefined,
+      { provider: Providers.DEEPSEEK }
+    );
+
+    expect(result.messages).toHaveLength(1);
+    expect(result.messages[0]).toBeInstanceOf(AIMessage);
+    expect(result.messages[0].content).toBe('Done.');
+    expect(
+      (result.messages[0] as AIMessage).additional_kwargs.reasoning_content
+    ).toBe('Think. Thinking. Reasoning. Reasoning content.');
+  });
+
+  it('should attach later DeepSeek reasoning to an existing tool-call assistant message', () => {
+    const payload: TPayload = [
+      {
+        role: 'assistant',
+        content: [
+          {
+            type: ContentTypes.THINK,
+            [ContentTypes.THINK]: 'Need calculator. ',
+          },
+          {
+            type: ContentTypes.TEXT,
+            [ContentTypes.TEXT]: 'Using calculator.',
+            tool_call_ids: ['call_1'],
+          },
+          {
+            type: ContentTypes.THINK,
+            [ContentTypes.THINK]: 'Preparing tool call.',
+          },
+          {
+            type: ContentTypes.TOOL_CALL,
+            tool_call: {
+              id: 'call_1',
+              name: 'calculator',
+              args: '{"input":"127 * 453"}',
+              output: '57531',
+            },
+          },
+        ],
+      },
+    ];
+
+    const result = formatAgentMessages(
+      payload,
+      undefined,
+      undefined,
+      undefined,
+      { provider: Providers.DEEPSEEK }
+    );
+
+    expect(result.messages).toHaveLength(2);
+    expect(result.messages[0]).toBeInstanceOf(AIMessage);
+    expect(result.messages[1]).toBeInstanceOf(ToolMessage);
+
+    const toolCallMessage = result.messages[0] as AIMessage;
+
+    expect(toolCallMessage.content).toBe('Using calculator.');
+    expect(toolCallMessage.tool_calls).toHaveLength(1);
+    expect(toolCallMessage.additional_kwargs.reasoning_content).toBe(
+      'Need calculator. Preparing tool call.'
+    );
+  });
+
   it('should strip thinking blocks and join TEXT parts as string', () => {
     const payload = [
       {