@ai.ntellect/core 0.6.16 → 0.6.19

package/dist/modules/embedding/index.js

@@ -0,0 +1,59 @@
+"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.Embedding = void 0;
+const ai_1 = require("ai");
+/**
+ * @module Embedding
+ * @description A module for generating and managing text embeddings.
+ * Provides functionality for converting text into vector representations
+ * and calculating similarities between embeddings.
+ * @implements {IEmbeddingModule}
+ */
+class Embedding {
+    /**
+     * Creates an instance of Embedding
+     * @param {IEmbeddingModel} embeddingModel - The embedding model implementation to use
+     */
+    constructor(embeddingModel) {
+        this.embeddingModel = embeddingModel;
+    }
+    /**
+     * Generates an embedding vector for a single text
+     * @param {string} text - The text to embed
+     * @returns {Promise<number[]>} The embedding vector
+     */
+    embedText(text) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.embeddingModel.embed(text);
+        });
+    }
+    /**
+     * Generates embedding vectors for multiple texts
+     * @param {string[]} texts - Array of texts to embed
+     * @returns {Promise<number[][]>} Array of embedding vectors
+     */
+    embedMany(texts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.embeddingModel.embedMany(texts);
+        });
+    }
+    /**
+     * Calculates the similarity score between two embeddings
+     * @param {number[]} embedding1 - First embedding vector
+     * @param {number[]} embedding2 - Second embedding vector
+     * @returns {number} Similarity score between 0 and 100
+     */
+    calculateSimilarity(embedding1, embedding2) {
+        return ((0, ai_1.cosineSimilarity)(embedding1, embedding2) + 1) * 50;
+    }
+}
+exports.Embedding = Embedding;

package/dist/modules/memory/adapters/in-memory/index.js

@@ -0,0 +1,210 @@
+"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.InMemoryAdapter = void 0;
+/**
+ * @module InMemoryAdapter
+ * @description In-memory implementation of the memory storage adapter.
+ * Provides a simple Map-based storage solution
+ * @implements {IMemoryAdapter}
+ */
+class InMemoryAdapter {
+    /**
+     * Creates an instance of InMemoryAdapter
+     */
+    constructor() {
+        this.storage = new Map();
+        this.jobs = new Map();
+        this.requests = new Map();
+    }
+    /**
+     * Initializes storage for a room
+     * @param {string} roomId - Room identifier
+     * @returns {Promise<void>}
+     */
+    init(roomId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.storage.has(roomId)) {
+                this.storage.set(roomId, []);
+            }
+        });
+    }
+    /**
+     * Creates a new memory entry
+     * @param {CreateMemoryInput & { embedding?: number[] }} input - Memory data with optional embedding
+     * @returns {Promise<BaseMemoryType | undefined>} Created memory or existing memory if duplicate
+     */
+    createMemory(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.init(input.roomId);
+            // Check if memory already exists
+            const memories = this.storage.get(input.roomId) || [];
+            const existingMemory = memories.find((m) => m.data === input.data);
+            if (existingMemory) {
+                return existingMemory;
+            }
+            // Create new memory
+            const memory = {
+                id: input.id || crypto.randomUUID(),
+                data: input.data,
+                embedding: input.embedding,
+                roomId: input.roomId,
+                createdAt: new Date(),
+            };
+            memories.push(memory);
+            this.storage.set(input.roomId, memories);
+            return memory;
+        });
+    }
+    /**
+     * Retrieves a memory by ID and room ID
+     * @param {string} id - Memory identifier
+     * @param {string} roomId - Room identifier
+     * @returns {Promise<BaseMemoryType | null>} Memory entry or null if not found
+     */
+    getMemoryById(id, roomId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const memories = this.storage.get(roomId) || [];
+            return memories.find((m) => m.id === id) || null;
+        });
+    }
+    /**
+     * Searches for memories based on query and options
+     * @param {string} query - Search query
+     * @param {Object} options - Search options
+     * @param {string} options.roomId - Room identifier
+     * @param {number} [options.limit] - Maximum number of results
+     * @returns {Promise<BaseMemoryType[]>} Array of matching memories
+     */
+    getMemoryByIndex(query, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const memories = this.storage.get(options.roomId) || [];
+            const filtered = memories.filter((m) => m.data.includes(query));
+            return filtered.slice(0, options.limit || filtered.length);
+        });
+    }
+    /**
+     * Retrieves all memories for a room
+     * @param {string} roomId - Room identifier
+     * @returns {Promise<BaseMemoryType[]>} Array of all memories
+     */
+    getAllMemories(roomId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.storage.get(roomId) || [];
+        });
+    }
+    /**
+     * Deletes a specific memory
+     * @param {string} id - Memory identifier
+     * @param {string} roomId - Room identifier
+     * @returns {Promise<void>}
+     */
+    clearMemoryById(id, roomId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const memories = this.storage.get(roomId) || [];
+            const filtered = memories.filter((m) => m.id !== id);
+            this.storage.set(roomId, filtered);
+        });
+    }
+    /**
+     * Clears all memories across all rooms
+     * @returns {Promise<void>}
+     */
+    clearAllMemories() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.storage.clear();
+            this.jobs.clear();
+            this.requests.clear();
+        });
+    }
+    /**
+     * Saves a job to the internal storage
+     * @param {string} id - Job identifier
+     * @param {ICronJob} job - Job data
+     * @returns {Promise<void>}
+     */
+    saveJob(id, job) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.jobs.set(id, job);
+        });
+    }
+    /**
+     * Saves a request to the internal storage
+     * @param {string} id - Request identifier
+     * @param {ScheduledRequest} request - Request data
+     * @returns {Promise<void>}
+     */
+    saveRequest(id, request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.requests.set(id, request);
+        });
+    }
+    /**
+     * Retrieves a job by ID
+     * @param {string} id - Job identifier
+     * @returns {Promise<ICronJob | undefined>} Job data or undefined if not found
+     */
+    getJob(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.jobs.get(id);
+        });
+    }
+    /**
+     * Retrieves a request by ID
+     * @param {string} id - Request identifier
+     * @returns {Promise<ScheduledRequest | undefined>} Request data or undefined if not found
+     */
+    getRequest(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.requests.get(id);
+        });
+    }
+    /**
+     * Deletes a job by ID
+     * @param {string} id - Job identifier
+     * @returns {Promise<void>}
+     */
+    deleteJob(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.jobs.delete(id);
+        });
+    }
+    /**
+     * Deletes a request by ID
+     * @param {string} id - Request identifier
+     * @returns {Promise<void>}
+     */
+    deleteRequest(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.requests.delete(id);
+        });
+    }
+    /**
+     * Retrieves all requests
+     * @returns {Promise<ScheduledRequest[]>} Array of all requests
+     */
+    getAllRequests() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Array.from(this.requests.values());
+        });
+    }
+    /**
+     * Clears all jobs and requests
+     * @returns {Promise<void>}
+     */
+    clear() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.jobs.clear();
+            this.requests.clear();
+        });
+    }
+}
+exports.InMemoryAdapter = InMemoryAdapter;

