@ai.ntellect/core 0.4.1 → 0.6.0

package/dist/memory/persistent.js

@@ -1,189 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PersistentMemory = void 0;
-const ai_1 = require("ai");
-const text_splitter_1 = require("langchain/text_splitter");
-/**
- * Handles persistent memory storage using Meilisearch API
- */
-class PersistentMemory {
-    constructor(options) {
-        this.host = options.host;
-        this.apiKey = options.apiKey;
-        this.INDEX_PREFIX = options.indexPrefix || "memory";
-        this.embeddingModel = options.embeddingModel;
-    }
-    /**
-     * Initialize indexes
-     */
-    async init() {
-        try {
-            // Create or get main index
-            await this._getOrCreateIndex(this.INDEX_PREFIX);
-            console.log(`✅ Index '${this.INDEX_PREFIX}' initialized successfully`);
-        }
-        catch (error) {
-            console.error(`❌ Failed to initialize index: ${error}`);
-            throw error;
-        }
-    }
-    /**
-     * Make API request to Meilisearch
-     */
-    async _makeRequest(path, options = {}) {
-        const url = `${this.host}${path}`;
-        console.log("🔍 Making request to Meilisearch:", url);
-        const response = await fetch(url, {
-            ...options,
-            headers: {
-                "Content-Type": "application/json",
-                Authorization: `Bearer ${this.apiKey}`,
-                ...options.headers,
-            },
-        });
-        if (!response.ok) {
-            console.log({ response });
-            throw new Error(`Meilisearch API error: ${response.statusText}`);
-        }
-        return response.json();
-    }
-    /**
-     * Get or create an index with proper settings
-     */
-    async _getOrCreateIndex(indexName) {
-        try {
-            // Check if index exists first
-            const indexExists = await this._makeRequest(`/indexes/${indexName}`, {
-                method: "GET",
-            }).catch(() => false);
-            if (!indexExists) {
-                console.log(`Creating new index: ${indexName}`);
-                await this._makeRequest("/indexes", {
-                    method: "POST",
-                    body: JSON.stringify({
-                        uid: indexName,
-                        primaryKey: "id",
-                    }),
-                });
-            }
-            // Update index settings
-            const settings = {
-                searchableAttributes: ["query", "purpose", "chunks.content"],
-                sortableAttributes: ["createdAt"],
-            };
-            await this._makeRequest(`/indexes/${indexName}/settings`, {
-                method: "PATCH",
-                body: JSON.stringify(settings),
-            });
-            console.log(`Index ${indexName} configured successfully`);
-        }
-        catch (error) {
-            console.error(`Failed to configure index ${indexName}:`, error);
-            throw error;
-        }
-    }
-    async processContent(content) {
-        // Split content into chunks
-        const textSplitter = new text_splitter_1.RecursiveCharacterTextSplitter({
-            chunkSize: 1000,
-        });
-        const chunks = await textSplitter.createDocuments([content]);
-        // Generate embeddings for all chunks
-        const { embeddings } = await (0, ai_1.embedMany)({
-            model: this.embeddingModel,
-            values: chunks.map((chunk) => chunk.pageContent),
-        });
-        // Create processed chunks with embeddings
-        return chunks.map((chunk, i) => ({
-            content: chunk.pageContent,
-            embedding: embeddings[i],
-        }));
-    }
-    /**
-     * Store a memory in the database
-     */
-    async createMemory(memory) {
-        try {
-            console.log(`📝 Creating memory in index: ${this.INDEX_PREFIX}`);
-            // Process content into chunks with embeddings
-            const chunks = await this.processContent(memory.data);
-            // Generate unique ID if not provided
-            const id = memory.id || crypto.randomUUID();
-            const document = {
-                ...memory,
-                chunks,
-                createdAt: memory.createdAt.toISOString(),
-            };
-            const response = await this._makeRequest(`/indexes/${this.INDEX_PREFIX}/documents`, {
-                method: "POST",
-                body: JSON.stringify([document]),
-            });
-            console.log("✅ Memory created successfully", { id });
-            return response;
-        }
-        catch (error) {
-            console.error("❌ Failed to create memory:", error);
-            throw error;
-        }
-    }
-    /**
-     * Find best matching memories
-     */
-    async findRelevantDocuments(query, options = {}) {
-        console.log(`\n🔍 Searching in index: ${this.INDEX_PREFIX}`);
-        console.log("Query:", query);
-        try {
-            // Generate embedding for the query
-            const { embedding: queryEmbedding } = await (0, ai_1.embed)({
-                model: this.embeddingModel,
-                value: query,
-            });
-            // Search in the index
-            const searchResults = await this._makeRequest(`/indexes/${this.INDEX_PREFIX}/search`, {
-                method: "POST",
-                body: JSON.stringify({
-                    q: query,
-                    limit: options.maxResults || 10,
-                }),
-            });
-            if (!searchResults?.hits?.length) {
-                console.log("❌ No matches found");
-                return [];
-            }
-            // Process and filter results using cosine similarity
-            const results = searchResults.hits
-                .flatMap((hit) => {
-                const chunkSimilarities = hit.chunks.map((chunk) => ({
-                    query: hit.query,
-                    data: hit.data,
-                    similarityPercentage: ((0, ai_1.cosineSimilarity)(queryEmbedding, chunk.embedding) + 1) * 50,
-                    createdAt: hit.createdAt,
-                }));
-                return chunkSimilarities.reduce((best, current) => current.similarityPercentage > best.similarityPercentage
-                    ? current
-                    : best, chunkSimilarities[0]);
-            })
-                .filter((match) => match.similarityPercentage >= (options.similarityThreshold || 70))
-                .sort((a, b) => b.similarityPercentage - a.similarityPercentage);
-            console.log(`✨ Found ${results.length} relevant matches`);
-            return results.map((result) => ({
-                query: result.query,
-                data: result.data,
-                createdAt: result.createdAt,
-            }));
-        }
-        catch (error) {
-            console.error("❌ Search failed:", error);
-            return [];
-        }
-    }
-    /**
-     * Delete memories for a given scope and user
-     */
-    async deleteMemories() {
-        return this._makeRequest(`/indexes/${this.INDEX_PREFIX}`, {
-            method: "DELETE",
-        });
-    }
-}
-exports.PersistentMemory = PersistentMemory;

