@librechat/agents 3.0.775 → 3.1.0

package/src/llm/bedrock/utils/message_outputs.ts

@@ -0,0 +1,310 @@
+/**
+ * Utility functions for converting Bedrock Converse responses to LangChain messages.
+ * Ported from @langchain/aws common.js
+ */
+import { AIMessage, AIMessageChunk } from '@langchain/core/messages';
+import { ChatGenerationChunk } from '@langchain/core/outputs';
+import type {
+  BedrockMessage,
+  ConverseResponse,
+  ContentBlockDeltaEvent,
+  ConverseStreamMetadataEvent,
+  ContentBlockStartEvent,
+  ReasoningContentBlock,
+  ReasoningContentBlockDelta,
+  MessageContentReasoningBlock,
+  MessageContentReasoningBlockReasoningTextPartial,
+  MessageContentReasoningBlockRedacted,
+} from '../types';
+
+/**
+ * Convert a Bedrock reasoning block delta to a LangChain partial reasoning block.
+ */
+export function bedrockReasoningDeltaToLangchainPartialReasoningBlock(
+  reasoningContent: ReasoningContentBlockDelta
+):
+  | MessageContentReasoningBlockReasoningTextPartial
+  | MessageContentReasoningBlockRedacted {
+  const { text, redactedContent, signature } =
+    reasoningContent as ReasoningContentBlockDelta & {
+      text?: string;
+      redactedContent?: Uint8Array;
+      signature?: string;
+    };
+
+  if (typeof text === 'string') {
+    return {
+      type: 'reasoning_content',
+      reasoningText: { text },
+    };
+  }
+  if (signature != null) {
+    return {
+      type: 'reasoning_content',
+      reasoningText: { signature },
+    };
+  }
+  if (redactedContent != null) {
+    return {
+      type: 'reasoning_content',
+      redactedContent: Buffer.from(redactedContent).toString('base64'),
+    };
+  }
+  throw new Error('Invalid reasoning content');
+}
+
+/**
+ * Convert a Bedrock reasoning block to a LangChain reasoning block.
+ */
+export function bedrockReasoningBlockToLangchainReasoningBlock(
+  reasoningContent: ReasoningContentBlock
+): MessageContentReasoningBlock {
+  const { reasoningText, redactedContent } =
+    reasoningContent as ReasoningContentBlock & {
+      reasoningText?: { text?: string; signature?: string };
+      redactedContent?: Uint8Array;
+    };
+
+  if (reasoningText != null) {
+    return {
+      type: 'reasoning_content',
+      reasoningText: reasoningText,
+    };
+  }
+  if (redactedContent != null) {
+    return {
+      type: 'reasoning_content',
+      redactedContent: Buffer.from(redactedContent).toString('base64'),
+    };
+  }
+  throw new Error('Invalid reasoning content');
+}
+
+/**
+ * Convert a Bedrock Converse message to a LangChain message.
+ */
+export function convertConverseMessageToLangChainMessage(
+  message: BedrockMessage,
+  responseMetadata: Omit<ConverseResponse, 'output'>
+): AIMessage {
+  if (message.content == null) {
+    throw new Error('No message content found in response.');
+  }
+  if (message.role !== 'assistant') {
+    throw new Error(
+      `Unsupported message role received in ChatBedrockConverse response: ${message.role}`
+    );
+  }
+
+  let requestId: string | undefined;
+  if (
+    '$metadata' in responseMetadata &&
+    responseMetadata.$metadata != null &&
+    typeof responseMetadata.$metadata === 'object' &&
+    'requestId' in responseMetadata.$metadata
+  ) {
+    requestId = responseMetadata.$metadata.requestId as string;
+  }
+
+  let tokenUsage:
+    | { input_tokens: number; output_tokens: number; total_tokens: number }
+    | undefined;
+  if (responseMetadata.usage != null) {
+    const input_tokens = responseMetadata.usage.inputTokens ?? 0;
+    const output_tokens = responseMetadata.usage.outputTokens ?? 0;
+    tokenUsage = {
+      input_tokens,
+      output_tokens,
+      total_tokens:
+        responseMetadata.usage.totalTokens ?? input_tokens + output_tokens,
+    };
+  }
+
+  if (
+    message.content.length === 1 &&
+    'text' in message.content[0] &&
+    typeof message.content[0].text === 'string'
+  ) {
+    return new AIMessage({
+      content: message.content[0].text,
+      response_metadata: responseMetadata,
+      usage_metadata: tokenUsage,
+      id: requestId,
+    });
+  } else {
+    const toolCalls: Array<{
+      id?: string;
+      name: string;
+      args: Record<string, unknown>;
+      type: 'tool_call';
+    }> = [];
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const content: any[] = [];
+
+    message.content.forEach((c) => {
+      if (
+        'toolUse' in c &&
+        c.toolUse != null &&
+        c.toolUse.name != null &&
+        c.toolUse.name !== '' &&
+        c.toolUse.input != null &&
+        typeof c.toolUse.input === 'object'
+      ) {
+        toolCalls.push({
+          id: c.toolUse.toolUseId,
+          name: c.toolUse.name,
+          args: c.toolUse.input as Record<string, unknown>,
+          type: 'tool_call',
+        });
+      } else if ('text' in c && typeof c.text === 'string') {
+        content.push({ type: 'text', text: c.text });
+      } else if ('reasoningContent' in c && c.reasoningContent != null) {
+        content.push(
+          bedrockReasoningBlockToLangchainReasoningBlock(c.reasoningContent)
+        );
+      } else {
+        content.push(c);
+      }
+    });
+
+    return new AIMessage({
+      content: content.length ? content : '',
+      tool_calls: toolCalls.length ? toolCalls : undefined,
+      response_metadata: responseMetadata,
+      usage_metadata: tokenUsage,
+      id: requestId,
+    });
+  }
+}
+
+/**
+ * Handle a content block delta event from Bedrock Converse stream.
+ */
+export function handleConverseStreamContentBlockDelta(
+  contentBlockDelta: ContentBlockDeltaEvent
+): ChatGenerationChunk {
+  if (contentBlockDelta.delta == null) {
+    throw new Error('No delta found in content block.');
+  }
+
+  if (typeof contentBlockDelta.delta.text === 'string') {
+    return new ChatGenerationChunk({
+      text: contentBlockDelta.delta.text,
+      message: new AIMessageChunk({
+        content: contentBlockDelta.delta.text,
+        response_metadata: {
+          contentBlockIndex: contentBlockDelta.contentBlockIndex,
+        },
+      }),
+    });
+  } else if (contentBlockDelta.delta.toolUse != null) {
+    const index = contentBlockDelta.contentBlockIndex;
+    return new ChatGenerationChunk({
+      text: '',
+      message: new AIMessageChunk({
+        content: '',
+        tool_call_chunks: [
+          {
+            args: contentBlockDelta.delta.toolUse.input as string,
+            index,
+            type: 'tool_call_chunk',
+          },
+        ],
+        response_metadata: {
+          contentBlockIndex: contentBlockDelta.contentBlockIndex,
+        },
+      }),
+    });
+  } else if (contentBlockDelta.delta.reasoningContent != null) {
+    const reasoningBlock =
+      bedrockReasoningDeltaToLangchainPartialReasoningBlock(
+        contentBlockDelta.delta.reasoningContent
+      );
+    // Extract the text for additional_kwargs.reasoning_content (for stream handler compatibility)
+    const reasoningText =
+      'reasoningText' in reasoningBlock
+        ? (reasoningBlock.reasoningText.text ??
+          reasoningBlock.reasoningText.signature ??
+          ('redactedContent' in reasoningBlock
+            ? reasoningBlock.redactedContent
+            : ''))
+        : '';
+    return new ChatGenerationChunk({
+      text: '',
+      message: new AIMessageChunk({
+        content: [reasoningBlock],
+        additional_kwargs: {
+          // Set reasoning_content for stream handler to detect reasoning mode
+          reasoning_content: reasoningText,
+        },
+        response_metadata: {
+          contentBlockIndex: contentBlockDelta.contentBlockIndex,
+        },
+      }),
+    });
+  } else {
+    throw new Error(
+      `Unsupported content block type(s): ${JSON.stringify(contentBlockDelta.delta, null, 2)}`
+    );
+  }
+}
+
+/**
+ * Handle a content block start event from Bedrock Converse stream.
+ */
+export function handleConverseStreamContentBlockStart(
+  contentBlockStart: ContentBlockStartEvent
+): ChatGenerationChunk | null {
+  const index = contentBlockStart.contentBlockIndex;
+
+  if (contentBlockStart.start?.toolUse != null) {
+    return new ChatGenerationChunk({
+      text: '',
+      message: new AIMessageChunk({
+        content: '',
+        tool_call_chunks: [
+          {
+            name: contentBlockStart.start.toolUse.name,
+            id: contentBlockStart.start.toolUse.toolUseId,
+            index,
+            type: 'tool_call_chunk',
+          },
+        ],
+        response_metadata: {
+          contentBlockIndex: index,
+        },
+      }),
+    });
+  }
+
+  // Return null for non-tool content block starts (text blocks don't need special handling)
+  return null;
+}
+
+/**
+ * Handle a metadata event from Bedrock Converse stream.
+ */
+export function handleConverseStreamMetadata(
+  metadata: ConverseStreamMetadataEvent,
+  extra: { streamUsage: boolean }
+): ChatGenerationChunk {
+  const inputTokens = metadata.usage?.inputTokens ?? 0;
+  const outputTokens = metadata.usage?.outputTokens ?? 0;
+  const usage_metadata = {
+    input_tokens: inputTokens,
+    output_tokens: outputTokens,
+    total_tokens: metadata.usage?.totalTokens ?? inputTokens + outputTokens,
+  };
+
+  return new ChatGenerationChunk({
+    text: '',
+    message: new AIMessageChunk({
+      content: '',
+      usage_metadata: extra.streamUsage ? usage_metadata : undefined,
+      response_metadata: {
+        // Use the same key as returned from the Converse API
+        metadata,
+      },
+    }),
+  });
+}

