@librechat/agents 2.4.30 → 2.4.33

package/src/stream.ts

@@ -1,120 +1,71 @@
 // src/stream.ts
-import { nanoid } from 'nanoid';
 import type { AIMessageChunk } from '@langchain/core/messages';
-import type { ToolCall, ToolCallChunk } from '@langchain/core/messages/tool';
+import type { ToolCall } from '@langchain/core/messages/tool';
 import type { Graph } from '@/graphs';
 import type * as t from '@/types';
 import { StepTypes, ContentTypes, GraphEvents, ToolCallTypes } from '@/common';
-
-function getNonEmptyValue(possibleValues: string[]): string | undefined {
-  for (const value of possibleValues) {
-    if (value && value.trim() !== '') {
-      return value;
-    }
+import { handleToolCalls, handleToolCallChunks } from '@/tools/handlers';
+import { getMessageId } from '@/messages';
+
+/**
+ * Parses content to extract thinking sections enclosed in <think> tags using string operations
+ * @param content The content to parse
+ * @returns An object with separated text and thinking content
+ */
+function parseThinkingContent(content: string): {
+  text: string;
+  thinking: string;
+} {
+  // If no think tags, return the original content as text
+  if (!content.includes('<think>')) {
+    return { text: content, thinking: '' };
   }
-  return undefined;
-}
 
-export const getMessageId = (
-  stepKey: string,
-  graph: Graph<t.BaseGraphState>,
-  returnExistingId = false
-): string | undefined => {
-  const messageId = graph.messageIdsByStepKey.get(stepKey);
-  if (messageId != null && messageId) {
-    return returnExistingId ? messageId : undefined;
-  }
+  let textResult = '';
+  const thinkingResult: string[] = [];
+  let position = 0;
 
-  const prelimMessageId = graph.prelimMessageIdsByStepKey.get(stepKey);
-  if (prelimMessageId != null && prelimMessageId) {
-    graph.prelimMessageIdsByStepKey.delete(stepKey);
-    graph.messageIdsByStepKey.set(stepKey, prelimMessageId);
-    return prelimMessageId;
-  }
+  while (position < content.length) {
+    const thinkStart = content.indexOf('<think>', position);
 
-  const message_id = `msg_${nanoid()}`;
-  graph.messageIdsByStepKey.set(stepKey, message_id);
-  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 (thinkStart === -1) {
+      // No more think tags, add the rest and break
+      textResult += content.slice(position);
+      break;
+    }
 
-  if (!toolCalls) {
-    return;
-  }
+    // Add text before the think tag
+    textResult += content.slice(position, thinkStart);
 
-  if (toolCalls.length === 0) {
-    return;
-  }
+    const thinkEnd = content.indexOf('</think>', thinkStart);
+    if (thinkEnd === -1) {
+      // Malformed input, no closing tag
+      textResult += content.slice(thinkStart);
+      break;
+    }
 
-  const stepKey = graph.getStepKey(metadata);
+    // Add the thinking content
+    const thinkContent = content.slice(thinkStart + 7, thinkEnd);
+    thinkingResult.push(thinkContent);
 
-  for (const tool_call of toolCalls) {
-    const toolCallId = tool_call.id ?? `toolu_${nanoid()}`;
-    tool_call.id = toolCallId;
-    if (!toolCallId || graph.toolCallStepIds.has(toolCallId)) {
-      continue;
-    }
+    // Move position to after the think tag
+    position = thinkEnd + 8; // 8 is the length of '</think>'
+  }
 
-    let prevStepId = '';
-    let prevRunStep: t.RunStep | undefined;
-    try {
-      prevStepId = graph.getStepIdByKey(stepKey, graph.contentData.length - 1);
-      prevRunStep = graph.getRunStep(prevStepId);
-    } catch {
-      // no previous step
-    }
+  return {
+    text: textResult.trim(),
+    thinking: thinkingResult.join('\n').trim(),
+  };
+}
 
-    const dispatchToolCallIds = (lastMessageStepId: string): void => {
-      graph.dispatchMessageDelta(lastMessageStepId, {
-        content: [
-          {
-            type: 'text',
-            text: '',
-            tool_call_ids: [toolCallId],
-          },
-        ],
-      });
-    };
-    /* If the previous step exists and is a message creation */
-    if (
-      prevStepId &&
-      prevRunStep &&
-      prevRunStep.type === StepTypes.MESSAGE_CREATION
-    ) {
-      dispatchToolCallIds(prevStepId);
-      graph.messageStepHasToolCalls.set(prevStepId, true);
-      /* 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.messageStepHasToolCalls.set(prevStepId, true);
+function getNonEmptyValue(possibleValues: string[]): string | undefined {
+  for (const value of possibleValues) {
+    if (value && value.trim() !== '') {
+      return value;
     }
-
-    graph.dispatchRunStep(stepKey, {
-      type: StepTypes.TOOL_CALLS,
-      tool_calls: [tool_call],
-    });
   }
-};
-
+  return undefined;
+}
 export class ChatModelStreamHandler implements t.EventHandler {
   handle(
     event: string,
@@ -179,7 +130,7 @@ export class ChatModelStreamHandler implements t.EventHandler {
       chunk.tool_call_chunks.length &&
       typeof chunk.tool_call_chunks[0]?.index === 'number'
     ) {
-      this.handleToolCallChunks({
+      handleToolCallChunks({
         graph,
         stepKey,
         toolCallChunks: chunk.tool_call_chunks,
@@ -239,6 +190,40 @@ hasToolCallChunks: ${hasToolCallChunks}
             },
           ],
         });
+      } else if (graph.currentTokenType === 'think_and_text') {
+        const { text, thinking } = parseThinkingContent(content);
+        if (thinking) {
+          graph.dispatchReasoningDelta(stepId, {
+            content: [
+              {
+                type: ContentTypes.THINK,
+                think: thinking,
+              },
+            ],
+          });
+        }
+        if (text) {
+          graph.currentTokenType = ContentTypes.TEXT;
+          graph.tokenTypeSwitch = 'content';
+          const newStepKey = graph.getStepKey(metadata);
+          const message_id = getMessageId(newStepKey, graph) ?? '';
+          graph.dispatchRunStep(newStepKey, {
+            type: StepTypes.MESSAGE_CREATION,
+            message_creation: {
+              message_id,
+            },
+          });
+
+          const newStepId = graph.getStepIdByKey(newStepKey);
+          graph.dispatchMessageDelta(newStepId, {
+            content: [
+              {
+                type: ContentTypes.TEXT,
+                text: text,
+              },
+            ],
+          });
+        }
       } else {
         graph.dispatchReasoningDelta(stepId, {
           content: [
@@ -273,88 +258,6 @@ hasToolCallChunks: ${hasToolCallChunks}
       });
     }
   }
-  handleToolCallChunks = ({
-    graph,
-    stepKey,
-    toolCallChunks,
-  }: {
-    graph: Graph;
-    stepKey: string;
-    toolCallChunks: ToolCallChunk[];
-  }): void => {
-    let prevStepId: string;
-    let prevRunStep: t.RunStep | undefined;
-    try {
-      prevStepId = graph.getStepIdByKey(stepKey, graph.contentData.length - 1);
-      prevRunStep = graph.getRunStep(prevStepId);
-    } catch {
-      /** Edge Case: If no previous step exists, create a new message creation step */
-      const message_id = getMessageId(stepKey, graph, true) ?? '';
-      prevStepId = graph.dispatchRunStep(stepKey, {
-        type: StepTypes.MESSAGE_CREATION,
-        message_creation: {
-          message_id,
-        },
-      });
-      prevRunStep = graph.getRunStep(prevStepId);
-    }
-
-    const _stepId = graph.getStepIdByKey(stepKey, prevRunStep?.index);
-
-    /** Edge Case: Tool Call Run Step or `tool_call_ids` never dispatched */
-    const tool_calls: ToolCall[] | undefined =
-      prevStepId &&
-      prevRunStep &&
-      prevRunStep.type === StepTypes.MESSAGE_CREATION
-        ? []
-        : undefined;
-
-    /** Edge Case: `id` and `name` fields cannot be empty strings */
-    for (const toolCallChunk of toolCallChunks) {
-      if (toolCallChunk.name === '') {
-        toolCallChunk.name = undefined;
-      }
-      if (toolCallChunk.id === '') {
-        toolCallChunk.id = undefined;
-      } else if (
-        tool_calls != null &&
-        toolCallChunk.id != null &&
-        toolCallChunk.name != null
-      ) {
-        tool_calls.push({
-          args: {},
-          id: toolCallChunk.id,
-          name: toolCallChunk.name,
-          type: ToolCallTypes.TOOL_CALL,
-        });
-      }
-    }
-
-    let stepId: string = _stepId;
-    const alreadyDispatched =
-      prevRunStep?.type === StepTypes.MESSAGE_CREATION &&
-      graph.messageStepHasToolCalls.has(prevStepId);
-    if (!alreadyDispatched && tool_calls?.length === toolCallChunks.length) {
-      graph.dispatchMessageDelta(prevStepId, {
-        content: [
-          {
-            type: ContentTypes.TEXT,
-            text: '',
-            tool_call_ids: tool_calls.map((tc) => tc.id ?? ''),
-          },
-        ],
-      });
-      graph.messageStepHasToolCalls.set(prevStepId, true);
-      stepId = graph.dispatchRunStep(stepKey, {
-        type: StepTypes.TOOL_CALLS,
-        tool_calls,
-      });
-    }
-    graph.dispatchRunStepDelta(stepId, {
-      type: StepTypes.TOOL_CALLS,
-      tool_calls: toolCallChunks,
-    });
-  };
   handleReasoning(chunk: Partial<AIMessageChunk>, graph: Graph): void {
     let reasoning_content = chunk.additional_kwargs?.[graph.reasoningKey] as
       | string
@@ -384,6 +287,14 @@ hasToolCallChunks: ${hasToolCallChunks}
     ) {
       graph.currentTokenType = ContentTypes.TEXT;
       graph.tokenTypeSwitch = 'content';
+    } else if (
+      chunk.content != null &&
+      typeof chunk.content === 'string' &&
+      chunk.content.includes('<think>') &&
+      chunk.content.includes('</think>')
+    ) {
+      graph.currentTokenType = 'think_and_text';
+      graph.tokenTypeSwitch = 'content';
     } else if (
       chunk.content != null &&
       typeof chunk.content === 'string' &&

package/src/tools/ToolNode.ts

@@ -1,10 +1,18 @@
-import { END, MessagesAnnotation, isCommand, isGraphInterrupt } 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 {
+  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 { RunnableCallable } from '@/utils';
 import { GraphNodeKeys } from '@/common';
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -15,6 +23,7 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
   handleToolErrors = true;
   toolCallStepIds?: Map<string, string>;
   errorHandler?: t.ToolNodeConstructorParams['errorHandler'];
+  private toolUsageCount: Map<string, number>;
 
   constructor({
     tools,
@@ -28,11 +37,20 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
   }: t.ToolNodeConstructorParams) {
     super({ name, tags, func: (input, config) => this.run(input, config) });
     this.tools = tools;
-    this.toolMap = toolMap ?? new Map(tools.map(tool => [tool.name, tool]));
+    this.toolMap = toolMap ?? new Map(tools.map((tool) => [tool.name, tool]));
     this.toolCallStepIds = toolCallStepIds;
     this.handleToolErrors = handleToolErrors ?? this.handleToolErrors;
     this.loadRuntimeTools = loadRuntimeTools;
     this.errorHandler = errorHandler;
+    this.toolUsageCount = new Map<string, number>();
+  }
+
+  /**
+   * Returns a snapshot of the current tool usage counts.
+   * @returns A ReadonlyMap where keys are tool names and values are their usage counts.
+   */
+  public getToolUsageCounts(): ReadonlyMap<string, number> {
+    return new Map(this.toolUsageCount); // Return a copy
   }
 
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -50,7 +68,7 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
         (message as AIMessage).tool_calls ?? []
       );
       this.tools = tools;
-      this.toolMap = toolMap ?? new Map(tools.map(tool => [tool.name, tool]));
+      this.toolMap = toolMap ?? new Map(tools.map((tool) => [tool.name, tool]));
     }
     const outputs = await Promise.all(
       (message as AIMessage).tool_calls?.map(async (call) => {
@@ -59,11 +77,13 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
           if (tool === undefined) {
             throw new Error(`Tool "${call.name}" not found.`);
           }
+          const turn = this.toolUsageCount.get(call.name) ?? 0;
+          this.toolUsageCount.set(call.name, turn + 1);
           const args = call.args;
           const stepId = this.toolCallStepIds?.get(call.id!);
           const output = await tool.invoke(
-            { ...call, args, type: 'tool_call', stepId },
-            config,
+            { ...call, args, type: 'tool_call', stepId, turn },
+            config
           );
           if (
             (isBaseMessage(output) && output._getType() === 'tool') ||
@@ -86,12 +106,15 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
           if (isGraphInterrupt(e)) {
             throw e;
           }
-          this.errorHandler?.({
-            error: e,
-            id: call.id!,
-            name: call.name,
-            input: call.args,
-          }, config.metadata);
+          this.errorHandler?.(
+            {
+              error: e,
+              id: call.id!,
+              name: call.name,
+              input: call.args,
+            },
+            config.metadata
+          );
           return new ToolMessage({
             content: `Error: ${e.message}\n Please fix your mistakes.`,
             name: call.name,
@@ -130,4 +153,4 @@ export function toolsCondition(
   } else {
     return END;
   }
-}
+}

package/src/tools/handlers.ts

@@ -0,0 +1,167 @@
+/* eslint-disable no-console */
+// src/tools/handlers.ts
+import { nanoid } from 'nanoid';
+import type { ToolCall, ToolCallChunk } from '@langchain/core/messages/tool';
+import type { Graph } from '@/graphs';
+import type * as t from '@/types';
+import { StepTypes, ContentTypes, ToolCallTypes } from '@/common';
+import { getMessageId } from '@/messages';
+
+export function handleToolCallChunks({
+  graph,
+  stepKey,
+  toolCallChunks,
+}: {
+  graph: Graph;
+  stepKey: string;
+  toolCallChunks: ToolCallChunk[];
+}): void {
+  let prevStepId: string;
+  let prevRunStep: t.RunStep | undefined;
+  try {
+    prevStepId = graph.getStepIdByKey(stepKey, graph.contentData.length - 1);
+    prevRunStep = graph.getRunStep(prevStepId);
+  } catch {
+    /** Edge Case: If no previous step exists, create a new message creation step */
+    const message_id = getMessageId(stepKey, graph, true) ?? '';
+    prevStepId = graph.dispatchRunStep(stepKey, {
+      type: StepTypes.MESSAGE_CREATION,
+      message_creation: {
+        message_id,
+      },
+    });
+    prevRunStep = graph.getRunStep(prevStepId);
+  }
+
+  const _stepId = graph.getStepIdByKey(stepKey, prevRunStep?.index);
+
+  /** Edge Case: Tool Call Run Step or `tool_call_ids` never dispatched */
+  const tool_calls: ToolCall[] | undefined =
+    prevStepId && prevRunStep && prevRunStep.type === StepTypes.MESSAGE_CREATION
+      ? []
+      : undefined;
+
+  /** Edge Case: `id` and `name` fields cannot be empty strings */
+  for (const toolCallChunk of toolCallChunks) {
+    if (toolCallChunk.name === '') {
+      toolCallChunk.name = undefined;
+    }
+    if (toolCallChunk.id === '') {
+      toolCallChunk.id = undefined;
+    } else if (
+      tool_calls != null &&
+      toolCallChunk.id != null &&
+      toolCallChunk.name != null
+    ) {
+      tool_calls.push({
+        args: {},
+        id: toolCallChunk.id,
+        name: toolCallChunk.name,
+        type: ToolCallTypes.TOOL_CALL,
+      });
+    }
+  }
+
+  let stepId: string = _stepId;
+  const alreadyDispatched =
+    prevRunStep?.type === StepTypes.MESSAGE_CREATION &&
+    graph.messageStepHasToolCalls.has(prevStepId);
+  if (!alreadyDispatched && tool_calls?.length === toolCallChunks.length) {
+    graph.dispatchMessageDelta(prevStepId, {
+      content: [
+        {
+          type: ContentTypes.TEXT,
+          text: '',
+          tool_call_ids: tool_calls.map((tc) => tc.id ?? ''),
+        },
+      ],
+    });
+    graph.messageStepHasToolCalls.set(prevStepId, true);
+    stepId = graph.dispatchRunStep(stepKey, {
+      type: StepTypes.TOOL_CALLS,
+      tool_calls,
+    });
+  }
+  graph.dispatchRunStepDelta(stepId, {
+    type: StepTypes.TOOL_CALLS,
+    tool_calls: toolCallChunks,
+  });
+}
+
+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 stepKey = graph.getStepKey(metadata);
+
+  for (const tool_call of toolCalls) {
+    const toolCallId = tool_call.id ?? `toolu_${nanoid()}`;
+    tool_call.id = toolCallId;
+    if (!toolCallId || graph.toolCallStepIds.has(toolCallId)) {
+      continue;
+    }
+
+    let prevStepId = '';
+    let prevRunStep: t.RunStep | undefined;
+    try {
+      prevStepId = graph.getStepIdByKey(stepKey, graph.contentData.length - 1);
+      prevRunStep = graph.getRunStep(prevStepId);
+    } catch {
+      // no previous step
+    }
+
+    const dispatchToolCallIds = (lastMessageStepId: string): void => {
+      graph.dispatchMessageDelta(lastMessageStepId, {
+        content: [
+          {
+            type: 'text',
+            text: '',
+            tool_call_ids: [toolCallId],
+          },
+        ],
+      });
+    };
+    /* If the previous step exists and is a message creation */
+    if (
+      prevStepId &&
+      prevRunStep &&
+      prevRunStep.type === StepTypes.MESSAGE_CREATION
+    ) {
+      dispatchToolCallIds(prevStepId);
+      graph.messageStepHasToolCalls.set(prevStepId, true);
+      /* 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.messageStepHasToolCalls.set(prevStepId, true);
+    }
+
+    graph.dispatchRunStep(stepKey, {
+      type: StepTypes.TOOL_CALLS,
+      tool_calls: [tool_call],
+    });
+  }
+};