@librechat/agents 3.3.3 → 3.3.4

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

@@ -4,13 +4,14 @@
  * This util file contains functions for converting LangChain messages to Anthropic messages.
  */
 import { createHash } from 'node:crypto';
+import { isProxy } from 'node:util/types';
 import { ToolCall } from '@langchain/core/messages/tool';
 import {
   type BaseMessage,
   type SystemMessage,
   HumanMessage,
   type AIMessage,
-  type ToolMessage,
+  ToolMessage,
   isAIMessage,
   type Data,
   type StandardContentBlockConverter,
@@ -33,6 +34,11 @@ import {
   AnthropicCompactionBlockParam,
   AnthropicToolResponse,
 } from '../types';
+import {
+  cloneToolMessageWithContent,
+  serializeStructuredValueBounded,
+} from '@/utils/toolContent';
+import { HARD_MAX_TOOL_RESULT_CHARS } from '@/utils/truncation';
 import { Constants } from '@/common';
 
 type StandardTextBlock = Data.StandardTextBlock;
@@ -157,11 +163,25 @@ function hoistToolResultCacheControl(
   }
   let cacheControl: unknown;
   const stripped = content.map((block) => {
-    if ('cache_control' in block) {
-      cacheControl ??= (block as Record<string, unknown>).cache_control;
-      const clone = { ...(block as Record<string, unknown>) };
-      delete clone.cache_control;
-      return clone as MessageContentComplex;
+    if (typeof block !== 'object' || block == null || isProxy(block)) {
+      return block;
+    }
+    try {
+      const descriptors = Object.getOwnPropertyDescriptors(block);
+      const cacheControlDescriptor = descriptors.cache_control;
+      if (
+        cacheControlDescriptor.enumerable === true &&
+        'value' in cacheControlDescriptor
+      ) {
+        cacheControl ??= cacheControlDescriptor.value;
+        delete descriptors.cache_control;
+        return Object.create(
+          Object.getPrototypeOf(block),
+          descriptors
+        ) as MessageContentComplex;
+      }
+    } catch {
+      return block;
     }
     return block;
   });
@@ -169,6 +189,115 @@ function hoistToolResultCacheControl(
   return { content: stripped, cacheControl };
 }
 
+/**
+ * A ToolMessage can already contain an Anthropic-native `tool_result` block
+ * (for example, when a tool returns provider-native structured content). The
+ * outer ToolMessage conversion supplies the one required result envelope, so
+ * unwrap an exact single nested envelope rather than sending an invalid
+ * `tool_result.content: [{ type: "tool_result", ... }]` payload.
+ */
+function unwrapToolMessageResultContent(content: ToolMessage['content']): {
+  content: string | MessageContentComplex[] | undefined;
+  cacheControl: unknown;
+  isError: boolean | undefined;
+} {
+  if (!Array.isArray(content) || content.length !== 1) {
+    return { content, cacheControl: undefined, isError: undefined };
+  }
+
+  const block = content[0];
+  if (typeof block !== 'object' || block == null || isProxy(block)) {
+    return { content, cacheControl: undefined, isError: undefined };
+  }
+
+  try {
+    const type = Object.getOwnPropertyDescriptor(block, 'type');
+    const nestedContent = Object.getOwnPropertyDescriptor(block, 'content');
+    if (
+      type?.enumerable !== true ||
+      !('value' in type) ||
+      type.value !== 'tool_result' ||
+      (nestedContent != null &&
+        (nestedContent.enumerable !== true || !('value' in nestedContent)))
+    ) {
+      return { content, cacheControl: undefined, isError: undefined };
+    }
+
+    const cacheControl = Object.getOwnPropertyDescriptor(
+      block,
+      'cache_control'
+    );
+    const isError = Object.getOwnPropertyDescriptor(block, 'is_error');
+    const nested =
+      nestedContent != null && 'value' in nestedContent
+        ? nestedContent.value
+        : undefined;
+    if (typeof nested === 'string') {
+      return {
+        content: nested,
+        cacheControl:
+          cacheControl?.enumerable === true && 'value' in cacheControl
+            ? cacheControl.value
+            : undefined,
+        isError:
+          isError?.enumerable === true &&
+          'value' in isError &&
+          typeof isError.value === 'boolean'
+            ? isError.value
+            : undefined,
+      };
+    }
+    if (Array.isArray(nested)) {
+      return {
+        content: nested as MessageContentComplex[],
+        cacheControl:
+          cacheControl?.enumerable === true && 'value' in cacheControl
+            ? cacheControl.value
+            : undefined,
+        isError:
+          isError?.enumerable === true &&
+          'value' in isError &&
+          typeof isError.value === 'boolean'
+            ? isError.value
+            : undefined,
+      };
+    }
+    if (nested == null) {
+      return {
+        content: undefined,
+        cacheControl:
+          cacheControl?.enumerable === true && 'value' in cacheControl
+            ? cacheControl.value
+            : undefined,
+        isError:
+          isError?.enumerable === true &&
+          'value' in isError &&
+          typeof isError.value === 'boolean'
+            ? isError.value
+            : undefined,
+      };
+    }
+    return {
+      content: serializeStructuredValueBounded(
+        nested,
+        HARD_MAX_TOOL_RESULT_CHARS
+      ).content,
+      cacheControl:
+        cacheControl?.enumerable === true && 'value' in cacheControl
+          ? cacheControl.value
+          : undefined,
+      isError:
+        isError?.enumerable === true &&
+        'value' in isError &&
+        typeof isError.value === 'boolean'
+          ? isError.value
+          : undefined,
+    };
+  } catch {
+    return { content, cacheControl: undefined, isError: undefined };
+  }
+}
+
 function _ensureMessageContents(
   messages: BaseMessage[]
 ): (SystemMessage | HumanMessage | AIMessage)[] {
@@ -209,21 +338,38 @@ function _ensureMessageContents(
           );
         }
       } else {
-        const toolMessageContent = (
-          message as { content?: BaseMessage['content'] | null }
-        ).content;
+        const toolMessage = message as ToolMessage;
+        const toolMessageContent = toolMessage.content;
+        const unwrapped = unwrapToolMessageResultContent(toolMessageContent);
+        const formattedContent =
+          unwrapped.content == null
+            ? undefined
+            : _formatContent(
+              unwrapped.content === toolMessageContent
+                ? toolMessage
+                : cloneToolMessageWithContent(
+                  toolMessage,
+                      unwrapped.content as Parameters<
+                        typeof cloneToolMessageWithContent
+                      >[1]
+                )
+            );
         // Hoist a tail cache_control off the inner content onto the
         // tool_result block itself (the documented cacheable position).
-        const { content: hoistedContent, cacheControl } =
-          toolMessageContent != null
-            ? hoistToolResultCacheControl(_formatContent(message))
+        const { content: hoistedContent, cacheControl: innerCacheControl } =
+          formattedContent != null
+            ? hoistToolResultCacheControl(formattedContent)
             : { content: undefined, cacheControl: undefined };
+        const cacheControl = unwrapped.cacheControl ?? innerCacheControl;
         updatedMsgs.push(
           new HumanMessage({
             content: [
               {
                 type: 'tool_result',
                 ...(hoistedContent != null ? { content: hoistedContent } : {}),
+                ...(unwrapped.isError != null
+                  ? { is_error: unwrapped.isError }
+                  : {}),
                 ...(cacheControl != null
                   ? { cache_control: cacheControl as { type: 'ephemeral' } }
                   : {}),

package/src/llm/anthropic/utils/tool-id-normalization.test.ts

@@ -84,6 +84,115 @@ describe('normalizeAnthropicToolCallId', () => {
 });
 
 describe('_convertMessagesToAnthropicPayload — cross-provider ID normalization', () => {
+  it('flattens an Anthropic-native tool_result returned by a tool', () => {
+    const toolCallId = 'toolu_native_result';
+    const payload = _convertMessagesToAnthropicPayload([
+      new HumanMessage('run the native tool'),
+      new AIMessage({
+        content: '',
+        tool_calls: [
+          {
+            id: toolCallId,
+            name: 'native_tool',
+            args: {},
+            type: 'tool_call',
+          },
+        ],
+      }),
+      new ToolMessage({
+        tool_call_id: toolCallId,
+        content: [
+          {
+            type: 'tool_result',
+            tool_use_id: toolCallId,
+            cache_control: { type: 'ephemeral', ttl: '1h' },
+            is_error: true,
+            content: [
+              {
+                type: 'text',
+                text: 'native result',
+                cache_control: { type: 'ephemeral' },
+              },
+              {
+                type: 'image_url',
+                image_url: 'data:image/png;base64,AA==',
+              },
+            ],
+          },
+        ],
+      }),
+    ]);
+
+    const result = (
+      payload.messages.find(
+        (message) =>
+          message.role === 'user' &&
+          Array.isArray(message.content) &&
+          message.content.some((block) => block.type === 'tool_result')
+      )!.content as unknown as Array<Record<string, unknown>>
+    ).find((block) => block.type === 'tool_result')!;
+
+    expect(result).toEqual({
+      type: 'tool_result',
+      tool_use_id: toolCallId,
+      cache_control: { type: 'ephemeral', ttl: '1h' },
+      is_error: true,
+      content: [
+        { type: 'text', text: 'native result' },
+        {
+          type: 'image',
+          source: {
+            type: 'base64',
+            media_type: 'image/png',
+            data: 'AA==',
+          },
+        },
+      ],
+    });
+    expect(
+      (result.content as unknown as Array<Record<string, unknown>>).some(
+        (block) => block.type === 'tool_result'
+      )
+    ).toBe(false);
+  });
+
+  it('flattens a content-less native error tool_result', () => {
+    const toolCallId = 'toolu_empty_error';
+    const payload = _convertMessagesToAnthropicPayload([
+      new AIMessage({
+        content: '',
+        tool_calls: [
+          {
+            id: toolCallId,
+            name: 'native_tool',
+            args: {},
+            type: 'tool_call',
+          },
+        ],
+      }),
+      new ToolMessage({
+        tool_call_id: toolCallId,
+        content: [
+          {
+            type: 'tool_result',
+            tool_use_id: toolCallId,
+            is_error: true,
+          },
+        ],
+      }),
+    ]);
+
+    const result = (
+      payload.messages.find((message) => message.role === 'user')!
+        .content as unknown as Array<Record<string, unknown>>
+    )[0];
+    expect(result).toEqual({
+      type: 'tool_result',
+      tool_use_id: toolCallId,
+      is_error: true,
+    });
+  });
+
   it('normalizes Responses-style IDs on tool_use AND matching tool_result', () => {
     const responsesId = 'fc_67abc1234def567|call_abc123def456ghi789jkl0mnopqrs';
 

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

@@ -1,6 +1,7 @@
-import { AIMessage, HumanMessage } from '@langchain/core/messages';
+import { AIMessage, HumanMessage, ToolMessage } from '@langchain/core/messages';
 import type { BaseMessage } from '@langchain/core/messages';
 import { convertToConverseMessages } from './message_inputs';
+import { toLangChainContent } from '@/messages/langchain';
 
 /**
  * Native-Bedrock reasoning serialization. A `reasoning_content` block whose
@@ -31,6 +32,53 @@ const assistantContent = (result: ConverseResult): ConverseBlock[] => {
   return (msg?.content ?? []) as ConverseBlock[];
 };
 
+describe('convertToConverseMessages — Anthropic tool replay', () => {
+  it('deduplicates raw tool_use blocks and unwraps tool_result content', () => {
+    const messages: BaseMessage[] = [
+      new HumanMessage('Search'),
+      new AIMessage({
+        content: toLangChainContent([
+          { type: 'text', text: 'Searching.' },
+          {
+            type: 'tool_use',
+            id: 'call_search',
+            name: 'search',
+            input: '',
+          },
+        ]),
+        tool_calls: [
+          {
+            id: 'call_search',
+            name: 'search',
+            args: { query: 'test' },
+          },
+        ],
+      }),
+      new ToolMessage({
+        content: toLangChainContent([
+          {
+            type: 'tool_result',
+            tool_use_id: 'call_search',
+            is_error: true,
+            content: 'result body',
+          },
+        ]),
+        tool_call_id: 'call_search',
+      }),
+    ];
+
+    const converted = convertToConverseMessages(messages);
+    const serialized = JSON.stringify(converted);
+
+    expect(serialized.match(/"toolUseId":"call_search"/g)).toHaveLength(2);
+    expect(serialized.match(/"toolUse":/g)).toHaveLength(1);
+    expect(serialized.match(/"toolResult":/g)).toHaveLength(1);
+    expect(serialized).toContain('"text":"result body"');
+    expect(serialized).toContain('"status":"error"');
+    expect(serialized).not.toContain('"type":"tool_result"');
+  });
+});
+
 describe('convertToConverseMessages — native Bedrock reasoning serialization', () => {
   it('drops a signature-only reasoning block, keeping text and tool calls', () => {
     const messages: BaseMessage[] = [

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

@@ -4,6 +4,7 @@
  */
 import {
   type BaseMessage,
+  type ToolMessage,
   isAIMessage,
   type Data,
   parseBase64DataUrl,
@@ -27,6 +28,8 @@ import type {
   BedrockContentBlock,
   MessageContentReasoningBlock,
 } from '../types';
+import { serializeStructuredValueBounded } from '@/utils/toolContent';
+import { HARD_MAX_TOOL_RESULT_CHARS } from '@/utils/truncation';
 
 /**
  * Reasoning blocks from other providers, relative to Bedrock. Bedrock's native
@@ -698,6 +701,13 @@ function convertAIMessageToConverseMessage(msg: BaseMessage): BedrockMessage {
   if (typeof msg.content === 'string' && msg.content !== '') {
     assistantMsg.content?.push({ text: msg.content });
   } else if (Array.isArray(msg.content)) {
+    const parsedToolCallIds = new Set(
+      isAIMessage(msg)
+        ? (msg.tool_calls ?? []).flatMap((toolCall) =>
+          toolCall.id != null ? [toolCall.id] : []
+        )
+        : []
+    );
     const concatenatedBlocks = concatenateLangchainReasoningBlocks(
       msg.content as Array<MessageContentComplex | MessageContentReasoningBlock>
     );
@@ -707,6 +717,33 @@ function convertAIMessageToConverseMessage(msg: BaseMessage): BedrockMessage {
       if (block.type === 'text') {
         const text = (block as { text?: string }).text ?? '';
         appendSerializableBedrockTextBlock(contentBlocks, text);
+      } else if (block.type === 'tool_use') {
+        const toolUse = block as {
+          id?: unknown;
+          name?: unknown;
+          input?: unknown;
+        };
+        if (
+          typeof toolUse.id === 'string' &&
+          parsedToolCallIds.has(toolUse.id)
+        ) {
+          return;
+        }
+        if (
+          typeof toolUse.id !== 'string' ||
+          typeof toolUse.name !== 'string' ||
+          toolUse.input == null ||
+          typeof toolUse.input !== 'object'
+        ) {
+          throw new Error('Invalid Anthropic tool_use content block');
+        }
+        contentBlocks.push({
+          toolUse: {
+            toolUseId: toolUse.id,
+            name: toolUse.name,
+            input: toolUse.input as Record<string, unknown>,
+          },
+        } as BedrockContentBlock);
       } else if (block.type === 'reasoning_content') {
         const reasoningBlock = block as MessageContentReasoningBlock;
         // Bedrock Converse rejects reasoningContent whose reasoningText.text is
@@ -756,13 +793,20 @@ function convertAIMessageToConverseMessage(msg: BaseMessage): BedrockMessage {
 
   // Important: this must be placed after any reasoning content blocks
   if (isAIMessage(msg) && msg.tool_calls != null && msg.tool_calls.length > 0) {
-    const toolUseBlocks = msg.tool_calls.map((tc) => ({
-      toolUse: {
-        toolUseId: tc.id,
-        name: tc.name,
-        input: tc.args as Record<string, unknown>,
-      },
-    }));
+    const existingToolUseIds = new Set(
+      (assistantMsg.content ?? [])
+        .filter((content) => 'toolUse' in content)
+        .map((content) => content.toolUse?.toolUseId)
+    );
+    const toolUseBlocks = msg.tool_calls
+      .filter((toolCall) => !existingToolUseIds.has(toolCall.id))
+      .map((toolCall) => ({
+        toolUse: {
+          toolUseId: toolCall.id,
+          name: toolCall.name,
+          input: toolCall.args as Record<string, unknown>,
+        },
+      }));
     assistantMsg.content = [
       ...(assistantMsg.content ?? []),
       ...toolUseBlocks,
@@ -917,17 +961,45 @@ function convertHumanMessageToConverseMessage(
  */
 function convertToolMessageToConverseMessage(msg: BaseMessage): BedrockMessage {
   const toolCallId = (msg as { tool_call_id?: string }).tool_call_id;
+  let isError = (msg as ToolMessage).status === 'error';
 
   let content: BedrockContentBlock[];
   if (typeof msg.content === 'string') {
     content = [{ text: msg.content }];
   } else if (Array.isArray(msg.content)) {
-    content = msg.content.map((block) =>
-      convertLangChainContentBlockToConverseContentBlock({
-        block,
-        onUnknown: 'passthrough',
-      })
-    );
+    content = msg.content.flatMap((block) => {
+      if (typeof block === 'object' && block.type === 'tool_result') {
+        if ((block as { is_error?: unknown }).is_error === true) {
+          isError = true;
+        }
+        const toolResultContent = (block as { content?: unknown }).content;
+        if (typeof toolResultContent === 'string') {
+          return [{ text: toolResultContent }];
+        }
+        if (Array.isArray(toolResultContent)) {
+          return toolResultContent.map((nestedBlock) =>
+            convertLangChainContentBlockToConverseContentBlock({
+              block: nestedBlock,
+              onUnknown: 'passthrough',
+            })
+          );
+        }
+        return [
+          {
+            text: serializeStructuredValueBounded(
+              toolResultContent,
+              HARD_MAX_TOOL_RESULT_CHARS
+            ).content,
+          },
+        ];
+      }
+      return [
+        convertLangChainContentBlockToConverseContentBlock({
+          block,
+          onUnknown: 'passthrough',
+        }),
+      ];
+    });
   } else {
     content = [{ text: String(msg.content) }];
   }
@@ -958,6 +1030,7 @@ function convertToolMessageToConverseMessage(msg: BaseMessage): BedrockMessage {
         toolResult: {
           toolUseId: toolCallId,
           content: toolResultContent as { text: string }[],
+          ...(isError ? { status: 'error' as const } : {}),
         },
       },
       ...trailingCachePoints,

package/src/llm/google/utils/common.test.ts

@@ -1,6 +1,9 @@
 import { expect, test, describe } from '@jest/globals';
-import { AIMessageChunk } from '@langchain/core/messages';
-import type { Content, EnhancedGenerateContentResponse } from '@google/generative-ai';
+import { AIMessage, AIMessageChunk } from '@langchain/core/messages';
+import type {
+  Content,
+  EnhancedGenerateContentResponse,
+} from '@google/generative-ai';
 import {
   STREAMED_TOOL_CALL_SEAL_METADATA_KEY,
   STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY,
@@ -8,9 +11,53 @@ import {
 } from '@/tools/streamedToolCallSeals';
 import {
   convertResponseContentToChatGenerationChunk,
+  convertMessageContentToParts,
   dropUnsupportedModelTurnPrefill,
   rejectsModelTurnPrefill,
 } from './common';
+import { toLangChainContent } from '@/messages/langchain';
+
+describe('convertMessageContentToParts cross-provider tool calls', () => {
+  test('deduplicates Anthropic tool_use content mirrored in parsed tool_calls', () => {
+    const message = new AIMessage({
+      content: toLangChainContent([
+        { type: 'text', text: 'Checking.' },
+        {
+          type: 'tool_use',
+          id: 'call_weather',
+          name: 'weather',
+          input: '',
+        },
+        { type: 'text', index: 0, input: '{"city":"NYC"}' },
+      ]),
+      tool_calls: [
+        {
+          id: 'call_weather',
+          name: 'weather',
+          args: { city: 'NYC' },
+        },
+      ],
+    });
+
+    const parts = convertMessageContentToParts(
+      message,
+      false,
+      [],
+      'gemini-3.5-flash'
+    );
+    const functionCalls = parts.filter((part) => 'functionCall' in part);
+
+    expect(functionCalls).toHaveLength(1);
+    expect(parts).not.toContainEqual({});
+    expect(functionCalls[0]).toMatchObject({
+      functionCall: {
+        id: 'call_weather',
+        name: 'weather',
+        args: { city: 'NYC' },
+      },
+    });
+  });
+});
 
 function buildResponse(
   parts: Array<Record<string, unknown>>
@@ -72,7 +119,9 @@ describe('rejectsModelTurnPrefill', () => {
     expect(rejectsModelTurnPrefill('gemini-3.6-flash')).toBe(true);
     expect(rejectsModelTurnPrefill('gemini-3.5-flash-lite')).toBe(true);
     expect(rejectsModelTurnPrefill('models/gemini-3.6-flash')).toBe(true);
-    expect(rejectsModelTurnPrefill('google/gemini-3.5-flash-lite-latest')).toBe(true);
+    expect(rejectsModelTurnPrefill('google/gemini-3.5-flash-lite-latest')).toBe(
+      true
+    );
   });
 
   test('is false for models that still accept prefill and for empty input', () => {
@@ -86,34 +135,51 @@ describe('rejectsModelTurnPrefill', () => {
 
 describe('dropUnsupportedModelTurnPrefill', () => {
   const userTurn: Content = { role: 'user', parts: [{ text: 'Hi' }] };
-  const modelTurn: Content = { role: 'model', parts: [{ text: 'Hello, I am' }] };
+  const modelTurn: Content = {
+    role: 'model',
+    parts: [{ text: 'Hello, I am' }],
+  };
 
   test('drops a trailing model turn for no-prefill models', () => {
     const contents: Content[] = [userTurn, modelTurn];
-    const result = dropUnsupportedModelTurnPrefill(contents, 'gemini-3.6-flash');
+    const result = dropUnsupportedModelTurnPrefill(
+      contents,
+      'gemini-3.6-flash'
+    );
     expect(result).toEqual([userTurn]);
   });
 
   test('drops multiple consecutive trailing model turns but keeps one turn', () => {
     const contents: Content[] = [userTurn, modelTurn, modelTurn];
-    const result = dropUnsupportedModelTurnPrefill(contents, 'gemini-3.5-flash-lite');
+    const result = dropUnsupportedModelTurnPrefill(
+      contents,
+      'gemini-3.5-flash-lite'
+    );
     expect(result).toEqual([userTurn]);
   });
 
   test('leaves a trailing model turn for models that accept prefill', () => {
     const contents: Content[] = [userTurn, modelTurn];
-    const result = dropUnsupportedModelTurnPrefill(contents, 'gemini-3.5-flash');
+    const result = dropUnsupportedModelTurnPrefill(
+      contents,
+      'gemini-3.5-flash'
+    );
     expect(result).toBe(contents);
   });
 
   test('is a no-op when the request already ends with a user turn', () => {
     const contents: Content[] = [modelTurn, userTurn];
-    const result = dropUnsupportedModelTurnPrefill(contents, 'gemini-3.6-flash');
+    const result = dropUnsupportedModelTurnPrefill(
+      contents,
+      'gemini-3.6-flash'
+    );
     expect(result).toBe(contents);
   });
 
   test('is a no-op for empty or undefined contents', () => {
     expect(dropUnsupportedModelTurnPrefill([], 'gemini-3.6-flash')).toEqual([]);
-    expect(dropUnsupportedModelTurnPrefill(undefined, 'gemini-3.6-flash')).toBeUndefined();
+    expect(
+      dropUnsupportedModelTurnPrefill(undefined, 'gemini-3.6-flash')
+    ).toBeUndefined();
   });
 });