@librechat/agents 2.4.21 → 2.4.30

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

@@ -0,0 +1,114 @@
+/* eslint-disable @typescript-eslint/explicit-function-return-type */
+/* eslint-disable @typescript-eslint/no-empty-object-type */
+import { z } from 'zod';
+import {
+  BaseLLMOutputParser,
+  OutputParserException,
+} from '@langchain/core/output_parsers';
+import { JsonOutputKeyToolsParserParams } from '@langchain/core/output_parsers/openai_tools';
+import { ChatGeneration } from '@langchain/core/outputs';
+import { ToolCall } from '@langchain/core/messages/tool';
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+interface AnthropicToolsOutputParserParams<T extends Record<string, any>>
+  extends JsonOutputKeyToolsParserParams<T> {}
+
+export class AnthropicToolsOutputParser<
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  T extends Record<string, any> = Record<string, any>,
+> extends BaseLLMOutputParser<T> {
+  static lc_name() {
+    return 'AnthropicToolsOutputParser';
+  }
+
+  lc_namespace = ['langchain', 'anthropic', 'output_parsers'];
+
+  returnId = false;
+
+  /** The type of tool calls to return. */
+  keyName: string;
+
+  /** Whether to return only the first tool call. */
+  returnSingle = false;
+
+  zodSchema?: z.ZodType<T>;
+
+  constructor(params: AnthropicToolsOutputParserParams<T>) {
+    super(params);
+    this.keyName = params.keyName;
+    this.returnSingle = params.returnSingle ?? this.returnSingle;
+    this.zodSchema = params.zodSchema;
+  }
+
+  protected async _validateResult(result: unknown): Promise<T> {
+    let parsedResult = result;
+    if (typeof result === 'string') {
+      try {
+        parsedResult = JSON.parse(result);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      } catch (e: any) {
+        throw new OutputParserException(
+          `Failed to parse. Text: "${JSON.stringify(
+            result,
+            null,
+            2
+          )}". Error: ${JSON.stringify(e.message)}`,
+          result
+        );
+      }
+    } else {
+      parsedResult = result;
+    }
+    if (this.zodSchema === undefined) {
+      return parsedResult as T;
+    }
+    const zodParsedResult = await this.zodSchema.safeParseAsync(parsedResult);
+    if (zodParsedResult.success) {
+      return zodParsedResult.data;
+    } else {
+      throw new OutputParserException(
+        `Failed to parse. Text: "${JSON.stringify(
+          result,
+          null,
+          2
+        )}". Error: ${JSON.stringify(zodParsedResult.error.errors)}`,
+        JSON.stringify(parsedResult, null, 2)
+      );
+    }
+  }
+
+  async parseResult(generations: ChatGeneration[]): Promise<T> {
+    const tools = generations.flatMap((generation) => {
+      const { message } = generation;
+      if (!Array.isArray(message.content)) {
+        return [];
+      }
+      const tool = extractToolCalls(message.content)[0];
+      return tool;
+    });
+    if (tools[0] === undefined) {
+      throw new Error(
+        'No parseable tool calls provided to AnthropicToolsOutputParser.'
+      );
+    }
+    const [tool] = tools;
+    const validatedResult = await this._validateResult(tool.args);
+    return validatedResult;
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function extractToolCalls(content: Record<string, any>[]) {
+  const toolCalls: ToolCall[] = [];
+  for (const block of content) {
+    if (block.type === 'tool_use') {
+      toolCalls.push({
+        name: block.name,
+        args: block.input,
+        id: block.id,
+        type: 'tool_call',
+      });
+    }
+  }
+  return toolCalls;
+}

package/src/llm/openai/index.ts

@@ -7,6 +7,7 @@ import {
   ChatOpenAI as OriginalChatOpenAI,
   AzureChatOpenAI as OriginalAzureChatOpenAI,
 } from '@langchain/openai';
+import type { OpenAICoreRequestOptions } from 'node_modules/@langchain/deepseek/node_modules/@langchain/openai';
 import type * as t from '@langchain/openai';
 
 function createAbortHandler(controller: AbortController): () => void {
@@ -191,8 +192,8 @@ export class ChatDeepSeek extends OriginalChatDeepSeek {
     return this.client;
   }
   protected _getClientOptions(
-    options?: t.OpenAICoreRequestOptions
-  ): t.OpenAICoreRequestOptions {
+    options?: OpenAICoreRequestOptions
+  ): OpenAICoreRequestOptions {
     if (!(this.client as OpenAIClient | undefined)) {
       const openAIEndpointConfig: t.OpenAIEndpointConfig = {
         baseURL: this.clientConfig.baseURL,
@@ -214,7 +215,7 @@ export class ChatDeepSeek extends OriginalChatDeepSeek {
     const requestOptions = {
       ...this.clientConfig,
       ...options,
-    } as t.OpenAICoreRequestOptions;
+    } as OpenAICoreRequestOptions;
     return requestOptions;
   }
 }
@@ -224,8 +225,8 @@ export class ChatXAI extends OriginalChatXAI {
     return this.client;
   }
   protected _getClientOptions(
-    options?: t.OpenAICoreRequestOptions
-  ): t.OpenAICoreRequestOptions {
+    options?: OpenAICoreRequestOptions
+  ): OpenAICoreRequestOptions {
     if (!(this.client as OpenAIClient | undefined)) {
       const openAIEndpointConfig: t.OpenAIEndpointConfig = {
         baseURL: this.clientConfig.baseURL,
@@ -247,7 +248,7 @@ export class ChatXAI extends OriginalChatXAI {
     const requestOptions = {
       ...this.clientConfig,
       ...options,
-    } as t.OpenAICoreRequestOptions;
+    } as OpenAICoreRequestOptions;
     return requestOptions;
   }
 }

package/src/messages/core.ts

@@ -1,5 +1,11 @@
 // src/messages.ts
-import { AIMessageChunk, HumanMessage, ToolMessage, AIMessage, BaseMessage } from '@langchain/core/messages';
+import {
+  AIMessageChunk,
+  HumanMessage,
+  ToolMessage,
+  AIMessage,
+  BaseMessage,
+} from '@langchain/core/messages';
 import type { ToolCall } from '@langchain/core/messages/tool';
 import type * as t from '@/types';
 import { Providers } from '@/common';
@@ -7,7 +13,7 @@ import { Providers } from '@/common';
 export function getConverseOverrideMessage({
   userMessage,
   lastMessageX,
-  lastMessageY
+  lastMessageY,
 }: {
   userMessage: string[];
   lastMessageX: AIMessageChunk | null;
@@ -43,13 +49,22 @@ const allowedTypesByProvider: Record<string, string[]> = {
 const modifyContent = ({
   provider,
   messageType,
-  content
+  content,
 }: {
-  provider: Providers, messageType: string, content: t.ExtendedMessageContent[]
+  provider: Providers;
+  messageType: string;
+  content: t.ExtendedMessageContent[];
 }): t.ExtendedMessageContent[] => {
-  const allowedTypes = allowedTypesByProvider[provider] ?? allowedTypesByProvider.default;
-  return content.map(item => {
-    if (item && typeof item === 'object' && 'type' in item && item.type != null && item.type) {
+  const allowedTypes =
+    allowedTypesByProvider[provider] ?? allowedTypesByProvider.default;
+  return content.map((item) => {
+    if (
+      item &&
+      typeof item === 'object' &&
+      'type' in item &&
+      item.type != null &&
+      item.type
+    ) {
       let newType = item.type;
       if (newType.endsWith('_delta')) {
         newType = newType.replace('_delta', '');
@@ -59,7 +74,12 @@ const modifyContent = ({
       }
 
       /* Handle the edge case for empty object 'tool_use' input in AI messages */
-      if (messageType === 'ai' && newType === 'tool_use' && 'input' in item && item.input === '') {
+      if (
+        messageType === 'ai' &&
+        newType === 'tool_use' &&
+        'input' in item &&
+        item.input === ''
+      ) {
         return { ...item, type: newType, input: '{}' };
       }
 
@@ -69,7 +89,9 @@ const modifyContent = ({
   });
 };
 
-type ContentBlock = Partial<t.BedrockReasoningContentText> | t.MessageDeltaUpdate;
+type ContentBlock =
+  | Partial<t.BedrockReasoningContentText>
+  | t.MessageDeltaUpdate;
 
 function reduceBlocks(blocks: ContentBlock[]): ContentBlock[] {
   const reduced: ContentBlock[] = [];
@@ -78,14 +100,25 @@ function reduceBlocks(blocks: ContentBlock[]): ContentBlock[] {
     const lastBlock = reduced[reduced.length - 1] as ContentBlock | undefined;
 
     // Merge consecutive 'reasoning_content'
-    if (block.type === 'reasoning_content' && lastBlock?.type === 'reasoning_content') {
+    if (
+      block.type === 'reasoning_content' &&
+      lastBlock?.type === 'reasoning_content'
+    ) {
       // append text if exists
       if (block.reasoningText?.text != null && block.reasoningText.text) {
-        (lastBlock.reasoningText as t.BedrockReasoningContentText['reasoningText']).text = (lastBlock.reasoningText?.text ?? '') + block.reasoningText.text;
+        (
+          lastBlock.reasoningText as t.BedrockReasoningContentText['reasoningText']
+        ).text =
+          (lastBlock.reasoningText?.text ?? '') + block.reasoningText.text;
       }
       // preserve the signature if exists
-      if (block.reasoningText?.signature != null && block.reasoningText.signature) {
-        (lastBlock.reasoningText as t.BedrockReasoningContentText['reasoningText']).signature = block.reasoningText.signature;
+      if (
+        block.reasoningText?.signature != null &&
+        block.reasoningText.signature
+      ) {
+        (
+          lastBlock.reasoningText as t.BedrockReasoningContentText['reasoningText']
+        ).signature = block.reasoningText.signature;
       }
     }
     // Merge consecutive 'text'
@@ -102,19 +135,35 @@ function reduceBlocks(blocks: ContentBlock[]): ContentBlock[] {
   return reduced;
 }
 
-export function modifyDeltaProperties(provider: Providers, obj?: AIMessageChunk): AIMessageChunk | undefined {
+export function modifyDeltaProperties(
+  provider: Providers,
+  obj?: AIMessageChunk
+): AIMessageChunk | undefined {
   if (!obj || typeof obj !== 'object') return obj;
 
-  const messageType = obj._getType ? obj._getType() : '';
+  const messageType = (obj as Partial<AIMessageChunk>)._getType
+    ? obj._getType()
+    : '';
 
   if (provider === Providers.BEDROCK && Array.isArray(obj.content)) {
     obj.content = reduceBlocks(obj.content as ContentBlock[]);
   }
   if (Array.isArray(obj.content)) {
-    obj.content = modifyContent({ provider, messageType, content: obj.content });
+    obj.content = modifyContent({
+      provider,
+      messageType,
+      content: obj.content,
+    });
   }
-  if (obj.lc_kwargs && Array.isArray(obj.lc_kwargs.content)) {
-    obj.lc_kwargs.content = modifyContent({ provider, messageType, content: obj.lc_kwargs.content });
+  if (
+    (obj as Partial<AIMessageChunk>).lc_kwargs &&
+    Array.isArray(obj.lc_kwargs.content)
+  ) {
+    obj.lc_kwargs.content = modifyContent({
+      provider,
+      messageType,
+      content: obj.lc_kwargs.content,
+    });
   }
   return obj;
 }
@@ -124,48 +173,65 @@ export function formatAnthropicMessage(message: AIMessageChunk): AIMessage {
     return new AIMessage({ content: message.content });
   }
 
-  const toolCallMap = new Map(message.tool_calls.map(tc => [tc.id, tc]));
+  const toolCallMap = new Map(message.tool_calls.map((tc) => [tc.id, tc]));
   let formattedContent: string | t.ExtendedMessageContent[];
 
   if (Array.isArray(message.content)) {
-    formattedContent = message.content.reduce<t.ExtendedMessageContent[]>((acc, item) => {
-      if (typeof item === 'object' && item !== null) {
-        const extendedItem = item as t.ExtendedMessageContent;
-        if (extendedItem.type === 'text' && extendedItem.text != null && extendedItem.text) {
-          acc.push({ type: 'text', text: extendedItem.text });
-        } else if (extendedItem.type === 'tool_use' && extendedItem.id != null && extendedItem.id) {
-          const toolCall = toolCallMap.get(extendedItem.id);
-          if (toolCall) {
-            acc.push({
-              type: 'tool_use',
-              id: extendedItem.id,
-              name: toolCall.name,
-              input: toolCall.args as unknown as string
-            });
-          }
-        } else if ('input' in extendedItem && extendedItem.input != null && extendedItem.input) {
-          try {
-            const parsedInput = JSON.parse(extendedItem.input);
-            const toolCall = message.tool_calls?.find(tc => tc.args.input === parsedInput.input);
+    formattedContent = message.content.reduce<t.ExtendedMessageContent[]>(
+      (acc, item) => {
+        if (typeof item === 'object') {
+          const extendedItem = item as t.ExtendedMessageContent;
+          if (
+            extendedItem.type === 'text' &&
+            extendedItem.text != null &&
+            extendedItem.text
+          ) {
+            acc.push({ type: 'text', text: extendedItem.text });
+          } else if (
+            extendedItem.type === 'tool_use' &&
+            extendedItem.id != null &&
+            extendedItem.id
+          ) {
+            const toolCall = toolCallMap.get(extendedItem.id);
             if (toolCall) {
               acc.push({
                 type: 'tool_use',
-                id: toolCall.id,
+                id: extendedItem.id,
                 name: toolCall.name,
-                input: toolCall.args as unknown as string
+                input: toolCall.args as unknown as string,
               });
             }
-          } catch {
-            if (extendedItem.input) {
-              acc.push({ type: 'text', text: extendedItem.input });
+          } else if (
+            'input' in extendedItem &&
+            extendedItem.input != null &&
+            extendedItem.input
+          ) {
+            try {
+              const parsedInput = JSON.parse(extendedItem.input);
+              const toolCall = message.tool_calls?.find(
+                (tc) => tc.args.input === parsedInput.input
+              );
+              if (toolCall) {
+                acc.push({
+                  type: 'tool_use',
+                  id: toolCall.id,
+                  name: toolCall.name,
+                  input: toolCall.args as unknown as string,
+                });
+              }
+            } catch {
+              if (extendedItem.input) {
+                acc.push({ type: 'text', text: extendedItem.input });
+              }
             }
           }
+        } else if (typeof item === 'string') {
+          acc.push({ type: 'text', text: item });
         }
-      } else if (typeof item === 'string') {
-        acc.push({ type: 'text', text: item });
-      }
-      return acc;
-    }, []);
+        return acc;
+      },
+      []
+    );
   } else if (typeof message.content === 'string') {
     formattedContent = message.content;
   } else {
@@ -179,39 +245,48 @@ export function formatAnthropicMessage(message: AIMessageChunk): AIMessage {
   //   type: 'tool_call',
   // }));
 
-  const formattedToolCalls: t.AgentToolCall[] = message.tool_calls.map(toolCall => ({
-    id: toolCall.id ?? '',
-    type: 'function',
-    function: {
-      name: toolCall.name,
-      arguments: toolCall.args
-    }
-  }));
+  const formattedToolCalls: t.AgentToolCall[] = message.tool_calls.map(
+    (toolCall) => ({
+      id: toolCall.id ?? '',
+      type: 'function',
+      function: {
+        name: toolCall.name,
+        arguments: toolCall.args,
+      },
+    })
+  );
 
   return new AIMessage({
     content: formattedContent,
     tool_calls: formattedToolCalls as ToolCall[],
     additional_kwargs: {
       ...message.additional_kwargs,
-    }
+    },
   });
 }
 
-export function convertMessagesToContent(messages: BaseMessage[]): t.MessageContentComplex[] {
+export function convertMessagesToContent(
+  messages: BaseMessage[]
+): t.MessageContentComplex[] {
   const processedContent: t.MessageContentComplex[] = [];
 
   const addContentPart = (message: BaseMessage | null): void => {
-    const content = message?.lc_kwargs.content != null ? message.lc_kwargs.content : message?.content;
+    const content =
+      message?.lc_kwargs.content != null
+        ? message.lc_kwargs.content
+        : message?.content;
     if (content === undefined) {
       return;
     }
     if (typeof content === 'string') {
       processedContent.push({
         type: 'text',
-        text: content
+        text: content,
       });
     } else if (Array.isArray(content)) {
-      const filteredContent = content.filter(item => item && item.type !== 'tool_use');
+      const filteredContent = content.filter(
+        (item) => item != null && item.type !== 'tool_use'
+      );
       processedContent.push(...filteredContent);
     }
   };
@@ -223,10 +298,13 @@ export function convertMessagesToContent(messages: BaseMessage[]): t.MessageCont
     const message = messages[i] as BaseMessage | null;
     const messageType = message?._getType();
 
-    if (messageType === 'ai' && (message as AIMessage).tool_calls?.length) {
+    if (
+      messageType === 'ai' &&
+      ((message as AIMessage).tool_calls?.length ?? 0) > 0
+    ) {
       const tool_calls = (message as AIMessage).tool_calls || [];
       for (const tool_call of tool_calls) {
-        if (!tool_call.id) {
+        if (tool_call.id == null || !tool_call.id) {
           continue;
         }
 
@@ -236,7 +314,10 @@ export function convertMessagesToContent(messages: BaseMessage[]): t.MessageCont
       addContentPart(message);
       currentAIMessageIndex = processedContent.length - 1;
       continue;
-    } else if (messageType === 'tool' && (message as ToolMessage).tool_call_id) {
+    } else if (
+      messageType === 'tool' &&
+      (message as ToolMessage).tool_call_id
+    ) {
       const id = (message as ToolMessage).tool_call_id;
       const output = (message as ToolMessage).content;
       const tool_call = toolCallMap.get(id);
@@ -265,35 +346,41 @@ export function formatAnthropicArtifactContent(messages: BaseMessage[]): void {
   if (!(lastMessage instanceof ToolMessage)) return;
 
   // Find the latest AIMessage with tool_calls that this tool message belongs to
-  const latestAIParentIndex = findLastIndex(messages,
-    msg => (msg instanceof AIMessageChunk &&
-          (msg.tool_calls?.length ?? 0) > 0 &&
-          msg.tool_calls?.some(tc => tc.id === lastMessage.tool_call_id)) ?? false
+  const latestAIParentIndex = findLastIndex(
+    messages,
+    (msg) =>
+      (msg instanceof AIMessageChunk &&
+        (msg.tool_calls?.length ?? 0) > 0 &&
+        msg.tool_calls?.some((tc) => tc.id === lastMessage.tool_call_id)) ??
+      false
   );
 
   if (latestAIParentIndex === -1) return;
 
   // Check if any tool message after the AI message has array artifact content
   const hasArtifactContent = messages.some(
-    (msg, i) => i > latestAIParentIndex
-      && msg instanceof ToolMessage
-      && msg.artifact != null
-      && msg.artifact?.content != null
-      && Array.isArray(msg.artifact.content)
+    (msg, i) =>
+      i > latestAIParentIndex &&
+      msg instanceof ToolMessage &&
+      msg.artifact != null &&
+      msg.artifact?.content != null &&
+      Array.isArray(msg.artifact.content)
   );
 
   if (!hasArtifactContent) return;
 
   const message = messages[latestAIParentIndex] as AIMessageChunk;
-  const toolCallIds = message.tool_calls?.map(tc => tc.id) ?? [];
+  const toolCallIds = message.tool_calls?.map((tc) => tc.id) ?? [];
 
   for (let j = latestAIParentIndex + 1; j < messages.length; j++) {
     const msg = messages[j];
-    if (msg instanceof ToolMessage &&
-        toolCallIds.includes(msg.tool_call_id) &&
-        msg.artifact != null &&
-        Array.isArray(msg.artifact?.content) &&
-        Array.isArray(msg.content)) {
+    if (
+      msg instanceof ToolMessage &&
+      toolCallIds.includes(msg.tool_call_id) &&
+      msg.artifact != null &&
+      Array.isArray(msg.artifact?.content) &&
+      Array.isArray(msg.content)
+    ) {
       msg.content = msg.content.concat(msg.artifact.content);
     }
   }
@@ -304,21 +391,25 @@ export function formatArtifactPayload(messages: BaseMessage[]): void {
   if (!(lastMessageY instanceof ToolMessage)) return;
 
   // Find the latest AIMessage with tool_calls that this tool message belongs to
-  const latestAIParentIndex = findLastIndex(messages,
-    msg => (msg instanceof AIMessageChunk &&
-          (msg.tool_calls?.length ?? 0) > 0 &&
-          msg.tool_calls?.some(tc => tc.id === lastMessageY.tool_call_id)) ?? false
+  const latestAIParentIndex = findLastIndex(
+    messages,
+    (msg) =>
+      (msg instanceof AIMessageChunk &&
+        (msg.tool_calls?.length ?? 0) > 0 &&
+        msg.tool_calls?.some((tc) => tc.id === lastMessageY.tool_call_id)) ??
+      false
   );
 
   if (latestAIParentIndex === -1) return;
 
   // Check if any tool message after the AI message has array artifact content
   const hasArtifactContent = messages.some(
-    (msg, i) => i > latestAIParentIndex
-      && msg instanceof ToolMessage
-      && msg.artifact != null
-      && msg.artifact?.content != null
-      && Array.isArray(msg.artifact.content)
+    (msg, i) =>
+      i > latestAIParentIndex &&
+      msg instanceof ToolMessage &&
+      msg.artifact != null &&
+      msg.artifact?.content != null &&
+      Array.isArray(msg.artifact.content)
   );
 
   if (!hasArtifactContent) return;
@@ -326,20 +417,27 @@ export function formatArtifactPayload(messages: BaseMessage[]): void {
   // Collect all relevant tool messages and their artifacts
   const relevantMessages = messages
     .slice(latestAIParentIndex + 1)
-    .filter(msg => msg instanceof ToolMessage) as ToolMessage[];
+    .filter((msg) => msg instanceof ToolMessage) as ToolMessage[];
 
   // Aggregate all content and artifacts
   const aggregatedContent: t.MessageContentComplex[] = [];
 
-  relevantMessages.forEach(msg => {
+  relevantMessages.forEach((msg) => {
     if (!Array.isArray(msg.artifact?.content)) {
       return;
     }
-    if (!Array.isArray(msg.content)) {
-      return;
+    let currentContent = msg.content;
+    if (!Array.isArray(currentContent)) {
+      currentContent = [
+        {
+          type: 'text',
+          text: msg.content,
+        },
+      ];
     }
-    aggregatedContent.push(...msg.content);
-    msg.content = 'Tool response is included in the next message as a Human message';
+    aggregatedContent.push(...currentContent);
+    msg.content =
+      'Tool response is included in the next message as a Human message';
     aggregatedContent.push(...msg.artifact.content);
   });
 
@@ -349,11 +447,14 @@ export function formatArtifactPayload(messages: BaseMessage[]): void {
   }
 }
 
-export function findLastIndex<T>(array: T[], predicate: (value: T) => boolean): number {
+export function findLastIndex<T>(
+  array: T[],
+  predicate: (value: T) => boolean
+): number {
   for (let i = array.length - 1; i >= 0; i--) {
     if (predicate(array[i])) {
       return i;
     }
   }
   return -1;
-}
+}

package/src/run.ts

@@ -141,7 +141,7 @@ export class Run<T extends t.BaseGraphState> {
         }
 
         const jsonSchema = zodToJsonSchema(
-          tool.schema.describe(tool.description ?? ''),
+          (tool.schema as t.ZodObjectAny).describe(tool.description ?? ''),
           tool.name
         );
         return (