@librechat/agents 2.3.1 → 2.3.3

package/src/specs/tool-error.test.ts

@@ -1,5 +1,4 @@
-/* eslint-disable no-console */
-/* eslint-disable @typescript-eslint/no-explicit-any */
+
 import { z } from 'zod';
 import { config } from 'dotenv';
 config();
@@ -71,7 +70,7 @@ describe('Tool Error Handling Tests', () => {
     [GraphEvents.CHAT_MODEL_STREAM]: new ChatModelStreamHandler(),
     [GraphEvents.ON_RUN_STEP_COMPLETED]: {
       handle: (event: GraphEvents.ON_RUN_STEP_COMPLETED, data: t.StreamEventData): void => {
-        if ((data.result as t.MessageContentComplex)?.['type'] === 'tool_call') {
+        if ((data.result as t.MessageContentComplex)['type'] === 'tool_call') {
           run.Graph?.overrideTestModel(['Looks like there was an error calling the tool.'], 5);
         }
         onRunStepCompletedSpy(event, data);
@@ -118,16 +117,16 @@ describe('Tool Error Handling Tests', () => {
     });
 
     const toolCalls: ToolCall[] = [
-        {
-          name: "errorTool",
-          args: {
-            input: "test input",
-          },
-          id: "call_test123",
-          type: "tool_call",
-        }
-      ];
-    
+      {
+        name: 'errorTool',
+        args: {
+          input: 'test input',
+        },
+        id: 'call_test123',
+        type: 'tool_call',
+      }
+    ];
+
     const firstResponse = 'Let me try calling the tool';
     run.Graph?.overrideTestModel([firstResponse], 5, toolCalls);
 
@@ -142,12 +141,12 @@ describe('Tool Error Handling Tests', () => {
 
     // Verify handleToolCallError was called
     expect(handleToolCallErrorSpy).toHaveBeenCalled();
-    
+
     // Find the tool call content part
-    const toolCallPart = contentParts.find(part => 
-      part?.type === 'tool_call'
+    const toolCallPart = contentParts.find(part =>
+      part.type === 'tool_call'
     ) as t.ToolCallContent | undefined;
-    
+
     // Verify the error message in contentParts
     expect(toolCallPart).toBeDefined();
     expect(toolCallPart?.tool_call?.args).toEqual(JSON.stringify(toolCalls[0].args));

package/src/stream.ts

@@ -47,22 +47,21 @@ export const handleToolCalls = (toolCalls?: ToolCall[], metadata?: Record<string
     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 (e) {
+    } catch {
       // no previous step
     }
 
@@ -92,10 +91,10 @@ export const handleToolCalls = (toolCalls?: ToolCall[], metadata?: Record<string
       graph.messageStepHasToolCalls.set(prevStepId, true);
     }
 
-      graph.dispatchRunStep(stepKey, {
-        type: StepTypes.TOOL_CALLS,
-        tool_calls: [tool_call],
-      });
+    graph.dispatchRunStep(stepKey, {
+      type: StepTypes.TOOL_CALLS,
+      tool_calls: [tool_call],
+    });
   }
 };
 
@@ -117,7 +116,7 @@ export class ChatModelStreamHandler implements t.EventHandler {
     this.handleReasoning(chunk, graph);
 
     let hasToolCalls = false;
-    if (chunk.tool_calls && chunk.tool_calls.length > 0 && chunk.tool_calls.every((tc) => tc.id)) {
+    if (chunk.tool_calls && chunk.tool_calls.length > 0 && chunk.tool_calls.every((tc) => tc.id != null && tc.id !== '')) {
       hasToolCalls = true;
       handleToolCalls(chunk.tool_calls, metadata, graph);
     }
@@ -166,7 +165,7 @@ export class ChatModelStreamHandler implements t.EventHandler {
     const stepId = graph.getStepIdByKey(stepKey);
     const runStep = graph.getRunStep(stepId);
     if (!runStep) {
-      // eslint-disable-next-line no-console
+
       console.warn(`\n
 ==============================================================
 
@@ -206,16 +205,20 @@ hasToolCallChunks: ${hasToolCallChunks}
           }],
         });
       }
-    } else if (content.every((c) => c.type?.startsWith(ContentTypes.TEXT))) {
+    } else if (content.every((c) => c.type?.startsWith(ContentTypes.TEXT) ?? false)) {
       graph.dispatchMessageDelta(stepId, {
         content,
       });
-    } else if (content.every((c) => c.type?.startsWith(ContentTypes.THINKING) || c.type?.startsWith(ContentTypes.REASONING_CONTENT))) {
+    } else if (content.every(
+      (c) =>
+        (c.type?.startsWith(ContentTypes.THINKING) ?? false) ||
+      (c.type?.startsWith(ContentTypes.REASONING_CONTENT) ?? false)
+    )) {
       graph.dispatchReasoningDelta(stepId, {
         content: content.map((c) => ({
           type: ContentTypes.THINK,
-          think: (c as t.ThinkingContentText).thinking ?? (c as t.BedrockReasoningContentText).reasoningText?.text ?? '',
-      }))});
+          think: (c as t.ThinkingContentText).thinking ?? (c as Partial<t.BedrockReasoningContentText>).reasoningText?.text ?? '',
+        }))});
     }
   }
   handleToolCallChunks = ({
@@ -232,7 +235,7 @@ hasToolCallChunks: ${hasToolCallChunks}
     try {
       prevStepId = graph.getStepIdByKey(stepKey, graph.contentData.length - 1);
       prevRunStep = graph.getRunStep(prevStepId);
-    } catch (e) {
+    } 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, {
@@ -245,13 +248,13 @@ hasToolCallChunks: ${hasToolCallChunks}
     }
 
     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 === '') {
@@ -371,7 +374,7 @@ export function createContentAggregator(): t.ContentAggregatorResult {
     } else if (
       partType.startsWith(ContentTypes.AGENT_UPDATE) &&
       ContentTypes.AGENT_UPDATE in contentPart &&
-      contentPart.agent_update
+      contentPart.agent_update != null
     ) {
       const update: t.AgentUpdate = {
         type: ContentTypes.AGENT_UPDATE,

package/src/tools/ToolNode.ts

@@ -91,7 +91,7 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
             id: call.id!,
             name: call.name,
             input: call.args,
-          }, config?.metadata);
+          }, config.metadata);
           return new ToolMessage({
             content: `Error: ${e.message}\n Please fix your mistakes.`,
             name: call.name,

package/src/types/stream.ts

@@ -56,12 +56,13 @@ export type RunStep = {
   index: number; // #new
   stepIndex?: number; // #new
   stepDetails: StepDetails;
-  usage?: null | {
+  usage?: null | object;
+  // {
     // Define usage structure if it's ever non-null
     // prompt_tokens: number; // #new
     // completion_tokens: number; // #new
     // total_tokens: number; // #new
-  };
+  // };
 };
 
 /**
@@ -285,7 +286,7 @@ export type MessageContentComplex = (ThinkingContentText | AgentUpdate | ToolCal
 export interface TMessage {
   role?: string;
   content?: MessageContentComplex[] | string;
-  [key: string]: any;
+  [key: string]: unknown;
 }
 
 export type TPayload = Array<Partial<TMessage>>;

package/src/utils/tokens.ts

@@ -1,13 +1,13 @@
-import { Tiktoken } from "js-tiktoken/lite";
-import type { BaseMessage } from "@langchain/core/messages";
-import { ContentTypes } from "@/common/enum";
+import { Tiktoken } from 'js-tiktoken/lite';
+import type { BaseMessage } from '@langchain/core/messages';
+import { ContentTypes } from '@/common/enum';
 
 export function getTokenCountForMessage(message: BaseMessage, getTokenCount: (text: string) => number): number {
-  let tokensPerMessage = 3;
+  const tokensPerMessage = 3;
 
-  const processValue = (value: unknown) => {
+  const processValue = (value: unknown): void => {
     if (Array.isArray(value)) {
-      for (let item of value) {
+      for (const item of value) {
         if (
           !item ||
           !item.type ||
@@ -58,13 +58,13 @@ export function getTokenCountForMessage(message: BaseMessage, getTokenCount: (te
 }
 
 export const createTokenCounter = async () => {
-  const res = await fetch(`https://tiktoken.pages.dev/js/o200k_base.json`);
+  const res = await fetch('https://tiktoken.pages.dev/js/o200k_base.json');
   const o200k_base = await res.json();
 
-  const countTokens = (text: string) => {
+  const countTokens = (text: string): number => {
     const enc = new Tiktoken(o200k_base);
     return enc.encode(text).length;
-  }
-  
-  return (message: BaseMessage) => getTokenCountForMessage(message, countTokens);
-}
+  };
+
+  return (message: BaseMessage): number => getTokenCountForMessage(message, countTokens);
+};