Add more defillama endpoints (#63)

* fix: Remove is enabled check for raw data requests

- Leave enabled check only for llm agent usage
- Raw data tool will be enabled if a corresponding api key has been provided in env

* feat: Enhance DefiLlamaTool for multi-token price retrieval and historical data

- Introduced support for fetching prices of multiple tokens in a single request.
- Added a new method for retrieving historical token prices based on a specified timestamp.
- Updated schemas to validate input parameters for both current and historical price requests.
- Improved error handling to provide detailed feedback for low confidence price data.
- Expanded unit tests to cover new functionalities, including multi-token and historical price fetching.

* refactor: Update DefiLlamaTool schemas and parsing logic

- Removed historical price response schema in favor of a unified price response schema.
- Enhanced token identifier description to include native token format.
- Updated parsing logic to utilize the new schema for historical price retrieval.
- Simplified type inference in the parseResult method to focus solely on the price response schema.

* chore: Update .dockerignore and .gitignore to include .cursor

* feat: Add TimestampConverterTool for timestamp conversions

- Introduced TimestampConverterTool to convert between ISO strings and numeric timestamps (milliseconds or seconds).
- Updated ToolName enum to include TIMESTAMP_CONVERTER.
- Registered the new tool in availableTools and updated specialtyDomains to include it.
- Added comprehensive unit tests to validate conversion functionality and error handling.

* feat: Introduce CalculatorTool for arithmetic operations

- Added CalculatorTool to perform various arithmetic operations including addition, subtraction, multiplication, division, power, square root, and percentage calculations.
- Updated ToolName enum to include CALCULATOR.
- Registered the new tool in availableTools for easy access.
- Implemented comprehensive unit tests to validate functionality and error handling for all operations.

* feat: Add Utility domain for general-purpose tools

- Introduced a new domain, UTILITY, to encompass general-purpose utility tools.
- Added capabilities for mathematical calculations, time conversions, and data formatting.
- Registered tools including Calculator and TimestampConverter under the new domain, enhancing the toolset for common operations.

* fix: Update default search width parameter in DefiLlamaTool

- Changed the default value of the SearchWidthParamSchema from "4h" to "6h".
- Enhanced the description to clarify accepted candle notation and provide examples for better user understanding.

* feat: Add get_token_price_chart tool to DefiLlamaTool

- Introduced a new tool for fetching token price charts from DefiLlama, supporting multiple tokens and customizable parameters.
- Enhanced schemas to validate input for the new chart tool, including options for start and end timestamps, span, period, and search width.
- Implemented error handling for low confidence price data and API/network errors.
- Expanded unit tests to cover various scenarios for the new tool, ensuring robust functionality and error management.

* feat: Add get_token_price_percentage_change tool to DefiLlamaTool

- Introduced a new tool for fetching percentage changes in token prices over specified time periods.
- Enhanced schemas to validate input parameters, including coins, timestamp, lookForward, and period.
- Implemented error handling for API/network errors and low confidence data.
- Updated unit tests to cover various scenarios for the new percentage change tool, ensuring robust functionality and error management.

Author: nicky-ru

.dockerignore

@@ -5,3 +5,5 @@ npm-debug.log
 .env.*
 
 configs/.env.*
+
+.cursor

.gitignore

@@ -39,4 +39,6 @@ bun.lockb
 *.db
 package-lock.json
 
-/coverage/
+/coverage/
+
+.cursor

src/registry/toolClasses.ts

@@ -14,6 +14,8 @@ import { CMCBaseTool } from "../tools/cmc";
 import { DefiLlamaTool } from "../tools/defillama";
 import { AskSpecialtyTool } from "../tools/askSpecialty";
 import { ToolName } from "./toolNames";
+import { TimestampConverterTool } from "../tools/time";
+import { CalculatorTool } from "../tools/calculator";
 
 export const availableTools = [
   {
@@ -72,4 +74,12 @@ export const availableTools = [
     name: ToolName.ASK_SPECIALTY,
     toolClass: AskSpecialtyTool,
   },
+  {
+    name: ToolName.TIMESTAMP_CONVERTER,
+    toolClass: TimestampConverterTool,
+  },
+  {
+    name: ToolName.CALCULATOR,
+    toolClass: CalculatorTool,
+  },
 ];

src/registry/toolNames.ts

@@ -13,4 +13,6 @@ export enum ToolName {
   CMC = "cmc",
   DEFILLAMA = "defillama",
   ASK_SPECIALTY = "ask_specialty",
+  TIMESTAMP_CONVERTER = "timestamp_converter",
+  CALCULATOR = "calculator",
 }

src/tools/__tests__/calculator.test.ts

@@ -0,0 +1,123 @@
+import { describe, expect, it, beforeEach } from "vitest";
+import { CalculatorTool } from "../calculator";
+
+describe("CalculatorTool", () => {
+  let tool: CalculatorTool;
+
+  beforeEach(() => {
+    tool = new CalculatorTool();
+  });
+
+  describe("basic operations", () => {
+    it("should add two numbers", async () => {
+      const result = await tool.execute({
+        operation: "add",
+        operand1: 5,
+        operand2: 3,
+      });
+      expect(result).toBe("8");
+    });
+
+    it("should subtract two numbers", async () => {
+      const result = await tool.execute({
+        operation: "subtract",
+        operand1: 10,
+        operand2: 4,
+      });
+      expect(result).toBe("6");
+    });
+
+    it("should multiply two numbers", async () => {
+      const result = await tool.execute({
+        operation: "multiply",
+        operand1: 6,
+        operand2: 7,
+      });
+      expect(result).toBe("42");
+    });
+
+    it("should divide two numbers", async () => {
+      const result = await tool.execute({
+        operation: "divide",
+        operand1: 15,
+        operand2: 3,
+      });
+      expect(result).toBe("5");
+    });
+  });
+
+  describe("advanced operations", () => {
+    it("should calculate power", async () => {
+      const result = await tool.execute({
+        operation: "power",
+        operand1: 2,
+        operand2: 3,
+      });
+      expect(result).toBe("8");
+    });
+
+    it("should calculate square root", async () => {
+      const result = await tool.execute({
+        operation: "sqrt",
+        operand1: 16,
+      });
+      expect(result).toBe("4");
+    });
+
+    it("should calculate percentage", async () => {
+      const result = await tool.execute({
+        operation: "percentage",
+        operand1: 50,
+        operand2: 20,
+      });
+      expect(result).toBe("10");
+    });
+  });
+
+  describe("error handling", () => {
+    it("should handle division by zero", async () => {
+      const result = await tool.execute({
+        operation: "divide",
+        operand1: 10,
+        operand2: 0,
+      });
+      expect(result).toBe("Error executing calculator tool");
+    });
+
+    it("should handle negative square root", async () => {
+      const result = await tool.execute({
+        operation: "sqrt",
+        operand1: -16,
+      });
+      expect(result).toBe("Error executing calculator tool");
+    });
+
+    it("should handle missing second operand", async () => {
+      const result = await tool.execute({
+        operation: "add",
+        operand1: 5,
+      });
+      expect(result).toBe("Error executing calculator tool");
+    });
+  });
+
+  describe("floating point precision", () => {
+    it("should handle floating point calculations", async () => {
+      const result = await tool.execute({
+        operation: "divide",
+        operand1: 10,
+        operand2: 3,
+      });
+      expect(result).toBe("3.3333333333");
+    });
+
+    it("should handle large numbers", async () => {
+      const result = await tool.execute({
+        operation: "multiply",
+        operand1: 1e10,
+        operand2: 1e10,
+      });
+      expect(result).toBe("100000000000000000000");
+    });
+  });
+});