package/src/messages/cache.test.ts

@@ -921,7 +921,7 @@ describe('Immutability - addCacheControl does not mutate original messages', ()
     expect('cache_control' in originalFirstBlock).toBe(true);
   });
 
-  it('should keep lc_kwargs.content in sync with content for LangChain messages', () => {
+  it('should remove lc_kwargs to prevent serialization mismatch for LangChain messages', () => {
     type LangChainLikeMsg = TestMsg & {
       lc_kwargs?: { content?: MessageContentComplex[] };
     };
@@ -955,14 +955,11 @@ describe('Immutability - addCacheControl does not mutate original messages', ()
     const resultFirst = result[0] as LangChainLikeMsg;
     const resultThird = result[2] as LangChainLikeMsg;
 
-    expect(resultFirst.content).toEqual(resultFirst.lc_kwargs?.content);
-    expect(resultThird.content).toEqual(resultThird.lc_kwargs?.content);
+    expect(resultFirst.lc_kwargs).toBeUndefined();
+    expect(resultThird.lc_kwargs).toBeUndefined();
 
     const firstContent = resultFirst.content as MessageContentComplex[];
-    const firstLcContent = resultFirst.lc_kwargs
-      ?.content as MessageContentComplex[];
     expect('cache_control' in firstContent[0]).toBe(true);
-    expect('cache_control' in firstLcContent[0]).toBe(true);
 
     const originalFirst = messagesWithLcKwargs[0];
     const originalContent = originalFirst.content as MessageContentComplex[];
@@ -1100,7 +1097,7 @@ describe('Immutability - addBedrockCacheControl does not mutate original message
     expect('cache_control' in anthropicFirstContent[0]).toBe(true);
   });
 
-  it('should keep lc_kwargs.content in sync with content for LangChain messages', () => {
+  it('should remove lc_kwargs to prevent serialization mismatch for LangChain messages', () => {
     type LangChainLikeMsg = TestMsg & {
       lc_kwargs?: { content?: MessageContentComplex[] };
     };
@@ -1127,14 +1124,11 @@ describe('Immutability - addBedrockCacheControl does not mutate original message
     const resultFirst = bedrockResult[0] as LangChainLikeMsg;
     const resultSecond = bedrockResult[1] as LangChainLikeMsg;
 
-    expect(resultFirst.content).toEqual(resultFirst.lc_kwargs?.content);
-    expect(resultSecond.content).toEqual(resultSecond.lc_kwargs?.content);
+    expect(resultFirst.lc_kwargs).toBeUndefined();
+    expect(resultSecond.lc_kwargs).toBeUndefined();
 
     const firstContent = resultFirst.content as MessageContentComplex[];
-    const firstLcContent = resultFirst.lc_kwargs
-      ?.content as MessageContentComplex[];
     expect(firstContent.some((b) => 'cachePoint' in b)).toBe(true);
-    expect(firstLcContent.some((b) => 'cachePoint' in b)).toBe(true);
 
     const originalFirst = messagesWithLcKwargs[0];
     const originalContent = originalFirst.content as MessageContentComplex[];

package/src/messages/cache.ts

@@ -1,11 +1,4 @@
-import {
-  BaseMessage,
-  MessageContentComplex,
-  AIMessage,
-  HumanMessage,
-  SystemMessage,
-  ToolMessage,
-} from '@langchain/core/messages';
+import { BaseMessage, MessageContentComplex } from '@langchain/core/messages';
 import type { AnthropicMessage } from '@/types/messages';
 import type Anthropic from '@anthropic-ai/sdk';
 import { ContentTypes } from '@/common/enum';
@@ -30,73 +23,42 @@ function deepCloneContent<T extends string | MessageContentComplex[]>(
 }
 
 /**
- * Simple shallow clone with deep-cloned content.
- * Used for stripping cache control where we don't need proper LangChain instances.
+ * Clones a message with deep-cloned content, explicitly excluding LangChain
+ * serialization metadata to prevent coercion issues.
  */
-function shallowCloneMessage<T extends MessageWithContent>(message: T): T {
-  return {
-    ...message,
-    content: deepCloneContent(message.content ?? ''),
-  } as T;
-}
-
-/**
- * Creates a new LangChain message instance with the given content.
- * Required when adding cache points to ensure proper serialization.
- */
-function createNewMessage<T extends MessageWithContent>(
+function cloneMessage<T extends MessageWithContent>(
   message: T,
-  content: MessageContentComplex[]
+  content: string | MessageContentComplex[]
 ): T {
-  if ('getType' in message && typeof message.getType === 'function') {
-    const baseMsg = message as unknown as BaseMessage;
-    const msgType = baseMsg.getType();
-
-    const baseFields = {
-      content,
-      name: baseMsg.name,
-      additional_kwargs: { ...baseMsg.additional_kwargs },
-      response_metadata: { ...baseMsg.response_metadata },
-      id: baseMsg.id,
+  const {
+    lc_kwargs: _lc_kwargs,
+    lc_serializable: _lc_serializable,
+    lc_namespace: _lc_namespace,
+    ...rest
+  } = message as T & {
+    lc_kwargs?: unknown;
+    lc_serializable?: unknown;
+    lc_namespace?: unknown;
+  };
+
+  const cloned = { ...rest, content } as T;
+
+  // LangChain messages don't have a direct 'role' property - derive it from getType()
+  if (
+    'getType' in message &&
+    typeof message.getType === 'function' &&
+    !('role' in cloned)
+  ) {
+    const msgType = (message as unknown as BaseMessage).getType();
+    const roleMap: Record<string, string> = {
+      human: 'user',
+      ai: 'assistant',
+      system: 'system',
+      tool: 'tool',
     };
-
-    switch (msgType) {
-    case 'human':
-      return new HumanMessage(baseFields) as unknown as T;
-    case 'ai': {
-      const aiMsg = baseMsg as AIMessage;
-      return new AIMessage({
-        ...baseFields,
-        tool_calls: aiMsg.tool_calls ? [...aiMsg.tool_calls] : [],
-        invalid_tool_calls: aiMsg.invalid_tool_calls
-          ? [...aiMsg.invalid_tool_calls]
-          : [],
-        usage_metadata: aiMsg.usage_metadata,
-      }) as unknown as T;
-    }
-    case 'system':
-      return new SystemMessage(baseFields) as unknown as T;
-    case 'tool': {
-      const toolMsg = baseMsg as ToolMessage;
-      return new ToolMessage({
-        ...baseFields,
-        tool_call_id: toolMsg.tool_call_id,
-        status: toolMsg.status,
-        artifact: toolMsg.artifact,
-      }) as unknown as T;
-    }
-    default:
-      break;
-    }
+    (cloned as Record<string, unknown>).role = roleMap[msgType] || msgType;
   }
 
-  const cloned = { ...message, content } as T;
-  const lcKwargs = (cloned as Record<string, unknown>).lc_kwargs as
-    | Record<string, unknown>
-    | undefined;
-  if (lcKwargs != null) {
-    (cloned as Record<string, unknown>).lc_kwargs = { ...lcKwargs, content };
-  }
   return cloned;
 }
 
@@ -174,37 +136,28 @@ export function addCacheControl<T extends AnthropicMessage | BaseMessage>(
     }
 
     if (userMessagesModified >= 2 || !isUserMessage) {
-      updatedMessages[i] = shallowCloneMessage(
-        originalMessage as MessageWithContent
+      updatedMessages[i] = cloneMessage(
+        originalMessage as MessageWithContent,
+        workingContent
       ) as T;
-      (updatedMessages[i] as MessageWithContent).content = workingContent;
       continue;
     }
 
-    let cacheAdded = false;
     for (let j = workingContent.length - 1; j >= 0; j--) {
       const contentPart = workingContent[j];
       if ('type' in contentPart && contentPart.type === 'text') {
         (contentPart as Anthropic.TextBlockParam).cache_control = {
           type: 'ephemeral',
         };
-        cacheAdded = true;
         userMessagesModified++;
         break;
       }
     }
 
-    if (cacheAdded) {
-      updatedMessages[i] = createNewMessage(
-        originalMessage as MessageWithContent,
-        workingContent
-      ) as T;
-    } else {
-      updatedMessages[i] = shallowCloneMessage(
-        originalMessage as MessageWithContent
-      ) as T;
-      (updatedMessages[i] as MessageWithContent).content = workingContent;
-    }
+    updatedMessages[i] = cloneMessage(
+      originalMessage as MessageWithContent,
+      workingContent
+    ) as T;
   }
 
   return updatedMessages;
@@ -249,22 +202,14 @@ export function stripAnthropicCacheControl<T extends MessageWithContent>(
       continue;
     }
 
-    const message = shallowCloneMessage(originalMessage);
-    updatedMessages[i] = message;
-
-    for (
-      let j = 0;
-      j < (message.content as MessageContentComplex[]).length;
-      j++
-    ) {
-      const block = (message.content as MessageContentComplex[])[j] as Record<
-        string,
-        unknown
-      >;
+    const clonedContent = deepCloneContent(content);
+    for (let j = 0; j < clonedContent.length; j++) {
+      const block = clonedContent[j] as Record<string, unknown>;
       if ('cache_control' in block) {
         delete block.cache_control;
       }
     }
+    updatedMessages[i] = cloneMessage(originalMessage, clonedContent);
   }
 
   return updatedMessages;
@@ -302,12 +247,10 @@ export function stripBedrockCacheControl<T extends MessageWithContent>(
       continue;
     }
 
-    const message = shallowCloneMessage(originalMessage);
-    updatedMessages[i] = message;
-
-    message.content = (message.content as MessageContentComplex[]).filter(
+    const clonedContent = deepCloneContent(content).filter(
       (block) => !isCachePoint(block as MessageContentComplex)
-    ) as typeof content;
+    );
+    updatedMessages[i] = cloneMessage(originalMessage, clonedContent);
   }
 
   return updatedMessages;
@@ -377,8 +320,7 @@ export function addBedrockCacheControl<
     }
 
     if (messagesModified >= 2 || isToolMessage || isEmptyString) {
-      updatedMessages[i] = shallowCloneMessage(originalMessage);
-      (updatedMessages[i] as MessageWithContent).content = workingContent;
+      updatedMessages[i] = cloneMessage(originalMessage, workingContent);
       continue;
     }
 
@@ -397,8 +339,7 @@ export function addBedrockCacheControl<
     }
 
     if (!hasCacheableContent) {
-      updatedMessages[i] = shallowCloneMessage(originalMessage);
-      (updatedMessages[i] as MessageWithContent).content = workingContent;
+      updatedMessages[i] = cloneMessage(originalMessage, workingContent);
       continue;
     }
 
@@ -424,7 +365,7 @@ export function addBedrockCacheControl<
       } as MessageContentComplex);
     }
 
-    updatedMessages[i] = createNewMessage(originalMessage, workingContent);
+    updatedMessages[i] = cloneMessage(originalMessage, workingContent);
     messagesModified++;
   }
 

package/src/messages/core.ts

@@ -41,7 +41,7 @@ User: ${userMessage[1]}
 const _allowedTypes = ['image_url', 'text', 'tool_use', 'tool_result'];
 const allowedTypesByProvider: Record<string, string[]> = {
   default: _allowedTypes,
-  [Providers.ANTHROPIC]: [..._allowedTypes, 'thinking'],
+  [Providers.ANTHROPIC]: [..._allowedTypes, 'thinking', 'redacted_thinking'],
   [Providers.BEDROCK]: [..._allowedTypes, 'reasoning_content'],
   [Providers.OPENAI]: _allowedTypes,
 };