@librechat/agents 3.0.1 → 3.0.3

package/src/scripts/test-tools-before-handoff.ts

@@ -1,7 +1,6 @@
 import { config } from 'dotenv';
 config();
 
-import { TavilySearch } from '@langchain/tavily';
 import { HumanMessage, BaseMessage } from '@langchain/core/messages';
 import { Run } from '@/run';
 import { Providers, GraphEvents } from '@/common';
@@ -78,10 +77,7 @@ async function testToolsBeforeHandoff() {
         console.log(`\n🔧 Tool started:`);
         console.dir({ toolData, metadata }, { depth: null });
 
-        if (toolData?.output?.name === 'tavily_search_results_json') {
-          toolCallCount++;
-          console.log(`📊 Search #${toolCallCount} initiated`);
-        } else if (toolData?.output?.name?.includes('transfer_to_')) {
+        if (toolData?.output?.name?.includes('transfer_to_')) {
           handoffOccurred = true;
           const specialist = toolData.name.replace('transfer_to_', '');
           console.log(`\n🔀 Handoff initiated to: ${specialist}`);
@@ -100,21 +96,17 @@ async function testToolsBeforeHandoff() {
           modelName: 'gpt-4.1-mini',
           apiKey: process.env.OPENAI_API_KEY,
         },
-        tools: [new TavilySearch({ maxResults: 3 })],
-        instructions: `You are a Research Coordinator with access to web search and a report writer specialist.
+        tools: [],
+        instructions: `You are a Research Coordinator with access to a report writer specialist.
         
         Your workflow MUST follow these steps IN ORDER:
-        1. FIRST: Write an initial response acknowledging the request and outlining your research plan
-           - Explain what aspects you'll investigate
-           - Describe your search strategy
-        2. SECOND: Conduct exactly 2 web searches to gather comprehensive information
-           - Search 1: Get general information about the topic
-           - Search 2: Get specific details, recent updates, or complementary data
-           - Note: Even if your searches are unsuccessful, you MUST still proceed to handoff after EXACTLY 2 searches
-        3. FINALLY: After completing both searches, transfer to the report writer
-           - Provide the report writer with a summary of your findings
+        1. FIRST: Write an initial response acknowledging the request
+           - Explain what you understand about the topic
+           - Provide any general knowledge you have
+        2. FINALLY: Transfer to the report writer
+           - Provide the report writer with a summary of the information
         
-        CRITICAL: You MUST write your initial response before ANY tool use. Then complete both searches before handoff.`,
+        CRITICAL: You MUST write your initial response before transferring to the report writer.`,
         maxContextTokens: 8000,
       },
       {
@@ -159,10 +151,10 @@ async function testToolsBeforeHandoff() {
   }
 
   try {
-    // Single test query that requires research before report writing
-    const query = `Research the latest developments in quantum computing from 2025, 
+    // Single test query that requires handoff to report writer
+    const query = `Tell me about quantum computing developments, 
     including major breakthroughs and commercial applications. 
-    I need a comprehensive report with recent findings.`;
+    I need a comprehensive report.`;
 
     console.log('='.repeat(60));
     console.log(`USER QUERY: "${query}"`);
@@ -173,10 +165,9 @@ async function testToolsBeforeHandoff() {
     const run = await Run.create(runConfig);
 
     console.log('\nExpected behavior:');
-    console.log('1. Research Coordinator writes initial response/plan');
-    console.log('2. Research Coordinator performs 2 web searches');
-    console.log('3. Research Coordinator hands off to Report Writer');
-    console.log('4. Report Writer creates final report\n');
+    console.log('1. Research Coordinator writes initial response');
+    console.log('2. Research Coordinator hands off to Report Writer');
+    console.log('3. Report Writer creates final report\n');
 
     // Process with streaming
     conversationHistory.push(new HumanMessage(query));
@@ -204,11 +195,9 @@ async function testToolsBeforeHandoff() {
     console.log('EDGE CASE TEST RESULTS:');
     console.log('─'.repeat(60));
     console.log(`Tool calls before handoff: ${toolCallCount}`);
-    console.log(`Expected tool calls: 2`);
+    console.log(`Expected tool calls: 0 (no web search available)`);
     console.log(`Handoff occurred: ${handoffOccurred ? 'Yes ✅' : 'No ❌'}`);
-    console.log(
-      `Test status: ${toolCallCount === 2 && handoffOccurred ? 'PASSED ✅' : 'FAILED ❌'}`
-    );
+    console.log(`Test status: ${handoffOccurred ? 'PASSED ✅' : 'FAILED ❌'}`);
     console.log('─'.repeat(60));
 
     // Display conversation history

package/src/scripts/tools.ts

@@ -3,7 +3,6 @@
 import { config } from 'dotenv';
 config();
 import { HumanMessage, BaseMessage } from '@langchain/core/messages';
-import { TavilySearchResults } from '@langchain/community/tools/tavily_search';
 import type * as t from '@/types';
 import { ChatModelStreamHandler, createContentAggregator } from '@/stream';
 import { ToolEndHandler, ModelEndHandler } from '@/events';
@@ -95,11 +94,13 @@ async function testStandardStreaming(): Promise<void> {
     graphConfig: {
       type: 'standard',
       llmConfig,
-      tools: [new TavilySearchResults()],
+      tools: [],
       instructions:
         'You are a friendly AI assistant. Always address the user by their name.',
       additional_instructions: `The user's name is ${userName} and they are located in ${location}.`,
+      maxContextTokens: 89000,
     },
+    indexTokenCountMap: { 0: 35 },
     returnContent: true,
     customHandlers,
   });
@@ -126,10 +127,7 @@ async function testStandardStreaming(): Promise<void> {
   const inputs = {
     messages: conversationHistory,
   };
-  const finalContentParts = await run.processStream(inputs, config, {
-    indexTokenCountMap: { 0: 35 },
-    maxContextTokens: 89000,
-  });
+  const finalContentParts = await run.processStream(inputs, config);
   const finalMessages = run.getRunMessages();
   if (finalMessages) {
     conversationHistory.push(...finalMessages);

package/src/specs/anthropic.simple.test.ts

@@ -3,7 +3,7 @@
 // src/scripts/cli.test.ts
 import { config } from 'dotenv';
 config();
-import { Calculator } from '@langchain/community/tools/calculator';
+import { Calculator } from '@/tools/Calculator';
 import {
   HumanMessage,
   BaseMessage,

package/src/specs/azure.simple.test.ts

@@ -3,7 +3,7 @@
 // src/scripts/cli.test.ts
 import { config } from 'dotenv';
 config();
-import { Calculator } from '@langchain/community/tools/calculator';
+import { Calculator } from '@/tools/Calculator';
 import {
   HumanMessage,
   BaseMessage,

package/src/specs/openai.simple.test.ts

@@ -3,7 +3,7 @@
 // src/scripts/cli.test.ts
 import { config } from 'dotenv';
 config();
-import { Calculator } from '@langchain/community/tools/calculator';
+import { Calculator } from '@/tools/Calculator';
 import {
   HumanMessage,
   BaseMessage,

package/src/specs/openrouter.simple.test.ts

@@ -1,6 +1,6 @@
 import { config } from 'dotenv';
 config();
-import { Calculator } from '@langchain/community/tools/calculator';
+import { Calculator } from '@/tools/Calculator';
 import {
   HumanMessage,
   BaseMessage,

package/src/tools/Calculator.test.ts

@@ -0,0 +1,278 @@
+import { Calculator } from './Calculator';
+
+describe('Calculator', () => {
+  let calculator: Calculator;
+
+  beforeEach(() => {
+    calculator = new Calculator();
+  });
+
+  describe('basic properties', () => {
+    it('should have correct name', () => {
+      expect(calculator.name).toBe('calculator');
+    });
+
+    it('should have correct description', () => {
+      expect(calculator.description).toBe(
+        'Useful for getting the result of a math expression. The input to this tool should be a valid mathematical expression that could be executed by a simple calculator.'
+      );
+    });
+
+    it('should have correct lc_name', () => {
+      expect(Calculator.lc_name()).toBe('Calculator');
+    });
+
+    it('should have correct lc_namespace', () => {
+      const namespace = calculator.lc_namespace;
+      expect(namespace).toContain('calculator');
+    });
+  });
+
+  describe('basic arithmetic operations', () => {
+    it('should add two numbers', async () => {
+      const result = await calculator._call('2 + 3');
+      expect(result).toBe('5');
+    });
+
+    it('should subtract two numbers', async () => {
+      const result = await calculator._call('10 - 4');
+      expect(result).toBe('6');
+    });
+
+    it('should multiply two numbers', async () => {
+      const result = await calculator._call('6 * 7');
+      expect(result).toBe('42');
+    });
+
+    it('should divide two numbers', async () => {
+      const result = await calculator._call('15 / 3');
+      expect(result).toBe('5');
+    });
+
+    it('should handle modulo operation', async () => {
+      const result = await calculator._call('17 % 5');
+      expect(result).toBe('2');
+    });
+
+    it('should handle exponentiation', async () => {
+      const result = await calculator._call('2 ^ 3');
+      expect(result).toBe('8');
+    });
+  });
+
+  describe('complex expressions', () => {
+    it('should handle order of operations', async () => {
+      const result = await calculator._call('2 + 3 * 4');
+      expect(result).toBe('14');
+    });
+
+    it('should handle parentheses', async () => {
+      const result = await calculator._call('(2 + 3) * 4');
+      expect(result).toBe('20');
+    });
+
+    it('should handle nested parentheses', async () => {
+      const result = await calculator._call('((2 + 3) * 4) / 5');
+      expect(result).toBe('4');
+    });
+
+    it('should handle multiple operations', async () => {
+      const result = await calculator._call('(10 + 5) * 2 - 8 / 4');
+      expect(result).toBe('28');
+    });
+  });
+
+  describe('decimal numbers', () => {
+    it('should handle decimal addition', async () => {
+      const result = await calculator._call('2.5 + 3.7');
+      expect(result).toBe('6.2');
+    });
+
+    it('should handle decimal multiplication', async () => {
+      const result = await calculator._call('2.5 * 4');
+      expect(result).toBe('10');
+    });
+
+    it('should handle decimal division', async () => {
+      const result = await calculator._call('7.5 / 2.5');
+      expect(result).toBe('3');
+    });
+  });
+
+  describe('negative numbers', () => {
+    it('should handle negative numbers in addition', async () => {
+      const result = await calculator._call('-5 + 3');
+      expect(result).toBe('-2');
+    });
+
+    it('should handle negative numbers in subtraction', async () => {
+      const result = await calculator._call('10 - (-5)');
+      expect(result).toBe('15');
+    });
+
+    it('should handle negative numbers in multiplication', async () => {
+      const result = await calculator._call('-4 * -3');
+      expect(result).toBe('12');
+    });
+
+    it('should handle negative numbers in division', async () => {
+      const result = await calculator._call('-12 / 4');
+      expect(result).toBe('-3');
+    });
+  });
+
+  describe('mathematical functions', () => {
+    it('should handle square root', async () => {
+      const result = await calculator._call('sqrt(16)');
+      expect(result).toBe('4');
+    });
+
+    it('should handle absolute value', async () => {
+      const result = await calculator._call('abs(-42)');
+      expect(result).toBe('42');
+    });
+
+    it('should handle sine function', async () => {
+      const result = await calculator._call('sin(0)');
+      expect(result).toBe('0');
+    });
+
+    it('should handle cosine function', async () => {
+      const result = await calculator._call('cos(0)');
+      expect(result).toBe('1');
+    });
+
+    it('should handle logarithm', async () => {
+      const result = await calculator._call('log(10)');
+      expect(parseFloat(result)).toBeCloseTo(2.302585, 5);
+    });
+
+    it('should handle exponential', async () => {
+      const result = await calculator._call('exp(0)');
+      expect(result).toBe('1');
+    });
+
+    it('should handle floor function', async () => {
+      const result = await calculator._call('floor(4.7)');
+      expect(result).toBe('4');
+    });
+
+    it('should handle ceil function', async () => {
+      const result = await calculator._call('ceil(4.3)');
+      expect(result).toBe('5');
+    });
+
+    it('should handle round function', async () => {
+      const result = await calculator._call('round(4.5)');
+      expect(result).toBe('5');
+    });
+  });
+
+  describe('constants', () => {
+    it('should handle pi constant', async () => {
+      const result = await calculator._call('pi');
+      expect(parseFloat(result)).toBeCloseTo(3.14159, 5);
+    });
+
+    it('should handle e constant', async () => {
+      const result = await calculator._call('e');
+      expect(parseFloat(result)).toBeCloseTo(2.71828, 5);
+    });
+
+    it('should use pi in calculations', async () => {
+      const result = await calculator._call('2 * pi');
+      expect(parseFloat(result)).toBeCloseTo(6.28318, 4);
+    });
+  });
+
+  describe('error handling', () => {
+    it('should return error message for invalid expression', async () => {
+      const result = await calculator._call('invalid expression');
+      expect(result).toBe('I don\'t know how to do that.');
+    });
+
+    it('should handle division by zero', async () => {
+      const result = await calculator._call('5 / 0');
+      expect(result).toBe('Infinity');
+    });
+
+    it('should return error message for incomplete expression', async () => {
+      const result = await calculator._call('5 +');
+      expect(result).toBe('I don\'t know how to do that.');
+    });
+
+    it('should return error message for mismatched parentheses', async () => {
+      const result = await calculator._call('(5 + 3');
+      expect(result).toBe('I don\'t know how to do that.');
+    });
+
+    it('should return error message for empty input', async () => {
+      const result = await calculator._call('');
+      expect(result).toBe('I don\'t know how to do that.');
+    });
+
+    it('should return error message for only whitespace', async () => {
+      const result = await calculator._call('   ');
+      expect(result).toBe('I don\'t know how to do that.');
+    });
+
+    it('should return error message for undefined variable', async () => {
+      const result = await calculator._call('x + 5');
+      expect(result).toBe('I don\'t know how to do that.');
+    });
+  });
+
+  describe('edge cases', () => {
+    it('should handle very large numbers', async () => {
+      const result = await calculator._call('999999999 * 999999999');
+      expect(parseFloat(result)).toBeCloseTo(999999998000000000, -10);
+    });
+
+    it('should handle very small decimal numbers', async () => {
+      const result = await calculator._call('0.0001 + 0.0002');
+      expect(parseFloat(result)).toBeCloseTo(0.0003, 10);
+    });
+
+    it('should handle expressions with spaces', async () => {
+      const result = await calculator._call('  5   +   3  ');
+      expect(result).toBe('8');
+    });
+
+    it('should handle zero in calculations', async () => {
+      const result = await calculator._call('0 + 0');
+      expect(result).toBe('0');
+    });
+
+    it('should handle power of zero', async () => {
+      const result = await calculator._call('5 ^ 0');
+      expect(result).toBe('1');
+    });
+
+    it('should handle zero to the power', async () => {
+      const result = await calculator._call('0 ^ 5');
+      expect(result).toBe('0');
+    });
+  });
+
+  describe('complex real-world calculations', () => {
+    it('should calculate area of circle', async () => {
+      const result = await calculator._call('pi * 5^2');
+      expect(parseFloat(result)).toBeCloseTo(78.53981, 4);
+    });
+
+    it('should calculate compound interest formula component', async () => {
+      const result = await calculator._call('(1 + 0.05/12)^(12*5)');
+      expect(parseFloat(result)).toBeCloseTo(1.28336, 4);
+    });
+
+    it('should calculate percentage', async () => {
+      const result = await calculator._call('(25 / 200) * 100');
+      expect(result).toBe('12.5');
+    });
+
+    it('should calculate average', async () => {
+      const result = await calculator._call('(10 + 20 + 30 + 40 + 50) / 5');
+      expect(result).toBe('30');
+    });
+  });
+});

package/src/tools/Calculator.ts

@@ -0,0 +1,25 @@
+import { Tool } from '@langchain/core/tools';
+import * as math from 'mathjs';
+
+export class Calculator extends Tool {
+  static lc_name(): string {
+    return 'Calculator';
+  }
+
+  get lc_namespace(): string[] {
+    return [...super.lc_namespace, 'calculator'];
+  }
+
+  name = 'calculator';
+
+  async _call(input: string): Promise<string> {
+    try {
+      return math.evaluate(input).toString();
+    } catch {
+      return 'I don\'t know how to do that.';
+    }
+  }
+
+  description =
+    'Useful for getting the result of a math expression. The input to this tool should be a valid mathematical expression that could be executed by a simple calculator.';
+}

package/src/types/llm.ts

@@ -2,7 +2,6 @@
 import { ChatOllama } from '@langchain/ollama';
 import { ChatMistralAI } from '@langchain/mistralai';
 import { ChatBedrockConverse } from '@langchain/aws';
-import { BedrockChat } from '@langchain/community/chat_models/bedrock/web';
 import type {
   BindToolsInput,
   BaseChatModelParams,
@@ -13,7 +12,6 @@ import type {
   AzureOpenAIInput,
   ClientOptions as OAIClientOptions,
 } from '@langchain/openai';
-import type { BedrockChatFields } from '@langchain/community/chat_models/bedrock/web';
 import type { GoogleGenerativeAIChatInput } from '@langchain/google-genai';
 import type { GeminiGenerationConfig } from '@langchain/google-common';
 import type { ChatVertexAIInput } from '@langchain/google-vertexai';
@@ -65,7 +63,6 @@ export type MistralAIClientOptions = ChatMistralAIInput;
 export type VertexAIClientOptions = ChatVertexAIInput & {
   includeThoughts?: boolean;
 };
-export type BedrockClientOptions = BedrockChatFields;
 export type BedrockAnthropicInput = ChatBedrockConverseInput & {
   additionalModelRequestFields?: ChatBedrockConverseInput['additionalModelRequestFields'] &
     AnthropicReasoning;
@@ -85,7 +82,6 @@ export type ClientOptions =
   | AnthropicClientOptions
   | MistralAIClientOptions
   | VertexAIClientOptions
-  | BedrockClientOptions
   | BedrockConverseClientOptions
   | GoogleClientOptions
   | DeepSeekClientOptions
@@ -113,7 +109,6 @@ export type ProviderOptionsMap = {
   [Providers.MISTRALAI]: MistralAIClientOptions;
   [Providers.MISTRAL]: MistralAIClientOptions;
   [Providers.OPENROUTER]: ChatOpenRouterCallOptions;
-  [Providers.BEDROCK_LEGACY]: BedrockClientOptions;
   [Providers.BEDROCK]: BedrockConverseClientOptions;
   [Providers.XAI]: XAIClientOptions;
 };
@@ -129,7 +124,6 @@ export type ChatModelMap = {
   [Providers.MISTRALAI]: ChatMistralAI;
   [Providers.MISTRAL]: ChatMistralAI;
   [Providers.OPENROUTER]: ChatOpenRouter;
-  [Providers.BEDROCK_LEGACY]: BedrockChat;
   [Providers.BEDROCK]: ChatBedrockConverse;
   [Providers.GOOGLE]: CustomChatGoogleGenerativeAI;
 };

package/dist/types/tools/example.d.ts

@@ -1,78 +0,0 @@
-import { TavilySearchResults } from '@langchain/community/tools/tavily_search';
-import { DynamicStructuredTool } from '@langchain/core/tools';
-import { z } from 'zod';
-export declare const fetchRandomImageTool: DynamicStructuredTool<z.ZodObject<{
-    input: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    input?: string | undefined;
-}, {
-    input?: string | undefined;
-}>, {
-    input?: string | undefined;
-}, {
-    input?: string | undefined;
-}, (string | undefined)[] | ({
-    type: string;
-    text: string;
-}[] | {
-    content: {
-        type: string;
-        image_url: {
-            url: string;
-        };
-    }[];
-})[]>;
-export declare const fetchRandomImageURL: DynamicStructuredTool<z.ZodObject<{
-    input: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    input?: string | undefined;
-}, {
-    input?: string | undefined;
-}>, {
-    input?: string | undefined;
-}, {
-    input?: string | undefined;
-}, (string | undefined)[] | ({
-    type: string;
-    text: string;
-}[] | {
-    content: {
-        type: string;
-        image_url: {
-            url: string;
-        };
-    }[];
-})[]>;
-export declare const chartTool: DynamicStructuredTool<z.ZodObject<{
-    data: z.ZodArray<z.ZodObject<{
-        label: z.ZodString;
-        value: z.ZodNumber;
-    }, "strip", z.ZodTypeAny, {
-        value: number;
-        label: string;
-    }, {
-        value: number;
-        label: string;
-    }>, "many">;
-}, "strip", z.ZodTypeAny, {
-    data: {
-        value: number;
-        label: string;
-    }[];
-}, {
-    data: {
-        value: number;
-        label: string;
-    }[];
-}>, {
-    data: {
-        value: number;
-        label: string;
-    }[];
-}, {
-    data: {
-        value: number;
-        label: string;
-    }[];
-}, string>;
-export declare const tavilyTool: TavilySearchResults;