@ai.ntellect/core 0.5.0 → 0.6.0

package/dist/test/memory/adapters/meilisearch.test.js

@@ -0,0 +1,250 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const meilisearch_1 = require("@/memory/adapters/meilisearch");
+const chai_1 = require("chai");
+const dotenv_1 = __importDefault(require("dotenv"));
+// Load environment variables
+dotenv_1.default.config();
+describe("MeilisearchAdapter", () => {
+    let meilisearchAdapter;
+    let mockBaseMemoryService;
+    const TEST_ROOM_ID = "test-room";
+    const testMemory = {
+        id: "test-id",
+        data: "test data",
+        query: "test query",
+        embedding: [0.1, 0.2, 0.3],
+        roomId: "test-room",
+        createdAt: new Date(),
+    };
+    beforeEach(() => {
+        // Use real Meilisearch if environment variables are set, otherwise mock
+        if (process.env.MEILISEARCH_HOST && process.env.MEILISEARCH_API_KEY) {
+            // Real Meilisearch configuration
+            // console.log("Real Meilisearch configuration");
+            meilisearchAdapter = new meilisearch_1.MeilisearchAdapter({
+                host: process.env.MEILISEARCH_HOST,
+                apiKey: process.env.MEILISEARCH_API_KEY,
+                searchableAttributes: ["content"],
+                sortableAttributes: ["createdAt"],
+            }, mockBaseMemoryService);
+        }
+        else {
+            // Mock fetch implementation
+            // console.log("Mock Meilisearch configuration");
+            global.fetch = (input, init) => __awaiter(void 0, void 0, void 0, function* () {
+                const url = input.toString();
+                // Mock for index check/creation
+                if (url.includes("/indexes")) {
+                    if ((init === null || init === void 0 ? void 0 : init.method) === "POST") {
+                        return new Response(JSON.stringify({ taskUid: 1 }));
+                    }
+                    if (url.endsWith("/indexes")) {
+                        return new Response(JSON.stringify({ results: [] }));
+                    }
+                    // Mock for specific index check
+                    if (url.includes(`/indexes/${TEST_ROOM_ID}`)) {
+                        return new Response(JSON.stringify({
+                            uid: TEST_ROOM_ID,
+                            primaryKey: "id",
+                        }));
+                    }
+                    if (url.includes("/indexes/memories")) {
+                        return new Response(JSON.stringify({
+                            uid: "memories",
+                            primaryKey: "id",
+                        }));
+                    }
+                }
+                // Mock for settings
+                if (url.includes("/settings")) {
+                    return new Response(JSON.stringify({ acknowledged: true }));
+                }
+                // Mock for documents
+                if (url.includes("/documents")) {
+                    if ((init === null || init === void 0 ? void 0 : init.method) === "POST") {
+                        return new Response(JSON.stringify({ taskUid: 2 }));
+                    }
+                    if ((init === null || init === void 0 ? void 0 : init.method) === "DELETE") {
+                        return new Response(JSON.stringify({ taskUid: 3 }));
+                    }
+                    return new Response(JSON.stringify([testMemory]));
+                }
+                return new Response(JSON.stringify({}));
+            });
+            mockBaseMemoryService = {
+                initializeConnection: () => __awaiter(void 0, void 0, void 0, function* () { }),
+                createMemory: () => __awaiter(void 0, void 0, void 0, function* () { }),
+                getMemoryById: () => __awaiter(void 0, void 0, void 0, function* () { return testMemory; }),
+                getMemoryByIndex: () => __awaiter(void 0, void 0, void 0, function* () { return [testMemory]; }),
+                getAllMemories: () => __awaiter(void 0, void 0, void 0, function* () { return [testMemory]; }),
+                clearMemoryById: () => __awaiter(void 0, void 0, void 0, function* () { }),
+                clearAllMemories: () => __awaiter(void 0, void 0, void 0, function* () { }),
+            };
+            meilisearchAdapter = new meilisearch_1.MeilisearchAdapter({
+                host: "http://localhost:7700",
+                apiKey: "aSampleMasterKey",
+                searchableAttributes: ["content"],
+                sortableAttributes: ["createdAt"],
+            }, mockBaseMemoryService);
+        }
+    });
+    describe("Initialization", () => {
+        it("should initialize storage", () => __awaiter(void 0, void 0, void 0, function* () {
+            yield (0, chai_1.expect)(meilisearchAdapter.init()).to.not.throw;
+        }));
+    });
+    describe("Memory Operations", () => {
+        beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
+            // Reset fetch mock for each test
+            if (!process.env.MEILISEARCH_HOST) {
+                global.fetch = (input, init) => __awaiter(void 0, void 0, void 0, function* () {
+                    const url = input.toString();
+                    // Mock for index check/creation
+                    if (url.includes("/indexes")) {
+                        if ((init === null || init === void 0 ? void 0 : init.method) === "POST") {
+                            return new Response(JSON.stringify({ taskUid: 1 }));
+                        }
+                        if (url.endsWith("/indexes")) {
+                            return new Response(JSON.stringify({ results: [] }));
+                        }
+                        // Mock for specific index check
+                        if (url.includes(`/indexes/${TEST_ROOM_ID}`)) {
+                            return new Response(JSON.stringify({
+                                uid: TEST_ROOM_ID,
+                                primaryKey: "id",
+                            }));
+                        }
+                        if (url.includes("/indexes/memories")) {
+                            return new Response(JSON.stringify({
+                                uid: "memories",
+                                primaryKey: "id",
+                            }));
+                        }
+                    }
+                    // Mock for settings
+                    if (url.includes("/settings")) {
+                        return new Response(JSON.stringify({ acknowledged: true }));
+                    }
+                    // Mock for documents
+                    if (url.includes("/documents")) {
+                        if ((init === null || init === void 0 ? void 0 : init.method) === "POST") {
+                            return new Response(JSON.stringify({ taskUid: 2 }));
+                        }
+                        if ((init === null || init === void 0 ? void 0 : init.method) === "DELETE") {
+                            return new Response(JSON.stringify({ taskUid: 3 }));
+                        }
+                        return new Response(JSON.stringify([testMemory]));
+                    }
+                    return new Response(JSON.stringify({}));
+                });
+            }
+            try {
+                yield meilisearchAdapter.init();
+                yield meilisearchAdapter.initializeStorage(TEST_ROOM_ID);
+            }
+            catch (error) {
+                console.error("Failed to initialize:", error);
+                throw error;
+            }
+        }));
+        it("should create memory", () => __awaiter(void 0, void 0, void 0, function* () {
+            const result = yield meilisearchAdapter.createMemory({
+                data: "test data",
+                query: "test query",
+                roomId: TEST_ROOM_ID,
+            });
+            (0, chai_1.expect)(result).to.exist;
+            (0, chai_1.expect)(result === null || result === void 0 ? void 0 : result.data).to.equal("test data");
+            (0, chai_1.expect)(result === null || result === void 0 ? void 0 : result.embedding).to.be.null;
+        }));
+        it("should search memories", () => __awaiter(void 0, void 0, void 0, function* () {
+            const results = yield meilisearchAdapter.getMemoryByIndex("test", {
+                roomId: TEST_ROOM_ID,
+                limit: 10,
+            });
+            (0, chai_1.expect)(results).to.be.an("array");
+            if (results.length > 0) {
+                const result = results[0];
+                if (result) {
+                    result.createdAt = new Date(result.createdAt);
+                }
+                (0, chai_1.expect)(result).to.deep.equal(testMemory);
+            }
+        }));
+        it("should handle memory retrieval by ID", () => __awaiter(void 0, void 0, void 0, function* () {
+            global.fetch = (input) => __awaiter(void 0, void 0, void 0, function* () {
+                const url = input.toString();
+                if (url.includes(`/indexes/${TEST_ROOM_ID}/documents/test-id`)) {
+                    return new Response(JSON.stringify(Object.assign(Object.assign({}, testMemory), { createdAt: testMemory.createdAt.toISOString() })));
+                }
+                return new Response(JSON.stringify({}));
+            });
+            const result = yield meilisearchAdapter.getMemoryById("test-id", TEST_ROOM_ID);
+            if (result) {
+                result.createdAt = new Date(result.createdAt);
+            }
+            (0, chai_1.expect)(result).to.deep.equal(testMemory);
+        }));
+        it("should handle non-existent memory", () => __awaiter(void 0, void 0, void 0, function* () {
+            global.fetch = () => __awaiter(void 0, void 0, void 0, function* () {
+                throw new Error("Not found");
+            });
+            const result = yield meilisearchAdapter.getMemoryById("non-existent", TEST_ROOM_ID);
+            (0, chai_1.expect)(result).to.be.null;
+        }));
+        it("should clear all memories", () => __awaiter(void 0, void 0, void 0, function* () {
+            yield (0, chai_1.expect)(meilisearchAdapter.clearAllMemories()).to.not.throw;
+        }));
+        it("should not create duplicate memory with same data", () => __awaiter(void 0, void 0, void 0, function* () {
+            // Create first memory
+            const firstMemory = yield meilisearchAdapter.createMemory({
+                data: "test data",
+                query: "test query",
+                roomId: TEST_ROOM_ID,
+            });
+            // Try to create second memory with same data
+            const secondMemory = yield meilisearchAdapter.createMemory({
+                data: "test data",
+                query: "test query",
+                roomId: TEST_ROOM_ID,
+            });
+            (0, chai_1.expect)(secondMemory).to.exist;
+            (0, chai_1.expect)(secondMemory === null || secondMemory === void 0 ? void 0 : secondMemory.id).to.equal(firstMemory === null || firstMemory === void 0 ? void 0 : firstMemory.id);
+            (0, chai_1.expect)(secondMemory === null || secondMemory === void 0 ? void 0 : secondMemory.data).to.equal(firstMemory === null || firstMemory === void 0 ? void 0 : firstMemory.data);
+            (0, chai_1.expect)(secondMemory === null || secondMemory === void 0 ? void 0 : secondMemory.query).to.equal(firstMemory === null || firstMemory === void 0 ? void 0 : firstMemory.query);
+            (0, chai_1.expect)(secondMemory === null || secondMemory === void 0 ? void 0 : secondMemory.roomId).to.equal(firstMemory === null || firstMemory === void 0 ? void 0 : firstMemory.roomId);
+        }));
+        it("should initialize storage", () => __awaiter(void 0, void 0, void 0, function* () {
+            global.fetch = (input, init) => __awaiter(void 0, void 0, void 0, function* () {
+                const url = input.toString();
+                // Mock pour la vérification de l'existence de l'index
+                if (url.includes(`/indexes/${TEST_ROOM_ID}`)) {
+                    return new Response(JSON.stringify({
+                        uid: TEST_ROOM_ID,
+                        primaryKey: "id",
+                    }));
+                }
+                // Mock pour les settings
+                if (url.includes("/settings")) {
+                    return new Response(JSON.stringify({ acknowledged: true }));
+                }
+                return new Response(JSON.stringify({}));
+            });
+            yield (0, chai_1.expect)(meilisearchAdapter.initializeStorage(TEST_ROOM_ID)).to.not
+                .throw;
+        }));
+    });
+});