package/dist/{memory → modules/memory}/adapters/meilisearch/index.js

@@ -10,10 +10,28 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MeilisearchAdapter = void 0;
+/**
+ * @module MeilisearchAdapter
+ * @description Adapter implementation for Meilisearch as a memory storage solution.
+ * Provides integration with Meilisearch for storing and retrieving memory entries.
+ * @implements {IMemoryAdapter}
+ */
 class MeilisearchAdapter {
+    /**
+     * Creates an instance of MeilisearchAdapter
+     * @param {MeilisearchConfig} config - Configuration for Meilisearch connection
+     */
     constructor(config) {
         this.config = config;
     }
+    /**
+     * Makes an HTTP request to the Meilisearch API
+     * @private
+     * @param {string} path - API endpoint path
+     * @param {RequestInit} [options] - Fetch request options
+     * @returns {Promise<any>} Response data
+     * @throws {Error} If the request fails
+     */
     makeRequest(path, options) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
@@ -33,6 +51,12 @@ class MeilisearchAdapter {
             }
         });
     }
+    /**
+     * Initializes a storage index for a room
+     * @private
+     * @param {string} roomId - Room identifier to create index for
+     * @returns {Promise<void>}
+     */
     initializeStorage(roomId) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
@@ -72,6 +96,13 @@ class MeilisearchAdapter {
             }
         });
     }
+    /**
+     * Adds documents to the Meilisearch index
+     * @private
+     * @param {BaseMemoryType[]} documents - Documents to add
+     * @param {string} roomId - Room identifier
+     * @returns {Promise<void>}
+     */
     addDocuments(documents, roomId) {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.makeRequest(`/indexes/${roomId}/documents`, {
@@ -80,6 +111,12 @@ class MeilisearchAdapter {
             });
         });
     }
+    /**
+     * Deletes a storage index for a room
+     * @private
+     * @param {string} roomId - Room identifier
+     * @returns {Promise<void>}
+     */
     deleteStorage(roomId) {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.makeRequest(`/indexes/${roomId}`, {
@@ -87,7 +124,11 @@ class MeilisearchAdapter {
             });
         });
     }
-    // Required BaseMemory implementations
+    /**
+     * Initializes the adapter for a specific room
+     * @param {string} roomId - Room identifier
+     * @returns {Promise<void>}
+     */
     init(roomId) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
@@ -101,6 +142,16 @@ class MeilisearchAdapter {
             }
         });
     }
