@ai.ntellect/core 0.0.24 → 0.0.26

package/dist/memory/index.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MemoryCache = void 0;
 const openai_1 = require("@ai-sdk/openai");
@@ -17,10 +8,9 @@ const zod_1 = require("zod");
 const types_1 = require("../types");
 class MemoryCache {
     constructor(options = {}) {
-        var _a, _b;
-        const ttlInHours = (_a = options.cacheTTL) !== null && _a !== void 0 ? _a : 1;
+        const ttlInHours = options.cacheTTL ?? 1;
         this.CACHE_TTL = ttlInHours * 60 * 60;
-        this.CACHE_PREFIX = (_b = options.cachePrefix) !== null && _b !== void 0 ? _b : 'memory:';
+        this.CACHE_PREFIX = options.cachePrefix ?? 'memory:';
         this.redis = (0, redis_1.createClient)({
             url: options.redisUrl || process.env.REDIS_URL,
             socket: {
@@ -30,21 +20,19 @@ class MemoryCache {
         });
         this.initRedis();
     }
-    initRedis() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.redis.on('error', err => {
-                console.error('Redis Client Error:', err);
-                // Implement retry logic if needed
-            });
-            try {
-                yield this.redis.connect();
-                console.log('Successfully connected to Redis');
-            }
-            catch (error) {
-                console.error('Failed to connect to Redis:', error);
-                // Handle connection failure
-            }
+    async initRedis() {
+        this.redis.on('error', err => {
+            console.error('Redis Client Error:', err);
+            // Implement retry logic if needed
         });
+        try {
+            await this.redis.connect();
+            console.log('Successfully connected to Redis');
+        }
+        catch (error) {
+            console.error('Failed to connect to Redis:', error);
+            // Handle connection failure
+        }
     }
     getMemoryKey(scope, userId) {
         if (scope === types_1.MemoryScope.GLOBAL) {
@@ -52,139 +40,129 @@ class MemoryCache {
         }
         return `${this.CACHE_PREFIX}user:${userId}:`;
     }
-    storeMemory(memory) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const prefix = this.getMemoryKey(memory.scope, memory.userId);
-            const key = `${prefix}${memory.id}`;
-            yield this.redis.set(key, JSON.stringify(memory), {
-                EX: this.CACHE_TTL
-            });
+    async storeMemory(memory) {
+        const prefix = this.getMemoryKey(memory.scope, memory.userId);
+        const key = `${prefix}${memory.id}`;
+        await this.redis.set(key, JSON.stringify(memory), {
+            EX: this.CACHE_TTL
         });
     }
-    findBestMatches(query_1) {
-        return __awaiter(this, arguments, void 0, function* (query, options = {}) {
-            console.log("\n🔍 Searching for query:", query);
-            const { embedding } = yield (0, ai_1.embed)({
-                model: openai_1.openai.embedding("text-embedding-3-small"),
-                value: query
+    async findBestMatches(query, options = {}) {
+        console.log("\n🔍 Searching for query:", query);
+        const { embedding } = await (0, ai_1.embed)({
+            model: openai_1.openai.embedding("text-embedding-3-small"),
+            value: query
+        });
+        const memories = await this.getAllMemories(options.scope, options.userId);
+        console.log("\n📚 Found", memories.length, "memories to compare with");
+        const matches = memories
+            .map(memory => {
+            const similarities = memory.embeddings.map(emb => {
+                const similarity = (0, ai_1.cosineSimilarity)(embedding, emb);
+                return (similarity + 1) * 50; // Convert to percentage
             });
-            const memories = yield this.getAllMemories(options.scope, options.userId);
-            console.log("\n📚 Found", memories.length, "memories to compare with");
-            const matches = memories
-                .map(memory => {
-                const similarities = memory.embeddings.map(emb => {
-                    const similarity = (0, ai_1.cosineSimilarity)(embedding, emb);
-                    return (similarity + 1) * 50; // Convert to percentage
-                });
-                const maxSimilarity = Math.max(...similarities);
-                console.log(`\n📊 Memory "${memory.purpose}":
+            const maxSimilarity = Math.max(...similarities);
+            console.log(`\n📊 Memory "${memory.purpose}":
           - Similarity: ${maxSimilarity.toFixed(2)}%
           - Original queries: ${memory.queries.join(", ")}`);
-                return {
-                    data: memory.data,
-                    similarityPercentage: maxSimilarity,
-                    purpose: memory.purpose,
-                };
-            })
-                .filter(match => { var _a; return match.similarityPercentage >= ((_a = options.similarityThreshold) !== null && _a !== void 0 ? _a : 70); })
-                .sort((a, b) => b.similarityPercentage - a.similarityPercentage);
-            const results = options.maxResults ? matches.slice(0, options.maxResults) : matches;
-            if (results.length > 0) {
-                console.log("\n✨ Best matches found:");
-                results.forEach(match => {
-                    console.log(`- ${match.purpose} (${match.similarityPercentage.toFixed(2)}%)`);
-                });
-            }
-            else {
-                console.log("No matches found");
-            }
-            console.dir({ results });
-            return results;
-        });
+            return {
+                data: memory.data,
+                similarityPercentage: maxSimilarity,
+                purpose: memory.purpose,
+            };
+        })
+            .filter(match => match.similarityPercentage >= (options.similarityThreshold ?? 70))
+            .sort((a, b) => b.similarityPercentage - a.similarityPercentage);
+        const results = options.maxResults ? matches.slice(0, options.maxResults) : matches;
+        if (results.length > 0) {
+            console.log("\n✨ Best matches found:");
+            results.forEach(match => {
+                console.log(`- ${match.purpose} (${match.similarityPercentage.toFixed(2)}%)`);
+            });
+        }
+        else {
+            console.log("No matches found");
+        }
+        console.dir({ results });
+        return results;
     }
-    getAllMemories(scope, userId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let patterns = [];
-            if (!scope || scope === types_1.MemoryScope.GLOBAL) {
-                const globalPrefix = this.getMemoryKey(types_1.MemoryScope.GLOBAL);
-                const globalKeys = yield this.redis.keys(`${globalPrefix}*`);
-                const globalPatterns = yield this.getMemoriesFromKeys(globalKeys);
-                patterns = patterns.concat(globalPatterns);
-            }
-            if (userId && (!scope || scope === types_1.MemoryScope.USER)) {
-                const userPrefix = this.getMemoryKey(types_1.MemoryScope.USER, userId);
-                const userKeys = yield this.redis.keys(`${userPrefix}*`);
-                const userPatterns = yield this.getMemoriesFromKeys(userKeys);
-                patterns = patterns.concat(userPatterns);
-            }
-            return patterns;
-        });
+    async getAllMemories(scope, userId) {
+        let patterns = [];
+        if (!scope || scope === types_1.MemoryScope.GLOBAL) {
+            const globalPrefix = this.getMemoryKey(types_1.MemoryScope.GLOBAL);
+            const globalKeys = await this.redis.keys(`${globalPrefix}*`);
+            const globalPatterns = await this.getMemoriesFromKeys(globalKeys);
+            patterns = patterns.concat(globalPatterns);
+        }
+        if (userId && (!scope || scope === types_1.MemoryScope.USER)) {
+            const userPrefix = this.getMemoryKey(types_1.MemoryScope.USER, userId);
+            const userKeys = await this.redis.keys(`${userPrefix}*`);
+            const userPatterns = await this.getMemoriesFromKeys(userKeys);
+            patterns = patterns.concat(userPatterns);
+        }
+        return patterns;
     }
-    getMemoriesFromKeys(keys) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const memories = [];
-            for (const key of keys) {
-                const data = yield this.redis.get(key);
-                if (data) {
-                    memories.push(JSON.parse(data));
-                }
+    async getMemoriesFromKeys(keys) {
+        const memories = [];
+        for (const key of keys) {
+            const data = await this.redis.get(key);
+            if (data) {
+                memories.push(JSON.parse(data));
             }
-            return memories;
-        });
+        }
+        return memories;
     }
-    createMemory(input) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { embedding } = yield (0, ai_1.embed)({
-                model: openai_1.openai.embedding("text-embedding-3-small"),
-                value: input.content
-            });
-            const existingPattern = yield this.findBestMatches(input.content, {
-                similarityThreshold: 95,
-                userId: input.userId,
-                scope: input.scope
+    async createMemory(input) {
+        const { embedding } = await (0, ai_1.embed)({
+            model: openai_1.openai.embedding("text-embedding-3-small"),
+            value: input.content
+        });
+        const existingPattern = await this.findBestMatches(input.content, {
+            similarityThreshold: 95,
+            userId: input.userId,
+            scope: input.scope
+        });
+        if (existingPattern.length > 0) {
+            console.log("\n🔍 Similar memory found:");
+            // Display only the name and similarity percentage
+            existingPattern.forEach(match => {
+                console.log(`- ${match.purpose} (${match.similarityPercentage.toFixed(2)}%)`);
             });
-            if (existingPattern.length > 0) {
-                console.log("\n🔍 Similar memory found:");
-                // Display only the name and similarity percentage
-                existingPattern.forEach(match => {
-                    console.log(`- ${match.purpose} (${match.similarityPercentage.toFixed(2)}%)`);
-                });
-                return;
-            }
-            const variations = yield (0, ai_1.generateObject)({
-                model: (0, openai_1.openai)("gpt-4"),
-                schema: zod_1.z.object({
-                    request: zod_1.z.string().describe("The request to be performed"),
-                    queries: zod_1.z.array(zod_1.z.object({
-                        text: zod_1.z.string()
-                    }))
-                }),
-                prompt: `For this input: "${input.content}"
+            return;
+        }
+        const variations = await (0, ai_1.generateObject)({
+            model: (0, openai_1.openai)("gpt-4"),
+            schema: zod_1.z.object({
+                request: zod_1.z.string().describe("The request to be performed"),
+                queries: zod_1.z.array(zod_1.z.object({
+                    text: zod_1.z.string()
+                }))
+            }),
+            prompt: `For this input: "${input.content}"
         Generate similar variations that should match the same context.
         Context type: ${input.type}
         Data: ${JSON.stringify(input.data)}
         - Keep variations natural and human-like
         - Include the original input
         - Add 3-5 variations`
-            });
-            const embeddingResults = yield (0, ai_1.embedMany)({
-                model: openai_1.openai.embedding("text-embedding-3-small"),
-                values: variations.object.queries.map(q => q.text)
-            });
-            const memory = {
-                id: crypto.randomUUID(),
-                type: input.type,
-                data: input.data,
-                purpose: variations.object.request,
-                queries: [input.content, ...variations.object.queries.map(q => q.text)],
-                embeddings: [embedding, ...embeddingResults.embeddings],
-                userId: input.userId,
-                scope: input.scope || (input.userId ? types_1.MemoryScope.USER : types_1.MemoryScope.GLOBAL),
-                createdAt: new Date()
-            };
-            yield this.storeMemory(memory);
-            return variations.object.request;
         });
+        const embeddingResults = await (0, ai_1.embedMany)({
+            model: openai_1.openai.embedding("text-embedding-3-small"),
+            values: variations.object.queries.map(q => q.text)
+        });
+        const memory = {
+            id: crypto.randomUUID(),
+            type: input.type,
+            data: input.data,
+            purpose: variations.object.request,
+            queries: [input.content, ...variations.object.queries.map(q => q.text)],
+            embeddings: [embedding, ...embeddingResults.embeddings],
+            userId: input.userId,
+            scope: input.scope || (input.userId ? types_1.MemoryScope.USER : types_1.MemoryScope.GLOBAL),
+            createdAt: new Date()
+        };
+        await this.storeMemory(memory);
+        return variations.object.request;
     }
 }
 exports.MemoryCache = MemoryCache;

package/dist/services/queue.d.ts

@@ -0,0 +1,13 @@
+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/queue.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ActionQueueManager = void 0;
 class ActionQueueManager {
@@ -20,7 +11,7 @@ class ActionQueueManager {
     }
     addToQueue(actions) {
         if (Array.isArray(actions)) {
-            console.log("Adding actions to queue:", actions.map(a => a.name).join(", "));
+            console.log("Adding actions to queue:", actions.map((a) => a.name).join(", "));
             this.queue.push(...actions);
         }
         else {
@@ -28,64 +19,60 @@ class ActionQueueManager {
             this.queue.push(actions);
         }
     }
-    processQueue() {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c, _d, _e;
-            if (this.isProcessing) {
-                console.warn("Queue is already being processed");
-                return;
-            }
-            this.isProcessing = true;
-            const actionPromises = [];
-            for (const action of this.queue) {
-                const actionConfig = this.actions.find((a) => a.name === action.name);
-                if ((_a = actionConfig === null || actionConfig === void 0 ? void 0 : actionConfig.confirmation) === null || _a === void 0 ? void 0 : _a.requireConfirmation) {
-                    // Wait for user confirmation before executing this action
-                    const shouldProceed = yield ((_c = (_b = this.callbacks).onConfirmationRequired) === null || _c === void 0 ? void 0 : _c.call(_b, actionConfig.confirmation.message || `Do you want to proceed with action: ${action.name}?`));
-                    if (!shouldProceed) {
-                        // Skip this action and add a cancelled result
-                        this.results.push({
-                            name: action.name,
-                            parameters: this.formatArguments(action.parameters),
-                            result: null,
-                            error: "Action cancelled by user",
-                            cancelled: true
-                        });
-                        continue;
-                    }
-                }
-                actionPromises.push(this.executeAction(action)
-                    .then((result) => {
-                    var _a, _b;
-                    (_b = (_a = this.callbacks).onActionComplete) === null || _b === void 0 ? void 0 : _b.call(_a, result);
-                    return result;
-                })
-                    .catch((error) => {
-                    var _a, _b;
-                    const result = {
+    async processQueue() {
+        if (this.isProcessing) {
+            console.warn("Queue is already being processed");
+            return;
+        }
+        this.isProcessing = true;
+        const actionPromises = [];
+        for (const action of this.queue) {
+            const actionConfig = this.actions.find((a) => a.name === action.name);
+            if (actionConfig?.confirmation?.requireConfirmation) {
+                // Wait for user confirmation before executing this action
+                const shouldProceed = await this.callbacks.onConfirmationRequired?.(actionConfig.confirmation.message ||
+                    `Do you want to proceed with action: ${action.name}?`);
+                if (!shouldProceed) {
+                    // Skip this action and add a cancelled result
+                    this.results.push({
                         name: action.name,
                         parameters: this.formatArguments(action.parameters),
                         result: null,
-                        error: error.message || "Unknown error occurred"
-                    };
-                    (_b = (_a = this.callbacks).onActionComplete) === null || _b === void 0 ? void 0 : _b.call(_a, result);
-                    return result;
-                }));
-            }
-            try {
-                const results = yield Promise.all(actionPromises);
-                this.results.push(...results);
-                this.queue = [];
-                (_e = (_d = this.callbacks).onQueueComplete) === null || _e === void 0 ? void 0 : _e.call(_d, this.results);
-                this.isProcessing = false;
-                return this.results;
-            }
-            catch (error) {
-                this.isProcessing = false;
-                console.error("Unexpected error in queue processing:", error);
-                throw error;
+                        error: "Action cancelled by user",
+                        cancelled: true,
+                    });
+                    continue;
+                }
             }
-        });
+            actionPromises.push(this.executeAction(action)
+                .then((result) => {
+                this.callbacks.onActionComplete?.(result);
+                return result;
+            })
+                .catch((error) => {
+                const result = {
+                    name: action.name,
+                    parameters: this.formatArguments(action.parameters),
+                    result: null,
+                    error: error.message || "Unknown error occurred",
+                };
+                this.callbacks.onActionComplete?.(result);
+                return result;
+            }));
+        }
+        try {
+            const results = await Promise.all(actionPromises);
+            this.results.push(...results);
+            this.queue = [];
+            this.callbacks.onQueueComplete?.(this.results);
+            this.isProcessing = false;
+            return this.results;
+        }
+        catch (error) {
+            this.isProcessing = false;
+            console.error("Unexpected error in queue processing:", error);
+            throw error;
+        }
     }
     formatArguments(args) {
         return args.reduce((acc, arg) => {
@@ -93,44 +80,45 @@ class ActionQueueManager {
             return acc;
         }, {});
     }
-    executeAction(action) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
-            // Call onActionStart callback
-            (_b = (_a = this.callbacks).onActionStart) === null || _b === void 0 ? void 0 : _b.call(_a, action);
-            const actionConfig = this.actions.find((a) => a.name === action.name);
-            if (!actionConfig) {
-                return {
-                    name: action.name,
-                    parameters: {},
-                    result: null,
-                    error: `Action '${action.name}' not found in actions list`,
-                };
-            }
-            const actionArgs = action.parameters.reduce((acc, arg) => {
-                acc[arg.name] = arg.value;
-                return acc;
-            }, {});
-            console.log(`Executing ${action.name} with args:`, actionArgs);
-            try {
-                const result = yield actionConfig.execute(actionArgs);
-                return {
-                    name: action.name,
-                    parameters: actionArgs,
-                    result,
-                    error: null,
-                };
-            }
-            catch (error) {
-                console.error(`Error executing action ${action.name}:`, error);
-                return {
-                    name: action.name,
-                    parameters: actionArgs,
-                    result: null,
-                    error: error.message || "Unknown error occurred",
-                };
-            }
-        });
+    async executeAction(action) {
+        // Call onActionStart callback
+        this.callbacks.onActionStart?.(action);
+        const actionConfig = this.actions.find((a) => a.name === action.name);
+        if (!actionConfig) {
+            return {
+                name: action.name,
+                parameters: {},
+                result: null,
+                error: `Action '${action.name}' not found in actions list`,
+            };
+        }
+        const actionArgs = action.parameters.reduce((acc, arg) => {
+            acc[arg.name] = arg.value;
+            return acc;
+        }, {});
+        try {
+            const result = await actionConfig.execute(actionArgs);
+            const actionResult = {
+                name: action.name,
+                parameters: actionArgs,
+                result,
+                error: null,
+            };
+            console.log("Action executed successfully: ", action.name);
+            console.dir(actionResult, { depth: null });
+            return actionResult;
+        }
+        catch (error) {
+            const actionResult = {
+                name: action.name,
+                parameters: actionArgs,
+                result: null,
+                error: error.message || "Unknown error occurred",
+            };
+            console.log("Action failed: ", action.name);
+            console.dir(actionResult, { depth: null });
+            return actionResult;
+        }
     }
 }
 exports.ActionQueueManager = ActionQueueManager;