@librechat/agents 2.4.318 → 2.4.319

package/src/messages/ids.ts

@@ -0,0 +1,26 @@
+// src/stream.ts
+import { nanoid } from 'nanoid';
+import type { Graph } from '@/graphs';
+import type * as t from '@/types';
+
+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;
+  }
+
+  const prelimMessageId = graph.prelimMessageIdsByStepKey.get(stepKey);
+  if (prelimMessageId != null && prelimMessageId) {
+    graph.prelimMessageIdsByStepKey.delete(stepKey);
+    graph.messageIdsByStepKey.set(stepKey, prelimMessageId);
+    return prelimMessageId;
+  }
+
+  const message_id = `msg_${nanoid()}`;
+  graph.messageIdsByStepKey.set(stepKey, message_id);
+  return message_id;
+};

package/src/messages/index.ts

@@ -1,3 +1,4 @@
 export * from './core';
+export * from './ids';
 export * from './prune';
 export * from './format';

package/src/stream.ts

@@ -1,10 +1,11 @@
 // 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';
+import { handleToolCalls, handleToolCallChunks } from '@/tools/handlers';
+import { getMessageId } from '@/messages';
 
 /**
  * Parses content to extract thinking sections enclosed in <think> tags using string operations
@@ -65,107 +66,6 @@ function getNonEmptyValue(possibleValues: string[]): string | undefined {
   }
   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;
-  }
-
-  const prelimMessageId = graph.prelimMessageIdsByStepKey.get(stepKey);
-  if (prelimMessageId != null && prelimMessageId) {
-    graph.prelimMessageIdsByStepKey.delete(stepKey);
-    graph.messageIdsByStepKey.set(stepKey, prelimMessageId);
-    return prelimMessageId;
-  }
-
-  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 (!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],
-    });
-  }
-};
-
 export class ChatModelStreamHandler implements t.EventHandler {
   handle(
     event: string,
@@ -230,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,
@@ -358,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

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],
+    });
+  }
+};

package/src/tools/search/tool.ts

@@ -170,10 +170,8 @@ export const createSearchTool = (
       });
       const turn = runnableConfig.toolCall?.turn ?? 0;
       const { output, references } = formatResultsForLLM(turn, searchResult);
-      return [
-        output,
-        { [Constants.WEB_SEARCH]: { turn, ...searchResult, references } },
-      ];
+      const data: t.SearchResultData = { turn, ...searchResult, references };
+      return [output, { [Constants.WEB_SEARCH]: data }];
     },
     {
       name: Constants.WEB_SEARCH,

package/src/tools/search/types.ts

@@ -27,6 +27,7 @@ export type ResultReference = {
   attribution?: string;
 };
 export interface SearchResultData {
+  turn?: number;
   organic?: ProcessedOrganic[];
   topStories?: ProcessedTopStory[];
   images?: ImageResult[];
@@ -98,15 +99,6 @@ export interface ScraperExtractionResult {
   no_extraction: ScraperContentResult;
 }
 
-// Define type for SearXNG result
-export interface SearXNGResult {
-  title?: string;
-  url?: string;
-  content?: string;
-  publishedDate?: string;
-  img_src?: string;
-}
-
 export interface JinaRerankerResult {
   index: number;
   relevance_score: number;
@@ -555,3 +547,11 @@ export interface SearxNGSearchPayload {
    */
   disabled_engines?: string;
 }
+
+export interface SearXNGResult {
+  title?: string;
+  url?: string;
+  content?: string;
+  publishedDate?: string;
+  img_src?: string;
+}