+    /**
+     * Performs a search in the Meilisearch index
+     * @private
+     * @param {string} query - Search query
+     * @param {string} roomId - Room identifier
+     * @param {Object} [options] - Search options
+     * @param {number} [options.limit] - Maximum number of results
+     * @param {number} [options.threshold] - Minimum score threshold
+     * @returns {Promise<SearchResult[]>} Search results
+     */
     search(query, roomId, options) {
         return __awaiter(this, void 0, void 0, function* () {
             const searchResults = yield this.makeRequest(`/indexes/${roomId}/search`, {
@@ -110,6 +161,9 @@ class MeilisearchAdapter {
                     limit: (options === null || options === void 0 ? void 0 : options.limit) || 10,
                 }),
             });
+            if (!searchResults.hits) {
+                return [];
+            }
             return searchResults.hits.map((hit) => ({
                 document: {
                     id: hit.id,
@@ -122,15 +176,27 @@ class MeilisearchAdapter {
             }));
         });
     }
+    /**
+     * Creates a new memory entry
+     * @param {CreateMemoryInput & { embedding?: number[] }} input - Memory data with optional embedding
+     * @returns {Promise<BaseMemoryType | undefined>} Created memory or undefined
+     */
     createMemory(input) {
         return __awaiter(this, void 0, void 0, function* () {
             // Initialize storage for this roomId if needed
             yield this.initializeStorage(input.roomId);
+            // Check if the memory already exists
+            const existingMemory = yield this.search(input.data, input.roomId, {
+                limit: 1,
+            });
+            if (existingMemory.length > 0) {
+                return existingMemory[0].document;
+            }
             // If not found, create new memory
             const memory = {
                 id: input.id || crypto.randomUUID(),
                 data: input.data,
-                embedding: input.embedding || null,
+                embedding: input.embedding,
                 roomId: input.roomId,
                 createdAt: new Date(),
             };
@@ -138,6 +204,12 @@ class MeilisearchAdapter {
             return memory;
         });
     }
+    /**
+     * Retrieves a memory by ID and room ID
+     * @param {string} id - Memory identifier
+     * @param {string} roomId - Room identifier
+     * @returns {Promise<BaseMemoryType | null>} Memory entry or null if not found
+     */
     getMemoryById(id, roomId) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
@@ -157,6 +229,14 @@ class MeilisearchAdapter {
             }
         });
     }
+    /**
+     * Searches for memories based on query and options
+     * @param {string} query - Search query
+     * @param {Object} options - Search options
+     * @param {string} options.roomId - Room identifier
+     * @param {number} [options.limit] - Maximum number of results
+     * @returns {Promise<BaseMemoryType[]>} Array of matching memories
+     */
     getMemoryByIndex(query, options) {
         return __awaiter(this, void 0, void 0, function* () {
             const results = yield this.search(query, options.roomId, {
@@ -173,6 +253,11 @@ class MeilisearchAdapter {
             }));
         });
     }
+    /**
+     * Retrieves all memories for a room
+     * @param {string} roomId - Room identifier
+     * @returns {Promise<BaseMemoryType[]>} Array of all memories
+     */
     getAllMemories(roomId) {
         return __awaiter(this, void 0, void 0, function* () {
             const results = yield this.makeRequest(`/indexes/${roomId}/documents`);
@@ -188,6 +273,12 @@ class MeilisearchAdapter {
             }));
         });
     }
+    /**
+     * Deletes a specific memory
+     * @param {string} id - Memory identifier
+     * @param {string} roomId - Room identifier
+     * @returns {Promise<void>}
+     */
     clearMemoryById(id, roomId) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
@@ -204,6 +295,10 @@ class MeilisearchAdapter {
             }
         });
     }
