@librechat/agents 1.8.8 → 1.8.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@librechat/agents",
-  "version": "1.8.8",
+  "version": "1.8.9",
   "main": "./dist/cjs/main.cjs",
   "module": "./dist/esm/main.mjs",
   "types": "./dist/types/index.d.ts",
@@ -42,10 +42,10 @@
     "start:cli": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/cli.ts --provider 'openAI' --name 'Jo' --location 'New York, NY'",
     "content": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/content.ts --provider 'anthropic' --name 'Jo' --location 'New York, NY'",
     "stream": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/stream.ts --provider 'anthropic' --name 'Jo' --location 'New York, NY'",
-    "code_exec": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/code_exec.ts --provider 'anthropic' --name 'Jo' --location 'New York, NY'",
+    "code_exec": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/code_exec.ts --provider 'google' --name 'Jo' --location 'New York, NY'",
     "image": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/image.ts --provider 'anthropic' --name 'Jo' --location 'New York, NY'",
     "code_exec_simple": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/code_exec_simple.ts --provider 'anthropic' --name 'Jo' --location 'New York, NY'",
-    "simple": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/simple.ts --provider 'openAI' --name 'Jo' --location 'New York, NY'",
+    "simple": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/simple.ts --provider 'anthropic' --name 'Jo' --location 'New York, NY'",
     "memory": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/memory.ts --provider 'openAI' --name 'Jo' --location 'New York, NY'",
     "tool-test": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/tools.ts --provider 'anthropic' --name 'Jo' --location 'New York, NY'",
     "abort": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/abort.ts --provider 'openAI' --name 'Jo' --location 'New York, NY'",
@@ -73,9 +73,10 @@
     "@langchain/anthropic": "^0.3.11",
     "@langchain/aws": "^0.1.2",
     "@langchain/community": "^0.3.14",
-    "@langchain/core": "^0.3.18",
-    "@langchain/google-vertexai": "^0.1.2",
-    "@langchain/langgraph": "^0.2.19",
+    "@langchain/core": "^0.3.26",
+    "@langchain/google-genai": "^0.1.6",
+    "@langchain/google-vertexai": "^0.1.5",
+    "@langchain/langgraph": "^0.2.34",
     "@langchain/mistralai": "^0.0.26",
     "@langchain/ollama": "^0.1.1",
     "@langchain/openai": "^0.3.14",

package/src/common/enum.ts

