@ai.ntellect/core 0.5.0 → 0.6.1

package/dist/test.js

@@ -1,438 +0,0 @@
-"use strict";
-// import ccxt from "ccxt";
-// import { configDotenv } from "dotenv";
-// import { parseEther } from "ethers";
-// import Parser from "rss-parser";
-// import { z } from "zod";
-// // import { Orchestrator } from "./llm/orchestrator";
-// configDotenv();
-// 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}`
-//       );
-//     }
-//   },
-// };
-// (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 = "c quoi les news";
-//   // 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é");
-// })();

package/dist/types.d.ts

@@ -1,258 +0,0 @@
-import { Embedding, EmbeddingModel, StreamTextResult } from "ai";
-import { z } from "zod";
-export interface BaseLLM {
-    process: (prompt: string) => Promise<string | object>;
-    streamProcess?: (prompt: string) => Promise<StreamTextResult<Record<string, any>>>;
-}
-export type User = {
-    id: string;
-};
-export interface QueueItem {
-    name: string;
-    parameters: QueueItemParameter[];
-}
-export interface IEventHandler {
-    emitQueueStart(actions: QueueItem[]): void;
-    emitActionStart(action: QueueItem): void;
-    emitActionComplete(action: QueueResult): void;
-    emitQueueComplete(): void;
-}
-export type AgentEvent = {
-    onMessage?: (data: any) => void;
-    onQueueStart?: (actions: QueueItem[]) => void;
-    onActionStart?: (action: QueueItem) => void;
-    onActionComplete?: (action: QueueResult) => void;
-    onQueueComplete?: (actions: QueueResult[]) => void;
-    onConfirmationRequired?: (message: string) => Promise<boolean>;
-};
-export interface QueueResult {
-    name: string;
-    parameters: Record<string, string>;
-    result: any;
-    error: string | null;
-    cancelled?: boolean;
-}
-export interface QueueCallbacks {
-    onActionStart?: (action: QueueItem) => void;
-    onActionComplete?: (result: QueueResult) => void;
-    onQueueComplete?: (results: QueueResult[]) => void;
-    onConfirmationRequired?: (message: string) => Promise<boolean>;
-}
-export interface ProcessPromptCallbacks {
-    onQueueStart?: (actions: QueueItem[]) => void | Promise<void>;
-    onActionStart?: (action: QueueItem) => void | Promise<void>;
-    onActionComplete?: (action: QueueResult) => void | Promise<void>;
-    onQueueComplete?: (actions: QueueResult[]) => void | Promise<void>;
-    onConfirmationRequired?: (message: string) => Promise<boolean>;
-}
-export type Behavior = {
-    role: string;
-    language: string;
-    guidelines: {
-        important: string[];
-        warnings: string[];
-        steps?: string[];
-    };
-    examplesMessages?: {
-        role: string;
-        content: string;
-    }[];
-};
-export type State = {
-    userRequest: string;
-    results: string;
-};
-export interface ActionSchema {
-    name: string;
-    description: string;
-    parameters: z.ZodObject<{
-        [key: string]: z.ZodType;
-    }>;
-    execute: (args: any) => Promise<any>;
-    examples?: {
-        role: string;
-        content: string;
-        parameters?: Record<string, any>;
-    }[];
-    confirmation?: {
-        requireConfirmation: boolean;
-        message: string;
-    };
-}
-export type ProcessPromptResult = {
-    type: "success" | "clarification" | "confirmation";
-    data: QueueResult[] | {
-        validationErrors: string[];
-        prompt: string;
-    } | {
-        actions: QueueItem[];
-    };
-    initialPrompt: string;
-};
-export interface ActionPattern {
-    id: string;
-    actions: QueueResult[];
-    embeddings: number[][];
-    queries: string[];
-    purpose: string;
-}
-export interface MatchOptions {
-    similarityThreshold?: number;
-    maxResults?: number;
-}
-export interface MatchResult {
-    data: any;
-    similarityPercentage: number;
-    purpose: string;
-    name?: string;
-    parameters?: Record<string, any>;
-}
-export interface SummarizerAgent {
-    process: (results: object, onFinish?: (event: any) => void) => Promise<{
-        actions: {
-            name: string;
-            reasoning: string;
-        }[];
-        response: string;
-    } | StreamTextResult<Record<string, any>>>;
-    streamProcess: (results: object, onFinish?: (event: any) => void) => Promise<StreamTextResult<Record<string, any>>>;
-}
-export interface CacheMemoryOptions {
-    embeddingModel: EmbeddingModel<string>;
-    cacheTTL?: number;
-    redisUrl?: string;
-    cachePrefix?: string;
-}
-export type GenerateObjectResponse = {
-    shouldContinue: boolean;
-    actions: Array<{
-        name: string;
-        parameters: Array<{
-            name: string;
-            value: any;
-        }>;
-        scheduler?: {
-            isScheduled: boolean;
-            cronExpression: string;
-            reason?: string;
-        };
-    }>;
-    socialResponse?: {
-        shouldRespond: boolean;
-        response?: string;
-        isPartialResponse?: boolean;
-    };
-    interpreter?: string;
-};
-export interface CreateMemoryInput {
-    query: string;
-    data: any;
-    userId?: string;
-    scope?: MemoryScope;
-    ttl?: number;
-}
-export interface CacheMemoryType {
-    id: string;
-    data: any;
-    query: string;
-    embedding: Embedding;
-    userId?: string;
-    scope: MemoryScope;
-    createdAt: Date;
-}
-export interface PersistentMemoryOptions {
-    host: string;
-    apiKey: string;
-    indexPrefix?: string;
-}
-export interface MemoryChunk {
-    content: string;
-    embedding: number[];
-}
-export type MemoryScopeType = (typeof MemoryScope)[keyof typeof MemoryScope];
-export interface LongTermMemory {
-    id: string;
-    query: string;
-    category: string;
-    data: any;
-    roomId: string;
-    createdAt: Date;
-    chunks?: MemoryChunk[];
-    tags: string[];
-}
-export declare const ActionSchema: z.ZodArray<z.ZodObject<{
-    name: z.ZodString;
-    parameters: z.ZodArray<z.ZodObject<{
-        name: z.ZodString;
-        value: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        value: string;
-        name: string;
-    }, {
-        value: string;
-        name: string;
-    }>, "many">;
-}, "strip", z.ZodTypeAny, {
-    name: string;
-    parameters: {
-        value: string;
-        name: string;
-    }[];
-}, {
-    name: string;
-    parameters: {
-        value: string;
-        name: string;
-    }[];
-}>, "many">;
-export declare enum MemoryType {
-    ACTION = "action",
-    CONVERSATION = "conversation",
-    KNOWLEDGE = "knowledge"
-}
-export declare enum MemoryScope {
-    GLOBAL = "global",
-    USER = "user"
-}
-export interface ActionData {
-    name?: string;
-    parameters?: Record<string, any>;
-}
-export interface QueueItemParameter {
-    name: string;
-    value: string;
-}
-export interface TransformedQueueItem {
-    name: string;
-    parameters: QueueItemParameter[];
-}
-export interface ScheduledAction {
-    id: string;
-    action: {
-        name: string;
-        parameters: QueueItemParameter[];
-    };
-    scheduledTime: Date;
-    userId: string;
-    status: "pending" | "completed" | "failed";
-    recurrence?: {
-        type: "daily" | "weekly" | "monthly";
-        interval: number;
-    };
-}
-export interface ScheduledActionEvents {
-    onActionStart?: (action: ScheduledAction) => void;
-    onActionComplete?: (action: ScheduledAction, result: any) => void;
-    onActionFailed?: (action: ScheduledAction, error: Error) => void;
-    onActionScheduled?: (action: ScheduledAction) => void;
-    onActionCancelled?: (actionId: string) => void;
-}
-export interface WorkflowPattern {
-    query: string;
-    actions: Array<{
-        done: boolean;
-        name: string;
-        result: string;
-    }>;
-    success: boolean;
-}