package/dist/test/memory/adapters/redis.test.js

@@ -0,0 +1,143 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const redis_1 = require("@/memory/adapters/redis");
+const chai_1 = require("chai");
+const dotenv_1 = __importDefault(require("dotenv"));
+const ioredis_1 = __importDefault(require("ioredis"));
+// Load environment variables
+dotenv_1.default.config();
+describe("RedisAdapter", () => {
+    before(function () {
+        this.timeout(15000);
+    });
+    let redisAdapter;
+    let mockBaseMemoryService;
+    let redisClient = null;
+    const fixedDate = new Date("2025-01-30T07:43:50.626Z");
+    const testMemory = {
+        id: "test-id",
+        data: "test data",
+        query: "test query",
+        embedding: [0.1, 0.2, 0.3],
+        roomId: "test-room",
+        createdAt: fixedDate,
+    };
+    beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
+        mockBaseMemoryService = {
+            initializeConnection: () => __awaiter(void 0, void 0, void 0, function* () { }),
+            createMemory: () => __awaiter(void 0, void 0, void 0, function* () { }),
+            getMemoryById: () => __awaiter(void 0, void 0, void 0, function* () { return testMemory; }),
+            getMemoryByIndex: () => __awaiter(void 0, void 0, void 0, function* () { return [testMemory]; }),
+            getAllMemories: () => __awaiter(void 0, void 0, void 0, function* () { return [testMemory]; }),
+            clearMemoryById: () => __awaiter(void 0, void 0, void 0, function* () { }),
+            clearAllMemories: () => __awaiter(void 0, void 0, void 0, function* () { }),
+        };
+        // Use real Redis if environment variables are set, otherwise mock
+        if (process.env.REDIS_URL) {
+            redisClient = new ioredis_1.default(process.env.REDIS_URL);
+            redisAdapter = new redis_1.RedisAdapter(process.env.REDIS_URL, {
+                cachePrefix: "test-prefix",
+                cacheTTL: 3600,
+            });
+        }
+        else {
+            // Mock Redis implementation
+            const mockRedis = {
+                connect: () => __awaiter(void 0, void 0, void 0, function* () { }),
+                disconnect: () => __awaiter(void 0, void 0, void 0, function* () { }),
+                set: (key, value) => __awaiter(void 0, void 0, void 0, function* () { return "OK"; }),
+                get: (key) => __awaiter(void 0, void 0, void 0, function* () {
+                    if (key.includes("test-id")) {
+                        return JSON.stringify(Object.assign(Object.assign({}, testMemory), { createdAt: fixedDate.toISOString() }));
+                    }
+                    return null;
+                }),
+                keys: (pattern) => __awaiter(void 0, void 0, void 0, function* () {
+                    return [`${pattern}test-id`];
+                }),
+                mget: (keys) => __awaiter(void 0, void 0, void 0, function* () {
+                    return keys.map(() => JSON.stringify(Object.assign(Object.assign({}, testMemory), { createdAt: fixedDate.toISOString() })));
+                }),
+                del: () => __awaiter(void 0, void 0, void 0, function* () { return 1; }),
+                flushall: () => __awaiter(void 0, void 0, void 0, function* () { return "OK"; }),
+                quit: () => __awaiter(void 0, void 0, void 0, function* () { }),
+            };
+            redisAdapter = new redis_1.RedisAdapter(mockRedis, {
+                cachePrefix: "test-prefix",
+                cacheTTL: 3600,
+            });
+        }
+        yield redisAdapter.initializeConnection();
+    }));
+    afterEach(() => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
+        if (redisClient) {
+            yield redisClient.quit();
+            redisClient = null;
+        }
+        // @ts-ignore pour éviter l'erreur de typage
+        yield ((_a = redisAdapter === null || redisAdapter === void 0 ? void 0 : redisAdapter.quit) === null || _a === void 0 ? void 0 : _a.call(redisAdapter));
+    }));
+    describe("Initialization", () => {
+        it("should initialize storage", () => __awaiter(void 0, void 0, void 0, function* () {
+            yield (0, chai_1.expect)(redisAdapter.initializeConnection()).to.not.throw;
+        }));
+    });
+    describe("Memory Operations", () => {
+        const TEST_ROOM_ID = "test-room";
+        it("should create memory", () => __awaiter(void 0, void 0, void 0, function* () {
+            yield (0, chai_1.expect)(redisAdapter.createMemory({
+                data: "test data",
+                query: "test query",
+                roomId: TEST_ROOM_ID,
+                id: "test-id",
+                embedding: [0.1, 0.2, 0.3],
+                createdAt: fixedDate,
+            })).to.not.throw;
+        }));
+        it("should get memory by ID", () => __awaiter(void 0, void 0, void 0, function* () {
+            const result = yield redisAdapter.getMemoryById("test-id", TEST_ROOM_ID);
+            if (result) {
+                result.createdAt = new Date(result.createdAt);
+            }
+            (0, chai_1.expect)(result).to.deep.equal(Object.assign(Object.assign({}, testMemory), { createdAt: testMemory.createdAt }));
+        }));
+        it("should get memories by index", () => __awaiter(void 0, void 0, void 0, function* () {
+            const results = yield redisAdapter.getMemoryByIndex("test", {
+                roomId: TEST_ROOM_ID,
+                limit: 10,
+            });
+            (0, chai_1.expect)(results).to.be.an("array");
+            if (results[0]) {
+                results[0].createdAt = new Date(results[0].createdAt);
+            }
+            (0, chai_1.expect)(results[0]).to.deep.equal(testMemory);
+        }));
+        it("should get all memories", () => __awaiter(void 0, void 0, void 0, function* () {
+            const results = yield redisAdapter.getAllMemories();
+            (0, chai_1.expect)(results).to.be.an("array");
+            if (results[0]) {
+                results[0].createdAt = new Date(results[0].createdAt);
+            }
+            (0, chai_1.expect)(results[0]).to.deep.equal(testMemory);
+        }));
+        it("should clear memory by ID", () => __awaiter(void 0, void 0, void 0, function* () {
+            yield (0, chai_1.expect)(redisAdapter.clearMemoryById("test-id")).to.not.throw;
+        }));
+        it("should clear all memories", () => __awaiter(void 0, void 0, void 0, function* () {
+            yield (0, chai_1.expect)(redisAdapter.clearAllMemories()).to.not.throw;
+        }));
+    });
+});

