@ai.ntellect/core 0.3.3 → 0.4.0

package/dist/memory/cache.d.ts

@@ -1,20 +1,21 @@
-import { CacheMemoryOptions, CacheMemoryType, CreateMemoryInput, MatchOptions, MemoryScope, QueueResult } from "../types";
+import { CacheMemoryOptions, CacheMemoryType, CreateMemoryInput, MatchOptions, MemoryScope } from "../types";
 export declare class CacheMemory {
     private redis;
     private readonly CACHE_PREFIX;
     private readonly CACHE_TTL;
-    constructor(options?: CacheMemoryOptions);
+    private readonly embeddingModel;
+    constructor(options: CacheMemoryOptions);
     private initRedis;
     private storeMemory;
     findSimilarActions(query: string, options?: MatchOptions & {
         userId?: string;
         scope?: MemoryScope;
     }): Promise<{
-        actions: QueueResult[];
-        similarityPercentage: number;
+        data: any;
         query: string;
+        createdAt: Date;
     }[]>;
-    getAllMemories(scope?: MemoryScope, userId?: string): Promise<CacheMemoryType[]>;
+    getAllMemories(): Promise<CacheMemoryType[]>;
     private getMemoriesFromKeys;
     createMemory(input: CreateMemoryInput): Promise<CacheMemoryType | undefined>;
     private createSingleMemory;

package/dist/memory/cache.js

@@ -6,7 +6,8 @@ const ai_1 = require("ai");
 const redis_1 = require("redis");
 const types_1 = require("../types");
 class CacheMemory {
-    constructor(options = {}) {
+    constructor(options) {
+        this.embeddingModel = options.embeddingModel;
         const ttlInHours = options.cacheTTL ?? 1;
         this.CACHE_TTL = ttlInHours * 60 * 60;
         this.CACHE_PREFIX = options.cachePrefix ?? "memory:";
@@ -31,11 +32,11 @@ class CacheMemory {
             console.error("❌ Failed to connect to Redis:", error);
         }
     }
-    async storeMemory(memory) {
+    async storeMemory(memory, ttl) {
         const prefix = this.CACHE_PREFIX;
         const key = `${prefix}${memory.id}`;
         const result = await this.redis.set(key, JSON.stringify(memory), {
-            EX: this.CACHE_TTL,
+            EX: ttl || this.CACHE_TTL,
         });
         console.log("💾 Cache memory created:", result);
     }
@@ -47,14 +48,14 @@ class CacheMemory {
             model: openai_1.openai.embedding("text-embedding-3-small"),
             value: query,
         });
-        const memories = await this.getAllMemories(options.scope, options.userId);
+        const memories = await this.getAllMemories();
         console.log(`\n📚 Found ${memories.length} cached queries to compare`);
         const matches = memories
             .map((memory) => {
             const similarity = (0, ai_1.cosineSimilarity)(embedding, memory.embedding);
             const similarityPercentage = (similarity + 1) * 50;
             return {
-                actions: memory.data,
+                data: memory.data,
                 query: memory.query,
                 similarityPercentage,
                 createdAt: memory.createdAt,
@@ -71,6 +72,7 @@ class CacheMemory {
             results.forEach((match, index) => {
                 console.log(`\n${index + 1}. Match Details:`);
                 console.log(`   Query: ${match.query}`);
+                console.log(`   Data: ${JSON.stringify(match.data)}`);
                 console.log(`   Similarity: ${match.similarityPercentage.toFixed(2)}%`);
                 console.log("─".repeat(50));
             });
@@ -78,9 +80,15 @@ class CacheMemory {
         else {
             console.log("\n❌ No similar queries found in cache");
         }
-        return results;
+        return results.map((match) => {
+            return {
+                data: match.data,
+                query: match.query,
+                createdAt: match.createdAt,
+            };
+        });
     }
-    async getAllMemories(scope, userId) {
+    async getAllMemories() {
         const keys = await this.redis.keys(`${this.CACHE_PREFIX}*`);
         const memories = await this.getMemoriesFromKeys(keys);
         return memories;
@@ -97,10 +105,9 @@ class CacheMemory {
     }
     async createMemory(input) {
         console.log("\n📝 Processing new memory creation");
-        console.log("Content:", input.content);
-        console.log("Type:", input.type);
-        console.log("Scope:", input.scope);
-        const existingPattern = await this.findSimilarActions(input.content, {
+        console.log("Content:", input.query);
+        console.log("TTL:", input.ttl ? `${input.ttl} seconds` : "default");
+        const existingPattern = await this.findSimilarActions(input.query, {
             similarityThreshold: 95,
             userId: input.userId,
             scope: input.scope,
@@ -111,7 +118,8 @@ class CacheMemory {
             existingPattern.forEach((match, index) => {
                 console.log(`\n${index + 1}. Existing Match:`);
                 console.log(`   Query: ${match.query}`);
-                console.log(`   Similarity: ${match.similarityPercentage.toFixed(2)}%`);
+                console.log(`   Data: ${JSON.stringify(match.data)}`);
+                console.log(`   Created At: ${match.createdAt}`);
             });
             console.log("\n⏭️  Skipping creation of new memory");
             return;
@@ -119,36 +127,38 @@ class CacheMemory {
         console.log("\n🆕 No similar memory found - creating new one");
         const memory = await this.createSingleMemory({
             id: crypto.randomUUID(),
-            content: input.content,
-            type: input.type,
+            query: input.query,
             data: input.data,
             userId: input.userId,
             scope: input.scope,
+            ttl: input.ttl,
         });
         return memory;
     }
     async createSingleMemory(params) {
         console.log("\n🏗️  Creating new cache memory");
         console.log("ID:", params.id);
-        console.log("Content:", params.content);
+        console.log("Content:", params.query);
         console.log("\n🧮 Generating embedding...");
         const { embedding } = await (0, ai_1.embed)({
-            model: openai_1.openai.embedding("text-embedding-3-small"),
-            value: params.content,
+            model: this.embeddingModel,
+            value: params.query,
         });
         console.log("✅ Embedding generated successfully");
         const memory = {
             id: params.id,
-            type: params.type,
             data: params.data,
-            query: params.content,
+            query: params.query,
             embedding,
             userId: params.userId,
             scope: params.scope || (params.userId ? types_1.MemoryScope.USER : types_1.MemoryScope.GLOBAL),
             createdAt: new Date(),
         };
-        await this.storeMemory(memory);
-        console.log("✅ Memory created and stored successfully");
+        await this.storeMemory(memory, params.ttl);
+        console.log("✅ Short-term memory created and stored successfully", {
+            ...memory,
+            ttl: params.ttl || this.CACHE_TTL,
+        });
         return memory;
     }
 }

package/dist/memory/persistent.d.ts

@@ -1,4 +1,5 @@
-import { Memory, MemoryScope } from "../types";
+import { EmbeddingModel } from "ai";
+import { LongTermMemory, MemoryScope } from "../types";
 interface SearchOptions {
     scope?: MemoryScope;
     userId?: string;
@@ -16,10 +17,12 @@ export declare class PersistentMemory {
     private readonly host;
     private readonly apiKey;
     private readonly INDEX_PREFIX;
+    private readonly embeddingModel;
     constructor(options: {
         host: string;
         apiKey: string;
         indexPrefix?: string;
+        embeddingModel: EmbeddingModel<string>;
     });
     /**
      * Initialize indexes
@@ -37,14 +40,13 @@ export declare class PersistentMemory {
     /**
      * Store a memory in the database
      */
-    createMemory(memory: Memory): Promise<unknown>;
+    createMemory(memory: LongTermMemory): Promise<unknown>;
     /**
      * Find best matching memories
      */
     findRelevantDocuments(query: string, options?: SearchOptions): Promise<{
         query: string;
         data: any;
-        similarityPercentage: number;
         createdAt: string;
     }[]>;
     /**

package/dist/memory/persistent.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PersistentMemory = void 0;
-const openai_1 = require("@ai-sdk/openai");
 const ai_1 = require("ai");
 const text_splitter_1 = require("langchain/text_splitter");
 /**
@@ -12,19 +11,28 @@ class PersistentMemory {
         this.host = options.host;
         this.apiKey = options.apiKey;
         this.INDEX_PREFIX = options.indexPrefix || "memory";
+        this.embeddingModel = options.embeddingModel;
     }
     /**
      * Initialize indexes
      */
     async init() {
-        // Create global index
-        await this._getOrCreateIndex(this.INDEX_PREFIX);
+        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: {
@@ -44,14 +52,20 @@ class PersistentMemory {
      */
     async _getOrCreateIndex(indexName) {
         try {
-            // Try to create index
-            await this._makeRequest("/indexes", {
-                method: "POST",
-                body: JSON.stringify({
-                    uid: indexName,
-                    primaryKey: "id",
-                }),
-            });
+            // 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"],
@@ -61,12 +75,11 @@ class PersistentMemory {
                 method: "PATCH",
                 body: JSON.stringify(settings),
             });
+            console.log(`Index ${indexName} configured successfully`);
         }
         catch (error) {
-            // Index might already exist, which is fine
-            if (!error.message.includes("already exists")) {
-                throw error;
-            }
+            console.error(`Failed to configure index ${indexName}:`, error);
+            throw error;
         }
     }
     async processContent(content) {
@@ -77,7 +90,7 @@ class PersistentMemory {
         const chunks = await textSplitter.createDocuments([content]);
         // Generate embeddings for all chunks
         const { embeddings } = await (0, ai_1.embedMany)({
-            model: openai_1.openai.embedding("text-embedding-3-small"),
+            model: this.embeddingModel,
             values: chunks.map((chunk) => chunk.pageContent),
         });
         // Create processed chunks with embeddings
@@ -90,76 +103,79 @@ class PersistentMemory {
      * Store a memory in the database
      */
     async createMemory(memory) {
-        await this._getOrCreateIndex(memory.roomId);
-        const chunks = await this.processContent(memory.data);
-        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("Stored persistent memory response:", response);
-        return response;
+        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 persistent memory");
+        console.log(`\n🔍 Searching in index: ${this.INDEX_PREFIX}`);
         console.log("Query:", query);
-        console.log("Options:", JSON.stringify(options, null, 2));
-        // Generate embedding for the query
-        const { embedding: queryEmbedding } = await (0, ai_1.embed)({
-            model: openai_1.openai.embedding("text-embedding-3-small"),
-            value: query,
-        });
-        const searchResults = [];
-        console.log("\n📚 Searching in global index:", this.INDEX_PREFIX);
         try {
-            const globalResults = await this._makeRequest(`/indexes/${this.INDEX_PREFIX}/search`, {
+            // 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 }),
+                body: JSON.stringify({
+                    q: query,
+                    limit: options.maxResults || 10,
+                }),
             });
-            if (globalResults?.hits) {
-                searchResults.push(...globalResults.hits);
+            if (!searchResults?.hits?.length) {
+                console.log("❌ No matches found");
+                return [];
             }
-        }
-        catch (error) {
-            console.error("❌ Error searching global index:", error);
-        }
-        const totalResults = searchResults.length;
-        console.log(`\n📊 Found ${totalResults} total matches`);
-        // Process and filter results using cosine similarity
-        const results = searchResults
-            .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,
+            // 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,
             }));
-            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);
-        // Log filtered results in a more structured way
-        if (results.length > 0) {
-            console.log("\n✨ Relevant matches found:");
-            console.log("─".repeat(50));
-            results.forEach((match, index) => {
-                console.log(`\n${index + 1}. Match Details:`);
-                console.log(`   Query: ${match.query}`);
-            });
         }
-        else {
-            console.log("\n❌ No relevant matches found");
+        catch (error) {
+            console.error("❌ Search failed:", error);
+            return [];
         }
-        return results;
     }
     /**
      * Delete memories for a given scope and user

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

@@ -0,0 +1,37 @@
+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

@@ -0,0 +1,93 @@
+"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,17 +1,40 @@
-import { Orchestrator } from "../llm/orchestrator";
-import { ActionSchema, ScheduledAction, ScheduledActionEvents } from "../types";
-import { ActionQueueManager } from "./queue";
-export declare class ActionScheduler {
-    private actionQueueManager;
-    private orchestrator;
-    private scheduledActions;
-    private storage;
-    private events;
-    constructor(actionQueueManager: ActionQueueManager, orchestrator: Orchestrator, events?: ScheduledActionEvents);
-    scheduleAction(action: ActionSchema, scheduledTime: Date, userId: string, recurrence?: ScheduledAction["recurrence"]): Promise<string>;
-    private initializeScheduledActions;
-    private scheduleExecution;
-    private executeScheduledAction;
-    private calculateNextExecutionTime;
-    cancelScheduledAction(actionId: string): Promise<boolean>;
+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 {};