@librechat/agents 3.3.2 → 3.3.4

package/src/langfuse.ts

@@ -1,4 +1,5 @@
 import { CallbackHandler } from '@langfuse/langchain';
+import { isParentCommand } from '@langchain/langgraph';
 import { context as otelContext } from '@opentelemetry/api';
 import { AIMessage, AIMessageChunk } from '@langchain/core/messages';
 import {
@@ -204,6 +205,20 @@ class ScopedLangfuseCallbackHandler extends CallbackHandler {
     return this.withRuntimeContext(() => super.handleChainStart(...args));
   }
 
+  override handleChainError(
+    ...args: Parameters<CallbackHandler['handleChainError']>
+  ): ReturnType<CallbackHandler['handleChainError']> {
+    const [error, runId, parentRunId] = args;
+    if (error != null && parentRunId != null && isParentCommand(error)) {
+      return super.handleChainEnd(
+        { controlFlow: 'ParentCommand' },
+        runId,
+        parentRunId
+      );
+    }
+    return super.handleChainError(...args);
+  }
+
   override handleAgentAction(
     ...args: Parameters<CallbackHandler['handleAgentAction']>
   ): ReturnType<CallbackHandler['handleAgentAction']> {

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,