package/dist/test/memory/base.test.js

@@ -0,0 +1,209 @@
+"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 });
+const memory_1 = require("@/memory");
+const chai_1 = require("chai");
+/**
+ * Test suite for the BaseMemory service
+ * This suite tests the memory management system that handles storage and retrieval of memory entries
+ */
+// Classe concrète pour tester BaseMemory
+class TestMemory extends memory_1.BaseMemory {
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.cacheService.initializeConnection();
+        });
+    }
+    createMemory(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const memory = {
+                id: crypto.randomUUID(),
+                data: input.data,
+                query: input.query,
+                embedding: input.embedding || null,
+                roomId: input.roomId,
+                createdAt: new Date(),
+            };
+            yield this.cacheService.createMemory(memory, input.ttl);
+            return memory;
+        });
+    }
+    getMemoryById(id, roomId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.cacheService.getMemoryById(id);
+        });
+    }
+    getMemoryByIndex(query, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.cacheService.getMemoryByIndex(query, options);
+        });
+    }
+    getAllMemories(roomId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.cacheService.getAllMemories();
+        });
+    }
+    clearMemoryById(id, roomId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.cacheService.clearMemoryById(id);
+        });
+    }
+    clearAllMemories() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.cacheService.clearAllMemories();
+        });
+    }
+}
+describe("BaseMemory", () => {
+    let memory;
+    let mockMemoryService;
+    const TEST_ROOM_ID = "test-room";
+    // Mock data for testing
+    const testMemory = {
+        id: "test-id",
+        data: "test data",
+        query: "test query",
+        embedding: [0.1, 0.2, 0.3],
+        roomId: "test-room",
+        createdAt: new Date(),
+    };
+    beforeEach(() => {
+        // Create mock implementation of BaseMemoryService
+        mockMemoryService = {
+            initializeConnection: () => __awaiter(void 0, void 0, void 0, function* () { return Promise.resolve(); }),
+            createMemory: (memory) => __awaiter(void 0, void 0, void 0, function* () { return Promise.resolve(); }),
+            getMemoryById: (id) => __awaiter(void 0, void 0, void 0, function* () { return Promise.resolve(testMemory); }),
+            getMemoryByIndex: (query, options) => __awaiter(void 0, void 0, void 0, function* () { return Promise.resolve([testMemory]); }),
+            getAllMemories: () => __awaiter(void 0, void 0, void 0, function* () { return Promise.resolve([testMemory]); }),
+            clearMemoryById: (id) => __awaiter(void 0, void 0, void 0, function* () { return Promise.resolve(); }),
+            clearAllMemories: () => __awaiter(void 0, void 0, void 0, function* () { return Promise.resolve(); }),
+        };
+        memory = new TestMemory(mockMemoryService);
+    });
+    describe("Initialization", () => {
+        it("should initialize the memory service", () => __awaiter(void 0, void 0, void 0, function* () {
+            let initCalled = false;
+            mockMemoryService.initializeConnection = () => __awaiter(void 0, void 0, void 0, function* () {
+                initCalled = true;
+            });
+            yield memory.init();
+            (0, chai_1.expect)(initCalled).to.be.true;
+        }));
+    });
+    describe("Memory Creation", () => {
+        it("should create a new memory entry", () => __awaiter(void 0, void 0, void 0, function* () {
+            const input = {
+                data: "test data",
+                query: "test query",
+                roomId: "test-room",
+                ttl: 3600,
+            };
+            const result = yield memory.createMemory(input);
+            (0, chai_1.expect)(result).to.exist;
+            (0, chai_1.expect)(result === null || result === void 0 ? void 0 : result.data).to.equal(input.data);
+            (0, chai_1.expect)(result === null || result === void 0 ? void 0 : result.query).to.equal(input.query);
+            (0, chai_1.expect)(result === null || result === void 0 ? void 0 : result.roomId).to.equal(input.roomId);
+            (0, chai_1.expect)(result === null || result === void 0 ? void 0 : result.id).to.be.a("string");
+        }));
+        it("should create memory with embedding", () => __awaiter(void 0, void 0, void 0, function* () {
+            const input = {
+                data: "test data",
+                query: "test query",
+                roomId: "test-room",
+                embedding: [0.1, 0.2, 0.3],
+            };
+            const result = yield memory.createMemory(input);
+            (0, chai_1.expect)(result === null || result === void 0 ? void 0 : result.embedding).to.deep.equal(input.embedding);
+        }));
+    });
+    describe("Memory Retrieval", () => {
+        it("should retrieve memory by ID", () => __awaiter(void 0, void 0, void 0, function* () {
+            const result = yield memory.getMemoryById("test-id", TEST_ROOM_ID);
+            (0, chai_1.expect)(result).to.deep.equal(testMemory);
+        }));
+        it("should retrieve memories by index", () => __awaiter(void 0, void 0, void 0, function* () {
+            const results = yield memory.getMemoryByIndex("test query", {
+                roomId: "test-room",
+                limit: 10,
+            });
+            (0, chai_1.expect)(results).to.be.an("array");
+            (0, chai_1.expect)(results[0]).to.deep.equal(testMemory);
+        }));
+        it("should retrieve all memories", () => __awaiter(void 0, void 0, void 0, function* () {
+            const results = yield memory.getAllMemories(TEST_ROOM_ID);
+            (0, chai_1.expect)(results).to.be.an("array");
+        }));
+    });
+    describe("Memory Clearing", () => {
+        it("should clear memory by ID", () => __awaiter(void 0, void 0, void 0, function* () {
+            yield memory.clearMemoryById("test-id", TEST_ROOM_ID);
+        }));
+        it("should clear all memories", () => __awaiter(void 0, void 0, void 0, function* () {
+            yield memory.clearAllMemories();
+        }));
+    });
+    describe("Error Handling", () => {
+        it("should handle errors during memory creation", () => __awaiter(void 0, void 0, void 0, function* () {
+            mockMemoryService.createMemory = () => __awaiter(void 0, void 0, void 0, function* () {
+                throw new Error("Creation failed");
+            });
+            try {
+                yield memory.createMemory({
+                    data: "test",
+                    query: "test",
+                    roomId: "test",
+                });
+                chai_1.expect.fail("Should have thrown an error");
+            }
+            catch (error) {
+                (0, chai_1.expect)(error).to.be.instanceOf(Error);
+                (0, chai_1.expect)(error.message).to.equal("Creation failed");
+            }
+        }));
+        it("should handle errors during memory retrieval", () => __awaiter(void 0, void 0, void 0, function* () {
+            mockMemoryService.getMemoryById = () => __awaiter(void 0, void 0, void 0, function* () {
+                throw new Error("Retrieval failed");
+            });
+            try {
+                yield memory.getMemoryById("test-id", TEST_ROOM_ID);
+                chai_1.expect.fail("Should have thrown an error");
+            }
+            catch (error) {
+                (0, chai_1.expect)(error).to.be.instanceOf(Error);
+                (0, chai_1.expect)(error.message).to.equal("Retrieval failed");
+            }
+        }));
+    });
+    describe("Edge Cases", () => {
+        it("should handle undefined embedding", () => __awaiter(void 0, void 0, void 0, function* () {
+            const input = {
+                data: "test data",
+                query: "test query",
+                roomId: "test-room",
+                embedding: undefined,
+            };
+            const result = yield memory.createMemory(input);
+            (0, chai_1.expect)(result === null || result === void 0 ? void 0 : result.embedding).to.be.null;
+        }));
+        it("should handle empty query results", () => __awaiter(void 0, void 0, void 0, function* () {
+            mockMemoryService.getMemoryByIndex = () => __awaiter(void 0, void 0, void 0, function* () { return []; });
+            const results = yield memory.getMemoryByIndex("nonexistent", {
+                roomId: "test-room",
+            });
+            (0, chai_1.expect)(results).to.be.an("array").that.is.empty;
+        }));
+        it("should handle non-existent memory ID", () => __awaiter(void 0, void 0, void 0, function* () {
+            mockMemoryService.getMemoryById = () => __awaiter(void 0, void 0, void 0, function* () { return null; });
+            const result = yield memory.getMemoryById("nonexistent", TEST_ROOM_ID);
+            (0, chai_1.expect)(result).to.be.null;
+        }));
+    });
+});