@librechat/agents 3.2.62 → 3.2.64

package/src/llm/bedrock/utils/message_inputs.test.ts

@@ -15,7 +15,10 @@ type ConverseResult = ReturnType<typeof convertToConverseMessages>;
 /** Minimal view of a converted Bedrock Converse content block the assertions read. */
 interface ConverseBlock {
   text?: string;
-  reasoningContent?: { reasoningText?: { text?: string; signature?: string } };
+  reasoningContent?: {
+    reasoningText?: { text?: string; signature?: string };
+    redactedContent?: Uint8Array;
+  };
   toolUse?: {
     toolUseId?: string;
     name?: string;
@@ -127,3 +130,275 @@ describe('convertToConverseMessages — native Bedrock reasoning serialization',
     );
   });
 });
+
+/**
+ * Same failure class, v1 converter path. Assistant messages carrying
+ * `response_metadata.output_version === 'v1'` are converted by
+ * `convertFromV1ToChatBedrockConverseMessage`, which serialized `reasoning` /
+ * `reasoning_content` blocks without the null/empty-text guard applied to the
+ * non-v1 path — a `reasoning` block whose `reasoning` is null/empty (e.g. a
+ * model responding with `thinking.display: "omitted"`, the Opus 4.7+ /
+ * Sonnet 5 default) reached Bedrock as `reasoningText: { text: null }` and the
+ * whole request was rejected with `Member must not be null`.
+ */
+describe('convertToConverseMessages — v1 reasoning serialization', () => {
+  const v1Metadata = {
+    output_version: 'v1',
+    model_provider: 'anthropic',
+  } as const;
+
+  it('drops a v1 reasoning block whose reasoning text is missing, keeping text and tool calls', () => {
+    const messages: BaseMessage[] = [
+      new HumanMessage('what data do you have?'),
+      new AIMessage({
+        content: [
+          { type: 'reasoning', reasoning: undefined } as never,
+          { type: 'text', text: 'Let me check your databases.' },
+        ],
+        tool_calls: [
+          {
+            id: 'tooluse_list',
+            name: 'list_databases',
+            args: {},
+            type: 'tool_call',
+          },
+        ],
+        response_metadata: v1Metadata,
+      }),
+    ];
+
+    expect(() => convertToConverseMessages(messages)).not.toThrow();
+    const content = assistantContent(convertToConverseMessages(messages));
+
+    expect(content.find((b) => b.reasoningContent != null)).toBeUndefined();
+    expect(content.some((b) => b.text === 'Let me check your databases.')).toBe(
+      true
+    );
+    const toolUse = content.find((b) => b.toolUse != null);
+    expect(toolUse?.toolUse).toMatchObject({
+      toolUseId: 'tooluse_list',
+      name: 'list_databases',
+    });
+  });
+
+  it('drops a v1 reasoning block whose reasoning text is empty', () => {
+    const messages: BaseMessage[] = [
+      new HumanMessage('hi'),
+      new AIMessage({
+        content: [
+          { type: 'reasoning', reasoning: '' },
+          { type: 'text', text: 'answer' },
+        ],
+        response_metadata: v1Metadata,
+      }),
+    ];
+
+    const content = assistantContent(convertToConverseMessages(messages));
+    expect(content.find((b) => b.reasoningContent != null)).toBeUndefined();
+    expect(content.some((b) => b.text === 'answer')).toBe(true);
+  });
+
+  it('drops a v1 signature-only reasoning_content block', () => {
+    const messages: BaseMessage[] = [
+      new HumanMessage('hi'),
+      new AIMessage({
+        content: [
+          {
+            type: 'reasoning_content',
+            reasoningText: { signature: 'sig-abc' },
+          },
+          { type: 'text', text: 'answer' },
+        ],
+        response_metadata: v1Metadata,
+      }),
+    ];
+
+    expect(() => convertToConverseMessages(messages)).not.toThrow();
+    const content = assistantContent(convertToConverseMessages(messages));
+    expect(content.find((b) => b.reasoningContent != null)).toBeUndefined();
+    expect(JSON.stringify(content)).not.toContain('sig-abc');
+    expect(content.some((b) => b.text === 'answer')).toBe(true);
+  });
+
+  it('emits a placeholder (not empty content) when dropping empties a v1 turn', () => {
+    const messages: BaseMessage[] = [
+      new HumanMessage('hi'),
+      new AIMessage({
+        content: [{ type: 'reasoning', reasoning: undefined } as never],
+        response_metadata: v1Metadata,
+      }),
+    ];
+
+    expect(() => convertToConverseMessages(messages)).not.toThrow();
+    const content = assistantContent(convertToConverseMessages(messages));
+    expect(content.length).toBeGreaterThan(0);
+    expect(content.find((b) => b.reasoningContent != null)).toBeUndefined();
+    expect(content.every((b) => typeof b.text === 'string')).toBe(true);
+  });
+
+  it.each(['', ' \n '])(
+    'emits a placeholder for invalid v1 text %j',
+    (text) => {
+      const messages: BaseMessage[] = [
+        new HumanMessage('hi'),
+        new AIMessage({
+          content: [{ type: 'text', text }],
+          response_metadata: v1Metadata,
+        }),
+      ];
+
+      const content = assistantContent(convertToConverseMessages(messages));
+      expect(content).toEqual([{ text: '_' }]);
+    }
+  );
+
+  it('merges whitespace-only v1 text into the preceding text block', () => {
+    const messages: BaseMessage[] = [
+      new HumanMessage('hi'),
+      new AIMessage({
+        content: [
+          { type: 'text', text: 'answer' },
+          { type: 'text', text: ' \n ' },
+        ],
+        response_metadata: v1Metadata,
+      }),
+    ];
+
+    const content = assistantContent(convertToConverseMessages(messages));
+    expect(content).toEqual([{ text: 'answer \n ' }]);
+  });
+
+  it('merges split v1 reasoning_content text and signature blocks before serialization', () => {
+    const splitContent = [
+      {
+        type: 'reasoning_content',
+        reasoningText: { text: 'first ' },
+      },
+      {
+        type: 'reasoning_content',
+        reasoningText: { text: 'second' },
+      },
+      {
+        type: 'reasoning_content',
+        reasoningText: { signature: 'sig-abc' },
+      },
+      { type: 'text', text: 'answer' },
+    ];
+    const originalContent = structuredClone(splitContent);
+    const messages: BaseMessage[] = [
+      new HumanMessage('hi'),
+      new AIMessage({
+        content: splitContent,
+        response_metadata: v1Metadata,
+      }),
+    ];
+
+    const content = assistantContent(convertToConverseMessages(messages));
+    const reasoning = content.filter((b) => b.reasoningContent != null);
+    expect(reasoning).toHaveLength(1);
+    expect(reasoning[0].reasoningContent?.reasoningText).toEqual({
+      text: 'first second',
+      signature: 'sig-abc',
+    });
+    expect(splitContent).toEqual(originalContent);
+  });
+
+  it('keeps independently signed v1 reasoning blocks separate', () => {
+    const messages: BaseMessage[] = [
+      new HumanMessage('hi'),
+      new AIMessage({
+        content: [
+          {
+            type: 'reasoning_content',
+            reasoningText: { text: 'first', signature: 'sig-first' },
+          },
+          {
+            type: 'reasoning_content',
+            reasoningText: { text: 'second', signature: 'sig-second' },
+          },
+          { type: 'text', text: 'answer' },
+        ],
+        response_metadata: v1Metadata,
+      }),
+    ];
+
+    const content = assistantContent(convertToConverseMessages(messages));
+    expect(
+      content
+        .filter((block) => block.reasoningContent != null)
+        .map((block) => block.reasoningContent?.reasoningText)
+    ).toEqual([
+      { text: 'first', signature: 'sig-first' },
+      { text: 'second', signature: 'sig-second' },
+    ]);
+  });
+
+  it('keeps adjacent redacted v1 reasoning payloads separate', () => {
+    const messages: BaseMessage[] = [
+      new HumanMessage('hi'),
+      new AIMessage({
+        content: [
+          { type: 'reasoning_content', redactedContent: 'YQ==' },
+          { type: 'reasoning_content', redactedContent: 'Yg==' },
+          { type: 'text', text: 'answer' },
+        ],
+        response_metadata: v1Metadata,
+      }),
+    ];
+
+    const content = assistantContent(convertToConverseMessages(messages));
+    const redacted = content
+      .map((block) => block.reasoningContent?.redactedContent)
+      .filter((value): value is Uint8Array => value != null)
+      .map((value) => Buffer.from(value).toString('utf8'));
+    expect(redacted).toEqual(['a', 'b']);
+  });
+
+  it('throws instead of returning empty assistant content for an unhandled v1 block', () => {
+    const messages: BaseMessage[] = [
+      new HumanMessage('hi'),
+      new AIMessage({
+        content: [
+          {
+            type: 'image',
+            source_type: 'base64',
+            data: 'aGVsbG8=',
+            mime_type: 'image/png',
+          } as never,
+        ],
+        response_metadata: v1Metadata,
+      }),
+    ];
+
+    expect(() => convertToConverseMessages(messages)).toThrow(
+      'Unsupported v1 content block type: image'
+    );
+  });
+
+  it('still converts v1 reasoning and reasoning_content blocks that carry text', () => {
+    const messages: BaseMessage[] = [
+      new HumanMessage('hi'),
+      new AIMessage({
+        content: [
+          { type: 'reasoning', reasoning: 'v1 standard reasoning' },
+          {
+            type: 'reasoning_content',
+            reasoningText: { text: 'native reasoning', signature: 'sig' },
+          },
+          { type: 'text', text: 'answer' },
+        ],
+        response_metadata: v1Metadata,
+      }),
+    ];
+
+    const content = assistantContent(convertToConverseMessages(messages));
+    const reasoningTexts = content
+      .filter((b) => b.reasoningContent != null)
+      .map((b) => b.reasoningContent?.reasoningText?.text);
+    expect(reasoningTexts).toEqual([
+      'v1 standard reasoning',
+      'native reasoning',
+    ]);
+    expect(content.some((b) => b.text === 'answer')).toBe(true);
+  });
+});

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