package/dist/services/queue.d.ts

@@ -1,13 +0,0 @@
-import { ActionSchema, QueueCallbacks, QueueItem, QueueResult } from "../types";
-export declare class ActionQueueManager {
-    private queue;
-    private results;
-    private callbacks;
-    private actions;
-    private isProcessing;
-    constructor(actions: ActionSchema[], callbacks?: QueueCallbacks);
-    addToQueue(actions: QueueItem | QueueItem[]): void;
-    processQueue(): Promise<QueueResult[] | undefined>;
-    private formatArguments;
-    private executeAction;
-}

package/dist/services/redis-cache.d.ts

@@ -1,37 +0,0 @@
-export interface CacheConfig {
-    host: string;
-    port: number;
-    password?: string;
-    ttl?: number;
-    cleanupInterval?: string;
-}
-export declare class RedisCache {
-    private redis;
-    private readonly defaultTTL;
-    private readonly cleanupJob;
-    constructor(config: CacheConfig);
-    /**
-     * Store previous actions for a specific request
-     */
-    storePreviousActions(requestId: string, actions: any[]): Promise<void>;
-    /**
-     * Get previous actions for a specific request
-     */
-    getPreviousActions(requestId: string): Promise<any[]>;
-    /**
-     * Store a recent message
-     */
-    storeRecentMessage(message: string, metadata?: Record<string, any>): Promise<void>;
-    /**
-     * Get recent messages
-     */
-    getRecentMessages(limit?: number): Promise<any[]>;
-    /**
-     * Cleanup expired keys
-     */
-    private cleanup;
-    /**
-     * Stop the cleanup job and close Redis connection
-     */
-    close(): Promise<void>;
-}

package/dist/services/redis-cache.js

