Fix formatting issues and removing unusued libaries

2026-05-14 07:26:46 +00:00 · 2024-12-30 22:31:15 +01:00
parent 3b4fddd65a
commit c00515f3d2
35 changed files with 574 additions and 662 deletions
--- a/src/actions/balance.ts
+++ b/src/actions/balance.ts
@@ -11,7 +11,7 @@ const balanceAction: Action = {
    "get wallet balance",
    "view balance",
    "show balance",
-    "check token balance"
+    "check token balance",
  ],
  description: `Get the balance of a Solana wallet or token account.
  If you want to get the balance of your wallet, you don't need to provide the tokenAddress.
@@ -23,37 +23,40 @@ const balanceAction: Action = {
        output: {
          status: "success",
          balance: "100",
-          token: "SOL"
+          token: "SOL",
        },
-        explanation: "Get SOL balance of the wallet"
-      }
+        explanation: "Get SOL balance of the wallet",
+      },
    ],
    [
      {
        input: {
-          tokenAddress: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
+          tokenAddress: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
        },
        output: {
          status: "success",
          balance: "1000",
-          token: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
+          token: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
        },
-        explanation: "Get USDC token balance"
-      }
-    ]
+        explanation: "Get USDC token balance",
+      },
+    ],
  ],
  schema: z.object({
-    tokenAddress: z.string().optional()
+    tokenAddress: z.string().optional(),
  }),
  handler: async (agent: SolanaAgentKit, input: Record<string, any>) => {
-    const balance = await get_balance(agent, input.tokenAddress && new PublicKey(input.tokenAddress));
+    const balance = await get_balance(
+      agent,
+      input.tokenAddress && new PublicKey(input.tokenAddress),
+    );

    return {
      status: "success",
      balance: balance,
-      token: input.tokenAddress || "SOL"
+      token: input.tokenAddress || "SOL",
    };
-  }
+  },
 };

-export default balanceAction; 
+export default balanceAction;
--- a/src/actions/createGibworkTask.ts
+++ b/src/actions/createGibworkTask.ts
@@ -1,7 +1,7 @@
 import { Action } from "../types/action";
 import { SolanaAgentKit } from "../agent";
 import { z } from "zod";
-import { PublicKey, VersionedTransaction } from "@solana/web3.js";
+import { PublicKey } from "@solana/web3.js";
 import { create_gibwork_task } from "../tools";

 const createGibworkTaskAction: Action = {
@@ -12,9 +12,10 @@ const createGibworkTaskAction: Action = {
    "create gig",
    "post task",
    "create work",
-    "new task on gibwork"
+    "new task on gibwork",
  ],
-  description: "Create a new task on the Gibwork platform with payment in SPL tokens",
+  description:
+    "Create a new task on the Gibwork platform with payment in SPL tokens",
  examples: [
    [
      {
@@ -24,45 +25,38 @@ const createGibworkTaskAction: Action = {
          requirements: "Experience with Rust and React",
          tags: ["solana", "rust", "react"],
          tokenMintAddress: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
-          tokenAmount: 100
+          tokenAmount: 100,
        },
        output: {
          status: "success",
          taskId: "task_123",
          signature: "3YKpM1...",
-          message: "Successfully created task: Build a Solana dApp"
+          message: "Successfully created task: Build a Solana dApp",
        },
-        explanation: "Create a new task on Gibwork with 100 USDC payment"
-      }
-    ]
+        explanation: "Create a new task on Gibwork with 100 USDC payment",
+      },
+    ],
  ],
  schema: z.object({
-    title: z.string()
-      .min(1)
-      .describe("Title of the task"),
-    content: z.string()
-      .min(1)
-      .describe("Description of the task"),
-    requirements: z.string()
+    title: z.string().min(1).describe("Title of the task"),
+    content: z.string().min(1).describe("Description of the task"),
+    requirements: z
+      .string()
      .min(1)
      .describe("Requirements to complete the task"),
-    tags: z.array(z.string())
+    tags: z
+      .array(z.string())
      .min(1)
      .describe("List of tags associated with the task"),
-    tokenMintAddress: z.string()
-      .describe("Token mint address for payment"),
-    tokenAmount: z.number()
-      .positive()
-      .describe("Payment amount for the task"),
-    payer: z.string()
+    tokenMintAddress: z.string().describe("Token mint address for payment"),
+    tokenAmount: z.number().positive().describe("Payment amount for the task"),
+    payer: z
+      .string()
      .optional()
-      .describe("Optional payer address (defaults to wallet address)")
+      .describe("Optional payer address (defaults to wallet address)"),
  }),
  handler: async (agent: SolanaAgentKit, input: Record<string, any>) => {
    try {
-      const tokenMintAddress = new PublicKey(input.tokenMintAddress);
-      const payer = input.payer ? new PublicKey(input.payer) : undefined;
-
      const responseData = await create_gibwork_task(
        agent,
        input.title,
@@ -71,22 +65,22 @@ const createGibworkTaskAction: Action = {
        input.tags,
        new PublicKey(input.tokenMintAddress),
        input.tokenAmount,
-        input.payer ? new PublicKey(input.payer) : undefined
+        input.payer ? new PublicKey(input.payer) : undefined,
      );

      return {
        status: "success",
        taskId: responseData.taskId,
        signature: responseData.signature,
-        message: `Successfully created task: ${input.title}`
+        message: `Successfully created task: ${input.title}`,
      };
    } catch (error: any) {
      return {
        status: "error",
-        message: `Failed to create task: ${error.message}`
+        message: `Failed to create task: ${error.message}`,
      };
    }
-  }
+  },
 };

-export default createGibworkTaskAction; 
+export default createGibworkTaskAction;
--- a/src/actions/createImage.ts
+++ b/src/actions/createImage.ts
@@ -1,8 +1,6 @@
 import { Action } from "../types/action";
 import { SolanaAgentKit } from "../agent";
 import { z } from "zod";
-import OpenAI from "openai";
-import { create } from "domain";
 import { create_image } from "../tools/create_image";

 const createImageAction: Action = {
@@ -13,9 +11,10 @@ const createImageAction: Action = {
    "make image",
    "generate artwork",
    "create picture",
-    "generate picture"
+    "generate picture",
  ],
-  description: "Create an AI-generated image based on a text prompt using OpenAI's DALL-E models",
+  description:
+    "Create an AI-generated image based on a text prompt using OpenAI's DALL-E models",
  examples: [
    [
      {
@@ -24,56 +23,56 @@ const createImageAction: Action = {
          model: "dall-e-3",
          size: "1024x1024",
          quality: "standard",
-          style: "natural"
+          style: "natural",
        },
        output: {
          status: "success",
          imageUrl: "https://example.com/image.png",
-          message: "Successfully generated image"
+          message: "Successfully generated image",
        },
-        explanation: "Generate an image of a sunset landscape using DALL-E 3"
-      }
-    ]
+        explanation: "Generate an image of a sunset landscape using DALL-E 3",
+      },
+    ],
  ],
  schema: z.object({
-    prompt: z.string()
+    prompt: z
+      .string()
      .min(1)
      .max(1000)
      .describe("The text description of the image to generate"),
-    model: z.enum(["dall-e-3"])
+    model: z
+      .enum(["dall-e-3"])
      .default("dall-e-3")
      .describe("The AI model to use for generation"),
-    size: z.enum(["256x256", "512x512", "1024x1024", "1792x1024", "1024x1792"])
+    size: z
+      .enum(["256x256", "512x512", "1024x1024", "1792x1024", "1024x1792"])
      .default("1024x1024")
      .describe("The size of the generated image"),
-    quality: z.enum(["standard", "hd"])
+    quality: z
+      .enum(["standard", "hd"])
      .default("standard")
      .describe("The quality level of the generated image"),
-    style: z.enum(["natural", "vivid"])
+    style: z
+      .enum(["natural", "vivid"])
      .default("natural")
-      .describe("The style of the generated image")
+      .describe("The style of the generated image"),
  }),
  handler: async (agent: SolanaAgentKit, input: Record<string, any>) => {
    try {
      if (!agent.openai_api_key) {
        return {
          status: "error",
-          message: "OpenAI API key not found in agent configuration"
+          message: "OpenAI API key not found in agent configuration",
        };
      }

      const { prompt, model, size } = input;
-
-      const openai = new OpenAI({
-        apiKey: agent.openai_api_key
-      });
-
      const response = await create_image(agent, prompt, model, size);

      return {
        status: "success",
        imageUrl: response.images[0].url,
-        message: "Successfully generated image"
+        message: "Successfully generated image",
      };
    } catch (error: any) {
      // Handle specific OpenAI error types
@@ -82,21 +81,21 @@ const createImageAction: Action = {
        if (status === 429) {
          return {
            status: "error",
-            message: "Rate limit exceeded. Please try again later."
+            message: "Rate limit exceeded. Please try again later.",
          };
        }
        return {
          status: "error",
-          message: `OpenAI API error: ${data.error?.message || error.message}`
+          message: `OpenAI API error: ${data.error?.message || error.message}`,
        };
      }

      return {
        status: "error",
-        message: `Failed to generate image: ${error.message}`
+        message: `Failed to generate image: ${error.message}`,
      };
    }
-  }
+  },
 };

-export default createImageAction; 
+export default createImageAction;
--- a/src/actions/createOpenbookMarket.ts
+++ b/src/actions/createOpenbookMarket.ts
@@ -1,8 +1,6 @@
 import { Action } from "../types/action";
 import { SolanaAgentKit } from "../agent";
 import { z } from "zod";
-import { OPEN_BOOK_PROGRAM, Raydium, TxVersion } from "@raydium-io/raydium-sdk-v2";
-import { MintLayout, TOKEN_PROGRAM_ID } from "@solana/spl-token";
 import { PublicKey } from "@solana/web3.js";
 import { openbookCreateMarket } from "../tools";

@@ -14,42 +12,41 @@ const createOpenbookMarketAction: Action = {
    "new openbook market",
    "create trading pair",
    "setup dex market",
-    "new trading market"
+    "new trading market",
  ],
  description: "Create a new trading market on Openbook DEX",
  examples: [
    [
      {
        input: {
-          baseMint: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",  // USDC
-          quoteMint: "So11111111111111111111111111111111111111112",   // SOL
+          baseMint: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v", // USDC
+          quoteMint: "So11111111111111111111111111111111111111112", // SOL
          lotSize: 1,
-          tickSize: 0.01
+          tickSize: 0.01,
        },
        output: {
          status: "success",
          signatures: ["2ZE7Rz...", "3YKpM1..."],
-          message: "Successfully created Openbook market"
+          message: "Successfully created Openbook market",
        },
-        explanation: "Create a new USDC/SOL market on Openbook with default lot and tick sizes"
-      }
-    ]
+        explanation:
+          "Create a new USDC/SOL market on Openbook with default lot and tick sizes",
+      },
+    ],
  ],
  schema: z.object({
-    baseMint: z.string()
-      .min(1)
-      .describe("The base token's mint address"),
-    quoteMint: z.string()
-      .min(1)
-      .describe("The quote token's mint address"),
-    lotSize: z.number()
+    baseMint: z.string().min(1).describe("The base token's mint address"),
+    quoteMint: z.string().min(1).describe("The quote token's mint address"),
+    lotSize: z
+      .number()
      .positive()
      .default(1)
      .describe("The minimum order size (lot size)"),
-    tickSize: z.number()
+    tickSize: z
+      .number()
      .positive()
      .default(0.01)
-      .describe("The minimum price increment (tick size)")
+      .describe("The minimum price increment (tick size)"),
  }),
  handler: async (agent: SolanaAgentKit, input: Record<string, any>) => {
    try {
@@ -58,27 +55,26 @@ const createOpenbookMarketAction: Action = {
      const lotSize = input.lotSize || 1;
      const tickSize = input.tickSize || 0.01;

-
      const signatures = await openbookCreateMarket(
        agent,
        baseMint,
        quoteMint,
        lotSize,
-        tickSize
+        tickSize,
      );

      return {
        status: "success",
        signatures,
-        message: "Successfully created Openbook market"
+        message: "Successfully created Openbook market",
      };
    } catch (error: any) {
      return {
        status: "error",
-        message: `Failed to create Openbook market: ${error.message}`
+        message: `Failed to create Openbook market: ${error.message}`,
      };
    }
-  }
+  },
 };

-export default createOpenbookMarketAction; 
+export default createOpenbookMarketAction;
--- a/src/actions/createOrcaSingleSidedWhirlpool.ts
+++ b/src/actions/createOrcaSingleSidedWhirlpool.ts
@@ -27,48 +27,58 @@ const createOrcaSingleSidedWhirlpoolAction: Action = {
    "initialize orca whirlpool",
    "create orca concentrated pool",
    "setup orca concentrated liquidity",
-    "create orca trading pair"
+    "create orca trading pair",
  ],
-  description: "Create a new single-sided whirlpool on Orca with concentrated liquidity",
+  description:
+    "Create a new single-sided whirlpool on Orca with concentrated liquidity",
  examples: [
    [
      {
        input: {
          depositTokenAmount: "1000000000000", // 1 million tokens with 6 decimals
-          depositTokenMint: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",  // USDC
-          otherTokenMint: "So11111111111111111111111111111111111111112",   // SOL
+          depositTokenMint: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v", // USDC
+          otherTokenMint: "So11111111111111111111111111111111111111112", // SOL
          initialPrice: "0.001",
          maxPrice: "5.0",
-          feeTier: 0.3
+          feeTier: 0.3,
        },
        output: {
          status: "success",
          signature: "2ZE7Rz...",
-          message: "Successfully created Orca single-sided whirlpool"
+          message: "Successfully created Orca single-sided whirlpool",
        },
-        explanation: "Create a USDC/SOL whirlpool with 1M USDC initial liquidity"
-      }
-    ]
+        explanation:
+          "Create a USDC/SOL whirlpool with 1M USDC initial liquidity",
+      },
+    ],
  ],
  schema: z.object({
-    depositTokenAmount: z.string()
+    depositTokenAmount: z
+      .string()
      .min(1)
-      .describe("The amount of deposit token to provide as liquidity (including decimals)"),
-    depositTokenMint: z.string()
+      .describe(
+        "The amount of deposit token to provide as liquidity (including decimals)",
+      ),
+    depositTokenMint: z
+      .string()
      .min(1)
      .describe("The mint address of the token being deposited"),
-    otherTokenMint: z.string()
+    otherTokenMint: z
+      .string()
      .min(1)
      .describe("The mint address of the other token in the pool"),
-    initialPrice: z.string()
+    initialPrice: z
+      .string()
      .min(1)
      .describe("Initial price of deposit token in terms of the other token"),
-    maxPrice: z.string()
+    maxPrice: z
+      .string()
      .min(1)
      .describe("Maximum price at which liquidity is added"),
-    feeTier: z.number()
+    feeTier: z
+      .number()
      .refine((val) => val in FEE_TIERS, "Invalid fee tier")
-      .describe("Fee tier percentage for the pool (e.g., 0.3 for 0.3%)")
+      .describe("Fee tier percentage for the pool (e.g., 0.3 for 0.3%)"),
  }),
  handler: async (agent: SolanaAgentKit, input: Record<string, any>) => {
    try {
@@ -87,21 +97,21 @@ const createOrcaSingleSidedWhirlpoolAction: Action = {
        otherTokenMint,
        initialPrice,
        maxPrice,
-        feeTier
+        feeTier,
      );

      return {
        status: "success",
        signature,
-        message: "Successfully created Orca single-sided whirlpool"
+        message: "Successfully created Orca single-sided whirlpool",
      };
    } catch (error: any) {
      return {
        status: "error",
-        message: `Failed to create whirlpool: ${error.message}`
+        message: `Failed to create whirlpool: ${error.message}`,
      };
    }
-  }
+  },
 };

-export default createOrcaSingleSidedWhirlpoolAction; 
+export default createOrcaSingleSidedWhirlpoolAction;
--- a/src/actions/deployCollection.ts
+++ b/src/actions/deployCollection.ts
@@ -1,4 +1,3 @@
-import { PublicKey } from "@solana/web3.js";
 import { Action } from "../types/action";
 import { SolanaAgentKit } from "../agent";
 import { z } from "zod";
@@ -17,7 +16,7 @@ const deployCollectionAction: Action = {
    "launch collection",
    "deploy nft collection",
    "create nft collection",
-    "mint collection"
+    "mint collection",
  ],
  description: `Deploy a new NFT collection on Solana blockchain.`,
  examples: [
@@ -26,43 +25,43 @@ const deployCollectionAction: Action = {
        input: {
          name: "My Collection",
          uri: "https://example.com/collection.json",
-          royaltyBasisPoints: 500
+          royaltyBasisPoints: 500,
        },
        output: {
          status: "success",
          message: "Collection deployed successfully",
          collectionAddress: "7nE9GvcwsqzYxmJLSrYmSB1V1YoJWVK1KWzAcWAzjXkN",
-          name: "My Collection"
+          name: "My Collection",
        },
-        explanation: "Deploy an NFT collection with 5% royalty"
-      }
+        explanation: "Deploy an NFT collection with 5% royalty",
+      },
    ],
    [
      {
        input: {
          name: "Basic Collection",
-          uri: "https://example.com/basic.json"
+          uri: "https://example.com/basic.json",
        },
        output: {
          status: "success",
          message: "Collection deployed successfully",
          collectionAddress: "8nE9GvcwsqzYxmJLSrYmSB1V1YoJWVK1KWzAcWAzjXkM",
-          name: "Basic Collection"
+          name: "Basic Collection",
        },
-        explanation: "Deploy a basic NFT collection without royalties"
-      }
-    ]
+        explanation: "Deploy a basic NFT collection without royalties",
+      },
+    ],
  ],
  schema: z.object({
    name: z.string().min(1, "Name is required"),
    uri: z.string().url("URI must be a valid URL"),
-    royaltyBasisPoints: z.number().min(0).max(10000).optional()
+    royaltyBasisPoints: z.number().min(0).max(10000).optional(),
  }),
  handler: async (agent: SolanaAgentKit, input: Record<string, any>) => {
    const options: CollectionOptions = {
      name: input.name,
      uri: input.uri,
-      royaltyBasisPoints: input.royaltyBasisPoints
+      royaltyBasisPoints: input.royaltyBasisPoints,
    };

    const result = await deploy_collection(agent, options);
@@ -71,9 +70,9 @@ const deployCollectionAction: Action = {
      status: "success",
      message: "Collection deployed successfully",
      collectionAddress: result.collectionAddress.toString(),
-      name: input.name
+      name: input.name,
    };
-  }
+  },
 };

-export default deployCollectionAction; 
+export default deployCollectionAction;
--- a/src/actions/deployToken.ts
+++ b/src/actions/deployToken.ts
@@ -1,5 +1,4 @@
-import { PublicKey } from "@solana/web3.js";
-import { Action, ActionExample } from "../types/action";
+import { Action } from "../types/action";
 import { SolanaAgentKit } from "../agent";
 import { z } from "zod";
 import { deploy_token } from "../tools";
@@ -13,7 +12,8 @@ const deployTokenAction: Action = {
    "create new token",
    "mint token",
  ],
-  description: "Deploy a new SPL token on the Solana blockchain with specified parameters",
+  description:
+    "Deploy a new SPL token on the Solana blockchain with specified parameters",
  examples: [
    [
      {
@@ -22,38 +22,38 @@ const deployTokenAction: Action = {
          uri: "https://example.com/token.json",
          symbol: "MTK",
          decimals: 9,
-          initialSupply: 1000000
+          initialSupply: 1000000,
        },
        output: {
          mint: "7nE9GvcwsqzYxmJLSrYmSB1V1YoJWVK1KWzAcWAzjXkN",
          status: "success",
-          message: "Token deployed successfully"
+          message: "Token deployed successfully",
        },
-        explanation: "Deploy a token with initial supply and metadata"
-      }
+        explanation: "Deploy a token with initial supply and metadata",
+      },
    ],
    [
      {
        input: {
          name: "Basic Token",
          uri: "https://example.com/basic.json",
-          symbol: "BASIC"
+          symbol: "BASIC",
        },
        output: {
          mint: "8nE9GvcwsqzYxmJLSrYmSB1V1YoJWVK1KWzAcWAzjXkM",
          status: "success",
-          message: "Token deployed successfully"
+          message: "Token deployed successfully",
        },
-        explanation: "Deploy a basic token with minimal parameters"
-      }
-    ]
+        explanation: "Deploy a basic token with minimal parameters",
+      },
+    ],
  ],
  schema: z.object({
    name: z.string().min(1, "Name is required"),
    uri: z.string().url("URI must be a valid URL"),
    symbol: z.string().min(1, "Symbol is required"),
    decimals: z.number().optional(),
-    initialSupply: z.number().optional()
+    initialSupply: z.number().optional(),
  }),
  handler: async (agent: SolanaAgentKit, input: Record<string, any>) => {
    try {
@@ -63,21 +63,21 @@ const deployTokenAction: Action = {
        input.uri,
        input.symbol,
        input.decimals,
-        input.initialSupply
+        input.initialSupply,
      );

      return {
        mint: result.mint.toString(),
        status: "success",
-        message: "Token deployed successfully"
+        message: "Token deployed successfully",
      };
    } catch (error: any) {
      return {
        status: "error",
-        message: `Token deployment failed: ${error.message}`
+        message: `Token deployment failed: ${error.message}`,
      };
    }
-  }
-}
+  },
+};

-export default deployTokenAction; 
+export default deployTokenAction;
--- a/src/actions/fetchPrice.ts
+++ b/src/actions/fetchPrice.ts
@@ -11,26 +11,29 @@ const fetchPriceAction: Action = {
    "check price",
    "token value",
    "price check",
-    "get price in usd"
+    "get price in usd",
  ],
-  description: "Fetch the current price of a Solana token in USDC using Jupiter API",
+  description:
+    "Fetch the current price of a Solana token in USDC using Jupiter API",
  examples: [
    [
      {
        input: {
-          tokenAddress: "So11111111111111111111111111111111111111112"
+          tokenAddress: "So11111111111111111111111111111111111111112",
        },
        output: {
          status: "success",
          price: "23.45",
-          message: "Current price: $23.45 USDC"
+          message: "Current price: $23.45 USDC",
        },
-        explanation: "Get the current price of SOL token in USDC"
-      }
-    ]
+        explanation: "Get the current price of SOL token in USDC",
+      },
+    ],
  ],
  schema: z.object({
-    tokenAddress: z.string().describe("The mint address of the token to fetch the price for")
+    tokenAddress: z
+      .string()
+      .describe("The mint address of the token to fetch the price for"),
  }),
  handler: async (agent: SolanaAgentKit, input: Record<string, any>) => {
    try {
@@ -40,15 +43,15 @@ const fetchPriceAction: Action = {
      return {
        status: "success",
        price,
-        message: `Current price: $${price} USDC`
+        message: `Current price: $${price} USDC`,
      };
    } catch (error: any) {
      return {
        status: "error",
-        message: `Failed to fetch price: ${error.message}`
+        message: `Failed to fetch price: ${error.message}`,
      };
    }
-  }
+  },
 };

-export default fetchPriceAction; 
+export default fetchPriceAction;
--- a/src/actions/getAllDomainsTLDs.ts
+++ b/src/actions/getAllDomainsTLDs.ts
@@ -11,9 +11,10 @@ const getAllDomainsTLDsAction: Action = {
    "fetch domain tlds",
    "get top level domains",
    "list available tlds",
-    "get domain suffixes"
+    "get domain suffixes",
  ],
-  description: "Get a list of all available top-level domains (TLDs) for Solana domains",
+  description:
+    "Get a list of all available top-level domains (TLDs) for Solana domains",
  examples: [
    [
      {
@@ -21,14 +22,15 @@ const getAllDomainsTLDsAction: Action = {
        output: {
          status: "success",
          tlds: [".sol", ".abc", ".backpack", ".bonk"],
-          message: "Successfully retrieved all domain TLDs"
+          message: "Successfully retrieved all domain TLDs",
        },
-        explanation: "Get a list of all available TLDs that can be used for Solana domains"
-      }
-    ]
+        explanation:
+          "Get a list of all available TLDs that can be used for Solana domains",
+      },
+    ],
  ],
  schema: z.object({}),
-  handler: async (agent: SolanaAgentKit, input: Record<string, any>) => {
+  handler: async (agent: SolanaAgentKit) => {
    try {
      // Get all domain TLDs
      const tlds = await getAllDomainsTLDs(agent);
@@ -36,15 +38,15 @@ const getAllDomainsTLDsAction: Action = {
      return {
        status: "success",
        tlds,
-        message: "Successfully retrieved all domain TLDs"
+        message: "Successfully retrieved all domain TLDs",
      };
    } catch (error: any) {
      return {
        status: "error",
-        message: `Failed to get domain TLDs: ${error.message}`
+        message: `Failed to get domain TLDs: ${error.message}`,
      };
    }
-  }
+  },
 };

-export default getAllDomainsTLDsAction; 
+export default getAllDomainsTLDsAction;
--- a/src/actions/getAllRegisteredAllDomains.ts
+++ b/src/actions/getAllRegisteredAllDomains.ts
@@ -11,7 +11,7 @@ const getAllRegisteredAllDomainsAction: Action = {
    "fetch registered domains",
    "get domain list",
    "list active domains",
-    "get registered names"
+    "get registered names",
  ],
  description: "Get a list of all registered domains across all TLDs",
  examples: [
@@ -19,28 +19,30 @@ const getAllRegisteredAllDomainsAction: Action = {
      {
        input: {
          limit: 100,
-          offset: 0
+          offset: 0,
        },
        output: {
          status: "success",
          domains: ["solana.sol", "bonk.abc", "wallet.backpack"],
          total: 3,
-          message: "Successfully retrieved registered domains"
+          message: "Successfully retrieved registered domains",
        },
-        explanation: "Get the first 100 registered domains across all TLDs"
-      }
-    ]
+        explanation: "Get the first 100 registered domains across all TLDs",
+      },
+    ],
  ],
  schema: z.object({
-    limit: z.number()
+    limit: z
+      .number()
      .positive()
      .max(1000)
      .default(100)
      .describe("Maximum number of domains to return"),
-    offset: z.number()
+    offset: z
+      .number()
      .nonnegative()
      .default(0)
-      .describe("Number of domains to skip")
+      .describe("Number of domains to skip"),
  }),
  handler: async (agent: SolanaAgentKit, input: Record<string, any>) => {
    try {
@@ -50,20 +52,19 @@ const getAllRegisteredAllDomainsAction: Action = {
      // Get all registered domains
      const domains = await getAllRegisteredAllDomains(agent);

-
      return {
        status: "success",
        domains: domains.slice(offset, offset + limit),
        total: domains.length,
-        message: "Successfully retrieved registered domains"
+        message: "Successfully retrieved registered domains",
      };
    } catch (error: any) {
      return {
        status: "error",
-        message: `Failed to get registered domains: ${error.message}`
+        message: `Failed to get registered domains: ${error.message}`,
      };
    }
-  }
+  },
 };

-export default getAllRegisteredAllDomainsAction; 
+export default getAllRegisteredAllDomainsAction;
--- a/src/actions/getMainAllDomainsDomain.ts
+++ b/src/actions/getMainAllDomainsDomain.ts
@@ -2,7 +2,6 @@ import { Action } from "../types/action";
 import { SolanaAgentKit } from "../agent";
 import { z } from "zod";
 import { PublicKey } from "@solana/web3.js";
-import { TldParser } from "@onsol/tldparser";
 import { getMainAllDomainsDomain } from "../tools";

 const getMainAllDomainsDomainAction: Action = {
@@ -13,52 +12,56 @@ const getMainAllDomainsDomainAction: Action = {
    "get default domain",
    "get main address name",
    "get primary name",
-    "get main domain name"
+    "get main domain name",
  ],
  description: "Get the main domain associated with a wallet address",
  examples: [
    [
      {
        input: {
-          address: "7nxQB..."
+          address: "7nxQB...",
        },
        output: {
          status: "success",
          domain: "solana.sol",
-          message: "Successfully retrieved main domain"
+          message: "Successfully retrieved main domain",
        },
-        explanation: "Get the main domain name for a given wallet address"
-      }
-    ]
+        explanation: "Get the main domain name for a given wallet address",
+      },
+    ],
  ],
  schema: z.object({
-    address: z.string()
+    address: z
+      .string()
      .min(1)
-      .describe("The wallet address to get the main domain for")
+      .describe("The wallet address to get the main domain for"),
  }),
  handler: async (agent: SolanaAgentKit, input: Record<string, any>) => {
    try {
-      const mainDomain = await getMainAllDomainsDomain(agent, new PublicKey(input.address));
+      const mainDomain = await getMainAllDomainsDomain(
+        agent,
+        new PublicKey(input.address),
+      );

      if (!mainDomain) {
        return {
          status: "error",
-          message: "No main domain found for this address"
+          message: "No main domain found for this address",
        };
      }

      return {
        status: "success",
        domain: mainDomain,
-        message: "Successfully retrieved main domain"
+        message: "Successfully retrieved main domain",
      };
    } catch (error: any) {
      return {
        status: "error",
-        message: `Failed to get main domain: ${error.message}`
+        message: `Failed to get main domain: ${error.message}`,
      };
    }
-  }
+  },
 };

-export default getMainAllDomainsDomainAction; 
+export default getMainAllDomainsDomainAction;
--- a/src/actions/getOwnedAllDomains.ts
+++ b/src/actions/getOwnedAllDomains.ts
@@ -12,29 +12,31 @@ const getOwnedAllDomainsAction: Action = {
    "fetch wallet domains",
    "get owned names",
    "list my domains",
-    "get address domains"
+    "get address domains",
  ],
-  description: "Get all domains owned by a specific wallet address across all TLDs",
+  description:
+    "Get all domains owned by a specific wallet address across all TLDs",
  examples: [
    [
      {
        input: {
-          address: "7nxQB..."
+          address: "7nxQB...",
        },
        output: {
          status: "success",
          domains: ["solana.sol", "wallet.abc", "user.backpack"],
          total: 3,
-          message: "Successfully retrieved owned domains"
+          message: "Successfully retrieved owned domains",
        },
-        explanation: "Get all domain names owned by a specific wallet address"
-      }
-    ]
+        explanation: "Get all domain names owned by a specific wallet address",
+      },
+    ],
  ],
  schema: z.object({
-    address: z.string()
+    address: z
+      .string()
      .min(1)
-      .describe("The wallet address to get owned domains for")
+      .describe("The wallet address to get owned domains for"),
  }),
  handler: async (agent: SolanaAgentKit, input: Record<string, any>) => {
    try {
@@ -47,15 +49,15 @@ const getOwnedAllDomainsAction: Action = {
        status: "success",
        domains,
        total: domains.length,
-        message: `Successfully retrieved ${domains.length} owned domain${domains.length === 1 ? '' : 's'}`
+        message: `Successfully retrieved ${domains.length} owned domain${domains.length === 1 ? "" : "s"}`,
      };
    } catch (error: any) {
      return {
        status: "error",
-        message: `Failed to get owned domains: ${error.message}`
+        message: `Failed to get owned domains: ${error.message}`,
      };
    }
-  }
+  },
 };

-export default getOwnedAllDomainsAction; 
+export default getOwnedAllDomainsAction;
--- a/src/actions/getOwnedDomainsForTLD.ts
+++ b/src/actions/getOwnedDomainsForTLD.ts
@@ -1,7 +1,6 @@
 import { Action } from "../types/action";
 import { SolanaAgentKit } from "../agent";
 import { z } from "zod";
-import { PublicKey } from "@solana/web3.js";
 import { getOwnedDomainsForTLD } from "../tools";

 const getOwnedDomainsForTLDAction: Action = {
@@ -12,29 +11,32 @@ const getOwnedDomainsForTLDAction: Action = {
    "fetch wallet domains by tld",
    "get owned names by extension",
    "list my domains by tld",
-    "get address domains for tld"
+    "get address domains for tld",
  ],
-  description: "Get all domains owned by a specific wallet address for a given top-level domain (TLD)",
+  description:
+    "Get all domains owned by a specific wallet address for a given top-level domain (TLD)",
  examples: [
    [
      {
        input: {
-          tld: "sol"
+          tld: "sol",
        },
        output: {
          status: "success",
          domains: ["solana.sol", "wallet.sol", "user.sol"],
          total: 3,
-          message: "Successfully retrieved owned domains for .sol"
+          message: "Successfully retrieved owned domains for .sol",
        },
-        explanation: "Get all .sol domain names owned by a specific wallet address"
-      }
-    ]
+        explanation:
+          "Get all .sol domain names owned by a specific wallet address",
+      },
+    ],
  ],
  schema: z.object({
-    tld: z.string()
+    tld: z
+      .string()
      .min(1)
-      .describe("The top-level domain to filter by (e.g., 'sol', 'abc')")
+      .describe("The top-level domain to filter by (e.g., 'sol', 'abc')"),
  }),
  handler: async (agent: SolanaAgentKit, input: Record<string, any>) => {
    try {
@@ -47,15 +49,15 @@ const getOwnedDomainsForTLDAction: Action = {
        status: "success",
        domains,
        total: domains.length,
-        message: `Successfully retrieved ${domains.length} owned domain${domains.length === 1 ? '' : 's'} for .${tld}`
+        message: `Successfully retrieved ${domains.length} owned domain${domains.length === 1 ? "" : "s"} for .${tld}`,
      };
    } catch (error: any) {
      return {
        status: "error",
-        message: `Failed to get owned domains: ${error.message}`
+        message: `Failed to get owned domains: ${error.message}`,
      };
    }
-  }
+  },
 };

-export default getOwnedDomainsForTLDAction; 
+export default getOwnedDomainsForTLDAction;
--- a/src/actions/getPrimaryDomain.ts
+++ b/src/actions/getPrimaryDomain.ts
@@ -1,7 +1,6 @@
 import { Action } from "../types/action";
 import { SolanaAgentKit } from "../agent";
 import { z } from "zod";
-import { getPrimaryDomain as _getPrimaryDomain } from "@bonfida/spl-name-service";
 import { PublicKey } from "@solana/web3.js";
 import { getPrimaryDomain } from "../tools";

@@ -13,51 +12,46 @@ const getPrimaryDomainAction: Action = {
    "check primary domain",
    "find primary domain",
    "get main domain",
-    "primary sol domain"
+    "primary sol domain",
  ],
-  description: "Get the primary .sol domain associated with a Solana wallet address",
+  description:
+    "Get the primary .sol domain associated with a Solana wallet address",
  examples: [
    [
      {
        input: {
-          account: "7nxQB..."
+          account: "7nxQB...",
        },
        output: {
          status: "success",
          domain: "vitalik.sol",
-          message: "Primary domain: vitalik.sol"
+          message: "Primary domain: vitalik.sol",
        },
-        explanation: "Get the primary .sol domain for a wallet address"
-      }
-    ]
+        explanation: "Get the primary .sol domain for a wallet address",
+      },
+    ],
  ],
  schema: z.object({
-    account: z.string()
-      .min(1)
-      .describe("The Solana wallet address to lookup")
+    account: z.string().min(1).describe("The Solana wallet address to lookup"),
  }),
  handler: async (agent: SolanaAgentKit, input: Record<string, any>) => {
    try {
      const account = new PublicKey(input.account);

-      const response = await getPrimaryDomain(
-        agent,
-        account
-      );
-
+      const response = await getPrimaryDomain(agent, account);

      return {
        status: "success",
        domain: response,
-        message: `Primary domain: ${response}`
+        message: `Primary domain: ${response}`,
      };
    } catch (error: any) {
      return {
        status: "error",
-        message: `Failed to get primary domain: ${error.message}`
+        message: `Failed to get primary domain: ${error.message}`,
      };
    }
-  }
+  },
 };

-export default getPrimaryDomainAction; 
+export default getPrimaryDomainAction;
--- a/src/actions/getTPS.ts
+++ b/src/actions/getTPS.ts
@@ -10,9 +10,10 @@ const getTPSAction: Action = {
    "check network speed",
    "network performance",
    "transaction throughput",
-    "network tps"
+    "network tps",
  ],
-  description: "Get the current transactions per second (TPS) of the Solana network",
+  description:
+    "Get the current transactions per second (TPS) of the Solana network",
  examples: [
    [
      {
@@ -20,11 +21,11 @@ const getTPSAction: Action = {
        output: {
          status: "success",
          tps: 3500,
-          message: "Current network TPS: 3500"
+          message: "Current network TPS: 3500",
        },
-        explanation: "Get the current TPS of the Solana network"
-      }
-    ]
+        explanation: "Get the current TPS of the Solana network",
+      },
+    ],
  ],
  schema: z.object({}), // No input parameters required
  handler: async (agent: SolanaAgentKit, _input: Record<string, any>) => {
@@ -33,15 +34,15 @@ const getTPSAction: Action = {
      return {
        status: "success",
        response,
-        message: `Current network TPS: ${response}`
+        message: `Current network TPS: ${response}`,
      };
    } catch (error: any) {
      return {
        status: "error",
-        message: `Failed to get TPS: ${error.message}`
+        message: `Failed to get TPS: ${error.message}`,
      };
    }
-  }
+  },
 };

-export default getTPSAction; 
+export default getTPSAction;
--- a/src/actions/getTokenData.ts
+++ b/src/actions/getTokenData.ts
@@ -12,14 +12,14 @@ const getTokenDataAction: Action = {
    "token details",
    "lookup token",
    "find token",
-    "token data"
+    "token data",
  ],
  description: "Get token data from either a token address or ticker symbol",
  examples: [
    [
      {
        input: {
-          address: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
+          address: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
        },
        output: {
          status: "success",
@@ -27,16 +27,16 @@ const getTokenDataAction: Action = {
            name: "USD Coin",
            symbol: "USDC",
            address: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
-            decimals: 6
-          }
+            decimals: 6,
+          },
        },
-        explanation: "Get token data using the token's address"
-      }
+        explanation: "Get token data using the token's address",
+      },
    ],
    [
      {
        input: {
-          ticker: "SOL"
+          ticker: "SOL",
        },
        output: {
          status: "success",
@@ -44,19 +44,21 @@ const getTokenDataAction: Action = {
            name: "Wrapped SOL",
            symbol: "SOL",
            address: "So11111111111111111111111111111111111111112",
-            decimals: 9
-          }
+            decimals: 9,
+          },
        },
-        explanation: "Get token data using the token's ticker symbol"
-      }
-    ]
+        explanation: "Get token data using the token's ticker symbol",
+      },
+    ],
  ],
-  schema: z.object({
-    address: z.string().optional().describe("The token's mint address"),
-    ticker: z.string().optional().describe("The token's ticker symbol")
-  }).refine(data => data.address || data.ticker, {
-    message: "Either address or ticker must be provided"
-  }),
+  schema: z
+    .object({
+      address: z.string().optional().describe("The token's mint address"),
+      ticker: z.string().optional().describe("The token's ticker symbol"),
+    })
+    .refine((data) => data.address || data.ticker, {
+      message: "Either address or ticker must be provided",
+    }),
  handler: async (agent: SolanaAgentKit, input: Record<string, any>) => {
    try {
      let tokenData: JupiterTokenData | undefined;
@@ -71,7 +73,7 @@ const getTokenDataAction: Action = {
      if (!tokenData) {
        return {
          status: "error",
-          message: "Token not found or not verified"
+          message: "Token not found or not verified",
        };
      }
      return {
@@ -81,16 +83,16 @@ const getTokenDataAction: Action = {
          symbol: tokenData.symbol,
          address: tokenData.address,
          decimals: tokenData.decimals,
-          logoURI: tokenData.logoURI
-        }
+          logoURI: tokenData.logoURI,
+        },
      };
    } catch (error: any) {
      return {
        status: "error",
-        message: `Failed to get token data: ${error.message}`
+        message: `Failed to get token data: ${error.message}`,
      };
    }
-  }
+  },
 };

-export default getTokenDataAction; 
+export default getTokenDataAction;
--- a/src/actions/index.ts
+++ b/src/actions/index.ts
@@ -58,4 +58,4 @@ export const actions = [
  launchPumpfunTokenAction,
 ];

-export type { Action, ActionExample, Handler } from "../types/action"; 
+export type { Action, ActionExample, Handler } from "../types/action";
--- a/src/actions/launchPumpfunToken.ts
+++ b/src/actions/launchPumpfunToken.ts
@@ -1,7 +1,6 @@
 import { Action } from "../types/action";
 import { SolanaAgentKit } from "../agent";
 import { z } from "zod";
-import { VersionedTransaction, Keypair } from "@solana/web3.js";
 import { launchPumpFunToken } from "../tools";

 const launchPumpfunTokenAction: Action = {
@@ -12,9 +11,10 @@ const launchPumpfunTokenAction: Action = {
    "deploy pumpfun token",
    "create meme token",
    "launch memecoin",
-    "create pump token"
+    "create pump token",
  ],
-  description: "Launch a new token on Pump.fun with customizable metadata and initial liquidity",
+  description:
+    "Launch a new token on Pump.fun with customizable metadata and initial liquidity",
  examples: [
    [
      {
@@ -28,78 +28,79 @@ const launchPumpfunTokenAction: Action = {
          website: "https://sampletoken.com",
          initialLiquiditySOL: 0.1,
          slippageBps: 10,
-          priorityFee: 0.0001
+          priorityFee: 0.0001,
        },
        output: {
          status: "success",
          signature: "2ZE7Rz...",
          mint: "7nxQB...",
          metadataUri: "https://arweave.net/...",
-          message: "Successfully launched token on Pump.fun"
+          message: "Successfully launched token on Pump.fun",
        },
-        explanation: "Launch a new token with custom metadata and 0.1 SOL initial liquidity"
-      }
-    ]
+        explanation:
+          "Launch a new token with custom metadata and 0.1 SOL initial liquidity",
+      },
+    ],
  ],
  schema: z.object({
-    tokenName: z.string()
-      .min(1)
-      .max(32)
-      .describe("Name of the token"),
-    tokenTicker: z.string()
+    tokenName: z.string().min(1).max(32).describe("Name of the token"),
+    tokenTicker: z
+      .string()
      .min(2)
      .max(10)
      .describe("Ticker symbol of the token"),
-    description: z.string()
+    description: z
+      .string()
      .min(1)
      .max(1000)
      .describe("Description of the token"),
-    imageUrl: z.string()
-      .url()
-      .describe("URL of the token image"),
-    twitter: z.string()
-      .optional()
-      .describe("Twitter handle (optional)"),
-    telegram: z.string()
-      .optional()
-      .describe("Telegram group link (optional)"),
-    website: z.string()
-      .url()
-      .optional()
-      .describe("Website URL (optional)"),
-    initialLiquiditySOL: z.number()
+    imageUrl: z.string().url().describe("URL of the token image"),
+    twitter: z.string().optional().describe("Twitter handle (optional)"),
+    telegram: z.string().optional().describe("Telegram group link (optional)"),
+    website: z.string().url().optional().describe("Website URL (optional)"),
+    initialLiquiditySOL: z
+      .number()
      .min(0.0001)
      .default(0.0001)
      .describe("Initial liquidity in SOL"),
-    slippageBps: z.number()
+    slippageBps: z
+      .number()
      .min(1)
      .max(1000)
      .default(5)
      .describe("Slippage tolerance in basis points"),
-    priorityFee: z.number()
+    priorityFee: z
+      .number()
      .min(0.00001)
      .default(0.00005)
-      .describe("Priority fee in SOL")
+      .describe("Priority fee in SOL"),
  }),
  handler: async (agent: SolanaAgentKit, input: Record<string, any>) => {
    try {
      const { tokenName, tokenTicker, description, imageUrl } = input;
-      const result = await launchPumpFunToken(agent, tokenName, tokenTicker, description, imageUrl, input);
+      const result = await launchPumpFunToken(
+        agent,
+        tokenName,
+        tokenTicker,
+        description,
+        imageUrl,
+        input,
+      );

      return {
        status: "success",
        signature: result.signature,
        mint: result.mint,
        metadataUri: result.metadataUri,
-        message: "Successfully launched token on Pump.fun"
+        message: "Successfully launched token on Pump.fun",
      };
    } catch (error: any) {
      return {
        status: "error",
-        message: `Failed to launch token: ${error.message}`
+        message: `Failed to launch token: ${error.message}`,
      };
    }
-  }
+  },
 };

-export default launchPumpfunTokenAction; 
+export default launchPumpfunTokenAction;
--- a/src/actions/lendAsset.ts
+++ b/src/actions/lendAsset.ts
@@ -1,7 +1,6 @@
 import { Action } from "../types/action";
 import { SolanaAgentKit } from "../agent";
 import { z } from "zod";
-import { VersionedTransaction } from "@solana/web3.js";
 import { lendAsset } from "../tools";

 const lendAssetAction: Action = {
@@ -12,28 +11,26 @@ const lendAssetAction: Action = {
    "earn yield",
    "lend with lulo",
    "deposit usdc",
-    "lending"
+    "lending",
  ],
  description: "Lend USDC tokens to earn yield using Lulo protocol",
  examples: [
    [
      {
        input: {
-          amount: 100
+          amount: 100,
        },
        output: {
          status: "success",
          signature: "4xKpN2...",
-          message: "Successfully lent 100 USDC"
+          message: "Successfully lent 100 USDC",
        },
-        explanation: "Lend 100 USDC to earn yield on Lulo"
-      }
-    ]
+        explanation: "Lend 100 USDC to earn yield on Lulo",
+      },
+    ],
  ],
  schema: z.object({
-    amount: z.number()
-      .positive()
-      .describe("Amount of USDC to lend")
+    amount: z.number().positive().describe("Amount of USDC to lend"),
  }),
  handler: async (agent: SolanaAgentKit, input: Record<string, any>) => {
    try {
@@ -44,15 +41,15 @@ const lendAssetAction: Action = {
      return {
        status: "success",
        signature: response,
-        message: `Successfully lent ${amount} USDC`
+        message: `Successfully lent ${amount} USDC`,
      };
    } catch (error: any) {
      return {
        status: "error",
-        message: `Lending failed: ${error.message}`
+        message: `Lending failed: ${error.message}`,
      };
    }
-  }
+  },
 };

-export default lendAssetAction; 
+export default lendAssetAction;
--- a/src/actions/mintNFT.ts
+++ b/src/actions/mintNFT.ts
@@ -11,7 +11,7 @@ const mintNFTAction: Action = {
    "create nft",
    "mint token",
    "create token",
-    "add nft to collection"
+    "add nft to collection",
  ],
  description: `Mint a new NFT in a collection on Solana blockchain.`,
  examples: [
@@ -20,7 +20,7 @@ const mintNFTAction: Action = {
        input: {
          collectionMint: "J1S9H3QjnRtBbbuD4HjPV6RpRhwuk4zKbxsnCHuTgh9w",
          name: "My NFT",
-          uri: "https://example.com/nft.json"
+          uri: "https://example.com/nft.json",
        },
        output: {
          status: "success",
@@ -28,12 +28,12 @@ const mintNFTAction: Action = {
          mintAddress: "7nE9GvcwsqzYxmJLSrYmSB1V1YoJWVK1KWzAcWAzjXkN",
          metadata: {
            name: "My NFT",
-            uri: "https://example.com/nft.json"
+            uri: "https://example.com/nft.json",
          },
-          recipient: "7nE9GvcwsqzYxmJLSrYmSB1V1YoJWVK1KWzAcWAzjXkN"
+          recipient: "7nE9GvcwsqzYxmJLSrYmSB1V1YoJWVK1KWzAcWAzjXkN",
        },
-        explanation: "Mint an NFT to the default wallet"
-      }
+        explanation: "Mint an NFT to the default wallet",
+      },
    ],
    [
      {
@@ -41,7 +41,7 @@ const mintNFTAction: Action = {
          collectionMint: "J1S9H3QjnRtBbbuD4HjPV6RpRhwuk4zKbxsnCHuTgh9w",
          name: "Gift NFT",
          uri: "https://example.com/gift.json",
-          recipient: "9aUn5swQzUTRanaaTwmszxiv89cvFwUCjEBv1vZCoT1u"
+          recipient: "9aUn5swQzUTRanaaTwmszxiv89cvFwUCjEBv1vZCoT1u",
        },
        output: {
          status: "success",
@@ -49,19 +49,19 @@ const mintNFTAction: Action = {
          mintAddress: "8nE9GvcwsqzYxmJLSrYmSB1V1YoJWVK1KWzAcWAzjXkM",
          metadata: {
            name: "Gift NFT",
-            uri: "https://example.com/gift.json"
+            uri: "https://example.com/gift.json",
          },
-          recipient: "9aUn5swQzUTRanaaTwmszxiv89cvFwUCjEBv1vZCoT1u"
+          recipient: "9aUn5swQzUTRanaaTwmszxiv89cvFwUCjEBv1vZCoT1u",
        },
-        explanation: "Mint an NFT to a specific recipient"
-      }
-    ]
+        explanation: "Mint an NFT to a specific recipient",
+      },
+    ],
  ],
  schema: z.object({
    collectionMint: z.string().min(32, "Invalid collection mint address"),
    name: z.string().min(1, "Name is required"),
    uri: z.string().url("URI must be a valid URL"),
-    recipient: z.string().min(32, "Invalid recipient address")
+    recipient: z.string().min(32, "Invalid recipient address"),
  }),
  handler: async (agent: SolanaAgentKit, input: Record<string, any>) => {
    const result = await mintCollectionNFT(
@@ -69,9 +69,9 @@ const mintNFTAction: Action = {
      new PublicKey(input.collectionMint),
      {
        name: input.name,
-        uri: input.uri
+        uri: input.uri,
      },
-      input.recipient ? new PublicKey(input.recipient) : undefined
+      input.recipient ? new PublicKey(input.recipient) : undefined,
    );

    return {
@@ -80,11 +80,11 @@ const mintNFTAction: Action = {
      mintAddress: result.mint.toString(),
      metadata: {
        name: input.name,
-        uri: input.uri
+        uri: input.uri,
      },
-      recipient: input.recipient || result.mint.toString()
+      recipient: input.recipient || result.mint.toString(),
    };
-  }
+  },
 };

-export default mintNFTAction; 
+export default mintNFTAction;
--- a/src/actions/pythFetchPrice.ts
+++ b/src/actions/pythFetchPrice.ts
@@ -1,8 +1,6 @@
 import { Action } from "../types/action";
 import { SolanaAgentKit } from "../agent";
 import { z } from "zod";
-import { PriceServiceConnection } from "@pythnetwork/price-service-client";
-import BN from "bn.js";
 import { pythFetchPrice } from "../tools";

 const pythFetchPriceAction: Action = {
@@ -13,28 +11,29 @@ const pythFetchPriceAction: Action = {
    "pyth oracle price",
    "fetch from pyth",
    "pyth price feed",
-    "oracle price"
+    "oracle price",
  ],
  description: "Fetch the current price from a Pyth oracle price feed",
  examples: [
    [
      {
        input: {
-          priceFeedId: "Gnt27xtC473ZT2Mw5u8wZ68Z3gULkSTb5DuxJy7eJotD"  // SOL/USD price feed
+          priceFeedId: "Gnt27xtC473ZT2Mw5u8wZ68Z3gULkSTb5DuxJy7eJotD", // SOL/USD price feed
        },
        output: {
          status: "success",
          price: "23.45",
-          message: "Current price: $23.45"
+          message: "Current price: $23.45",
        },
-        explanation: "Get the current SOL/USD price from Pyth oracle"
-      }
-    ]
+        explanation: "Get the current SOL/USD price from Pyth oracle",
+      },
+    ],
  ],
  schema: z.object({
-    priceFeedId: z.string()
+    priceFeedId: z
+      .string()
      .min(1)
-      .describe("The Pyth price feed ID to fetch the price from")
+      .describe("The Pyth price feed ID to fetch the price from"),
  }),
  handler: async (_agent: SolanaAgentKit, input: Record<string, any>) => {
    try {
@@ -45,15 +44,15 @@ const pythFetchPriceAction: Action = {
      return {
        status: "success",
        price: priceStr,
-        message: `Current price: $${priceStr}`
+        message: `Current price: $${priceStr}`,
      };
    } catch (error: any) {
      return {
        status: "error",
-        message: `Failed to fetch price from Pyth: ${error.message}`
+        message: `Failed to fetch price from Pyth: ${error.message}`,
      };
    }
-  }
+  },
 };

-export default pythFetchPriceAction; 
+export default pythFetchPriceAction;
--- a/src/actions/raydiumCreateAmmV4.ts
+++ b/src/actions/raydiumCreateAmmV4.ts
@@ -1,15 +1,6 @@
 import { Action } from "../types/action";
 import { SolanaAgentKit } from "../agent";
 import { z } from "zod";
-import {
-  AMM_V4,
-  FEE_DESTINATION_ID,
-  MARKET_STATE_LAYOUT_V3,
-  OPEN_BOOK_PROGRAM,
-  Raydium,
-  TxVersion,
-} from "@raydium-io/raydium-sdk-v2";
-import { MintLayout, TOKEN_PROGRAM_ID } from "@solana/spl-token";
 import { PublicKey } from "@solana/web3.js";
 import BN from "bn.js";
 import { raydiumCreateAmmV4 } from "../tools";
@@ -22,49 +13,51 @@ const raydiumCreateAmmV4Action: Action = {
    "initialize raydium v4 amm",
    "create raydium v4 market maker",
    "setup raydium v4 pool",
-    "create raydium v4 trading pair"
+    "create raydium v4 trading pair",
  ],
-  description: "Create a new AMM V4 pool on Raydium with advanced features and improved efficiency",
+  description:
+    "Create a new AMM V4 pool on Raydium with advanced features and improved efficiency",
  examples: [
    [
      {
        input: {
-          baseMint: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",  // USDC
-          quoteMint: "So11111111111111111111111111111111111111112",   // SOL
+          baseMint: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v", // USDC
+          quoteMint: "So11111111111111111111111111111111111111112", // SOL
          baseAmount: 1000,
          quoteAmount: 10,
-          startPrice: 100,  // 1 SOL = 100 USDC
-          openTime: 1672531200  // Unix timestamp
+          startPrice: 100, // 1 SOL = 100 USDC
+          openTime: 1672531200, // Unix timestamp
        },
        output: {
          status: "success",
          signature: "2ZE7Rz...",
          poolId: "7nxQB...",
-          message: "Successfully created Raydium AMM V4 pool"
+          message: "Successfully created Raydium AMM V4 pool",
        },
-        explanation: "Create a USDC-SOL V4 pool with initial liquidity and price"
-      }
-    ]
+        explanation:
+          "Create a USDC-SOL V4 pool with initial liquidity and price",
+      },
+    ],
  ],
  schema: z.object({
-    baseMint: z.string()
-      .min(1)
-      .describe("The base token mint address"),
-    quoteMint: z.string()
-      .min(1)
-      .describe("The quote token mint address"),
-    baseAmount: z.number()
+    baseMint: z.string().min(1).describe("The base token mint address"),
+    quoteMint: z.string().min(1).describe("The quote token mint address"),
+    baseAmount: z
+      .number()
      .positive()
      .describe("Initial base token amount to provide as liquidity"),
-    quoteAmount: z.number()
+    quoteAmount: z
+      .number()
      .positive()
      .describe("Initial quote token amount to provide as liquidity"),
-    startPrice: z.number()
+    startPrice: z
+      .number()
      .positive()
      .describe("Initial price of quote token in base token units"),
-    openTime: z.number()
+    openTime: z
+      .number()
      .positive()
-      .describe("Unix timestamp when trading should start")
+      .describe("Unix timestamp when trading should start"),
  }),
  handler: async (agent: SolanaAgentKit, input: Record<string, any>) => {
    try {
@@ -73,20 +66,26 @@ const raydiumCreateAmmV4Action: Action = {
      const quoteAmount = new BN(input.quoteAmount);
      const startTime = new BN(input.startTime);

-      const txId = await raydiumCreateAmmV4(agent, marketId, baseAmount, quoteAmount, startTime);
+      const txId = await raydiumCreateAmmV4(
+        agent,
+        marketId,
+        baseAmount,
+        quoteAmount,
+        startTime,
+      );

      return {
        status: "success",
        signature: txId,
-        message: "Successfully created Raydium AMM V4 pool"
+        message: "Successfully created Raydium AMM V4 pool",
      };
    } catch (error: any) {
      return {
        status: "error",
-        message: `Failed to create AMM V4 pool: ${error.message}`
+        message: `Failed to create AMM V4 pool: ${error.message}`,
      };
    }
-  }
+  },
 };

-export default raydiumCreateAmmV4Action; 
+export default raydiumCreateAmmV4Action;
--- a/src/actions/raydiumCreateCpmm.ts
+++ b/src/actions/raydiumCreateCpmm.ts
@@ -1,13 +1,6 @@
 import { Action } from "../types/action";
 import { SolanaAgentKit } from "../agent";
 import { z } from "zod";
-import {
-  CREATE_CPMM_POOL_FEE_ACC,
-  CREATE_CPMM_POOL_PROGRAM,
-  Raydium,
-  TxVersion,
-} from "@raydium-io/raydium-sdk-v2";
-import { MintLayout } from "@solana/spl-token";
 import { PublicKey } from "@solana/web3.js";
 import BN from "bn.js";
 import { raydiumCreateCpmm } from "../tools";
@@ -20,45 +13,46 @@ const raydiumCreateCpmmAction: Action = {
    "initialize raydium amm",
    "create constant product market maker",
    "setup raydium cpmm",
-    "create raydium trading pair"
+    "create raydium trading pair",
  ],
-  description: "Create a new Constant Product Market Maker (CPMM) pool on Raydium",
+  description:
+    "Create a new Constant Product Market Maker (CPMM) pool on Raydium",
  examples: [
    [
      {
        input: {
-          baseMint: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",  // USDC
-          quoteMint: "So11111111111111111111111111111111111111112",   // SOL
+          baseMint: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v", // USDC
+          quoteMint: "So11111111111111111111111111111111111111112", // SOL
          baseAmount: 1000,
          quoteAmount: 10,
-          startTime: 1672531200  // Unix timestamp
+          startTime: 1672531200, // Unix timestamp
        },
        output: {
          status: "success",
          signature: "2ZE7Rz...",
          poolId: "7nxQB...",
-          message: "Successfully created Raydium CPMM pool"
+          message: "Successfully created Raydium CPMM pool",
        },
-        explanation: "Create a USDC-SOL pool with initial liquidity of 1000 USDC and 10 SOL"
-      }
-    ]
+        explanation:
+          "Create a USDC-SOL pool with initial liquidity of 1000 USDC and 10 SOL",
+      },
+    ],
  ],
  schema: z.object({
-    baseMint: z.string()
-      .min(1)
-      .describe("The base token mint address"),
-    quoteMint: z.string()
-      .min(1)
-      .describe("The quote token mint address"),
-    baseAmount: z.number()
+    baseMint: z.string().min(1).describe("The base token mint address"),
+    quoteMint: z.string().min(1).describe("The quote token mint address"),
+    baseAmount: z
+      .number()
      .positive()
      .describe("Initial base token amount to provide as liquidity"),
-    quoteAmount: z.number()
+    quoteAmount: z
+      .number()
      .positive()
      .describe("Initial quote token amount to provide as liquidity"),
-    startTime: z.number()
+    startTime: z
+      .number()
      .positive()
-      .describe("Unix timestamp when trading should start")
+      .describe("Unix timestamp when trading should start"),
  }),
  handler: async (agent: SolanaAgentKit, input: Record<string, any>) => {
    try {
@@ -69,20 +63,28 @@ const raydiumCreateCpmmAction: Action = {
      const mintBAmount = new BN(input.quoteAmount);
      const startTime = new BN(input.startTime);

-      const txId = await raydiumCreateCpmm(agent, mintA, mintB, configId, mintAAmount, mintBAmount, startTime);
+      const txId = await raydiumCreateCpmm(
+        agent,
+        mintA,
+        mintB,
+        configId,
+        mintAAmount,
+        mintBAmount,
+        startTime,
+      );

      return {
        status: "success",
        signature: txId,
-        message: "Successfully created Raydium CPMM pool"
+        message: "Successfully created Raydium CPMM pool",
      };
    } catch (error: any) {
      return {
        status: "error",
-        message: `Failed to create CPMM pool: ${error.message}`
+        message: `Failed to create CPMM pool: ${error.message}`,
      };
    }
-  }
+  },
 };

-export default raydiumCreateCpmmAction; 
+export default raydiumCreateCpmmAction;
--- a/src/actions/registerDomain.ts
+++ b/src/actions/registerDomain.ts
@@ -1,10 +1,6 @@
 import { Action } from "../types/action";
 import { SolanaAgentKit } from "../agent";
 import { z } from "zod";
-import { Transaction } from "@solana/web3.js";
-import { registerDomainNameV2 } from "@bonfida/spl-name-service";
-import { getAssociatedTokenAddressSync } from "@solana/spl-token";
-import { TOKENS } from "../constants";
 import { registerDomain } from "../tools";

 const registerDomainAction: Action = {
@@ -15,7 +11,7 @@ const registerDomainAction: Action = {
    "get domain name",
    "register .sol",
    "purchase domain",
-    "domain registration"
+    "domain registration",
  ],
  description: "Register a .sol domain name using Bonfida Name Service",
  examples: [
@@ -23,26 +19,25 @@ const registerDomainAction: Action = {
      {
        input: {
          name: "mydomain",
-          spaceKB: 1
+          spaceKB: 1,
        },
        output: {
          status: "success",
          signature: "2ZE7Rz...",
-          message: "Successfully registered mydomain.sol"
+          message: "Successfully registered mydomain.sol",
        },
-        explanation: "Register a new .sol domain with 1KB storage space"
-      }
-    ]
+        explanation: "Register a new .sol domain with 1KB storage space",
+      },
+    ],
  ],
  schema: z.object({
-    name: z.string()
-      .min(1)
-      .describe("Domain name to register (without .sol)"),
-    spaceKB: z.number()
+    name: z.string().min(1).describe("Domain name to register (without .sol)"),
+    spaceKB: z
+      .number()
      .min(1)
      .max(10)
      .default(1)
-      .describe("Space allocation in KB (max 10KB)")
+      .describe("Space allocation in KB (max 10KB)"),
  }),
  handler: async (agent: SolanaAgentKit, input: Record<string, any>) => {
    try {
@@ -54,15 +49,15 @@ const registerDomainAction: Action = {
      return {
        status: "success",
        signature,
-        message: `Successfully registered ${name}.sol`
+        message: `Successfully registered ${name}.sol`,
      };
    } catch (error: any) {
      return {
        status: "error",
-        message: `Domain registration failed: ${error.message}`
+        message: `Domain registration failed: ${error.message}`,
      };
    }
-  }
+  },
 };

-export default registerDomainAction; 
+export default registerDomainAction;
--- a/src/actions/requestFunds.ts
+++ b/src/actions/requestFunds.ts
@@ -10,7 +10,7 @@ const requestFundsAction: Action = {
    "get test sol",
    "use faucet",
    "request test tokens",
-    "get devnet sol"
+    "get devnet sol",
  ],
  description: "Request SOL from Solana faucet (devnet/testnet only)",
  examples: [
@@ -20,11 +20,11 @@ const requestFundsAction: Action = {
        output: {
          status: "success",
          message: "Successfully requested faucet funds",
-          network: "devnet.solana.com"
+          network: "devnet.solana.com",
        },
-        explanation: "Request SOL from the devnet faucet"
-      }
-    ]
+        explanation: "Request SOL from the devnet faucet",
+      },
+    ],
  ],
  schema: z.object({}), // No input parameters required
  handler: async (agent: SolanaAgentKit, _input: Record<string, any>) => {
@@ -33,9 +33,9 @@ const requestFundsAction: Action = {
    return {
      status: "success",
      message: "Successfully requested faucet funds",
-      network: agent.connection.rpcEndpoint.split("/")[2]
+      network: agent.connection.rpcEndpoint.split("/")[2],
    };
-  }
+  },
 };

-export default requestFundsAction; 
+export default requestFundsAction;
--- a/src/actions/resolveDomain.ts
+++ b/src/actions/resolveDomain.ts
@@ -1,7 +1,6 @@
 import { Action } from "../types/action";
 import { SolanaAgentKit } from "../agent";
 import { z } from "zod";
-import { TldParser } from "@onsol/tldparser";
 import { resolveAllDomains } from "../tools";

 const resolveDomainAction: Action = {
@@ -11,25 +10,25 @@ const resolveDomainAction: Action = {
    "lookup domain",
    "get domain owner",
    "check domain",
-    "find domain owner"
+    "find domain owner",
  ],
  description: "Resolve a Solana domain name to get its owner's public key",
  examples: [
    [
      {
        input: {
-          domain: "example.sol"
+          domain: "example.sol",
        },
        output: {
          status: "success",
-          owner: "7nxQB..."
+          owner: "7nxQB...",
        },
-        explanation: "Resolve a .sol domain name to get the owner's public key"
-      }
-    ]
+        explanation: "Resolve a .sol domain name to get the owner's public key",
+      },
+    ],
  ],
  schema: z.object({
-    domain: z.string().min(1).describe("The domain name to resolve")
+    domain: z.string().min(1).describe("The domain name to resolve"),
  }),
  handler: async (agent: SolanaAgentKit, input: Record<string, any>) => {
    try {
@@ -38,15 +37,15 @@ const resolveDomainAction: Action = {
      return {
        status: "success",
        owner: tld,
-        message: `Successfully resolved domain ${domain}`
+        message: `Successfully resolved domain ${domain}`,
      };
    } catch (error: any) {
      return {
        status: "error",
-        message: `Failed to resolve domain: ${error.message}`
+        message: `Failed to resolve domain: ${error.message}`,
      };
    }
-  }
+  },
 };

-export default resolveDomainAction; 
+export default resolveDomainAction;
--- a/src/actions/resolveSolDomain.ts
+++ b/src/actions/resolveSolDomain.ts
@@ -1,7 +1,6 @@
 import { Action } from "../types/action";
 import { SolanaAgentKit } from "../agent";
 import { z } from "zod";
-import { resolve } from "@bonfida/spl-name-service";
 import { resolveSolDomain } from "../tools";

 const resolveSolDomainAction: Action = {
@@ -12,47 +11,49 @@ const resolveSolDomainAction: Action = {
    "get sol domain owner",
    "check sol domain",
    "find sol domain owner",
-    "resolve .sol"
+    "resolve .sol",
  ],
-  description: "Resolve a .sol domain to its corresponding Solana wallet address using Bonfida Name Service",
+  description:
+    "Resolve a .sol domain to its corresponding Solana wallet address using Bonfida Name Service",
  examples: [
    [
      {
        input: {
-          domain: "vitalik.sol"
+          domain: "vitalik.sol",
        },
        output: {
          status: "success",
          owner: "7nxQB...",
-          message: "Successfully resolved vitalik.sol"
+          message: "Successfully resolved vitalik.sol",
        },
-        explanation: "Resolve a .sol domain to get the owner's wallet address"
-      }
-    ]
+        explanation: "Resolve a .sol domain to get the owner's wallet address",
+      },
+    ],
  ],
  schema: z.object({
-    domain: z.string()
+    domain: z
+      .string()
      .min(1)
-      .describe("The .sol domain to resolve (with or without .sol suffix)")
+      .describe("The .sol domain to resolve (with or without .sol suffix)"),
  }),
  handler: async (agent: SolanaAgentKit, input: Record<string, any>) => {
    try {
      const domain = input.domain as string;

-      const res = await resolveSolDomain(agent,domain)
+      const res = await resolveSolDomain(agent, domain);

      return {
        status: "success",
        owner: res.toString(),
-        message: `Successfully resolved ${res}`
+        message: `Successfully resolved ${res}`,
      };
    } catch (error: any) {
      return {
        status: "error",
-        message: `Failed to resolve domain: ${error.message}`
+        message: `Failed to resolve domain: ${error.message}`,
      };
    }
-  }
+  },
 };

-export default resolveSolDomainAction; 
+export default resolveSolDomainAction;
--- a/src/actions/stakeWithJup.ts
+++ b/src/actions/stakeWithJup.ts
@@ -1,8 +1,7 @@
 import { Action } from "../types/action";
 import { SolanaAgentKit } from "../agent";
 import { z } from "zod";
-import { VersionedTransaction } from "@solana/web3.js";
-import { stakeWithJup, trade } from "../tools";
+import { stakeWithJup } from "../tools";

 const stakeWithJupAction: Action = {
  name: "solana_stake_with_jup",
@@ -12,46 +11,45 @@ const stakeWithJupAction: Action = {
    "jup staking",
    "stake with jup",
    "liquid staking",
-    "get jupsol"
+    "get jupsol",
  ],
-  description: "Stake SOL tokens with Jupiter's liquid staking protocol to receive jupSOL",
+  description:
+    "Stake SOL tokens with Jupiter's liquid staking protocol to receive jupSOL",
  examples: [
    [
      {
        input: {
-          amount: 1.5
+          amount: 1.5,
        },
        output: {
          status: "success",
          signature: "5KtPn3...",
-          message: "Successfully staked 1.5 SOL for jupSOL"
+          message: "Successfully staked 1.5 SOL for jupSOL",
        },
-        explanation: "Stake 1.5 SOL to receive jupSOL tokens"
-      }
-    ]
+        explanation: "Stake 1.5 SOL to receive jupSOL tokens",
+      },
+    ],
  ],
  schema: z.object({
-    amount: z.number()
-      .positive()
-      .describe("Amount of SOL to stake")
+    amount: z.number().positive().describe("Amount of SOL to stake"),
  }),
  handler: async (agent: SolanaAgentKit, input: Record<string, any>) => {
    try {
      const amount = input.amount as number;
-      
-      const res = await stakeWithJup(agent,amount)
+
+      const res = await stakeWithJup(agent, amount);
      return {
        status: "success",
        res,
-        message: `Successfully staked ${amount} SOL for jupSOL`
+        message: `Successfully staked ${amount} SOL for jupSOL`,
      };
    } catch (error: any) {
      return {
        status: "error",
-        message: `jupSOL staking failed: ${error.message}`
+        message: `jupSOL staking failed: ${error.message}`,
      };
    }
-  }
+  },
 };

-export default stakeWithJupAction; 
+export default stakeWithJupAction;
--- a/src/actions/trade.ts
+++ b/src/actions/trade.ts
@@ -11,7 +11,7 @@ const tradeAction: Action = {
    "exchange tokens",
    "trade tokens",
    "convert tokens",
-    "swap sol"
+    "swap sol",
  ],
  description: `This tool can be used to swap tokens to another token (It uses Jupiter Exchange).`,
  examples: [
@@ -19,18 +19,19 @@ const tradeAction: Action = {
      {
        input: {
          outputMint: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
-          inputAmount: 1
+          inputAmount: 1,
        },
        output: {
          status: "success",
          message: "Trade executed successfully",
-          transaction: "5UfgJ5vVZxUxefDGqzqkVLHzHxVTyYH9StYyHKgvHYmXJgqJKxEqy9k4Rz9LpXrHF9kUZB7",
+          transaction:
+            "5UfgJ5vVZxUxefDGqzqkVLHzHxVTyYH9StYyHKgvHYmXJgqJKxEqy9k4Rz9LpXrHF9kUZB7",
          inputAmount: 1,
          inputToken: "SOL",
-          outputToken: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
+          outputToken: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
        },
-        explanation: "Swap 1 SOL for USDC"
-      }
+        explanation: "Swap 1 SOL for USDC",
+      },
    ],
    [
      {
@@ -38,34 +39,36 @@ const tradeAction: Action = {
          outputMint: "So11111111111111111111111111111111111111112",
          inputAmount: 100,
          inputMint: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
-          slippageBps: 100
+          slippageBps: 100,
        },
        output: {
          status: "success",
          message: "Trade executed successfully",
-          transaction: "4VfgJ5vVZxUxefDGqzqkVLHzHxVTyYH9StYyHKgvHYmXJgqJKxEqy9k4Rz9LpXrHF9kUZB7",
+          transaction:
+            "4VfgJ5vVZxUxefDGqzqkVLHzHxVTyYH9StYyHKgvHYmXJgqJKxEqy9k4Rz9LpXrHF9kUZB7",
          inputAmount: 100,
          inputToken: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
-          outputToken: "So11111111111111111111111111111111111111112"
+          outputToken: "So11111111111111111111111111111111111111112",
        },
-        explanation: "Swap 100 USDC for SOL with 1% slippage"
-      }
-    ]
+        explanation: "Swap 100 USDC for SOL with 1% slippage",
+      },
+    ],
  ],
  schema: z.object({
    outputMint: z.string().min(32, "Invalid output mint address"),
    inputAmount: z.number().positive("Input amount must be positive"),
    inputMint: z.string().min(32, "Invalid input mint address").optional(),
-    slippageBps: z.number().min(0).max(10000).optional()
+    slippageBps: z.number().min(0).max(10000).optional(),
  }),
  handler: async (agent: SolanaAgentKit, input: Record<string, any>) => {
-    const tx = await trade(agent,
+    const tx = await trade(
+      agent,
      new PublicKey(input.outputMint),
      input.inputAmount,
      input.inputMint
        ? new PublicKey(input.inputMint)
        : new PublicKey("So11111111111111111111111111111111111111112"),
-      input.slippageBps
+      input.slippageBps,
    );

    return {
@@ -74,9 +77,9 @@ const tradeAction: Action = {
      transaction: tx,
      inputAmount: input.inputAmount,
      inputToken: input.inputMint || "SOL",
-      outputToken: input.outputMint
+      outputToken: input.outputMint,
    };
-  }
+  },
 };

-export default tradeAction; 
+export default tradeAction;
--- a/src/actions/transfer.ts
+++ b/src/actions/transfer.ts
@@ -11,7 +11,7 @@ const transferAction: Action = {
    "transfer funds",
    "send money",
    "send sol",
-    "transfer tokens"
+    "transfer tokens",
  ],
  description: `Transfer tokens or SOL to another address (also called as wallet address).`,
  examples: [
@@ -19,7 +19,7 @@ const transferAction: Action = {
      {
        input: {
          to: "8x2dR8Mpzuz2YqyZyZjUbYWKSWesBo5jMx2Q9Y86udVk",
-          amount: 1
+          amount: 1,
        },
        output: {
          status: "success",
@@ -27,17 +27,18 @@ const transferAction: Action = {
          amount: 1,
          recipient: "8x2dR8Mpzuz2YqyZyZjUbYWKSWesBo5jMx2Q9Y86udVk",
          token: "SOL",
-          transaction: "5UfgJ5vVZxUxefDGqzqkVLHzHxVTyYH9StYyHKgvHYmXJgqJKxEqy9k4Rz9LpXrHF9kUZB7"
+          transaction:
+            "5UfgJ5vVZxUxefDGqzqkVLHzHxVTyYH9StYyHKgvHYmXJgqJKxEqy9k4Rz9LpXrHF9kUZB7",
        },
-        explanation: "Transfer 1 SOL to the recipient address"
-      }
+        explanation: "Transfer 1 SOL to the recipient address",
+      },
    ],
    [
      {
        input: {
          to: "8x2dR8Mpzuz2YqyZyZjUbYWKSWesBo5jMx2Q9Y86udVk",
          amount: 100,
-          mint: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
+          mint: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
        },
        output: {
          status: "success",
@@ -45,22 +46,23 @@ const transferAction: Action = {
          amount: 100,
          recipient: "8x2dR8Mpzuz2YqyZyZjUbYWKSWesBo5jMx2Q9Y86udVk",
          token: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
-          transaction: "4VfgJ5vVZxUxefDGqzqkVLHzHxVTyYH9StYyHKgvHYmXJgqJKxEqy9k4Rz9LpXrHF9kUZB7"
+          transaction:
+            "4VfgJ5vVZxUxefDGqzqkVLHzHxVTyYH9StYyHKgvHYmXJgqJKxEqy9k4Rz9LpXrHF9kUZB7",
        },
-        explanation: "Transfer 100 USDC tokens to the recipient address"
-      }
-    ]
+        explanation: "Transfer 100 USDC tokens to the recipient address",
+      },
+    ],
  ],
  schema: z.object({
    to: z.string().min(32, "Invalid Solana address"),
    amount: z.number().positive("Amount must be positive"),
-    mint: z.string().optional()
+    mint: z.string().optional(),
  }),
  handler: async (agent: SolanaAgentKit, input: Record<string, any>) => {
    const recipient = new PublicKey(input.to);
    const mintAddress = input.mint ? new PublicKey(input.mint) : undefined;

-    const tx = await transfer(agent,recipient, input.amount, mintAddress);
+    const tx = await transfer(agent, recipient, input.amount, mintAddress);

    return {
      status: "success",
@@ -68,9 +70,9 @@ const transferAction: Action = {
      amount: input.amount,
      recipient: input.to,
      token: input.mint || "SOL",
-      transaction: tx
+      transaction: tx,
    };
-  }
+  },
 };

-export default transferAction; 
+export default transferAction;
--- a/src/langchain/index.ts
+++ b/src/langchain/index.ts
@@ -10,7 +10,6 @@ import { create_image } from "../tools/create_image";
 import { BN } from "@coral-xyz/anchor";
 import { FEE_TIERS } from "../tools";
 import { toJSON } from "../utils/toJSON";
-import { wrapLangChainTool } from "../utils/langchainWrapper";
 import deployTokenAction from "../actions/deployToken";
 import balanceAction from "../actions/balance";
 import transferAction from "../actions/transfer";
@@ -41,7 +40,7 @@ export class SolanaBalanceTool extends Tool {
      return JSON.stringify({
        status: "error",
        message: error.message,
-        code: error.code || "UNKNOWN_ERROR"
+        code: error.code || "UNKNOWN_ERROR",
      });
    }
  }
@@ -69,7 +68,7 @@ export class SolanaTransferTool extends Tool {
      return JSON.stringify({
        status: "error",
        message: error.message,
-        code: error.code || "UNKNOWN_ERROR"
+        code: error.code || "UNKNOWN_ERROR",
      });
    }
  }
@@ -97,7 +96,7 @@ export class SolanaDeployTokenTool extends Tool {
      return JSON.stringify({
        status: "error",
        message: error.message,
-        code: error.code || "UNKNOWN_ERROR"
+        code: error.code || "UNKNOWN_ERROR",
      });
    }
  }
@@ -125,7 +124,7 @@ export class SolanaDeployCollectionTool extends Tool {
      return JSON.stringify({
        status: "error",
        message: error.message,
-        code: error.code || "UNKNOWN_ERROR"
+        code: error.code || "UNKNOWN_ERROR",
      });
    }
  }
@@ -153,7 +152,7 @@ export class SolanaMintNFTTool extends Tool {
      return JSON.stringify({
        status: "error",
        message: error.message,
-        code: error.code || "UNKNOWN_ERROR"
+        code: error.code || "UNKNOWN_ERROR",
      });
    }
  }
@@ -181,7 +180,7 @@ export class SolanaTradeTool extends Tool {
      return JSON.stringify({
        status: "error",
        message: error.message,
-        code: error.code || "UNKNOWN_ERROR"
+        code: error.code || "UNKNOWN_ERROR",
      });
    }
  }
@@ -206,7 +205,7 @@ export class SolanaRequestFundsTool extends Tool {
      return JSON.stringify({
        status: "error",
        message: error.message,
-        code: error.code || "UNKNOWN_ERROR"
+        code: error.code || "UNKNOWN_ERROR",
      });
    }
  }
--- a/src/types/action.ts
+++ b/src/types/action.ts
@@ -13,7 +13,10 @@ export interface ActionExample {
 /**
 * Handler function type for executing the action
 */
-export type Handler = (agent: SolanaAgentKit, input: Record<string, any>) => Promise<Record<string, any>>;
+export type Handler = (
+  agent: SolanaAgentKit,
+  input: Record<string, any>,
+) => Promise<Record<string, any>>;

 /**
 * Main Action interface inspired by ELIZA
@@ -50,4 +53,4 @@ export interface Action {
   * Function that executes the action
   */
  handler: Handler;
-} 
+}
--- a/src/utils/actionExecutor.ts
+++ b/src/utils/actionExecutor.ts
@@ -7,9 +7,10 @@ import { actions } from "../actions";
 */
 export function findAction(query: string): Action | undefined {
  const normalizedQuery = query.toLowerCase().trim();
-  return actions.find(action => 
-    action.name.toLowerCase() === normalizedQuery ||
-    action.similes.some(simile => simile.toLowerCase() === normalizedQuery)
+  return actions.find(
+    (action) =>
+      action.name.toLowerCase() === normalizedQuery ||
+      action.similes.some((simile) => simile.toLowerCase() === normalizedQuery),
  );
 }

@@ -19,18 +20,18 @@ export function findAction(query: string): Action | undefined {
 export async function executeAction(
  action: Action,
  agent: SolanaAgentKit,
-  input: Record<string, any>
+  input: Record<string, any>,
 ): Promise<Record<string, any>> {
  try {
    // Validate input using Zod schema
    const validatedInput = action.schema.parse(input);
-    
+
    // Execute the action with validated input
    const result = await action.handler(agent, validatedInput);
-    
+
    return {
      status: "success",
-      ...result
+      ...result,
    };
  } catch (error: any) {
    // Handle Zod validation errors specially
@@ -39,14 +40,14 @@ export async function executeAction(
        status: "error",
        message: "Validation error",
        details: error.errors,
-        code: "VALIDATION_ERROR"
+        code: "VALIDATION_ERROR",
      };
    }
-    
+
    return {
      status: "error",
      message: error.message,
-      code: error.code || "EXECUTION_ERROR"
+      code: error.code || "EXECUTION_ERROR",
    };
  }
 }
@@ -57,11 +58,11 @@ export async function executeAction(
 export function getActionExamples(action: Action): string {
  return action.examples
    .flat()
-    .map(example => {
+    .map((example) => {
      return `Input: ${JSON.stringify(example.input, null, 2)}
 Output: ${JSON.stringify(example.output, null, 2)}
 Explanation: ${example.explanation}
 ---`;
    })
    .join("\n");
-} 
+}
--- a/src/utils/langchainWrapper.ts
+++ b/src/utils/langchainWrapper.ts
@@ -1,96 +0,0 @@
-import { Tool } from "langchain/tools";
-import { Action } from "../types/action";
-import { SolanaAgentKit } from "../agent";
-import { z } from "zod";
-
-/**
- * Convert a LangChain tool to our Action interface
- */
-export function wrapLangChainTool(tool: Tool, agent: SolanaAgentKit): Action {
-  // Parse the description to extract input parameters
-  const inputParams = parseToolDescription(tool.description);
-  
-  return {
-    name: tool.name,
-    similes: [], // LangChain tools don't have similes
-    description: tool.description,
-    examples: [], // LangChain tools don't have examples
-    schema: createZodSchema(inputParams),
-    handler: async (agent: SolanaAgentKit, input: Record<string, any>) => {
-      const result = await tool.call(JSON.stringify(input));
-      try {
-        return JSON.parse(result);
-      } catch {
-        return { result };
-      }
-    }
-  };
-}
-
-/**
- * Parse tool description to extract input parameters
- */
-function parseToolDescription(description: string): Array<{name: string, type: string, required: boolean}> {
-  const lines = description.split('\n');
-  const params: Array<{name: string, type: string, required: boolean}> = [];
-  
-  let inInputsSection = false;
-  for (const line of lines) {
-    const trimmed = line.trim();
-    
-    if (trimmed === 'Inputs:' || trimmed === 'Inputs (input is a JSON string):') {
-      inInputsSection = true;
-      continue;
-    }
-    
-    if (inInputsSection && trimmed) {
-      // Match patterns like: name: string, eg "value" (required)
-      const match = trimmed.match(/(\w+):\s*([\w\[\]]+)(?:,\s*eg[:\s]+"[^"]+")?(?:\s*\((required|optional)\))?/);
-      if (match) {
-        params.push({
-          name: match[1],
-          type: match[2],
-          required: match[3] === 'required'
-        });
-      }
-    }
-  }
-  
-  return params;
-}
-
-/**
- * Create a Zod schema from parsed parameters
- */
-function createZodSchema(params: Array<{name: string, type: string, required: boolean}>): z.ZodType<any> {
-  const schemaObj: Record<string, z.ZodType<any>> = {};
-  
-  for (const param of params) {
-    let schema: z.ZodType<any>;
-    
-    switch (param.type.toLowerCase()) {
-      case 'string':
-        schema = z.string();
-        break;
-      case 'number':
-        schema = z.number();
-        break;
-      case 'boolean':
-        schema = z.boolean();
-        break;
-      case 'string[]':
-        schema = z.array(z.string());
-        break;
-      default:
-        schema = z.any();
-    }
-    
-    if (!param.required) {
-      schema = schema.optional();
-    }
-    
-    schemaObj[param.name] = schema;
-  }
-  
-  return z.object(schemaObj);
-} 
--- a/test/index.ts
+++ b/test/index.ts
@@ -7,8 +7,6 @@ import { ChatOpenAI } from "@langchain/openai";
 import * as dotenv from "dotenv";
 import * as fs from "fs";
 import * as readline from "readline";
-import { Tool } from "@langchain/core/tools";
-import { Action } from "../src/types/action";

 dotenv.config();