@librechat/agents 2.4.318 → 2.4.320

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@librechat/agents",
-  "version": "2.4.318",
+  "version": "2.4.320",
   "main": "./dist/cjs/main.cjs",
   "module": "./dist/esm/main.mjs",
   "types": "./dist/types/index.d.ts",

package/src/events.ts

@@ -1,9 +1,12 @@
 /* eslint-disable no-console */
 // src/events.ts
-import type { UsageMetadata, BaseMessageFields } from '@langchain/core/messages';
+import type {
+  UsageMetadata,
+  BaseMessageFields,
+} from '@langchain/core/messages';
 import type { Graph } from '@/graphs';
 import type * as t from '@/types';
-import { handleToolCalls } from '@/stream';
+import { handleToolCalls } from '@/tools/handlers';
 import { Providers } from '@/common';
 
 export class HandlerRegistry {
@@ -27,7 +30,12 @@ export class ModelEndHandler implements t.EventHandler {
     this.collectedUsage = collectedUsage;
   }
 
-  handle(event: string, data: t.ModelEndData, metadata?: Record<string, unknown>, graph?: Graph): void {
+  handle(
+    event: string,
+    data: t.ModelEndData,
+    metadata?: Record<string, unknown>,
+    graph?: Graph
+  ): void {
     if (!graph || !metadata) {
       console.warn(`Graph or metadata not found in ${event} event`);
       return;
@@ -43,9 +51,12 @@ export class ModelEndHandler implements t.EventHandler {
     }
 
     console.log(`====== ${event.toUpperCase()} ======`);
-    console.dir({
-      usage,
-    }, { depth: null });
+    console.dir(
+      {
+        usage,
+      },
+      { depth: null }
+    );
 
     if (metadata.provider !== Providers.GOOGLE) {
       return;
@@ -60,7 +71,12 @@ export class ToolEndHandler implements t.EventHandler {
   constructor(callback?: t.ToolEndCallback) {
     this.callback = callback;
   }
-  handle(event: string, data: t.StreamEventData | undefined, metadata?: Record<string, unknown>, graph?: Graph): void {
+  handle(
+    event: string,
+    data: t.StreamEventData | undefined,
+    metadata?: Record<string, unknown>,
+    graph?: Graph
+  ): void {
     if (!graph || !metadata) {
       console.warn(`Graph or metadata not found in ${event} event`);
       return;
@@ -74,14 +90,17 @@ export class ToolEndHandler implements t.EventHandler {
 
     this.callback?.(toolEndData, metadata);
 
-    graph.handleToolCallCompleted({ input: toolEndData.input, output: toolEndData.output }, metadata);
+    graph.handleToolCallCompleted(
+      { input: toolEndData.input, output: toolEndData.output },
+      metadata
+    );
   }
 }
 
 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 isMessageChunk = !!(chunk && 'message' in chunk);
     const msg = isMessageChunk ? chunk.message : undefined;
     if (msg && msg.tool_call_chunks && msg.tool_call_chunks.length > 0) {
       console.log(msg.tool_call_chunks);
@@ -116,11 +135,17 @@ export class TestChatStreamHandler implements t.EventHandler {
 }
 
 export class LLMStreamHandler implements t.EventHandler {
-  handle(event: string, data: t.StreamEventData | undefined, metadata?: Record<string, unknown>): void {
+  handle(
+    event: string,
+    data: t.StreamEventData | undefined,
+    metadata?: Record<string, unknown>
+  ): void {
     const chunk = data?.chunk;
-    const  isMessageChunk = !!(chunk && 'message' in chunk);
+    const isMessageChunk = !!(chunk && 'message' in chunk);
     const msg = isMessageChunk && chunk.message;
-    if (metadata) { console.log(metadata); }
+    if (metadata) {
+      console.log(metadata);
+    }
     if (msg && msg.tool_call_chunks && msg.tool_call_chunks.length > 0) {
       console.log(msg.tool_call_chunks);
     } else if (msg && msg.content) {
@@ -133,12 +158,21 @@ export class LLMStreamHandler implements t.EventHandler {
   }
 }
 
-export const createMetadataAggregator = (_collected?: Record<string, NonNullable<BaseMessageFields['response_metadata']>>[]): t.MetadataAggregatorResult => {
+export const createMetadataAggregator = (
+  _collected?: Record<
+    string,
+    NonNullable<BaseMessageFields['response_metadata']>
+  >[]
+): t.MetadataAggregatorResult => {
   const collected = _collected || [];
 
   const handleLLMEnd: t.HandleLLMEnd = (output) => {
     const { generations } = output;
-    const lastMessageOutput = (generations[generations.length - 1] as (t.StreamGeneration | undefined)[] | undefined)?.[0];
+    const lastMessageOutput = (
+      generations[generations.length - 1] as
+        | (t.StreamGeneration | undefined)[]
+        | undefined
+    )?.[0];
     if (!lastMessageOutput) {
       return;
     }
@@ -149,4 +183,4 @@ export const createMetadataAggregator = (_collected?: Record<string, NonNullable
   };
 
   return { handleLLMEnd, collected };
-};
+};

package/src/index.ts

@@ -10,6 +10,7 @@ export * from './graphs';
 
 /* Tools */
 export * from './tools/CodeExecutor';
+export * from './tools/handlers';
 export * from './tools/search';
 
 /* Misc. */

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/search.ts

@@ -65,7 +65,7 @@ const chunker = {
   },
 };
 
-const createSourceUpdateCallback = (sourceMap: Map<string, t.ValidSource>) => {
+function createSourceUpdateCallback(sourceMap: Map<string, t.ValidSource>) {
   return (link: string, update?: Partial<t.ValidSource>): void => {
     const source = sourceMap.get(link);
     if (source) {
@@ -75,7 +75,7 @@ const createSourceUpdateCallback = (sourceMap: Map<string, t.ValidSource>) => {
       });
     }
   };
-};
+}
 
 const getHighlights = async ({
   query,
@@ -315,10 +315,7 @@ export const createSourceProcessor = (
   scraperInstance?: FirecrawlScraper
 ): {
   processSources: (
-    result: t.SearchResult,
-    numElements: number,
-    query: string,
-    proMode?: boolean
+    fields: t.ProcessSourcesFields
   ) => Promise<t.SearchResultData>;
   topResults: number;
 } => {
@@ -338,14 +335,17 @@ export const createSourceProcessor = (
     scrapeMany: async ({
       query,
       links,
+      onGetHighlights,
     }: {
       query: string;
       links: string[];
+      onGetHighlights: t.SearchToolConfig['onGetHighlights'];
     }): Promise<Array<t.ScrapeResult>> => {
       console.log(`Scraping ${links.length} links with Firecrawl`);
       const promises: Array<Promise<t.ScrapeResult>> = [];
       try {
-        for (const currentLink of links) {
+        for (let i = 0; i < links.length; i++) {
+          const currentLink = links[i];
           const promise: Promise<t.ScrapeResult> = firecrawlScraper
             .scrapeUrl(currentLink, {})
             .then(([url, response]) => {
@@ -383,6 +383,9 @@ export const createSourceProcessor = (
                   reranker,
                   content: result.content,
                 });
+                if (onGetHighlights) {
+                  onGetHighlights(result.url);
+                }
                 return {
                   ...result,
                   highlights,
@@ -416,16 +419,22 @@ export const createSourceProcessor = (
     links,
     query,
     target,
+    onGetHighlights,
     onContentScraped,
   }: {
     links: string[];
     query: string;
     target: number;
+    onGetHighlights: t.SearchToolConfig['onGetHighlights'];
     onContentScraped?: (link: string, update?: Partial<t.ValidSource>) => void;
   }): Promise<void> => {
     const initialLinks = links.slice(0, target);
     // const remainingLinks = links.slice(target).reverse();
-    const results = await webScraper.scrapeMany({ query, links: initialLinks });
+    const results = await webScraper.scrapeMany({
+      query,
+      links: initialLinks,
+      onGetHighlights,
+    });
     for (const result of results) {
       if (result.error === true) {
         continue;
@@ -440,12 +449,13 @@ export const createSourceProcessor = (
     }
   };
 
-  const processSources = async (
-    result: t.SearchResult,
-    numElements: number,
-    query: string,
-    proMode: boolean = false
-  ): Promise<t.SearchResultData> => {
+  const processSources = async ({
+    result,
+    numElements,
+    query,
+    proMode = true,
+    onGetHighlights,
+  }: t.ProcessSourcesFields): Promise<t.SearchResultData> => {
     try {
       if (!result.data) {
         return {
@@ -473,6 +483,7 @@ export const createSourceProcessor = (
         await fetchContents({
           query,
           target: 1,
+          onGetHighlights,
           onContentScraped,
           links: [wikiSources[0].link],
         });
@@ -507,8 +518,9 @@ export const createSourceProcessor = (
 
       const onContentScraped = createSourceUpdateCallback(sourceMap);
       await fetchContents({
-        links: allLinks,
         query,
+        links: allLinks,
+        onGetHighlights,
         onContentScraped,
         target: numElements,
       });