@@ -1,93 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RedisCache = void 0;
-const ioredis_1 = __importDefault(require("ioredis"));
-const node_cron_1 = __importDefault(require("node-cron"));
-class RedisCache {
-    constructor(config) {
-        this.redis = new ioredis_1.default({
-            host: config.host,
-            port: config.port,
-            password: config.password,
-        });
-        this.defaultTTL = config.ttl || 1800; // 30 minutes in seconds
-        // Setup cleanup job (default: every 30 minutes)
-        this.cleanupJob = node_cron_1.default.schedule(config.cleanupInterval || "*/30 * * * *", () => this.cleanup());
-    }
-    /**
-     * Store previous actions for a specific request
-     */
-    async storePreviousActions(requestId, actions) {
-        const key = `previous_actions:${requestId}`;
-        await this.redis.setex(key, this.defaultTTL, JSON.stringify({
-            timestamp: new Date().toISOString(),
-            actions,
-        }));
-    }
-    /**
-     * Get previous actions for a specific request
-     */
-    async getPreviousActions(requestId) {
-        const key = `previous_actions:${requestId}`;
-        const data = await this.redis.get(key);
-        if (!data)
-            return [];
-        const parsed = JSON.parse(data);
-        return parsed.actions;
-    }
-    /**
-     * Store a recent message
-     */
-    async storeRecentMessage(message, metadata) {
-        const id = crypto.randomUUID();
-        const key = `recent_messages:${id}`;
-        await this.redis.setex(key, this.defaultTTL, JSON.stringify({
-            timestamp: new Date().toISOString(),
-            message,
-            metadata,
-        }));
-    }
-    /**
-     * Get recent messages
-     */
-    async getRecentMessages(limit = 10) {
-        const keys = await this.redis.keys("recent_messages:*");
-        if (!keys.length)
-            return [];
-        const messages = await Promise.all(keys.map(async (key) => {
-            const data = await this.redis.get(key);
-            return data ? JSON.parse(data) : null;
-        }));
-        return messages
-            .filter(Boolean)
-            .sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime())
-            .slice(0, limit);
-    }
-    /**
-     * Cleanup expired keys
-     */
-    async cleanup() {
-        console.log("🧹 Starting cache cleanup...");
-        try {
-            // Redis automatically removes expired keys
-            // This is just for logging purposes
-            const actionKeys = await this.redis.keys("previous_actions:*");
-            const messageKeys = await this.redis.keys("recent_messages:*");
-            console.log(`Cache status: ${actionKeys.length} actions, ${messageKeys.length} messages`);
-        }
-        catch (error) {
-            console.error("❌ Cache cleanup error:", error);
-        }
-    }
-    /**
-     * Stop the cleanup job and close Redis connection
-     */
-    async close() {
-        this.cleanupJob.stop();
-        await this.redis.quit();
-    }
-}
-exports.RedisCache = RedisCache;

package/dist/services/scheduler.d.ts

@@ -1,40 +0,0 @@
-import { AgentRuntime } from "../llm/orchestrator";
-import { RedisCache } from "./redis-cache";
-interface ScheduledRequest {
-    id: string;
-    originalRequest: string;
-    cronExpression: string;
-    isRecurring: boolean;
-    createdAt: Date;
-}
-export declare class TaskScheduler {
-    private scheduledRequests;
-    private cronJobs;
-    private readonly agentRuntime;
-    private readonly cache;
-    constructor(agentRuntime: AgentRuntime, cache: RedisCache);
-    /**
-     * Schedule a new request to be processed later
-     */
-    scheduleRequest(request: {
-        originalRequest: string;
-        cronExpression: string;
-    }): Promise<string>;
-    /**
-     * Execute a scheduled request by launching a new process
-     */
-    private executeScheduledRequest;
-    /**
-     * Cancel a scheduled request
-     */
-    cancelScheduledRequest(requestId: string): boolean;
-    /**
-     * Get all scheduled requests
-     */
-    getScheduledRequests(): ScheduledRequest[];
-    /**
-     * Stop all cron jobs
-     */
-    stopAll(): void;
-}
-export {};

package/dist/services/scheduler.js

