@ai.ntellect/core 0.3.1 → 0.3.3

package/dist/test.js

@@ -1,373 +1,504 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getRssNews = exports.getChainsTVL = exports.fetchMarkPrice = exports.prepareEvmTransaction = exports.getNetworkProvider = exports.networkConfigs = exports.checkHoneypot = void 0;
-const ccxt_1 = __importDefault(require("ccxt"));
-const ethers_1 = require("ethers");
-const rss_parser_1 = __importDefault(require("rss-parser"));
-const zod_1 = require("zod");
-const agent_1 = require("./agent");
-const interpreter_1 = require("./llm/interpreter");
-const context_1 = require("./llm/interpreter/context");
-const orchestrator_1 = require("./llm/orchestrator");
-const cache_1 = require("./memory/cache");
-const persistent_1 = require("./memory/persistent");
-// Mapping des noms de chaînes vers leurs IDs
-const CHAIN_IDS = {
-    ethereum: "1",
-    bsc: "56",
-    polygon: "137",
-    matic: "137",
-    avalanche: "43114",
-    avax: "43114",
-    fantom: "250",
-    ftm: "250",
-    arbitrum: "42161",
-    arb: "42161",
-    optimism: "10",
-    base: "8453",
-    zksync: "324",
-    solana: "solana",
-    sol: "solana",
-};
-exports.checkHoneypot = {
-    name: "check-honeypot",
-    description: `Analyze a token to detect if it is a honeypot. RESPECT THIS FORMAT FOR CHAIN NAME: ${CHAIN_IDS.toString()}`,
-    parameters: zod_1.z.object({
-        address: zod_1.z.string().describe("Address of the token"),
-        chainName: zod_1.z.string().describe("Chain name (default: eth)"),
-    }),
-    execute: async ({ address, chainName, }) => {
-        try {
-            const API_URL = "https://api.honeypot.is/v2/IsHoneypot";
-            const chainId = getChainId(chainName);
-            console.log("💰 Checking honeypot for token", {
-                address,
-                chainId,
-            });
-            if (chainId === "solana") {
-                return {
-                    status: "error",
-                    message: "L'analyse des tokens Solana n'est pas encore supportée. Cette fonctionnalité sera disponible prochainement.",
-                    chain: {
-                        name: "Solana",
-                        id: "solana",
-                    },
-                };
-            }
-            const queryParams = new URLSearchParams({
-                address: address,
-                ...(chainId && { chainId }),
-                ...{ simulateLiquidity: "true" },
-            });
-            const response = await fetch(`${API_URL}?${queryParams}`);
-            if (!response.ok) {
-                throw new Error(`Erreur API: ${response.status} ${response.statusText}`);
-            }
-            const data = await response.json();
-            const result = {
-                status: "success",
-                token: {
-                    name: data.token.name,
-                    symbol: data.token.symbol,
-                    address: data.token.address,
-                    holders: data.token.totalHolders,
-                },
-                risk: {
-                    level: data.summary.risk,
-                    score: data.summary.riskLevel,
-                    flags: data.summary.flags || [],
-                },
-                analysis: {
-                    isHoneypot: data.honeypotResult?.isHoneypot || false,
-                    reason: data.honeypotResult?.honeypotReason || null,
-                    buyTax: data.simulationResult?.buyTax || 0,
-                    sellTax: data.simulationResult?.sellTax || 0,
-                    holders: {
-                        total: data.holderAnalysis?.holders || 0,
-                        successful: data.holderAnalysis?.successful || 0,
-                        failed: data.holderAnalysis?.failed || 0,
-                        siphoned: data.holderAnalysis?.siphoned || 0,
-                    },
-                },
-                chain: {
-                    name: data.chain.name,
-                    id: data.chain.id,
-                },
-            };
-            return result;
-        }
-        catch (error) {
-            throw error;
-        }
-    },
-};
-function getChainId(chainName) {
-    if (!chainName)
-        return undefined;
-    const normalizedChainName = chainName.toLowerCase();
-    return CHAIN_IDS[normalizedChainName];
-}
-exports.networkConfigs = {
-    ethereum: {
-        name: "Ethereum Mainnet",
-        id: 1,
-        rpc: "https://eth.llamarpc.com",
-        explorerUrl: "https://etherscan.io",
-        nativeToken: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
-    },
-    polygon: {
-        name: "Polygon Mainnet",
-        id: 137,
-        rpc: "https://polygon.llamarpc.com",
-        explorerUrl: "https://polygonscan.com",
-        nativeToken: "0x0000000000000000000000000000000000001010",
-    },
-    arbitrum: {
-        name: "Arbitrum Mainnet",
-        id: 42161,
-        rpc: "https://arbitrum.llamarpc.com",
-        explorerUrl: "https://arbiscan.io",
-        nativeToken: "0x82af49447d8a07e3bd95bd0d56f35241523fbab1",
-    },
-    base: {
-        name: "Base Mainnet",
-        id: 8453,
-        rpc: "https://base.llamarpc.com",
-        explorerUrl: "https://basescan.org",
-        nativeToken: "0x4200000000000000000000000000000000000006",
-    },
-    solana: {
-        name: "Solana Mainnet",
-        rpc: "https://api.mainnet-beta.solana.com",
-        explorerUrl: "https://solscan.io",
-        nativeToken: "So11111111111111111111111111111111111111112",
-    },
-    sepolia: {
-        name: "Sepolia Testnet",
-        id: 11155111,
-        rpc: "https://sepolia.llamarpc.com",
-        explorerUrl: "https://sepolia.etherscan.io",
-        nativeToken: "0xfFf9976782d46CC05630D1f6eBAb18b2324d6B14",
-    },
-    baseSepolia: {
-        name: "Base Sepolia Testnet",
-        id: 84532,
-        rpc: "https://base-sepolia-rpc.publicnode.com",
-        explorerUrl: "https://sepolia.basescan.org",
-        nativeToken: "0x4200000000000000000000000000000000000006",
-    },
-};
-const getNetworkProvider = (networkName) => {
-    const config = exports.networkConfigs[networkName.toLowerCase()];
-    if (!config) {
-        throw new Error(`Network ${networkName} not supported`);
-    }
-    return { config };
-};
-exports.getNetworkProvider = getNetworkProvider;
-exports.prepareEvmTransaction = {
-    name: "prepare-evm-transaction",
-    description: "Prepare a transaction for the user to sign.",
-    parameters: zod_1.z.object({
-        walletAddress: zod_1.z.string(),
-        amount: zod_1.z
-            .string()
-            .describe("Ask the user for the amount to send, if not specified"),
-        network: zod_1.z
-            .string()
-            .describe("Examples networks: ethereum, arbitrum, base. IMPORTANT: You must respect the network name."),
-    }),
-    execute: async ({ walletAddress, amount, network, }) => {
-        try {
-            console.log("💰 Preparing transaction", {
-                to: walletAddress,
-                amount,
-                network,
-            });
-            const networkConfig = exports.networkConfigs[network.toLowerCase()];
-            if (!networkConfig) {
-                throw new Error(`Network ${network} not found`);
-            }
-            return {
-                to: walletAddress,
-                value: (0, ethers_1.parseEther)(amount).toString(),
-                chain: {
-                    id: networkConfig.id || 0,
-                    rpc: networkConfig.rpc,
-                },
-                type: "transfer",
-            };
-        }
-        catch (error) {
-            console.error("💰 Error sending transaction:", error);
-            throw new Error("An error occurred while sending the transaction");
-        }
-    },
-};
-exports.fetchMarkPrice = {
-    name: "fetch-mark-price",
-    description: "Fetches mark price for the market",
-    parameters: zod_1.z.object({
-        symbol: zod_1.z
-            .string()
-            .describe("Unified symbol of the market to fetch the ticker for (default: BTC/USDT)"),
-        params: zod_1.z.object({
-            subType: zod_1.z
-                .string()
-                .describe("Type of funding rate: 'linear' or 'inverse'"),
-        }),
-    }),
-    execute: async ({ symbol, params }) => {
-        try {
-            const binance = new ccxt_1.default.binance({});
-            // Fetch mark price from the Binance API
-            const markPrice = await binance.fetchMarkPrice(symbol, params);
-            console.log("Mark price fetched:", markPrice);
-            return markPrice;
-        }
-        catch (error) {
-            console.error("Error fetching mark price:", error);
-            throw error;
-        }
-    },
-};
-exports.getChainsTVL = {
-    name: "get_chains_tvl",
-    description: "Get current TVL (Total Value Locked) of all chains from DeFiLlama",
-    parameters: zod_1.z.object({
-        limit: zod_1.z
-            .number()
-            .optional()
-            .default(10)
-            .describe("Number of top chains to return (default: 10)"),
-    }),
-    execute: async ({ limit }) => {
-        try {
-            const response = await fetch("https://api.llama.fi/v2/chains", {
-                headers: { accept: "*/*" },
-            });
-            if (!response.ok) {
-                throw new Error(`HTTP error! status: ${response.status}`);
-            }
-            const chains = (await response.json());
-            // Sort chains by TVL in descending order and take top N
-            const topChains = chains
-                .sort((a, b) => b.tvl - a.tvl)
-                .slice(0, limit)
-                .map((chain) => ({
-                name: chain.name,
-                tvl: chain.tvl,
-                tokenSymbol: chain.tokenSymbol,
-            }));
-            const totalTVL = chains.reduce((sum, chain) => sum + chain.tvl, 0);
-            return {
-                summary: {
-                    totalTVL,
-                    numberOfChains: chains.length,
-                },
-                topChains,
-            };
-        }
-        catch (error) {
-            console.error("Error retrieving chains TVL data:", error);
-            throw new Error(`Failed to fetch chains TVL data: ${error.message}`);
-        }
-    },
-};
-const RSS_FEEDS = [
-    "https://www.investing.com/rss/news_301.rss",
-    "https://cointelegraph.com/rss/category/analysis",
-    "https://cointelegraph.com/rss/category/top-10-cryptocurrencies",
-];
-const parser = new rss_parser_1.default();
-function stripHtmlTags(content) {
-    if (!content)
-        return "";
-    return content
-        .replace(/<[^>]*>/g, "")
-        .replace(/\n/g, "")
-        .replace(" ", "");
-}
-exports.getRssNews = {
-    name: "get-news-rss",
-    description: "Get latest news about on website",
-    parameters: zod_1.z.object({}),
-    execute: async () => {
-        const itemsPerSource = 5;
-        try {
-            const feedPromises = RSS_FEEDS.map((url) => parser.parseURL(url));
-            const results = await Promise.allSettled(feedPromises);
-            const successfulFeeds = results
-                .filter((result) => {
-                return (result.status === "fulfilled" && result.value?.items?.length > 0);
-            })
-                .map((result) => result.value);
-            const allItems = successfulFeeds
-                .flatMap((feed) => feed.items.slice(0, itemsPerSource))
-                .sort((a, b) => {
-                const dateA = a.pubDate ? new Date(a.pubDate).getTime() : 0;
-                const dateB = b.pubDate ? new Date(b.pubDate).getTime() : 0;
-                return dateB - dateA;
-            })
-                .slice(0, 5)
-                .map((item) => ({
-                title: item.title,
-                content: stripHtmlTags(item.content),
-                link: item.link,
-                date: item.pubDate,
-                source: item.creator || new URL(item.link).hostname,
-            }));
-            const result = {
-                status: "success",
-                items: allItems,
-            };
-            return result;
-        }
-        catch (error) {
-            throw error;
-        }
-    },
-};
-(async () => {
-    const cacheMemory = new cache_1.CacheMemory();
-    const memory = new persistent_1.PersistentMemory({
-        host: "http://localhost:7700",
-        apiKey: "aSampleMasterKey",
-    });
-    const orchestrator = new orchestrator_1.Orchestrator({
-        id: "1",
-        tools: [],
-        memory: {
-            persistent: memory,
-            cache: cacheMemory,
-        },
-    });
-    const securityInterpreter = new interpreter_1.Interpreter("security", context_1.securityInterpreterContext);
-    const marketInterpreter = new interpreter_1.Interpreter("market", context_1.marketInterpreterContext);
-    const generalInterpreter = new interpreter_1.Interpreter("general", context_1.generalInterpreterContext);
-    // const ccacheMemory = await cacheMemory.findSimilarActions(
-    //   "le top 3 des chaines par TVL en DeFi",
-    //   {
-    //     similarityThreshold: 50,
-    //     maxResults: 5,
-    //     userId: "1",
-    //     scope: MemoryScope.GLOBAL,
-    //   }
-    // );
-    // console.log("✅ RECENT_ACTIONS: ", ccacheMemory);
-    const agent = new agent_1.Agent({
-        interpreters: [securityInterpreter, marketInterpreter, generalInterpreter],
-        orchestrator,
-        memory: {
-            persistent: memory,
-            cache: cacheMemory,
-        },
-        stream: false,
-        maxEvaluatorIteration: 1,
-    });
-    const prompt = "c quoi le top 3 des chaines par TVL en DeFi";
-    const result = await agent.process(prompt, {});
-})();
+// import ccxt from "ccxt";
+// import { parseEther } from "ethers";
+// import Parser from "rss-parser";
+// import { z } from "zod";
+// import { Agent } from "./agent";
+// import { Interpreter } from "./llm/interpreter";
+// import {
+//   generalInterpreterContext,
+//   marketInterpreterContext,
+//   securityInterpreterContext,
+// } from "./llm/interpreter/context";
+// import { Orchestrator } from "./llm/orchestrator";
+// import { CacheMemory } from "./memory/cache";
+// import { PersistentMemory } from "./memory/persistent";
+// import { ActionQueueManager } from "./services/queue";
+// import { ActionScheduler } from "./services/scheduler";
+// import { ScheduledAction } from "./types";
+// interface HoneypotParams {
+//   address: string;
+//   chainName?: string;
+//   simulateLiquidity?: boolean;
+// }
+// // Mapping des noms de chaînes vers leurs IDs
+// const CHAIN_IDS: { [key: string]: string } = {
+//   ethereum: "1",
+//   bsc: "56",
+//   polygon: "137",
+//   matic: "137",
+//   avalanche: "43114",
+//   avax: "43114",
+//   fantom: "250",
+//   ftm: "250",
+//   arbitrum: "42161",
+//   arb: "42161",
+//   optimism: "10",
+//   base: "8453",
+//   zksync: "324",
+//   solana: "solana",
+//   sol: "solana",
+// };
+// export const checkHoneypot = {
+//   name: "check-honeypot",
+//   description: `Analyze a token to detect if it is a honeypot. RESPECT THIS FORMAT FOR CHAIN NAME: ${CHAIN_IDS.toString()}`,
+//   parameters: z.object({
+//     address: z.string().describe("Address of the token"),
+//     chainName: z.string().describe("Chain name (default: eth)"),
+//   }),
+//   execute: async ({
+//     address,
+//     chainName,
+//   }: {
+//     address: string;
+//     chainName?: string;
+//   }) => {
+//     try {
+//       const API_URL = "https://api.honeypot.is/v2/IsHoneypot";
+//       const chainId = getChainId(chainName);
+//       console.log("💰 Checking honeypot for token", {
+//         address,
+//         chainId,
+//       });
+//       if (chainId === "solana") {
+//         return {
+//           status: "error",
+//           message:
+//             "L'analyse des tokens Solana n'est pas encore supportée. Cette fonctionnalité sera disponible prochainement.",
+//           chain: {
+//             name: "Solana",
+//             id: "solana",
+//           },
+//         };
+//       }
+//       const queryParams = new URLSearchParams({
+//         address: address,
+//         ...(chainId && { chainId }),
+//         ...{ simulateLiquidity: "true" },
+//       });
+//       const response = await fetch(`${API_URL}?${queryParams}`);
+//       if (!response.ok) {
+//         throw new Error(
+//           `Erreur API: ${response.status} ${response.statusText}`
+//         );
+//       }
+//       const data: any = await response.json();
+//       const result = {
+//         status: "success",
+//         token: {
+//           name: data.token.name,
+//           symbol: data.token.symbol,
+//           address: data.token.address,
+//           holders: data.token.totalHolders,
+//         },
+//         risk: {
+//           level: data.summary.risk,
+//           score: data.summary.riskLevel,
+//           flags: data.summary.flags || [],
+//         },
+//         analysis: {
+//           isHoneypot: data.honeypotResult?.isHoneypot || false,
+//           reason: data.honeypotResult?.honeypotReason || null,
+//           buyTax: data.simulationResult?.buyTax || 0,
+//           sellTax: data.simulationResult?.sellTax || 0,
+//           holders: {
+//             total: data.holderAnalysis?.holders || 0,
+//             successful: data.holderAnalysis?.successful || 0,
+//             failed: data.holderAnalysis?.failed || 0,
+//             siphoned: data.holderAnalysis?.siphoned || 0,
+//           },
+//         },
+//         chain: {
+//           name: data.chain.name,
+//           id: data.chain.id,
+//         },
+//       };
+//       return result;
+//     } catch (error: any) {
+//       throw error;
+//     }
+//   },
+// };
+// function getChainId(chainName?: string): string | undefined {
+//   if (!chainName) return undefined;
+//   const normalizedChainName = chainName.toLowerCase();
+//   return CHAIN_IDS[normalizedChainName];
+// }
+// export interface NetworkConfig {
+//   name: string;
+//   id?: number;
+//   rpc: string;
+//   explorerUrl: string;
+//   nativeToken: string; // WETH
+// }
+// export const networkConfigs: Record<string, NetworkConfig> = {
+//   ethereum: {
+//     name: "Ethereum Mainnet",
+//     id: 1,
+//     rpc: "https://eth.llamarpc.com",
+//     explorerUrl: "https://etherscan.io",
+//     nativeToken: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+//   },
+//   polygon: {
+//     name: "Polygon Mainnet",
+//     id: 137,
+//     rpc: "https://polygon.llamarpc.com",
+//     explorerUrl: "https://polygonscan.com",
+//     nativeToken: "0x0000000000000000000000000000000000001010",
+//   },
+//   arbitrum: {
+//     name: "Arbitrum Mainnet",
+//     id: 42161,
+//     rpc: "https://arbitrum.llamarpc.com",
+//     explorerUrl: "https://arbiscan.io",
+//     nativeToken: "0x82af49447d8a07e3bd95bd0d56f35241523fbab1",
+//   },
+//   base: {
+//     name: "Base Mainnet",
+//     id: 8453,
+//     rpc: "https://base.llamarpc.com",
+//     explorerUrl: "https://basescan.org",
+//     nativeToken: "0x4200000000000000000000000000000000000006",
+//   },
+//   solana: {
+//     name: "Solana Mainnet",
+//     rpc: "https://api.mainnet-beta.solana.com",
+//     explorerUrl: "https://solscan.io",
+//     nativeToken: "So11111111111111111111111111111111111111112",
+//   },
+//   sepolia: {
+//     name: "Sepolia Testnet",
+//     id: 11155111,
+//     rpc: "https://sepolia.llamarpc.com",
+//     explorerUrl: "https://sepolia.etherscan.io",
+//     nativeToken: "0xfFf9976782d46CC05630D1f6eBAb18b2324d6B14",
+//   },
+//   baseSepolia: {
+//     name: "Base Sepolia Testnet",
+//     id: 84532,
+//     rpc: "https://base-sepolia-rpc.publicnode.com",
+//     explorerUrl: "https://sepolia.basescan.org",
+//     nativeToken: "0x4200000000000000000000000000000000000006",
+//   },
+// };
+// export const getNetworkProvider = (networkName: string) => {
+//   const config = networkConfigs[networkName.toLowerCase()];
+//   if (!config) {
+//     throw new Error(`Network ${networkName} not supported`);
+//   }
+//   return { config };
+// };
+// export type TransactionPrepared = {
+//   to: string;
+//   value: string;
+//   data?: string;
+//   chain: {
+//     id: number;
+//     rpc: string;
+//   };
+//   type: "transfer" | "approve" | "swap";
+//   method?: string;
+//   params?: any[];
+// };
+// export const prepareEvmTransaction = {
+//   name: "prepare-evm-transaction",
+//   description: "Prepare a transaction for the user to sign.",
+//   parameters: z.object({
+//     walletAddress: z.string(),
+//     amount: z
+//       .string()
+//       .describe("Ask the user for the amount to send, if not specified"),
+//     network: z
+//       .string()
+//       .describe(
+//         "Examples networks: ethereum, arbitrum, base. IMPORTANT: You must respect the network name."
+//       ),
+//   }),
+//   execute: async ({
+//     walletAddress,
+//     amount,
+//     network,
+//   }: {
+//     walletAddress: string;
+//     amount: string;
+//     network: string;
+//   }): Promise<TransactionPrepared> => {
+//     try {
+//       console.log("💰 Preparing transaction", {
+//         to: walletAddress,
+//         amount,
+//         network,
+//       });
+//       const networkConfig = networkConfigs[network.toLowerCase()];
+//       if (!networkConfig) {
+//         throw new Error(`Network ${network} not found`);
+//       }
+//       return {
+//         to: walletAddress,
+//         value: parseEther(amount).toString(),
+//         chain: {
+//           id: networkConfig.id || 0,
+//           rpc: networkConfig.rpc,
+//         },
+//         type: "transfer",
+//       };
+//     } catch (error) {
+//       console.error("💰 Error sending transaction:", error);
+//       throw new Error("An error occurred while sending the transaction");
+//     }
+//   },
+// };
+// export const fetchMarkPrice = {
+//   name: "fetch-mark-price",
+//   description: "Fetches mark price for the market",
+//   parameters: z.object({
+//     symbol: z
+//       .string()
+//       .describe(
+//         "Unified symbol of the market to fetch the ticker for (default: BTC/USDT)"
+//       ),
+//     params: z.object({
+//       subType: z
+//         .string()
+//         .describe("Type of funding rate: 'linear' or 'inverse'"),
+//     }),
+//   }),
+//   execute: async ({ symbol, params }: { symbol: string; params: any }) => {
+//     try {
+//       const binance = new ccxt.binance({});
+//       // Fetch mark price from the Binance API
+//       const markPrice = await binance.fetchMarkPrice(symbol, params);
+//       console.log("Mark price fetched:", markPrice);
+//       return markPrice;
+//     } catch (error: any) {
+//       console.error("Error fetching mark price:", error);
+//       throw error;
+//     }
+//   },
+// };
+// interface ChainTVL {
+//   name: string;
+//   tvl: number;
+//   tokenSymbol: string | null;
+//   chainId: number | string | null;
+//   gecko_id: string | null;
+//   cmcId: string | null;
+// }
+// export const getChainsTVL = {
+//   name: "get_chains_tvl",
+//   description:
+//     "Get current TVL (Total Value Locked) of all chains from DeFiLlama",
+//   parameters: z.object({
+//     limit: z
+//       .number()
+//       .optional()
+//       .default(10)
+//       .describe("Number of top chains to return (default: 10)"),
+//   }),
+//   execute: async ({ limit }: { limit: number }) => {
+//     try {
+//       const response = await fetch("https://api.llama.fi/v2/chains", {
+//         headers: { accept: "*/*" },
+//       });
+//       if (!response.ok) {
+//         throw new Error(`HTTP error! status: ${response.status}`);
+//       }
+//       const chains = (await response.json()) as ChainTVL[];
+//       // Sort chains by TVL in descending order and take top N
+//       const topChains = chains
+//         .sort((a, b) => b.tvl - a.tvl)
+//         .slice(0, limit)
+//         .map((chain) => ({
+//           name: chain.name,
+//           tvl: chain.tvl,
+//           tokenSymbol: chain.tokenSymbol,
+//         }));
+//       const totalTVL = chains.reduce((sum, chain) => sum + chain.tvl, 0);
+//       return {
+//         summary: {
+//           totalTVL,
+//           numberOfChains: chains.length,
+//         },
+//         topChains,
+//       };
+//     } catch (error) {
+//       console.error("Error retrieving chains TVL data:", error);
+//       throw new Error(
+//         `Failed to fetch chains TVL data: ${(error as Error).message}`
+//       );
+//     }
+//   },
+// };
+// const RSS_FEEDS = [
+//   "https://www.investing.com/rss/news_301.rss",
+//   "https://cointelegraph.com/rss/category/analysis",
+//   "https://cointelegraph.com/rss/category/top-10-cryptocurrencies",
+// ];
+// const parser = new Parser();
+// function stripHtmlTags(content: string): string {
+//   if (!content) return "";
+//   return content
+//     .replace(/<[^>]*>/g, "")
+//     .replace(/\n/g, "")
+//     .replace(" ", "");
+// }
+// export const getRssNews = {
+//   name: "get-news-rss",
+//   description: "Get latest news about on website",
+//   parameters: z.object({}),
+//   execute: async () => {
+//     const itemsPerSource = 5;
+//     try {
+//       const feedPromises = RSS_FEEDS.map((url) => parser.parseURL(url));
+//       const results = await Promise.allSettled(feedPromises);
+//       const successfulFeeds = results
+//         .filter(
+//           (result): result is PromiseFulfilledResult<Parser.Output<any>> => {
+//             return (
+//               result.status === "fulfilled" && result.value?.items?.length > 0
+//             );
+//           }
+//         )
+//         .map((result) => result.value);
+//       const allItems = successfulFeeds
+//         .flatMap((feed) => feed.items.slice(0, itemsPerSource))
+//         .sort((a, b) => {
+//           const dateA = a.pubDate ? new Date(a.pubDate).getTime() : 0;
+//           const dateB = b.pubDate ? new Date(b.pubDate).getTime() : 0;
+//           return dateB - dateA;
+//         })
+//         .slice(0, 5)
+//         .map((item) => ({
+//           title: item.title,
+//           content: stripHtmlTags(item.content),
+//           link: item.link,
+//           date: item.pubDate,
+//           source: item.creator || new URL(item.link).hostname,
+//         }));
+//       const result = {
+//         status: "success",
+//         items: allItems,
+//       };
+//       return result;
+//     } catch (error: any) {
+//       throw error;
+//     }
+//   },
+// };
+// (async () => {
+//   const cacheMemory = new CacheMemory();
+//   const memory = new PersistentMemory({
+//     host: "http://localhost:7700",
+//     apiKey: "aSampleMasterKey",
+//   });
+//   const orchestrator = new Orchestrator({
+//     id: "1",
+//     tools: [
+//       prepareEvmTransaction,
+//       checkHoneypot,
+//       getChainsTVL,
+//       getRssNews,
+//       {
+//         name: "hello",
+//         description: "hello",
+//         parameters: z.object({
+//           name: z.string(),
+//         }),
+//         execute: async () => {
+//           console.log("hello");
+//         },
+//       },
+//     ],
+//     memory: {
+//       persistent: memory,
+//       cache: cacheMemory,
+//     },
+//   });
+//   const securityInterpreter = new Interpreter(
+//     "security",
+//     securityInterpreterContext
+//   );
+//   const marketInterpreter = new Interpreter("market", marketInterpreterContext);
+//   const generalInterpreter = new Interpreter(
+//     "general",
+//     generalInterpreterContext
+//   );
+//   // const ccacheMemory = await cacheMemory.findSimilarActions(
+//   //   "le top 3 des chaines par TVL en DeFi",
+//   //   {
+//   //     similarityThreshold: 50,
+//   //     maxResults: 5,
+//   //     userId: "1",
+//   //     scope: MemoryScope.GLOBAL,
+//   //   }
+//   // );
+//   // console.log("✅ RECENT_ACTIONS: ", ccacheMemory);
+//   const agent = new Agent({
+//     interpreters: [securityInterpreter, marketInterpreter, generalInterpreter],
+//     orchestrator,
+//     memory: {
+//       persistent: memory,
+//       cache: cacheMemory,
+//     },
+//     stream: false,
+//     maxEvaluatorIteration: 1,
+//   });
+//   const prompt = "tu pourrais analyser le bnb/usdt";
+//   // const result = await agent.process(prompt, {});
+//   const scheduler = new ActionScheduler(
+//     new ActionQueueManager(orchestrator.tools),
+//     orchestrator,
+//     {
+//       onActionScheduled: (action: ScheduledAction) => {
+//         console.log("🗓️ Action programmée:", {
+//           id: action.id,
+//           name: action.action.name,
+//           scheduledTime: action.scheduledTime,
+//         });
+//       },
+//       onActionStart: (action: ScheduledAction) => {
+//         console.log("▶️ Action démarrée:", action.id);
+//       },
+//       onActionComplete: (action: ScheduledAction, result: any) => {
+//         console.log("✅ Action terminée:", {
+//           id: action.id,
+//           result,
+//         });
+//       },
+//       onActionFailed: (action: ScheduledAction, error: any) => {
+//         console.error("❌ Action échouée:", {
+//           id: action.id,
+//           error: error.message,
+//         });
+//       },
+//       onActionCancelled: (actionId: string) => {
+//         console.log("🚫 Action annulée:", actionId);
+//       },
+//     }
+//   );
+//   // Test du scheduler
+//   console.log("🕒 Testing scheduler...");
+//   const scheduledTime = new Date(Date.now() + 10000);
+//   const actionId = await scheduler.scheduleAction(
+//     {
+//       name: "hello",
+//       description: "hello",
+//       parameters: z.object({
+//         name: z.string(),
+//       }),
+//       execute: async () => {
+//         console.log("hello");
+//         return "Hello executed!";
+//       },
+//     },
+//     scheduledTime,
+//     "user123",
+//     {
+//       type: "daily",
+//       interval: 1,
+//     }
+//   );
+//   // Attendre 15 secondes
+//   await new Promise((resolve) => setTimeout(resolve, 15000));
+//   console.log("✅ Test terminé");
+// })();