@librechat/agents 1.8.7 → 1.8.9

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;
   }
 }
 

package/src/types/llm.ts

@@ -6,12 +6,14 @@ import { ChatMistralAI } from '@langchain/mistralai';
 import { ChatBedrockConverse } from '@langchain/aws';
 import { ChatVertexAI } from '@langchain/google-vertexai';
 import { BedrockChat } from '@langchain/community/chat_models/bedrock/web';
+import { ChatGoogleGenerativeAI } from '@langchain/google-genai';
 import type { Runnable } from '@langchain/core/runnables';
 import type { StructuredTool } from '@langchain/core/tools';
 import type { BindToolsInput } from '@langchain/core/language_models/chat_models';
 import type { BedrockChatFields } from '@langchain/community/chat_models/bedrock/web';
 import type { ChatOpenAIFields } from '@langchain/openai';
 import type { OpenAI as OpenAIClient } from 'openai';
+import type { GoogleGenerativeAIChatInput } from '@langchain/google-genai';
 import type { ChatVertexAIInput } from '@langchain/google-vertexai';
 import type { ChatBedrockConverseInput } from '@langchain/aws';
 import type { ChatMistralAIInput } from '@langchain/mistralai';
@@ -29,8 +31,9 @@ export type MistralAIClientOptions = ChatMistralAIInput;
 export type VertexAIClientOptions = ChatVertexAIInput;
 export type BedrockClientOptions = BedrockChatFields;
 export type BedrockConverseClientOptions = ChatBedrockConverseInput;
+export type GoogleClientOptions = GoogleGenerativeAIChatInput;
 
-export type ClientOptions = OpenAIClientOptions | OllamaClientOptions | AnthropicClientOptions | MistralAIClientOptions | VertexAIClientOptions | BedrockClientOptions | BedrockConverseClientOptions;
+export type ClientOptions = OpenAIClientOptions | OllamaClientOptions | AnthropicClientOptions | MistralAIClientOptions | VertexAIClientOptions | BedrockClientOptions | BedrockConverseClientOptions | GoogleClientOptions;
 
 export type LLMConfig = {
   provider: Providers;
@@ -44,6 +47,7 @@ export type ProviderOptionsMap = {
   [Providers.VERTEXAI]: VertexAIClientOptions;
   [Providers.BEDROCK_LEGACY]: BedrockClientOptions;
   [Providers.BEDROCK]: BedrockConverseClientOptions;
+  [Providers.GOOGLE]: GoogleClientOptions;
 };
 
 export type ChatModelMap = {
@@ -54,6 +58,7 @@ export type ChatModelMap = {
   [Providers.VERTEXAI]: ChatVertexAI;
   [Providers.BEDROCK_LEGACY]: BedrockChat;
   [Providers.BEDROCK]: ChatBedrockConverse;
+  [Providers.GOOGLE]: ChatGoogleGenerativeAI;
 };
 
 export type ChatModelConstructorMap = {

package/src/utils/index.ts

@@ -1,2 +1,3 @@
 export * from './graph';
+export * from './misc';
 export * from './run';

package/src/utils/llmConfig.ts

@@ -35,6 +35,12 @@ const llmConfigs: Record<string, t.LLMConfig | undefined> = {
     streaming: true,
     streamUsage: true,
   },
+  [Providers.GOOGLE]: {
+    provider: Providers.GOOGLE,
+    model: 'gemini-2.0-flash-exp',
+    streaming: true,
+    streamUsage: true,
+  },
   [Providers.BEDROCK]: {
     provider: Providers.BEDROCK,
     model: 'anthropic.claude-3-sonnet-20240229-v1:0',

package/src/utils/misc.ts

@@ -0,0 +1,45 @@
+/**
+ * Unescapes a c-escaped string
+ * @param str The string to unescape
+ * @returns The unescaped string
+ */
+const unescapeString = (string: string): string => string.replace(/\\(.)/g, (_, char) => {
+  switch (char) {
+  case 'n':
+    return '\n';
+  case 't':
+    return '\t';
+  case 'r':
+    return '\r';
+  case '"':
+    return '"';
+  case '\'':
+    return '\'';
+  case '\\':
+    return '\\';
+  default:
+    return char;
+  }
+});
+
+/**
+ * Recursively unescapes all string values in an object
+ * @param obj The object to unescape
+ * @returns The unescaped object
+ */
+export function unescapeObject(obj: unknown, key?: string): unknown {
+  if (typeof obj === 'string') {
+    let unescaped = unescapeString(obj);
+    if (key === 'filePath' && unescaped.match(/^"(.+)"$/)) {
+      unescaped = unescaped.substring(1, unescaped.length - 1);
+    }
+    return unescaped;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((value) => unescapeObject(value, key === 'contextPaths' ? 'filePath' : ''));
+  }
+  if (typeof obj === 'object' && obj !== null) {
+    return Object.fromEntries(Object.entries(obj).map(([key, value]) => [key, unescapeObject(value, key)]));
+  }
+  return obj;
+}