@@ -1,99 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TaskScheduler = void 0;
-const node_cron_1 = __importDefault(require("node-cron"));
-class TaskScheduler {
-    constructor(agentRuntime, cache) {
-        this.scheduledRequests = new Map();
-        this.cronJobs = new Map();
-        this.agentRuntime = agentRuntime;
-        this.cache = cache;
-    }
-    /**
-     * Schedule a new request to be processed later
-     */
-    async scheduleRequest(request) {
-        const id = crypto.randomUUID();
-        const scheduledRequest = {
-            id,
-            originalRequest: request.originalRequest,
-            cronExpression: request.cronExpression,
-            isRecurring: false,
-            createdAt: new Date(),
-        };
-        // Create cron job
-        const cronJob = node_cron_1.default.schedule(request.cronExpression, async () => {
-            await this.executeScheduledRequest(scheduledRequest);
-            if (!scheduledRequest.isRecurring) {
-                this.cancelScheduledRequest(id);
-            }
-        });
-        // Store request and job
-        this.scheduledRequests.set(id, scheduledRequest);
-        this.cronJobs.set(id, cronJob);
-        console.log(`✅ Request scheduled with cron expression: ${request.cronExpression}`);
-        return id;
-    }
-    /**
-     * Execute a scheduled request by launching a new process
-     */
-    async executeScheduledRequest(request) {
-        try {
-            console.log(`🔄 Executing scheduled request from ${request.createdAt}`);
-            // Récupérer les actions précédentes du cache
-            const previousActions = await this.cache.getPreviousActions(request.id);
-            // Add context about when this request was scheduled
-            const contextualRequest = `You are a scheduler. 
-        You were asked to execute this request: ${request.originalRequest}\n 
-        Date of the request: ${request.createdAt.toISOString()}\n
-        Act like if you know the request was scheduled.
-        Don't reschedule the same action. 
-        Just execute it.`;
-            // Process the request as if it was just received
-            const result = await this.agentRuntime.process({
-                currentContext: contextualRequest,
-                previousActions,
-            });
-            // Store the new actions in cache
-            if (result.actions.length > 0) {
-                await this.cache.storePreviousActions(request.id, result.actions);
-            }
-            console.log(`✅ Scheduled request executed successfully`);
-        }
-        catch (error) {
-            console.error(`❌ Failed to execute scheduled request:`, error);
-        }
-    }
-    /**
-     * Cancel a scheduled request
-     */
-    cancelScheduledRequest(requestId) {
-        const cronJob = this.cronJobs.get(requestId);
-        if (cronJob) {
-            cronJob.stop();
-            this.cronJobs.delete(requestId);
-        }
-        return this.scheduledRequests.delete(requestId);
-    }
-    /**
-     * Get all scheduled requests
-     */
-    getScheduledRequests() {
-        return Array.from(this.scheduledRequests.values());
-    }
-    /**
-     * Stop all cron jobs
-     */
-    stopAll() {
-        for (const [id, cronJob] of this.cronJobs) {
-            cronJob.stop();
-            this.cronJobs.delete(id);
-            this.scheduledRequests.delete(id);
-        }
-        console.log("All scheduled requests stopped");
-    }
-}
-exports.TaskScheduler = TaskScheduler;

package/dist/services/telegram-monitor.js

