@librechat/agents 3.1.75 → 3.1.77-dev.1

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,
@@ -22,6 +28,7 @@ import type {
 import type { RunnableConfig } from '@langchain/core/runnables';
 import { emitAgentLog } from '@/utils/events';
 import { Providers, ContentTypes, Constants } from '@/common';
+import { toLangChainContent, toLangChainMessageFields } from './langchain';
 
 interface MediaMessageParams {
   message: {
@@ -210,7 +217,7 @@ export const formatMessage = ({
       return mediaMessage;
     }
 
-    return new HumanMessage(mediaMessage);
+    return new HumanMessage(toLangChainMessageFields(mediaMessage));
   }
 
   if (!langChain) {
@@ -218,11 +225,11 @@ export const formatMessage = ({
   }
 
   if (role === 'user') {
-    return new HumanMessage(formattedMessage);
+    return new HumanMessage(toLangChainMessageFields(formattedMessage));
   } else if (role === 'assistant') {
-    return new AIMessage(formattedMessage);
+    return new AIMessage(toLangChainMessageFields(formattedMessage));
   } else {
-    return new SystemMessage(formattedMessage);
+    return new SystemMessage(toLangChainMessageFields(formattedMessage));
   }
 };
 
@@ -276,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<
@@ -310,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
@@ -343,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;
@@ -376,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 ||
@@ -410,10 +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: currentContent }));
+    formattedMessages.push(createAIMessage(toLangChainContent(currentContent)));
   }
 
   return formattedMessages;
@@ -829,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>;
@@ -1077,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;
@@ -1542,7 +1622,7 @@ export function ensureThinkingBlockInMessages(
         'ensureThinkingBlockInMessages: injecting [Previous agent context] HumanMessage' +
           ` (${parts.length} msgs at index ${i}, no thinking block in chain)`
       );
-      result.push(new HumanMessage({ content: parts }));
+      result.push(new HumanMessage({ content: toLangChainContent(parts) }));
       i = j;
     } else {
       // Keep the message as is

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 = [
       {

package/src/messages/langchain.ts

@@ -0,0 +1,39 @@
+import type { MessageContent } from '@langchain/core/messages';
+import type * as t from '@/types';
+
+type LibreChatMessageContent =
+  | MessageContent
+  | string
+  | t.MessageContentComplex[]
+  | t.ExtendedMessageContent[];
+
+type WithLangChainContent<T extends { content: LibreChatMessageContent }> =
+  Omit<T, 'content'> & {
+    content: MessageContent;
+  };
+
+/**
+ * Bridges LibreChat's extended content blocks to LangChain 1.x MessageContent.
+ *
+ * LangChain 1.x narrowed message constructor types around ContentBlock, while
+ * LibreChat still carries provider-specific blocks through the same content
+ * field. This helper keeps the runtime shape unchanged during the dependency
+ * upgrade; tracking issue: https://github.com/danny-avila/agents/issues/130.
+ */
+export function toLangChainContent(
+  content: LibreChatMessageContent
+): MessageContent {
+  return content as MessageContent;
+}
+
+/**
+ * Applies the same LangChain 1.x content bridge to message constructor fields.
+ *
+ * Keep this cast-only helper local to constructor boundaries so follow-up work
+ * can replace it with aligned content types or explicit conversion logic.
+ */
+export function toLangChainMessageFields<
+  T extends { content: LibreChatMessageContent },
+>(message: T): WithLangChainContent<T> {
+  return message as WithLangChainContent<T>;
+}

package/src/messages/prune.ts

@@ -19,6 +19,7 @@ import {
 import { resolveContextPruningSettings } from './contextPruningSettings';
 import { ContentTypes, Providers, Constants } from '@/common';
 import { applyContextPruning } from './contextPruning';
+import { toLangChainContent } from './langchain';
 
 function sumTokenCounts(
   tokenMap: Record<string, number | undefined>,
@@ -343,7 +344,7 @@ function stripOrphanToolUseBlocks(
 
   return new AIMessage({
     ...message,
-    content: keptContent,
+    content: toLangChainContent(keptContent),
     tool_calls: keptToolCalls.length > 0 ? keptToolCalls : undefined,
   });
 }
@@ -542,7 +543,7 @@ function addThinkingBlock(
   content.unshift(thinkingBlock);
   return new AIMessage({
     ...message,
-    content,
+    content: toLangChainContent(content),
   });
 }
 
@@ -817,7 +818,7 @@ export function getMessagesWithinTokenLimit({
 
   thinkingStartIndex = originalLength - 1 - assistantIndex;
   const thinkingTokenCount = tokenCounter(
-    new AIMessage({ content: [thinkingBlock] })
+    new AIMessage({ content: toLangChainContent([thinkingBlock]) })
   );
   const newRemainingCount = remainingContextTokens - thinkingTokenCount;
   const newMessage = addThinkingBlock(
@@ -856,7 +857,7 @@ export function getMessagesWithinTokenLimit({
     }
   }
 
-  const firstMessage: AIMessage = newContext[newContext.length - 1];
+  const firstMessage = newContext[newContext.length - 1];
   const firstMessageType = newContext[newContext.length - 1].getType();
   if (firstMessageType === 'tool') {
     startType = ['ai', 'human'];
@@ -887,7 +888,10 @@ export function getMessagesWithinTokenLimit({
   }
 
   if (firstMessageType === 'ai') {
-    const newMessage = addThinkingBlock(firstMessage, thinkingBlock);
+    const newMessage = addThinkingBlock(
+      firstMessage as AIMessage,
+      thinkingBlock
+    );
     newContext[newContext.length - 1] = newMessage;
   } else {
     newContext.push(thinkingMessage);
@@ -1178,7 +1182,7 @@ export function preFlightTruncateToolCallInputs(params: {
 
     messages[i] = new AIMessage({
       ...aiMsg,
-      content: newContent,
+      content: toLangChainContent(newContent),
       tool_calls: newToolCalls.length > 0 ? newToolCalls : undefined,
     });
     indexTokenCountMap[i] = tokenCounter(messages[i]);
@@ -1290,7 +1294,7 @@ export function createPruneMessages(factoryParams: PruneMessagesFactoryParams) {
 
           params.messages[i] = new AIMessage({
             ...message,
-            content: [thinkingBlock],
+            content: toLangChainContent([thinkingBlock]),
             additional_kwargs: {
               ...message.additional_kwargs,
               reasoning_content: undefined,
@@ -1966,7 +1970,7 @@ export function createPruneMessages(factoryParams: PruneMessagesFactoryParams) {
               });
               emergencyMessages[i] = new AIMessage({
                 ...aiMsg,
-                content: newContent,
+                content: toLangChainContent(newContent),
                 tool_calls: newToolCalls.length > 0 ? newToolCalls : undefined,
               });
               indexTokenCountMap[i] = factoryParams.tokenCounter(