@@ -88,6 +88,29 @@ function isSerializableBedrockReasoningBlock(
   return content.redactedContent != null && content.redactedContent !== '';
 }
 
+function appendSerializableBedrockTextBlock(
+  contentBlocks: BedrockContentBlock[],
+  text: string
+): boolean {
+  if (text === '') {
+    return false;
+  }
+  const cleanedText = text.replace(/\n/g, '').trim();
+  if (cleanedText !== '') {
+    contentBlocks.push({ text });
+    return true;
+  }
+  const lastBlock = contentBlocks[contentBlocks.length - 1] as
+    | BedrockContentBlock
+    | undefined;
+  if (lastBlock == null || !('text' in lastBlock)) {
+    return false;
+  }
+  const mergedTextContent = `${lastBlock.text}${text}`;
+  (lastBlock as { text: string }).text = mergedTextContent;
+  return true;
+}
+
 /**
  * Concatenate consecutive reasoning blocks in content array.
  */
@@ -96,48 +119,57 @@ export function concatenateLangchainReasoningBlocks(
 ): Array<MessageContentComplex | MessageContentReasoningBlock> {
   const result: Array<MessageContentComplex | MessageContentReasoningBlock> =
     [];
+  let pendingReasoning: MessageContentReasoningBlock | undefined;
+
+  const flushPendingReasoning = (): void => {
+    if (pendingReasoning != null) {
+      result.push(pendingReasoning);
+      pendingReasoning = undefined;
+    }
+  };
 
   for (const block of content) {
-    if (block.type === 'reasoning_content') {
-      const currentReasoning = block as MessageContentReasoningBlock;
-      const lastIndex = result.length - 1;
-
-      // Check if we can merge with the previous block
-      if (lastIndex >= 0) {
-        const lastBlock = result[lastIndex];
-        if (
-          lastBlock.type === 'reasoning_content' &&
-          (lastBlock as MessageContentReasoningBlock).reasoningText != null &&
-          currentReasoning.reasoningText != null
-        ) {
-          const lastReasoning = lastBlock as MessageContentReasoningBlock;
-          // Merge consecutive reasoning text blocks
-          const lastText = lastReasoning.reasoningText?.text;
-          const currentText = currentReasoning.reasoningText.text;
-          if (
-            lastText != null &&
-            lastText !== '' &&
-            currentText != null &&
-            currentText !== ''
-          ) {
-            lastReasoning.reasoningText!.text = lastText + currentText;
-          } else if (
-            currentReasoning.reasoningText.signature != null &&
-            currentReasoning.reasoningText.signature !== ''
-          ) {
-            lastReasoning.reasoningText!.signature =
-              currentReasoning.reasoningText.signature;
-          }
-          continue;
-        }
+    if (block.type !== 'reasoning_content') {
+      flushPendingReasoning();
+      result.push(block);
+      continue;
+    }
+
+    const currentReasoning = block as MessageContentReasoningBlock;
+    if (currentReasoning.reasoningText != null) {
+      const previousText = pendingReasoning?.reasoningText?.text;
+      const previousSignature = pendingReasoning?.reasoningText?.signature;
+      const { text, signature } = currentReasoning.reasoningText;
+      const mergedReasoningText: { text?: string; signature?: string } = {};
+      if (previousText !== undefined || text !== undefined) {
+        mergedReasoningText.text = (previousText ?? '') + (text ?? '');
+      }
+      if (previousSignature !== undefined || signature !== undefined) {
+        mergedReasoningText.signature =
+          (previousSignature ?? '') + (signature ?? '');
       }
+      pendingReasoning = {
+        type: 'reasoning_content',
+        reasoningText: mergedReasoningText,
+      };
 
-      result.push({ ...block } as MessageContentReasoningBlock);
-    } else {
-      result.push(block);
+      // A signature seals the accumulated reasoning text. Any following
+      // reasoning block starts a new independently signed Bedrock block.
+      if ('signature' in currentReasoning.reasoningText) {
+        flushPendingReasoning();
+      }
+    }
+
+    if (currentReasoning.redactedContent != null) {
+      flushPendingReasoning();
+      result.push({
+        type: 'reasoning_content',
+        redactedContent: currentReasoning.redactedContent,
+      });
     }
   }
 
+  flushPendingReasoning();
   return result;
 }
 
@@ -666,23 +698,7 @@ function convertAIMessageToConverseMessage(msg: BaseMessage): BedrockMessage {
     concatenatedBlocks.forEach((block) => {
       if (block.type === 'text') {
         const text = (block as { text?: string }).text ?? '';
-        // Skip completely empty text blocks (common in AI messages with tool_use blocks)
-        if (text === '') {
-          return;
-        }
-        // Merge whitespace/newlines with previous text blocks to avoid validation errors.
-        const cleanedText = text.replace(/\n/g, '').trim();
-        if (cleanedText === '') {
-          if (contentBlocks.length > 0) {
-            const lastBlock = contentBlocks[contentBlocks.length - 1];
-            if ('text' in lastBlock) {
-              const mergedTextContent = `${lastBlock.text}${text}`;
-              (lastBlock as { text: string }).text = mergedTextContent;
-            }
-          }
-        } else {
-          contentBlocks.push({ text });
-        }
+        appendSerializableBedrockTextBlock(contentBlocks, text);
       } else if (block.type === 'reasoning_content') {
         const reasoningBlock = block as MessageContentReasoningBlock;
         // Bedrock Converse rejects reasoningContent whose reasoningText.text is
@@ -757,26 +773,35 @@ function convertAIMessageToConverseMessage(msg: BaseMessage): BedrockMessage {
 function convertFromV1ToChatBedrockConverseMessage(
   msg: BaseMessage
 ): BedrockMessage {
+  const contentBlocks: BedrockContentBlock[] = [];
   const assistantMsg: BedrockMessage = {
     role: 'assistant',
-    content: [],
+    content: contentBlocks,
   };
+  let droppedUnserializableContent = false;
+  let unconvertedContentType: string | undefined;
 
   if (Array.isArray(msg.content)) {
-    for (const block of msg.content as Array<
-      MessageContentComplex | MessageContentReasoningBlock
-    >) {
+    const concatenatedBlocks = concatenateLangchainReasoningBlocks(
+      msg.content as Array<MessageContentComplex | MessageContentReasoningBlock>
+    );
+    for (const block of concatenatedBlocks) {
       if (typeof block === 'string') {
-        assistantMsg.content?.push({ text: block });
+        if (!appendSerializableBedrockTextBlock(contentBlocks, block)) {
+          droppedUnserializableContent = true;
+        }
       } else if (block.type === 'text') {
-        assistantMsg.content?.push({ text: (block as { text: string }).text });
+        const text = (block as { text?: string }).text ?? '';
+        if (!appendSerializableBedrockTextBlock(contentBlocks, text)) {
+          droppedUnserializableContent = true;
+        }
       } else if (block.type === 'tool_call') {
         const toolCall = block as {
           id: string;
           name: string;
           args: Record<string, unknown>;
         };
-        assistantMsg.content?.push({
+        contentBlocks.push({
           toolUse: {
             toolUseId: toolCall.id,
             name: toolCall.name,
@@ -784,38 +809,51 @@ function convertFromV1ToChatBedrockConverseMessage(
           },
         } as BedrockContentBlock);
       } else if (block.type === 'reasoning') {
-        const reasoning = block as { reasoning: string };
-        assistantMsg.content?.push({
+        const reasoning = block as { reasoning?: string };
+        /** Bedrock Converse rejects `reasoningText` with a null/empty `text`
+         * (`Member must not be null`), e.g. when the producing model omitted
+         * reasoning text (`thinking.display: "omitted"`) — drop rather than send. */
+        if (reasoning.reasoning == null || reasoning.reasoning === '') {
+          droppedUnserializableContent = true;
+          continue;
+        }
+        contentBlocks.push({
           reasoningContent: {
             reasoningText: { text: reasoning.reasoning },
           },
         } as BedrockContentBlock);
       } else if (block.type === 'reasoning_content') {
-        assistantMsg.content?.push({
-          reasoningContent: langchainReasoningBlockToBedrockReasoningBlock(
-            block as MessageContentReasoningBlock
-          ),
+        const reasoningBlock = block as MessageContentReasoningBlock;
+        if (!isSerializableBedrockReasoningBlock(reasoningBlock)) {
+          droppedUnserializableContent = true;
+          continue;
+        }
+        contentBlocks.push({
+          reasoningContent:
+            langchainReasoningBlockToBedrockReasoningBlock(reasoningBlock),
         } as BedrockContentBlock);
+      } else {
+        unconvertedContentType ??= block.type;
       }
     }
-  } else if (typeof msg.content === 'string' && msg.content !== '') {
-    assistantMsg.content?.push({ text: msg.content });
+  } else if (typeof msg.content === 'string') {
+    if (!appendSerializableBedrockTextBlock(contentBlocks, msg.content)) {
+      droppedUnserializableContent = true;
+    }
   }
 
   // Also handle tool_calls from the message
   if (isAIMessage(msg) && msg.tool_calls != null && msg.tool_calls.length > 0) {
     // Check if tool calls are already in content
     const existingToolUseIds = new Set(
-      assistantMsg.content
-        ?.filter((c) => 'toolUse' in c)
-        .map(
-          (c) => (c as { toolUse: { toolUseId: string } }).toolUse.toolUseId
-        ) ?? []
+      contentBlocks
+        .filter((c) => 'toolUse' in c)
+        .map((c) => (c as { toolUse: { toolUseId: string } }).toolUse.toolUseId)
     );
 
     for (const tc of msg.tool_calls) {
       if (!existingToolUseIds.has(tc.id ?? '')) {
-        assistantMsg.content?.push({
+        contentBlocks.push({
           toolUse: {
             toolUseId: tc.id,
             name: tc.name,
@@ -826,6 +864,16 @@ function convertFromV1ToChatBedrockConverseMessage(
     }
   }
 
+  const hasNoContent = contentBlocks.length === 0;
+  if (hasNoContent && unconvertedContentType != null) {
+    throw new Error(
+      `Unsupported v1 content block type: ${unconvertedContentType}`
+    );
+  }
+  if (hasNoContent && droppedUnserializableContent) {
+    contentBlocks.push({ text: BEDROCK_EMPTY_TEXT_PLACEHOLDER });
+  }
+
   return assistantMsg;
 }
 

package/src/tools/ToolNode.ts

@@ -2746,7 +2746,11 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
             const batchRequest: t.ToolExecuteBatchRequest = {
               toolCalls: dispatchRequests,
               userId: config.configurable?.user_id as string | undefined,
-              agentId: this.agentId,
+              // Dispatch attribution, NOT the hook subagent-scope marker:
+              // hosts key tool/credential lookup on the owning agent, and
+              // the eager path sends `agentContext.agentId` — this must
+              // match it at the top level too.
+              agentId: this.executingAgentId,
               configurable: config.configurable as
                   | Record<string, unknown>
                   | undefined,