+    /**
+     * Clears all memories across all rooms
+     * @returns {Promise<void>}
+     */
     clearAllMemories() {
         return __awaiter(this, void 0, void 0, function* () {
             try {

package/dist/{memory → modules/memory}/adapters/redis/index.js

@@ -11,7 +11,20 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RedisAdapter = void 0;
 const redis_1 = require("redis");
+/**
+ * @module RedisAdapter
+ * @description Adapter implementation for Redis as a memory storage solution.
+ * Provides integration with Redis for storing and retrieving memory entries with TTL support.
+ * @implements {IMemoryAdapter}
+ */
 class RedisAdapter {
+    /**
+     * Creates an instance of RedisAdapter
+     * @param {string} redisUrl - Redis connection URL
+     * @param {Object} options - Configuration options
+     * @param {string} [options.cachePrefix="memory:"] - Prefix for Redis keys
+     * @param {number} [options.cacheTTL=3600] - Default TTL in seconds
+     */
     constructor(redisUrl, options) {
         this.redisUrl = redisUrl;
         this.cachePrefix = options.cachePrefix || "memory:";
@@ -24,36 +37,64 @@ class RedisAdapter {
             },
         });
     }
-    initializeConnection() {
+    /**
+     * Initializes the Redis connection
+     * @param {string} roomId - Room identifier
+     * @returns {Promise<void>}
+     */
+    init(roomId) {
         return __awaiter(this, void 0, void 0, function* () {
             this.redis.on("error", (err) => console.error("Redis Client Error:", err));
             yield this.redis.connect();
         });
     }
-    createMemory(memory, ttl) {
+    /**
+     * Creates a new memory entry in Redis
+     * @param {CreateMemoryInput & { embedding?: number[] }} input - Memory data with optional embedding
+     * @returns {Promise<BaseMemoryType | undefined>} Created memory or undefined
+     */
+    createMemory(input) {
         return __awaiter(this, void 0, void 0, function* () {
+            const memory = {
+                id: input.id || crypto.randomUUID(),
+                data: input.data,
+                embedding: input.embedding,
+                roomId: input.roomId,
+                createdAt: new Date(),
+            };
             const key = memory.roomId
                 ? `${this.cachePrefix}${memory.roomId}:${memory.id}`
                 : `${this.cachePrefix}${memory.id}`;
             yield this.redis.set(key, JSON.stringify(memory), {
-                EX: ttl || this.cacheTTL,
+                EX: this.cacheTTL,
             });
+            return memory;
         });
     }
+    /**
+     * Retrieves a memory by ID and room ID from Redis
+     * @param {string} id - Memory identifier
+     * @param {string} roomId - Room identifier
+     * @returns {Promise<BaseMemoryType | null>} Memory entry or null if not found
+     */
     getMemoryById(id, roomId) {
         return __awaiter(this, void 0, void 0, function* () {
-            const key = roomId
-                ? `${this.cachePrefix}${roomId}:${id}`
-                : `${this.cachePrefix}${id}`;
+            const key = `${this.cachePrefix}${roomId}:${id}`;
             const data = yield this.redis.get(key);
             return data ? JSON.parse(data) : null;
         });
     }
-    getMemoryByIndex(query_1) {
-        return __awaiter(this, arguments, void 0, function* (query, options = {}) {
-            const pattern = options.roomId
-                ? `${this.cachePrefix}${options.roomId}:*`
-                : `${this.cachePrefix}*`;
+    /**
+     * Searches for memories in Redis based on pattern matching
+     * @param {string} query - Search query
+     * @param {Object} options - Search options
+     * @param {string} options.roomId - Room identifier
+     * @param {number} [options.limit] - Maximum number of results
+     * @returns {Promise<BaseMemoryType[]>} Array of matching memories
+     */
+    getMemoryByIndex(query, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const pattern = `${this.cachePrefix}${options.roomId}:*`;
             const keys = yield this.redis.keys(pattern);
             const memories = yield Promise.all(keys.map((key) => __awaiter(this, void 0, void 0, function* () {
                 const data = yield this.redis.get(key);
@@ -62,9 +103,15 @@ class RedisAdapter {
             return memories.filter(Boolean).slice(0, options.limit || 10);
         });
     }
-    getAllMemories() {
+    /**
+     * Retrieves all memories for a room from Redis
+     * @param {string} roomId - Room identifier
+     * @returns {Promise<BaseMemoryType[]>} Array of all memories
+     */
+    getAllMemories(roomId) {
         return __awaiter(this, void 0, void 0, function* () {
-            const keys = yield this.redis.keys(`${this.cachePrefix}*`);
+            const pattern = `${this.cachePrefix}${roomId}:*`;
+            const keys = yield this.redis.keys(pattern);
             const memories = yield Promise.all(keys.map((key) => __awaiter(this, void 0, void 0, function* () {
                 const data = yield this.redis.get(key);
                 return data ? JSON.parse(data) : null;
@@ -72,11 +119,22 @@ class RedisAdapter {
             return memories.filter(Boolean);
         });
     }
-    clearMemoryById(id) {
+    /**
+     * Deletes a specific memory from Redis
+     * @param {string} id - Memory identifier
+     * @param {string} roomId - Room identifier
+     * @returns {Promise<void>}
+     */
+    clearMemoryById(id, roomId) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.redis.del(`${this.cachePrefix}${id}`);
+            const key = `${this.cachePrefix}${roomId}:${id}`;
+            yield this.redis.del(key);
         });
     }
+    /**
+     * Clears all memories across all rooms from Redis
+     * @returns {Promise<void>}
+     */
     clearAllMemories() {
         return __awaiter(this, void 0, void 0, function* () {
             const keys = yield this.redis.keys(`${this.cachePrefix}*`);
@@ -85,6 +143,10 @@ class RedisAdapter {
             }
         });
     }
+    /**
+     * Closes the Redis connection
+     * @returns {Promise<void>}
+     */
     quit() {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.redis) {