@librechat/agents 3.1.75 → 3.1.77-dev.1

package/src/llm/anthropic/types.ts

@@ -1,5 +1,9 @@
 import Anthropic from '@anthropic-ai/sdk';
-import { BindToolsInput } from '@langchain/core/language_models/chat_models';
+
+import type { BindToolsInput } from '@langchain/core/language_models/chat_models';
+import type { AnthropicBeta } from '@anthropic-ai/sdk/resources';
+
+export type { AnthropicBeta };
 
 export type AnthropicStreamUsage = Anthropic.Usage;
 export type AnthropicMessageDeltaEvent = Anthropic.MessageDeltaEvent;
@@ -22,8 +26,12 @@ export type AnthropicMessageCreateParams =
 export type AnthropicStreamingMessageCreateParams =
   Anthropic.MessageCreateParamsStreaming;
 export type AnthropicThinkingConfigParam = Anthropic.ThinkingConfigParam;
+export type AnthropicContextManagementConfigParam =
+  Anthropic.Beta.BetaContextManagementConfig;
 export type AnthropicMessageStreamEvent = Anthropic.MessageStreamEvent;
 export type AnthropicRequestOptions = Anthropic.RequestOptions;
+export type AnthropicMCPServerURLDefinition =
+  Anthropic.Beta.Messages.BetaRequestMCPServerURLDefinition;
 export type AnthropicToolChoice =
   | {
       type: 'tool';

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

@@ -10,10 +10,8 @@ import {
   type AIMessage,
   type ToolMessage,
   isAIMessage,
+  type Data,
   type StandardContentBlockConverter,
-  type StandardTextBlock,
-  type StandardImageBlock,
-  type StandardFileBlock,
   MessageContentComplex,
   isDataContentBlock,
   convertToProviderContentBlock,
@@ -36,6 +34,19 @@ import {
 } from '../types';
 import { Constants } from '@/common';
 
+type StandardTextBlock = Data.StandardTextBlock;
+type StandardImageBlock = Data.StandardImageBlock;
+type StandardFileBlock = Data.StandardFileBlock;
+type ImageUrlContentBlock = MessageContentComplex & {
+  image_url: string | { url: string };
+};
+type GoogleFunctionCallBlock = MessageContentComplex & {
+  functionCall: {
+    name: string;
+    args: Record<string, unknown>;
+  };
+};
+
 function _formatImage(imageUrl: string) {
   const parsed = parseBase64DataUrl({ dataUrl: imageUrl });
   if (parsed) {
@@ -83,7 +94,7 @@ function _ensureMessageContents(
   messages: BaseMessage[]
 ): (SystemMessage | HumanMessage | AIMessage)[] {
   // Merge runs of human/tool messages into single human messages with content blocks.
-  const updatedMsgs = [];
+  const updatedMsgs: BaseMessage[] = [];
   for (const message of messages) {
     if (message._getType() === 'tool') {
       if (typeof message.content === 'string') {
@@ -134,7 +145,7 @@ function _ensureMessageContents(
       updatedMsgs.push(message);
     }
   }
-  return updatedMsgs;
+  return updatedMsgs as (SystemMessage | HumanMessage | AIMessage)[];
 }
 
 export function _convertLangChainToolCallToAnthropic(
@@ -364,7 +375,8 @@ function _formatContent(message: BaseMessage) {
   if (typeof content === 'string') {
     return content;
   } else {
-    const contentBlocks = content.map((contentPart) => {
+    const contentParts = content as MessageContentComplex[];
+    const contentBlocks = contentParts.map((contentPart) => {
       /**
        * Normalize server_tool_use blocks into a clean shape the API accepts.
        * These blocks may arrive with the correct type (server_tool_use) or mislabeled
@@ -465,10 +477,11 @@ function _formatContent(message: BaseMessage) {
 
       if (contentPart.type === 'image_url') {
         let source;
-        if (typeof contentPart.image_url === 'string') {
-          source = _formatImage(contentPart.image_url);
+        const imageUrl = (contentPart as ImageUrlContentBlock).image_url;
+        if (typeof imageUrl === 'string') {
+          source = _formatImage(imageUrl);
         } else {
-          source = _formatImage(contentPart.image_url.url);
+          source = _formatImage(imageUrl.url);
         }
         return {
           type: 'image' as const, // Explicitly setting the type as "image"
@@ -484,38 +497,42 @@ function _formatContent(message: BaseMessage) {
           ...(cacheControl ? { cache_control: cacheControl } : {}),
         };
       } else if (contentPart.type === 'thinking') {
+        const thinkingPart = contentPart as AnthropicThinkingBlockParam;
         const block: AnthropicThinkingBlockParam = {
           type: 'thinking' as const, // Explicitly setting the type as "thinking"
-          thinking: contentPart.thinking,
-          signature: contentPart.signature,
+          thinking: thinkingPart.thinking,
+          signature: thinkingPart.signature,
           ...(cacheControl ? { cache_control: cacheControl } : {}),
         };
         return block;
       } else if (contentPart.type === 'redacted_thinking') {
+        const redactedPart = contentPart as AnthropicRedactedThinkingBlockParam;
         const block: AnthropicRedactedThinkingBlockParam = {
           type: 'redacted_thinking' as const, // Explicitly setting the type as "redacted_thinking"
-          data: contentPart.data,
+          data: redactedPart.data,
           ...(cacheControl ? { cache_control: cacheControl } : {}),
         };
         return block;
       } else if (contentPart.type === 'search_result') {
+        const searchResultPart = contentPart as AnthropicSearchResultBlockParam;
         const block: AnthropicSearchResultBlockParam = {
           type: 'search_result' as const,
-          title: contentPart.title,
-          source: contentPart.source,
+          title: searchResultPart.title,
+          source: searchResultPart.source,
           ...('cache_control' in contentPart && contentPart.cache_control
             ? { cache_control: contentPart.cache_control }
             : {}),
           ...('citations' in contentPart && contentPart.citations
             ? { citations: contentPart.citations }
             : {}),
-          content: contentPart.content,
+          content: searchResultPart.content,
         };
         return block;
       } else if (contentPart.type === 'compaction') {
+        const compactionPart = contentPart as AnthropicCompactionBlockParam;
         const block: AnthropicCompactionBlockParam = {
           type: 'compaction' as const,
-          content: contentPart.content,
+          content: compactionPart.content,
           ...(cacheControl ? { cache_control: cacheControl } : {}),
         };
         return block;
@@ -585,12 +602,13 @@ function _formatContent(message: BaseMessage) {
         typeof contentPart.functionCall === 'object' &&
         isAIMessage(message)
       ) {
+        const functionCallPart = contentPart as GoogleFunctionCallBlock;
         const correspondingToolCall = message.tool_calls?.find(
-          (toolCall) => toolCall.name === contentPart.functionCall.name
+          (toolCall) => toolCall.name === functionCallPart.functionCall.name
         );
         if (!correspondingToolCall) {
           throw new Error(
-            `Could not find tool call for function call ${contentPart.functionCall.name}`
+            `Could not find tool call for function call ${functionCallPart.functionCall.name}`
           );
         }
         // Google GenAI models include a `functionCall` object inside content. We should ignore it as Anthropic will not support it.
@@ -598,7 +616,7 @@ function _formatContent(message: BaseMessage) {
           id: correspondingToolCall.id,
           type: 'tool_use',
           name: correspondingToolCall.name,
-          input: contentPart.functionCall.args,
+          input: functionCallPart.functionCall.args,
         };
       } else {
         console.error(

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

@@ -1,16 +1,47 @@
-/**
- * This util file contains functions for converting Anthropic messages to LangChain messages.
- */
-import Anthropic from '@anthropic-ai/sdk';
-import {
-  AIMessage,
-  AIMessageChunk,
-  UsageMetadata,
-} from '@langchain/core/messages';
+/** This util file contains functions for converting Anthropic messages to LangChain messages. */
+import { AIMessage, AIMessageChunk } from '@langchain/core/messages';
+
+import type Anthropic from '@anthropic-ai/sdk';
+import type { UsageMetadata } from '@langchain/core/messages';
 import type { ToolCallChunk } from '@langchain/core/messages/tool';
-import { ChatGeneration } from '@langchain/core/outputs';
+import type { ChatGeneration } from '@langchain/core/outputs';
+import type { MessageContentComplex } from '@/types';
+import type { AnthropicMessageResponse } from '../types';
+
+import { toLangChainContent } from '@/messages/langchain';
 import { extractToolCalls } from './output_parsers';
-import { AnthropicMessageResponse } from '../types';
+
+interface AnthropicUsageData {
+  input_tokens?: number | null;
+  output_tokens?: number | null;
+  cache_creation_input_tokens?: number | null;
+  cache_read_input_tokens?: number | null;
+}
+
+export function getAnthropicUsageMetadata(
+  usage: AnthropicUsageData | null | undefined
+): UsageMetadata | undefined {
+  if (usage == null) {
+    return undefined;
+  }
+
+  const cacheCreationInputTokens = usage.cache_creation_input_tokens ?? 0;
+  const cacheReadInputTokens = usage.cache_read_input_tokens ?? 0;
+  // Anthropic reports uncached input separately from cache creation/read tokens.
+  const inputTokens =
+    (usage.input_tokens ?? 0) + cacheCreationInputTokens + cacheReadInputTokens;
+  const outputTokens = usage.output_tokens ?? 0;
+
+  return {
+    input_tokens: inputTokens,
+    output_tokens: outputTokens,
+    total_tokens: inputTokens + outputTokens,
+    input_token_details: {
+      cache_creation: cacheCreationInputTokens,
+      cache_read: cacheReadInputTokens,
+    },
+  };
+}
 
 function _isAnthropicCompactionBlock(
   block: unknown
@@ -32,34 +63,23 @@ export function _makeMessageChunkFromAnthropicEvent(
 ): {
   chunk: AIMessageChunk;
 } | null {
+  const responseMetadata = { model_provider: 'anthropic' };
   if (data.type === 'message_start') {
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     const { content, usage, ...additionalKwargs } = data.message;
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const filteredAdditionalKwargs: Record<string, any> = {};
-    for (const [key, value] of Object.entries(additionalKwargs)) {
-      if (value !== undefined && value !== null) {
-        filteredAdditionalKwargs[key] = value;
-      }
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const { input_tokens, output_tokens, ...rest }: Record<string, any> =
-      usage ?? {};
-    const usageMetadata: UsageMetadata = {
-      input_tokens,
-      output_tokens,
-      total_tokens: input_tokens + output_tokens,
-      input_token_details: {
-        cache_creation: rest.cache_creation_input_tokens,
-        cache_read: rest.cache_read_input_tokens,
-      },
-    };
+    const {
+      input_tokens: _inputTokens,
+      output_tokens: _outputTokens,
+      ...rest
+    } = usage;
+    const usageMetadata = getAnthropicUsageMetadata(usage);
     return {
       chunk: new AIMessageChunk({
         content: fields.coerceContentToString ? '' : [],
-        additional_kwargs: filteredAdditionalKwargs,
+        additional_kwargs: additionalKwargs,
         usage_metadata: fields.streamUsage ? usageMetadata : undefined,
         response_metadata: {
+          ...responseMetadata,
           usage: {
             ...rest,
           },
@@ -68,20 +88,25 @@ export function _makeMessageChunkFromAnthropicEvent(
       }),
     };
   } else if (data.type === 'message_delta') {
+    const messageDeltaResponseMetadata = { ...responseMetadata };
+    if ('context_management' in data.delta) {
+      Object.assign(messageDeltaResponseMetadata, {
+        context_management: data.delta.context_management,
+      });
+    }
     const usageMetadata: UsageMetadata = {
       input_tokens: 0,
       output_tokens: data.usage.output_tokens,
       total_tokens: data.usage.output_tokens,
       input_token_details: {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        cache_creation: (data.usage as any).cache_creation_input_tokens,
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        cache_read: (data.usage as any).cache_read_input_tokens,
+        cache_creation: data.usage.cache_creation_input_tokens ?? undefined,
+        cache_read: data.usage.cache_read_input_tokens ?? undefined,
       },
     };
     return {
       chunk: new AIMessageChunk({
         content: fields.coerceContentToString ? '' : [],
+        response_metadata: messageDeltaResponseMetadata,
         additional_kwargs: { ...data.delta },
         usage_metadata: fields.streamUsage ? usageMetadata : undefined,
       }),
@@ -119,21 +144,21 @@ export function _makeMessageChunkFromAnthropicEvent(
     } else {
       toolCallChunks = [];
     }
+    const content = [
+      {
+        index: data.index,
+        ...data.content_block,
+        input:
+          contentBlock.type === 'server_tool_use' ||
+          contentBlock.type === 'tool_use'
+            ? ''
+            : undefined,
+      },
+    ];
     return {
       chunk: new AIMessageChunk({
-        content: fields.coerceContentToString
-          ? ''
-          : [
-            {
-              index: data.index,
-              ...data.content_block,
-              input:
-                  contentBlock.type === 'server_tool_use' ||
-                  contentBlock.type === 'tool_use'
-                    ? ''
-                    : undefined,
-            },
-          ],
+        content: fields.coerceContentToString ? '' : content,
+        response_metadata: responseMetadata,
         additional_kwargs: {},
         tool_call_chunks: toolCallChunks,
       }),
@@ -154,8 +179,7 @@ export function _makeMessageChunkFromAnthropicEvent(
         }),
       };
     } else {
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      const contentBlock: Record<string, any> = data.delta;
+      const contentBlock: Record<string, unknown> = { ...data.delta };
       if ('citation' in contentBlock) {
         contentBlock.citations = [contentBlock.citation];
         delete contentBlock.citation;
@@ -167,6 +191,7 @@ export function _makeMessageChunkFromAnthropicEvent(
         return {
           chunk: new AIMessageChunk({
             content: [{ index: data.index, ...contentBlock, type: 'thinking' }],
+            response_metadata: responseMetadata,
           }),
         };
       }
@@ -174,6 +199,7 @@ export function _makeMessageChunkFromAnthropicEvent(
       return {
         chunk: new AIMessageChunk({
           content: [{ index: data.index, ...contentBlock, type: 'text' }],
+          response_metadata: responseMetadata,
         }),
       };
     }
@@ -181,17 +207,17 @@ export function _makeMessageChunkFromAnthropicEvent(
     data.type === 'content_block_delta' &&
     data.delta.type === 'input_json_delta'
   ) {
+    const content = [
+      {
+        index: data.index,
+        input: data.delta.partial_json,
+        type: data.delta.type,
+      },
+    ];
     return {
       chunk: new AIMessageChunk({
-        content: fields.coerceContentToString
-          ? ''
-          : [
-            {
-              index: data.index,
-              input: data.delta.partial_json,
-              type: data.delta.type,
-            },
-          ],
+        content: fields.coerceContentToString ? '' : content,
+        response_metadata: responseMetadata,
         additional_kwargs: {},
         tool_call_chunks: [
           {
@@ -206,21 +232,19 @@ export function _makeMessageChunkFromAnthropicEvent(
     data.content_block.type === 'text'
   ) {
     const content = data.content_block.text;
-    if (content !== undefined) {
-      return {
-        chunk: new AIMessageChunk({
-          content: fields.coerceContentToString
-            ? content
-            : [
-              {
-                index: data.index,
-                ...data.content_block,
-              },
-            ],
-          additional_kwargs: {},
-        }),
-      };
-    }
+    const contentBlock = [
+      {
+        index: data.index,
+        ...data.content_block,
+      },
+    ];
+    return {
+      chunk: new AIMessageChunk({
+        content: fields.coerceContentToString ? content : contentBlock,
+        response_metadata: responseMetadata,
+        additional_kwargs: {},
+      }),
+    };
   } else if (
     data.type === 'content_block_start' &&
     data.content_block.type === 'redacted_thinking'
@@ -230,6 +254,7 @@ export function _makeMessageChunkFromAnthropicEvent(
         content: fields.coerceContentToString
           ? ''
           : [{ index: data.index, ...data.content_block }],
+        response_metadata: responseMetadata,
       }),
     };
   } else if (
@@ -242,6 +267,7 @@ export function _makeMessageChunkFromAnthropicEvent(
         content: fields.coerceContentToString
           ? content
           : [{ index: data.index, ...data.content_block }],
+        response_metadata: responseMetadata,
       }),
     };
   } else if (
@@ -253,23 +279,24 @@ export function _makeMessageChunkFromAnthropicEvent(
         content: fields.coerceContentToString
           ? ''
           : [{ index: data.index, ...data.content_block }],
+        response_metadata: responseMetadata,
       }),
     };
   } else if (
     data.type === 'content_block_delta' &&
     data.delta.type === 'compaction_delta'
   ) {
+    const content = [
+      {
+        index: data.index,
+        ...data.delta,
+        type: 'compaction',
+      },
+    ];
     return {
       chunk: new AIMessageChunk({
-        content: fields.coerceContentToString
-          ? ''
-          : [
-            {
-              index: data.index,
-              ...data.delta,
-              type: 'compaction',
-            },
-          ],
+        content: fields.coerceContentToString ? '' : content,
+        response_metadata: responseMetadata,
       }),
     };
   }
@@ -280,20 +307,12 @@ export function anthropicResponseToChatMessages(
   messages: AnthropicMessageResponse[],
   additionalKwargs: Record<string, unknown>
 ): ChatGeneration[] {
-  const usage: Record<string, number> | null | undefined =
-    additionalKwargs.usage as Record<string, number> | null | undefined;
-  const usageMetadata =
-    usage != null
-      ? {
-        input_tokens: usage.input_tokens ?? 0,
-        output_tokens: usage.output_tokens ?? 0,
-        total_tokens: (usage.input_tokens ?? 0) + (usage.output_tokens ?? 0),
-        input_token_details: {
-          cache_creation: usage.cache_creation_input_tokens,
-          cache_read: usage.cache_read_input_tokens,
-        },
-      }
-      : undefined;
+  const responseMetadata = {
+    ...additionalKwargs,
+    model_provider: 'anthropic',
+  };
+  const usage = additionalKwargs.usage as AnthropicUsageData | null | undefined;
+  const usageMetadata = getAnthropicUsageMetadata(usage);
   if (messages.length === 1 && messages[0].type === 'text') {
     return [
       {
@@ -302,7 +321,7 @@ export function anthropicResponseToChatMessages(
           content: messages[0].text,
           additional_kwargs: additionalKwargs,
           usage_metadata: usageMetadata,
-          response_metadata: additionalKwargs,
+          response_metadata: responseMetadata,
           id: additionalKwargs.id as string,
         }),
       },
@@ -313,12 +332,11 @@ export function anthropicResponseToChatMessages(
       {
         text: '',
         message: new AIMessage({
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          content: messages as any,
+          content: toLangChainContent(messages as MessageContentComplex[]),
           additional_kwargs: additionalKwargs,
           tool_calls: toolCalls,
           usage_metadata: usageMetadata,
-          response_metadata: additionalKwargs,
+          response_metadata: responseMetadata,
           id: additionalKwargs.id as string,
         }),
       },

package/src/llm/bedrock/index.ts

@@ -27,7 +27,7 @@ import { AIMessageChunk } from '@langchain/core/messages';
 import { ChatGenerationChunk, ChatResult } from '@langchain/core/outputs';
 import type { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
 import type { ChatBedrockConverseInput } from '@langchain/aws';
-import type { BaseMessage } from '@langchain/core/messages';
+import type { BaseMessage, ResponseMetadata } from '@langchain/core/messages';
 import {
   convertToConverseMessages,
   handleConverseStreamContentBlockStart,
@@ -238,7 +238,7 @@ export class CustomChatBedrockConverse extends ChatBedrockConverse {
           text: '',
           message: new AIMessageChunk({
             content: '',
-            response_metadata: event,
+            response_metadata: { ...event } as ResponseMetadata,
           }),
         });
       }