@@ -1,118 +0,0 @@
-"use strict";
-// import dotenv from "dotenv";
-// import promptSync from "prompt-sync";
-// import { TelegramClient } from "telegram";
-// import { NewMessage } from "telegram/events";
-// import { StringSession } from "telegram/sessions";
-// dotenv.config();
-// const prompt = promptSync({ sigint: true });
-// export interface TokenLaunch {
-//   tokenAddress: string;
-//   messageUrl: string;
-//   timestamp: string;
-// }
-// export class TelegramMonitor {
-//   private client: TelegramClient;
-//   private botStartTime: Date;
-//   constructor() {
-//     if (!process.env.TELEGRAM_API_ID || !process.env.TELEGRAM_API_HASH) {
-//       throw new Error("TELEGRAM_API_ID and TELEGRAM_API_HASH must be set");
-//     }
-//     this.botStartTime = new Date();
-//     const apiId = parseInt(process.env.TELEGRAM_API_ID);
-//     const apiHash = process.env.TELEGRAM_API_HASH;
-//     // Utiliser une session stockée si disponible
-//     const sessionString = process.env.TELEGRAM_SESSION;
-//     this.client = new TelegramClient(
-//       new StringSession(sessionString),
-//       apiId,
-//       apiHash,
-//       {
-//         connectionRetries: 5,
-//       }
-//     );
-//   }
-//   async connect() {
-//     // Se connecter en tant qu'utilisateur
-//     await this.client.start({
-//       phoneNumber: async () => prompt("Numéro de téléphone ? "),
-//       password: async () => prompt("Mot de passe ? "),
-//       phoneCode: async () => prompt("Code reçu ? "),
-//       onError: (err) => console.log(err),
-//     });
-//     // Sauvegarder la session pour une utilisation ultérieure
-//     console.log("Session string à sauvegarder:", this.client.session.save());
-//   }
-//   async startMonitoring(
-//     channelUsername: string,
-//     callback: {
-//       onNewLaunch: (message: string) => void;
-//     }
-//   ) {
-//     console.log(`Démarrage du monitoring pour ${channelUsername}`);
-//     try {
-//       // S'assurer que le client est connecté
-//       if (!this.client.connected) {
-//         console.log("Client non connecté, tentative de connexion...");
-//         await this.client.connect();
-//         console.log("Client connecté avec succès");
-//       }
-//       console.log("État de la connexion:", this.client.connected);
-//       // Vérifier si le canal existe et est accessible
-//       try {
-//         const channel = await this.client.getEntity(channelUsername);
-//         console.log("Canal trouvé:", channel.id);
-//       } catch (e) {
-//         console.error("Erreur lors de l'accès au canal:", e);
-//       }
-//       this.client.addEventHandler(async (event: any) => {
-//         const message = event.message;
-//         if (!message) {
-//           console.log("Pas de message dans l'événement");
-//           return;
-//         }
-//         if (!message.text) {
-//           console.log("Message sans texte:", message);
-//           return;
-//         }
-//         try {
-//           callback.onNewLaunch(message.text);
-//         } catch (error) {
-//           console.error("Erreur lors du traitement du message:", error);
-//         }
-//       }, new NewMessage({ chats: [channelUsername] }));
-//       console.log("Handler d'événements ajouté avec succès");
-//     } catch (error) {
-//       console.error("Erreur lors du démarrage du monitoring:", error);
-//     }
-//   }
-//   static async generateNewSession() {
-//     // Supprimer la session existante
-//     const client = new TelegramClient(
-//       new StringSession(""),
-//       parseInt(process.env.TELEGRAM_API_ID || ""),
-//       process.env.TELEGRAM_API_HASH || "",
-//       {
-//         connectionRetries: 5,
-//       }
-//     );
-//     // Se connecter en tant qu'utilisateur
-//     await client.start({
-//       phoneNumber: async () => prompt("Numéro de téléphone ? "),
-//       password: async () => prompt("Mot de passe ? "),
-//       phoneCode: async () => prompt("Code reçu ? "),
-//       onError: (err) => console.log(err),
-//     });
-//     // Sauvegarder la nouvelle session pour une utilisation ultérieure
-//     console.log(
-//       "Nouvelle session string à sauvegarder:",
-//       client.session.save()
-//     );
-//   }
-// }
-// const telegramMonitor = new TelegramMonitor();
-// telegramMonitor.startMonitoring("testcalldegen", {
-//   onNewLaunch: (message: string) => {
-//     console.log("Nouveau message:", message);
-//   },
-// });

package/dist/t.d.ts

@@ -1,46 +0,0 @@
-export interface NetworkConfig {
-    name: string;
-    id?: number;
-    rpc: string;
-    explorerUrl: string;
-    nativeToken: string;
-}
-export declare const networkConfigs: Record<string, NetworkConfig>;
-export declare const getNetworkProvider: (networkName: string) => {
-    config: NetworkConfig;
-};
-import { z } from "zod";
-export type TransactionPrepared = {
-    to: string;
-    value: string;
-    data?: string;
-    chain: {
-        id: number;
-        rpc: string;
-    };
-    type: "transfer" | "approve" | "swap";
-    method?: string;
-    params?: any[];
-};
-export declare const prepareEvmTransaction: {
-    name: string;
-    description: string;
-    parameters: z.ZodObject<{
-        walletAddress: z.ZodString;
-        amount: z.ZodString;
-        network: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        walletAddress: string;
-        amount: string;
-        network: string;
-    }, {
-        walletAddress: string;
-        amount: string;
-        network: string;
-    }>;
-    execute: ({ walletAddress, amount, network, }: {
-        walletAddress: string;
-        amount: string;
-        network: string;
-    }) => Promise<TransactionPrepared>;
-};