@@ -74,6 +74,7 @@ export enum Providers {
   ANTHROPIC = 'anthropic',
   MISTRALAI = 'mistralai',
   OLLAMA = 'ollama',
+  GOOGLE = 'google',
 }
 
 export enum GraphNodeKeys {

package/src/events.ts

@@ -2,6 +2,8 @@
 // src/events.ts
 import type { Graph } from '@/graphs';
 import type * as t from '@/types';
+import { handleToolCalls } from '@/stream';
+import { Providers } from '@/common';
 
 export class HandlerRegistry {
   private handlers: Map<string, t.EventHandler> = new Map();
@@ -28,6 +30,12 @@ export class ModelEndHandler implements t.EventHandler {
     console.dir({
       usage,
     }, { depth: null });
+
+    if (metadata.provider !== Providers.GOOGLE) {
+      return;
+    }
+
+    handleToolCalls(data?.output?.tool_calls, metadata, graph);
   }
 }
 
@@ -58,7 +66,7 @@ export class TestLLMStreamHandler implements t.EventHandler {
   handle(event: string, data: t.StreamEventData | undefined): void {
     const chunk = data?.chunk;
     const  isMessageChunk = !!(chunk && 'message' in chunk);
-    const msg = isMessageChunk && chunk.message;
+    const msg = isMessageChunk ? chunk.message : undefined;
     if (msg && msg.tool_call_chunks && msg.tool_call_chunks.length > 0) {
       console.log(msg.tool_call_chunks);
     } else if (msg && msg.content) {

package/src/llm/anthropic/llm.ts

@@ -84,7 +84,7 @@ export class CustomAnthropic extends ChatAnthropicMessages {
     );
 
     for await (const data of stream) {
-      if (options.signal?.aborted) {
+      if (options.signal?.aborted === true) {
         stream.controller.abort();
         throw new Error('AbortError: User aborted the request.');
       }

package/src/llm/anthropic/types.ts

@@ -10,6 +10,7 @@ export type AnthropicToolResponse = {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   input: Record<string, any>;
 };
+
 export type AnthropicMessageParam = Anthropic.MessageParam;
 export type AnthropicMessageResponse =
   | Anthropic.ContentBlock
@@ -29,4 +30,9 @@ export type AnthropicToolChoice =
   | 'auto'
   | 'none'
   | string;
-export type ChatAnthropicToolType = AnthropicTool | BindToolsInput;
+export type ChatAnthropicToolType = AnthropicTool | BindToolsInput;
+export type AnthropicTextBlockParam = Anthropic.Messages.TextBlockParam;
+export type AnthropicImageBlockParam = Anthropic.Messages.ImageBlockParam;
+export type AnthropicToolUseBlockParam = Anthropic.Messages.ToolUseBlockParam;
+export type AnthropicToolResultBlockParam =
+  Anthropic.Messages.ToolResultBlockParam;

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

@@ -1,19 +1,25 @@
+/* eslint-disable no-console */
 /**
  * This util file contains functions for converting LangChain messages to Anthropic messages.
  */
 import {
-  BaseMessage,
-  SystemMessage,
-  HumanMessage,
   AIMessage,
+  BaseMessage,
   ToolMessage,
-  MessageContent,
   isAIMessage,
+  HumanMessage,
+  SystemMessage,
+  MessageContent,
 } from '@langchain/core/messages';
 import { ToolCall } from '@langchain/core/messages/tool';
 import type {
-  AnthropicMessageCreateParams,
   AnthropicToolResponse,
+  AnthropicMessageParam,
+  AnthropicTextBlockParam,
+  AnthropicImageBlockParam,
+  AnthropicToolUseBlockParam,
+  AnthropicMessageCreateParams,
+  AnthropicToolResultBlockParam,
 } from '@/llm/anthropic/types';
 
 function _formatImage(imageUrl: string): { type: string; media_type: string; data: string } {
@@ -130,7 +136,7 @@ function _formatContent(content: MessageContent): string | Record<string, any>[]
           ...(cacheControl ? { cache_control: cacheControl } : {}),
         };
       } else if (
-        textTypes.find((t) => t === contentPart.type) &&
+        textTypes.find((t) => t === contentPart.type) != null &&
         'text' in contentPart
       ) {
         // Assuming contentPart is of type MessageContentText here
@@ -139,7 +145,7 @@ function _formatContent(content: MessageContent): string | Record<string, any>[]
           text: contentPart.text,
           ...(cacheControl ? { cache_control: cacheControl } : {}),
         };
-      } else if (toolTypes.find((t) => t === contentPart.type)) {
+      } else if (toolTypes.find((t) => t === contentPart.type) != null) {
         const contentPartCopy = { ...contentPart };
         if ('index' in contentPartCopy) {
           // Anthropic does not support passing the index field here, so we remove it.
@@ -252,7 +258,79 @@ export function _convertMessagesToAnthropicPayload(
     }
   });
   return {
-    messages: formattedMessages,
+    messages: mergeMessages(formattedMessages as AnthropicMessageCreateParams['messages']),
     system,
   } as AnthropicMessageCreateParams;
+}
+
+function mergeMessages(messages?: AnthropicMessageCreateParams['messages']): AnthropicMessageParam[] {
+  if (!messages || messages.length <= 1) {
+    return messages ?? [];
+  }
+
+  const result: AnthropicMessageCreateParams['messages'] = [];
+  let currentMessage = messages[0];
+
+  const normalizeContent = (
+    content:
+      | string
+      | Array<
+          | AnthropicTextBlockParam
+          | AnthropicImageBlockParam
+          | AnthropicToolUseBlockParam
+          | AnthropicToolResultBlockParam
+        >
+  ): Array<
+    | AnthropicTextBlockParam
+    | AnthropicImageBlockParam
+    | AnthropicToolUseBlockParam
+    | AnthropicToolResultBlockParam
+  > => {
+    if (typeof content === 'string') {
+      return [
+        {
+          type: 'text',
+          text: content,
+        },
+      ];
+    }
+    return content;
+  };
+
+  const isToolResultMessage = (msg: (typeof messages)[0]): boolean => {
+    if (msg.role !== 'user') return false;
+
+    if (typeof msg.content === 'string') {
+      return false;
+    }
+
+    return (
+      Array.isArray(msg.content) &&
+      msg.content.every((item) => item.type === 'tool_result')
+    );
+  };
+
+  for (let i = 1; i < messages.length; i += 1) {
+    const nextMessage = messages[i];
+
+    if (
+      isToolResultMessage(currentMessage) &&
+      isToolResultMessage(nextMessage)
+    ) {
+      // Merge the messages by combining their content arrays
+      currentMessage = {
+        ...currentMessage,
+        content: [
+          ...normalizeContent(currentMessage.content),
+          ...normalizeContent(nextMessage.content),
+        ],
+      };
+    } else {
+      result.push(currentMessage);
+      currentMessage = nextMessage;
+    }
+  }
+
+  result.push(currentMessage);
+  return result;
 }

package/src/llm/providers.ts

@@ -2,13 +2,14 @@
 import { ChatOpenAI } from '@langchain/openai';
 import { ChatOllama } from '@langchain/ollama';
 import { ChatBedrockConverse } from '@langchain/aws';
-import { ChatAnthropic } from '@langchain/anthropic';
+// import { ChatAnthropic } from '@langchain/anthropic';
 import { ChatMistralAI } from '@langchain/mistralai';
 import { ChatVertexAI } from '@langchain/google-vertexai';
+import { ChatGoogleGenerativeAI } from '@langchain/google-genai';
 import { BedrockChat } from '@langchain/community/chat_models/bedrock/web';
 import type { ChatModelConstructorMap, ProviderOptionsMap, ChatModelMap } from '@/types';
 import { Providers } from '@/common';
-// import { CustomAnthropic } from '@/llm/anthropic/llm';
+import { CustomAnthropic } from '@/llm/anthropic/llm';
 
 export const llmProviders: Partial<ChatModelConstructorMap> = {
   [Providers.OPENAI]: ChatOpenAI,
@@ -17,8 +18,9 @@ export const llmProviders: Partial<ChatModelConstructorMap> = {
   [Providers.BEDROCK_LEGACY]: BedrockChat,
   [Providers.MISTRALAI]: ChatMistralAI,
   [Providers.BEDROCK]: ChatBedrockConverse,
-  // [Providers.ANTHROPIC]: CustomAnthropic,
-  [Providers.ANTHROPIC]: ChatAnthropic,
+  [Providers.ANTHROPIC]: CustomAnthropic,
+  // [Providers.ANTHROPIC]: ChatAnthropic,
+  [Providers.GOOGLE]: ChatGoogleGenerativeAI,
 };
 
 export const manualToolStreamProviders = new Set<Providers | string>([Providers.ANTHROPIC, Providers.BEDROCK, Providers.OLLAMA]);

package/src/llm/text.ts

@@ -1,73 +1,52 @@
 /* eslint-disable no-console */
-import { Readable } from 'stream';
-import type { ReadableOptions } from 'stream';
-export interface TextStreamOptions extends ReadableOptions {
+export interface TextStreamOptions {
   minChunkSize?: number;
   maxChunkSize?: number;
   delay?: number;
+  firstWordChunk?: boolean;
 }
 
 export type ProgressCallback = (chunk: string) => void;
 export type PostChunkCallback = (chunk: string) => void;
 
-export class TextStream extends Readable {
+export class TextStream {
   private text: string;
   private currentIndex: number;
   private minChunkSize: number;
   private maxChunkSize: number;
   private delay: number;
+  private firstWordChunk: boolean;
 
   constructor(text: string, options: TextStreamOptions = {}) {
-    super(options);
     this.text = text;
     this.currentIndex = 0;
-    this.minChunkSize = options.minChunkSize ?? 2;
-    this.maxChunkSize = options.maxChunkSize ?? 4;
-    this.delay = options.delay ?? 20; // Time in milliseconds
-  }
-
-  _read(): void {
-    const { delay, minChunkSize, maxChunkSize } = this;
-
-    if (this.currentIndex < this.text.length) {
-      setTimeout(() => {
-        const remainingChars = this.text.length - this.currentIndex;
-        const chunkSize = Math.min(this.randomInt(minChunkSize, maxChunkSize + 1), remainingChars);
-
-        const chunk = this.text.slice(this.currentIndex, this.currentIndex + chunkSize);
-        this.push(chunk);
-        this.currentIndex += chunkSize;
-      }, delay);
-    } else {
-      this.push(null); // signal end of data
-    }
+    this.minChunkSize = options.minChunkSize ?? 4;
+    this.maxChunkSize = options.maxChunkSize ?? 8;
+    this.delay = options.delay ?? 20;
+    this.firstWordChunk = options.firstWordChunk ?? true;
   }
 
   private randomInt(min: number, max: number): number {
     return Math.floor(Math.random() * (max - min)) + min;
   }
 
-  async processTextStream(progressCallback: ProgressCallback): Promise<void> {
-    const streamPromise = new Promise<void>((resolve, reject) => {
-      this.on('data', (chunk) => {
-        progressCallback(chunk.toString());
-      });
+  private static readonly BOUNDARIES = new Set([' ', '.', ',', '!', '?', ';', ':']);
 
-      this.on('end', () => {
-        resolve();
-      });
+  private findFirstWordBoundary(text: string, minSize: number): number {
+    if (minSize >= text.length) return text.length;
 
-      this.on('error', (err) => {
-        reject(err);
-      });
-    });
+    // Ensure we meet the minimum size first
+    let pos = minSize;
 
-    try {
-      await streamPromise;
-    } catch (err) {
-      console.error('[processTextStream] Error in text stream:', err);
-      // Handle the error appropriately, e.g., return an error message or throw an error
+    // Look forward until we find a boundary
+    while (pos < text.length) {
+      if (TextStream.BOUNDARIES.has(text[pos])) {
+        return pos + 1; // Include the boundary character
+      }
+      pos++;
     }
+
+    return text.length; // If no boundary found, return entire remaining text
   }
 
   async *generateText(progressCallback?: ProgressCallback): AsyncGenerator<string, void, unknown> {
@@ -76,11 +55,17 @@ export class TextStream extends Readable {
     while (this.currentIndex < this.text.length) {
       await new Promise(resolve => setTimeout(resolve, delay));
 
-      const remainingChars = this.text.length - this.currentIndex;
-      const chunkSize = Math.min(this.randomInt(minChunkSize, maxChunkSize + 1), remainingChars);
+      const remainingText = this.text.slice(this.currentIndex);
+      let chunkSize: number;
 
-      const chunk = this.text.slice(this.currentIndex, this.currentIndex + chunkSize);
+      if (this.firstWordChunk) {
+        chunkSize = this.findFirstWordBoundary(remainingText, minChunkSize);
+      } else {
+        const remainingChars = remainingText.length;
+        chunkSize = Math.min(this.randomInt(minChunkSize, maxChunkSize + 1), remainingChars);
+      }
 
+      const chunk = this.text.slice(this.currentIndex, this.currentIndex + chunkSize);
       progressCallback?.(chunk);
 
       yield chunk;

package/src/messages.ts

@@ -33,7 +33,7 @@ User: ${userMessage[1]}
 
 const modifyContent = (messageType: string, content: t.ExtendedMessageContent[]): t.ExtendedMessageContent[] => {
   return content.map(item => {
-    if (item && typeof item === 'object' && 'type' in item && item.type) {
+    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', '');
@@ -80,9 +80,9 @@ export function formatAnthropicMessage(message: AIMessageChunk): AIMessage {
     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) {
+        if (extendedItem.type === 'text' && extendedItem.text != null && extendedItem.text) {
           acc.push({ type: 'text', text: extendedItem.text });
-        } else if (extendedItem.type === 'tool_use' && extendedItem.id) {
+        } else if (extendedItem.type === 'tool_use' && extendedItem.id != null && extendedItem.id) {
           const toolCall = toolCallMap.get(extendedItem.id);
           if (toolCall) {
             acc.push({
@@ -92,7 +92,7 @@ export function formatAnthropicMessage(message: AIMessageChunk): AIMessage {
               input: toolCall.args as unknown as string
             });
           }
-        } else if ('input' in extendedItem && 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);

package/src/scripts/args.ts

@@ -20,7 +20,7 @@ export async function getArgs(): Promise<{ userName: string; location: string; p
       alias: 'p',
       type: 'string',
       description: 'LLM provider',
-      choices: ['openAI', 'anthropic', 'mistralai', 'vertexai', 'bedrock', 'ollama'],
+      choices: ['openAI', 'anthropic', 'mistralai', 'vertexai', 'bedrock', 'ollama', 'google'],
       default: 'openAI'
     })
     .help()

package/src/scripts/code_exec.ts

@@ -171,6 +171,10 @@ process.on('unhandledRejection', (reason, promise) => {
   process.exit(1);
 });
 
+process.on('uncaughtException', (err) => {
+  console.error('Uncaught Exception:', err);
+});
+
 testCodeExecution().catch((err) => {
   console.error(err);
   console.log('Conversation history:');

package/src/scripts/simple.ts

@@ -117,6 +117,10 @@ process.on('unhandledRejection', (reason, promise) => {
   process.exit(1);
 });
 
+process.on('uncaughtException', (err) => {
+  console.error('Uncaught Exception:', err);
+});
+
 testStandardStreaming().catch((err) => {
   console.error(err);
   console.log('Conversation history:');

package/src/stream.ts

@@ -33,6 +33,73 @@ const getMessageId = (stepKey: string, graph: Graph<t.BaseGraphState>, returnExi
   return message_id;
 };
 
+export const handleToolCalls = (toolCalls?: ToolCall[], metadata?: Record<string, unknown>, graph?: Graph): void => {
+  if (!graph || !metadata) {
+    console.warn(`Graph or metadata not found in ${event} event`);
+    return;
+  }
+
+  if (!toolCalls) {
+    return;
+  }
+
+  if (toolCalls.length === 0) {
+    return;
+  }
+
+  const tool_calls: ToolCall[] = [];
+  const tool_call_ids: string[] = [];
+  for (const tool_call of toolCalls) {
+    const toolCallId = tool_call.id ?? `toolu_${nanoid()}`;
+    tool_call.id = toolCallId;
+    if (!toolCallId || graph.toolCallStepIds.has(toolCallId)) {
+      continue;
+    }
+
+    tool_calls.push(tool_call);
+    tool_call_ids.push(toolCallId);
+  }
+
+  const stepKey = graph.getStepKey(metadata);
+
+  let prevStepId = '';
+  let prevRunStep: t.RunStep | undefined;
+  try {
+    prevStepId = graph.getStepIdByKey(stepKey, graph.contentData.length - 1);
+    prevRunStep = graph.getRunStep(prevStepId);
+  } catch (e) {
+    // no previous step
+  }
+
+  const dispatchToolCallIds = (lastMessageStepId: string): void => {
+    graph.dispatchMessageDelta(lastMessageStepId, {
+      content: [{
+        type: 'text',
+        text: '',
+        tool_call_ids,
+      }],
+    });
+  };
+    /* If the previous step exists and is a message creation */
+  if (prevStepId && prevRunStep && prevRunStep.type === StepTypes.MESSAGE_CREATION) {
+    dispatchToolCallIds(prevStepId);
+    /* If the previous step doesn't exist or is not a message creation */
+  } else if (!prevRunStep || prevRunStep.type !== StepTypes.MESSAGE_CREATION) {
+    const messageId = getMessageId(stepKey, graph, true) ?? '';
+    const stepId = graph.dispatchRunStep(stepKey, {
+      type: StepTypes.MESSAGE_CREATION,
+      message_creation: {
+        message_id: messageId,
+      },
+    });
+    dispatchToolCallIds(stepId);
+  }
+  graph.dispatchRunStep(stepKey, {
+    type: StepTypes.TOOL_CALLS,
+    tool_calls,
+  });
+};
+
 export class ChatModelStreamHandler implements t.EventHandler {
   handle(event: string, data: t.StreamEventData, metadata?: Record<string, unknown>, graph?: Graph): void {
     if (!graph) {
@@ -56,56 +123,7 @@ export class ChatModelStreamHandler implements t.EventHandler {
 
     if (chunk.tool_calls && chunk.tool_calls.length > 0 && chunk.tool_calls.every((tc) => tc.id)) {
       hasToolCalls = true;
-      const tool_calls: ToolCall[] = [];
-      const tool_call_ids: string[] = [];
-      for (const tool_call of chunk.tool_calls) {
-        const toolCallId = tool_call.id ?? '';
-        if (!toolCallId || graph.toolCallStepIds.has(toolCallId)) {
-          continue;
-        }
-
-        tool_calls.push(tool_call);
-        tool_call_ids.push(toolCallId);
-      }
-
-      const stepKey = graph.getStepKey(metadata);
-
-      let prevStepId = '';
-      let prevRunStep: t.RunStep | undefined;
-      try {
-        prevStepId = graph.getStepIdByKey(stepKey, graph.contentData.length - 1);
-        prevRunStep = graph.getRunStep(prevStepId);
-      } catch (e) {
-        // no previous step
-      }
-
-      const dispatchToolCallIds = (lastMessageStepId: string): void => {
-        graph.dispatchMessageDelta(lastMessageStepId, {
-          content: [{
-            type: 'text',
-            text: '',
-            tool_call_ids,
-          }],
-        });
-      };
-      /* If the previous step exists and is a message creation */
-      if (prevStepId && prevRunStep && prevRunStep.type === StepTypes.MESSAGE_CREATION) {
-        dispatchToolCallIds(prevStepId);
-        /* If the previous step doesn't exist or is not a message creation */
-      } else if (!prevRunStep || prevRunStep.type !== StepTypes.MESSAGE_CREATION) {
-        const messageId = getMessageId(stepKey, graph, true) ?? '';
-        const stepId = graph.dispatchRunStep(stepKey, {
-          type: StepTypes.MESSAGE_CREATION,
-          message_creation: {
-            message_id: messageId,
-          },
-        });
-        dispatchToolCallIds(stepId);
-      }
-      graph.dispatchRunStep(stepKey, {
-        type: StepTypes.TOOL_CALLS,
-        tool_calls,
-      });
+      handleToolCalls(chunk.tool_calls, metadata, graph);
     }
 
     const isEmptyContent = typeof content === 'undefined' || !content.length || typeof content === 'string' && !content;

package/src/tools/ToolNode.ts

@@ -1,11 +1,11 @@
-import { END, MessagesAnnotation } from '@langchain/langgraph';
+import { END, MessagesAnnotation, isCommand, isGraphInterrupt } from '@langchain/langgraph';
 import { ToolMessage, isBaseMessage } from '@langchain/core/messages';
 import type { RunnableConfig, RunnableToolLike } from '@langchain/core/runnables';
 import type { BaseMessage, AIMessage } from '@langchain/core/messages';
 import type { StructuredToolInterface } from '@langchain/core/tools';
 import type * as t from '@/types';
-import{ RunnableCallable } from '@/utils';
-import { GraphNodeKeys } from '@/common';
+import{ RunnableCallable, unescapeObject } from '@/utils';
+import { GraphNodeKeys, Providers } from '@/common';
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export class ToolNode<T = any> extends RunnableCallable<T, T> {
@@ -46,7 +46,6 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
       this.tools = tools;
       this.toolMap = toolMap ?? new Map(tools.map(tool => [tool.name, tool]));
     }
-
     const outputs = await Promise.all(
       (message as AIMessage).tool_calls?.map(async (call) => {
         const tool = this.toolMap.get(call.name);
@@ -54,11 +53,15 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
           if (tool === undefined) {
             throw new Error(`Tool "${call.name}" not found.`);
           }
+          const args = config.metadata?.provider === Providers.GOOGLE ? unescapeObject(call.args) : call.args;
           const output = await tool.invoke(
-            { ...call, type: 'tool_call' },
+            { ...call, args, type: 'tool_call' },
             config
           );
-          if (isBaseMessage(output) && output._getType() === 'tool') {
+          if (
+            (isBaseMessage(output) && output._getType() === 'tool') ||
+            isCommand(output)
+          ) {
             return output;
           } else {
             return new ToolMessage({
@@ -68,11 +71,14 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
               tool_call_id: call.id!,
             });
           }
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        } catch (e: any) {
+        } catch (_e: unknown) {
+          const e = _e as Error;
           if (!this.handleToolErrors) {
             throw e;
           }
+          if (isGraphInterrupt(e)) {
+            throw e;
+          }
           return new ToolMessage({
             content: `Error: ${e.message}\n Please fix your mistakes.`,
             name: call.name,
@@ -82,7 +88,17 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
       }) ?? []
     );
 
-    return (Array.isArray(input) ? outputs : { messages: outputs }) as T;
+    if (!outputs.some(isCommand)) {
+      return (Array.isArray(input) ? outputs : { messages: outputs }) as T;
+    }
+
+    const combinedOutputs = outputs.map((output) => {
+      if (isCommand(output)) {
+        return output;
+      }
+      return Array.isArray(input) ? [output] : { messages: [output] };
+    });
+    return combinedOutputs as T;
   }
 }