illuma-agents 1.0.2 → 1.0.4

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.';
+}