@librechat/agents 3.4.6 → 3.5.0

package/src/test/mockTools.ts

@@ -1,386 +0,0 @@
-// src/test/mockTools.ts
-/**
- * Shared mock tools for testing across all test scripts.
- * Centralizes tool definitions to follow DRY principles.
- */
-import { tool } from '@langchain/core/tools';
-import type { StructuredToolInterface } from '@langchain/core/tools';
-import type { LCTool, LCToolRegistry } from '@/types';
-
-// ============================================================================
-// Mock Tool Implementations
-// ============================================================================
-
-/**
- * Mock get_team_members tool - returns list of team members
- */
-export function createGetTeamMembersTool(): StructuredToolInterface {
-  return tool(
-    async () => {
-      await new Promise((resolve) => setTimeout(resolve, 50));
-      return [
-        { id: 'u1', name: 'Alice', department: 'Engineering' },
-        { id: 'u2', name: 'Bob', department: 'Marketing' },
-        { id: 'u3', name: 'Charlie', department: 'Engineering' },
-      ];
-    },
-    {
-      name: 'get_team_members',
-      description:
-        'Get list of team members. Returns array of objects with id, name, and department fields.',
-      schema: { type: 'object', properties: {}, required: [] },
-    }
-  );
-}
-
-/**
- * Mock get_expenses tool - returns expense records for a user
- */
-export function createGetExpensesTool(): StructuredToolInterface {
-  const expenseData: Record<
-    string,
-    Array<{ amount: number; category: string }>
-  > = {
-    u1: [
-      { amount: 150.0, category: 'travel' },
-      { amount: 75.5, category: 'meals' },
-    ],
-    u2: [
-      { amount: 200.0, category: 'marketing' },
-      { amount: 50.0, category: 'meals' },
-      { amount: 300.0, category: 'events' },
-    ],
-    u3: [
-      { amount: 500.0, category: 'equipment' },
-      { amount: 120.0, category: 'travel' },
-      { amount: 80.0, category: 'meals' },
-    ],
-  };
-
-  return tool(
-    async (input) => {
-      const { user_id } = input as { user_id: string };
-      await new Promise((resolve) => setTimeout(resolve, 30));
-      return expenseData[user_id] ?? [];
-    },
-    {
-      name: 'get_expenses',
-      description:
-        'Get expense records for a user. Returns array of objects with amount and category fields.',
-      schema: {
-        type: 'object',
-        properties: {
-          user_id: {
-            type: 'string',
-            description: 'The user ID to fetch expenses for',
-          },
-        },
-        required: ['user_id'],
-      },
-    }
-  );
-}
-
-/**
- * Mock get_weather tool - returns weather data for a city
- */
-export function createGetWeatherTool(): StructuredToolInterface {
-  const weatherData: Record<
-    string,
-    { temperature: number; condition: string } | undefined
-  > = {
-    'San Francisco': { temperature: 65, condition: 'Foggy' },
-    'New York': { temperature: 75, condition: 'Sunny' },
-    London: { temperature: 55, condition: 'Rainy' },
-    Tokyo: { temperature: 80, condition: 'Humid' },
-    SF: { temperature: 65, condition: 'Foggy' },
-    NYC: { temperature: 75, condition: 'Sunny' },
-  };
-
-  return tool(
-    async (input) => {
-      const { city } = input as { city: string };
-      await new Promise((resolve) => setTimeout(resolve, 40));
-      const weather = weatherData[city];
-      if (!weather) {
-        throw new Error(`Weather data not available for city: ${city}`);
-      }
-      return weather;
-    },
-    {
-      name: 'get_weather',
-      description:
-        'Get current weather for a city. Returns object with temperature (number) and condition (string) fields.',
-      schema: {
-        type: 'object',
-        properties: {
-          city: { type: 'string', description: 'City name' },
-        },
-        required: ['city'],
-      },
-    }
-  );
-}
-
-/**
- * Mock calculator tool - evaluates mathematical expressions
- */
-export function createCalculatorTool(): StructuredToolInterface {
-  return tool(
-    async (input) => {
-      const { expression } = input as { expression: string };
-      await new Promise((resolve) => setTimeout(resolve, 10));
-      // Simple eval for demo (in production, use a proper math parser)
-
-      const result = eval(expression);
-      return { expression, result };
-    },
-    {
-      name: 'calculator',
-      description: 'Evaluate a mathematical expression',
-      schema: {
-        type: 'object',
-        properties: {
-          expression: {
-            type: 'string',
-            description: 'Mathematical expression to evaluate',
-          },
-        },
-        required: ['expression'],
-      },
-    }
-  );
-}
-
-// ============================================================================
-// Tool Registry Definitions
-// ============================================================================
-
-/**
- * Creates a tool registry for programmatic tool calling tests.
- * Tools are configured with allowed_callers to demonstrate classification.
- */
-export function createProgrammaticToolRegistry(): LCToolRegistry {
-  const toolDefs: LCTool[] = [
-    {
-      name: 'get_team_members',
-      description:
-        'Get list of team members. Returns array of objects with id, name, and department fields.',
-      parameters: {
-        type: 'object',
-        properties: {},
-        required: [],
-      },
-      allowed_callers: ['code_execution'], // Programmatic-only
-      defer_loading: false,
-    },
-    {
-      name: 'get_expenses',
-      description:
-        'Get expense records for a user. Returns array of objects with amount and category fields.',
-      parameters: {
-        type: 'object',
-        properties: {
-          user_id: {
-            type: 'string',
-            description: 'The user ID to fetch expenses for',
-          },
-        },
-        required: ['user_id'],
-      },
-      allowed_callers: ['code_execution'], // Programmatic-only
-      defer_loading: false,
-    },
-    {
-      name: 'get_weather',
-      description:
-        'Get current weather for a city. Returns object with temperature (number) and condition (string) fields.',
-      parameters: {
-        type: 'object',
-        properties: {
-          city: {
-            type: 'string',
-            description: 'City name',
-          },
-        },
-        required: ['city'],
-      },
-      allowed_callers: ['direct', 'code_execution'], // Both contexts
-      defer_loading: false,
-    },
-    {
-      name: 'calculator',
-      description: 'Evaluate a mathematical expression',
-      parameters: {
-        type: 'object',
-        properties: {
-          expression: {
-            type: 'string',
-            description: 'Mathematical expression to evaluate',
-          },
-        },
-        required: ['expression'],
-      },
-      allowed_callers: ['code_execution'], // Programmatic-only
-      defer_loading: false,
-    },
-  ];
-
-  return new Map(toolDefs.map((t) => [t.name, t]));
-}
-
-/**
- * Creates a sample tool registry for tool search tests.
- * Includes mix of deferred and non-deferred tools.
- */
-export function createToolSearchToolRegistry(): LCToolRegistry {
-  const tools: LCTool[] = [
-    {
-      name: 'get_expenses',
-      description:
-        'Retrieve expense records from the database. Supports filtering by date range, category, and amount.',
-      parameters: {
-        type: 'object',
-        properties: {
-          start_date: {
-            type: 'string',
-            description: 'Start date for filtering',
-          },
-          end_date: { type: 'string', description: 'End date for filtering' },
-          category: { type: 'string', description: 'Expense category' },
-        },
-      },
-      defer_loading: true,
-    },
-    {
-      name: 'calculate_expense_totals',
-      description:
-        'Calculate total expenses by category or time period. Returns aggregated financial data.',
-      parameters: {
-        type: 'object',
-        properties: {
-          group_by: {
-            type: 'string',
-            description: 'Group by category or month',
-          },
-        },
-      },
-      defer_loading: true,
-    },
-    {
-      name: 'create_budget',
-      description:
-        'Create a new budget plan with spending limits for different categories.',
-      parameters: {
-        type: 'object',
-        properties: {
-          name: { type: 'string', description: 'Budget name' },
-          limits: { type: 'object', description: 'Category spending limits' },
-        },
-      },
-      defer_loading: true,
-    },
-    {
-      name: 'get_weather',
-      description: 'Get current weather conditions for a specified location.',
-      parameters: {
-        type: 'object',
-        properties: {
-          location: { type: 'string', description: 'City or coordinates' },
-        },
-      },
-      defer_loading: true,
-    },
-    {
-      name: 'get_forecast',
-      description: 'Get weather forecast for the next 7 days for a location.',
-      parameters: {
-        type: 'object',
-        properties: {
-          location: { type: 'string', description: 'City or coordinates' },
-          days: { type: 'number', description: 'Number of days to forecast' },
-        },
-      },
-      defer_loading: true,
-    },
-    {
-      name: 'send_email',
-      description:
-        'Send an email to one or more recipients with attachments support.',
-      parameters: {
-        type: 'object',
-        properties: {
-          to: {
-            type: 'array',
-            items: { type: 'string' },
-            description: 'Recipients',
-          },
-          subject: { type: 'string', description: 'Email subject' },
-          body: { type: 'string', description: 'Email body' },
-        },
-      },
-      defer_loading: true,
-    },
-    {
-      name: 'search_files',
-      description: 'Search for files in the file system by name or content.',
-      parameters: {
-        type: 'object',
-        properties: {
-          query: { type: 'string', description: 'Search query' },
-          path: { type: 'string', description: 'Directory to search in' },
-        },
-      },
-      defer_loading: true,
-    },
-    {
-      name: 'run_database_query',
-      description:
-        'Execute a SQL query against the database and return results.',
-      parameters: {
-        type: 'object',
-        properties: {
-          query: { type: 'string', description: 'SQL query to execute' },
-          database: { type: 'string', description: 'Target database' },
-        },
-      },
-      defer_loading: true,
-    },
-    {
-      name: 'generate_report',
-      description:
-        'Generate a PDF or Excel report from data with customizable templates.',
-      parameters: {
-        type: 'object',
-        properties: {
-          template: { type: 'string', description: 'Report template name' },
-          format: { type: 'string', description: 'Output format: pdf or xlsx' },
-          data: { type: 'object', description: 'Data to include in report' },
-        },
-      },
-      defer_loading: true,
-    },
-    {
-      name: 'translate_text',
-      description:
-        'Translate text between languages using machine translation.',
-      parameters: {
-        type: 'object',
-        properties: {
-          text: { type: 'string', description: 'Text to translate' },
-          source_lang: { type: 'string', description: 'Source language code' },
-          target_lang: { type: 'string', description: 'Target language code' },
-        },
-      },
-      defer_loading: true,
-    },
-    {
-      name: 'calculator',
-      description:
-        'Perform mathematical calculations. Supports basic arithmetic and scientific functions.',
-      defer_loading: false, // Not deferred - should be excluded by default
-    },
-  ];
-
-  return new Map(tools.map((t) => [t.name, t]));
-}

package/src/tools/Calculator.test.ts

@@ -1,278 +0,0 @@
-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');
-    });
-  });
-});