@ai.ntellect/core 0.6.16 → 0.6.19

package/test/modules/agenda/node-cron.test.ts

@@ -0,0 +1,286 @@
+import { expect } from "chai";
+import sinon from "sinon";
+import { Agenda } from "../../../modules/agenda";
+import { NodeCronAdapter } from "../../../modules/agenda/adapters/cron/node-cron";
+import { InMemoryAdapter } from "../../../modules/memory/adapters/in-memory";
+
+before(function () {
+  this.timeout(10000);
+});
+
+describe("Agenda Service", () => {
+  let agenda: Agenda;
+  const scheduledIds: string[] = []; // Track all scheduled request IDs
+
+  beforeEach(() => {
+    const cronService = new NodeCronAdapter();
+    const jobStorage = new InMemoryAdapter();
+    agenda = new Agenda(cronService, jobStorage);
+  });
+
+  afterEach(async () => {
+    // Cancel all scheduled requests by their IDs
+    scheduledIds.forEach((id) => agenda.cancelScheduledRequest(id));
+    scheduledIds.length = 0; // Clear the array
+
+    // Ensure all tasks are stopped
+    await agenda.stop();
+
+    await agenda.cancel({});
+
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  });
+
+  describe("Request Scheduling", () => {
+    it("should schedule a new request and return an id", async () => {
+      const request = {
+        originalRequest: "test request",
+        cronExpression: "0 0 * * *",
+      };
+
+      const id = await agenda.scheduleRequest(request);
+      scheduledIds.push(id); // Track the ID
+
+      expect(id).to.be.a("string");
+      expect(agenda.getScheduledRequests()).to.have.lengthOf(1);
+
+      const scheduledRequest = agenda.getScheduledRequests()[0];
+      expect(scheduledRequest.originalRequest).to.equal(
+        request.originalRequest
+      );
+      expect(scheduledRequest.cronExpression).to.equal(request.cronExpression);
+      expect(scheduledRequest.isRecurring).to.be.false;
+
+      agenda.cancelScheduledRequest(id);
+    });
+
+    it("should execute callbacks when scheduling and executing", async function () {
+      this.timeout(5000);
+
+      const onScheduledSpy = sinon.spy();
+      const onExecutedSpy = sinon.spy();
+
+      const request = {
+        originalRequest: "test request",
+        cronExpression: `${(new Date().getSeconds() + 1) % 60} * * * * *`,
+      };
+
+      const id = await agenda.scheduleRequest(request, {
+        onScheduled: onScheduledSpy,
+        onExecuted: onExecutedSpy,
+      });
+      scheduledIds.push(id);
+
+      expect(onScheduledSpy.calledOnce).to.be.true;
+
+      await new Promise<void>((resolve, reject) => {
+        const timeout = setTimeout(() => {
+          reject(new Error("Callback execution timeout"));
+        }, 4000);
+
+        const checkExecution = () => {
+          if (onExecutedSpy.calledOnce) {
+            clearTimeout(timeout);
+            agenda.cancelScheduledRequest(id);
+            resolve();
+            return;
+          }
+          setTimeout(checkExecution, 100);
+        };
+        checkExecution();
+      });
+
+      expect(onExecutedSpy.calledOnce).to.be.true;
+    });
+  });
+
+  describe("Request Management", () => {
+    it("should cancel a scheduled request", async () => {
+      const request = {
+        originalRequest: "test request",
+        cronExpression: "*/1 * * * *",
+      };
+
+      const id = await agenda.scheduleRequest(request);
+      scheduledIds.push(id);
+      const requests = await agenda.getScheduledRequests();
+      expect(requests).to.have.lengthOf(1);
+
+      const cancelled = await agenda.cancelScheduledRequest(id);
+      expect(cancelled).to.be.true;
+      const remainingRequests = await agenda.getScheduledRequests();
+      expect(remainingRequests).to.have.lengthOf(0);
+    });
+
+    it("should return false when cancelling non-existent request", async () => {
+      const cancelled = await agenda.cancelScheduledRequest("non-existent-id");
+      expect(cancelled).to.be.false;
+    });
+
+    it("should get all scheduled requests", async () => {
+      const requests = [
+        {
+          originalRequest: "request 1",
+          cronExpression: "*/1 * * * *",
+        },
+        {
+          originalRequest: "request 2",
+          cronExpression: "*/5 * * * *",
+        },
+      ];
+
+      for (const request of requests) {
+        const id = await agenda.scheduleRequest(request);
+        scheduledIds.push(id);
+      }
+
+      const scheduledRequests = await agenda.getScheduledRequests();
+      expect(scheduledRequests).to.have.lengthOf(2);
+      expect(scheduledRequests[0].originalRequest).to.equal("request 1");
+      expect(scheduledRequests[1].originalRequest).to.equal("request 2");
+    });
+  });
+
+  describe("Global Management", () => {
+    it("should stop all scheduled requests", async () => {
+      const requests = [
+        {
+          originalRequest: "request 1",
+          cronExpression: "*/1 * * * *",
+        },
+        {
+          originalRequest: "request 2",
+          cronExpression: "*/5 * * * *",
+        },
+      ];
+
+      for (const request of requests) {
+        await agenda.scheduleRequest(request);
+      }
+
+      const initialRequests = await agenda.getScheduledRequests();
+      expect(initialRequests).to.have.lengthOf(2);
+
+      await agenda.stopAll();
+      const remainingRequests = await agenda.getScheduledRequests();
+      expect(remainingRequests).to.have.lengthOf(0);
+    });
+  });
+
+  describe("Error Handling", () => {
+    it("should handle execution errors gracefully", async () => {
+      const consoleSpy = sinon.spy(console, "error");
+
+      const request = {
+        originalRequest: "error request",
+        cronExpression: "0 0 * * *",
+      };
+
+      const id = await agenda.scheduleRequest(request);
+
+      // Wait for execution
+      await new Promise((resolve) => setTimeout(resolve, 1100));
+
+      expect(consoleSpy.called).to.be.false;
+
+      agenda.cancelScheduledRequest(id);
+      consoleSpy.restore();
+    });
+  });
+
+  describe("Request Execution", () => {
+    it("should execute non-recurring requests only once", async function () {
+      this.timeout(5000);
+      const onExecutedSpy = sinon.spy();
+
+      const request = {
+        originalRequest: "single execution",
+        cronExpression: `${new Date().getSeconds() + 1} * * * * *`,
+      };
+
+      const id = await agenda.scheduleRequest(request, {
+        onExecuted: onExecutedSpy,
+      });
+
+      try {
+        await new Promise<void>((resolve, reject) => {
+          const timeout = setTimeout(
+            () => reject(new Error("Test timeout")),
+            4000
+          );
+          const checkExecution = () => {
+            if (onExecutedSpy.calledOnce) {
+              clearTimeout(timeout);
+              resolve();
+              return;
+            }
+            setTimeout(checkExecution, 100);
+          };
+          checkExecution();
+        });
+      } finally {
+        agenda.cancelScheduledRequest(id);
+      }
+
+      expect(onExecutedSpy.calledOnce).to.be.true;
+      expect(agenda.getScheduledRequests()).to.have.lengthOf(0);
+    });
+
+    it("should log execution status", async function () {
+      this.timeout(10000);
+      const consoleLogSpy = sinon.spy(console, "log");
+
+      const request = {
+        originalRequest: "test request",
+        cronExpression: `${new Date().getSeconds() + 1} * * * * *`,
+      };
+
+      const id = await agenda.scheduleRequest(request);
+
+      await new Promise<void>((resolve) => {
+        const checkExecution = () => {
+          if (
+            consoleLogSpy.calledWith(`🔄 Executing scheduled request: ${id}`) &&
+            consoleLogSpy.calledWith(
+              `✅ Scheduled request executed successfully: ${id}`
+            )
+          ) {
+            agenda.cancelScheduledRequest(id);
+            resolve();
+            return;
+          }
+          setTimeout(checkExecution, 100);
+        };
+        checkExecution();
+      });
+
+      expect(consoleLogSpy.calledWith(`🔄 Executing scheduled request: ${id}`))
+        .to.be.true;
+      expect(
+        consoleLogSpy.calledWith(
+          `✅ Scheduled request executed successfully: ${id}`
+        )
+      ).to.be.true;
+
+      consoleLogSpy.restore();
+    });
+  });
+});
+
+let globalAgenda: Agenda;
+before(() => {
+  const cronService = new NodeCronAdapter();
+  const jobStorage = new InMemoryAdapter();
+  globalAgenda = new Agenda(cronService, jobStorage);
+});
+
+after(async () => {
+  if (globalAgenda) {
+    globalAgenda.stopAll();
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+
+  await globalAgenda.stop();
+  await globalAgenda.cancel({});
+  await new Promise((resolve) => setTimeout(resolve, 100));
+});

package/test/modules/embedding/ai.test.ts

@@ -0,0 +1,78 @@
+import { openai } from "@ai-sdk/openai";
+import { expect } from "chai";
+import { Embedding } from "../../../modules/embedding";
+import { AIEmbeddingAdapter } from "../../../modules/embedding/adapters/ai";
+
+describe("EmbeddingModule", () => {
+  let embeddingModule: Embedding;
+
+  before(function () {
+    this.timeout(10000);
+  });
+
+  beforeEach(() => {
+    const model = openai.embedding("text-embedding-3-small");
+    const embeddingModel = new AIEmbeddingAdapter(model);
+    embeddingModule = new Embedding(embeddingModel);
+  });
+
+  it("should embed text", async function () {
+    try {
+      const embedding = await embeddingModule.embedText("Hello, world!");
+      expect(embedding).to.be.an("array");
+      expect(embedding.length).to.be.greaterThan(0);
+      expect(embedding[0]).to.be.a("number");
+    } catch (error) {
+      console.error("Error in embedText:", error);
+      throw error;
+    }
+  });
+
+  it("should embed many texts", async function () {
+    try {
+      const embeddings = await embeddingModule.embedMany([
+        "Hello, world!",
+        "Another test text",
+      ]);
+      expect(embeddings).to.be.an("array");
+      expect(embeddings.length).to.equal(2);
+      expect(embeddings[0]).to.be.an("array");
+      expect(embeddings[0][0]).to.be.a("number");
+    } catch (error) {
+      console.error("Error in embedMany:", error);
+      throw error;
+    }
+  });
+
+  it("should calculate similarity between two embeddings", () => {
+    const embedding1 = [1, 2, 3];
+    const embedding2 = [4, 5, 6];
+    const similarity = embeddingModule.calculateSimilarity(
+      embedding1,
+      embedding2
+    );
+    expect(similarity).to.be.a("number");
+    expect(similarity).to.be.within(0, 100);
+  });
+
+  it("should handle embedding errors gracefully", async function () {
+    const mockEmbeddingAdapter = {
+      embed: async () => {
+        throw new Error("Mock embedding error");
+      },
+      embedMany: async () => {
+        throw new Error("Mock embedding error");
+      },
+    };
+
+    const mockEmbeddingModule = new Embedding(mockEmbeddingAdapter);
+
+    try {
+      await mockEmbeddingModule.embedText("test");
+      expect.fail("Should have thrown an error");
+    } catch (error) {
+      expect(error).to.exist;
+      expect((error as Error).message).to.equal("Mock embedding error");
+    }
+  });
+});

package/test/modules/memory/adapters/in-memory.test.ts

@@ -0,0 +1,153 @@
+import { expect } from "chai";
+import { InMemoryAdapter } from "../../../memory/adapters/in-memory";
+import { BaseMemoryType } from "../../../types";
+
+describe("InMemoryAdapter", () => {
+  let inMemoryAdapter: InMemoryAdapter;
+  const fixedDate = new Date("2025-01-30T07:43:50.626Z");
+  const TEST_ROOM_ID = "test-room";
+
+  const testMemory: BaseMemoryType = {
+    id: "test-id",
+    data: "test data",
+    roomId: TEST_ROOM_ID,
+    createdAt: fixedDate,
+  };
+
+  beforeEach(async () => {
+    inMemoryAdapter = new InMemoryAdapter();
+    await inMemoryAdapter.init(TEST_ROOM_ID);
+  });
+
+  describe("Initialization", () => {
+    it("should initialize storage", async () => {
+      await expect(inMemoryAdapter.init("new-room")).to.not.throw;
+      const memories = await inMemoryAdapter.getAllMemories("new-room");
+      expect(memories).to.be.an("array").that.is.empty;
+    });
+  });
+
+  describe("Memory Operations", () => {
+    it("should create memory", async () => {
+      const memory = await inMemoryAdapter.createMemory({
+        data: "test data",
+        roomId: TEST_ROOM_ID,
+        id: "test-id",
+        embedding: [0.1, 0.2, 0.3],
+      });
+
+      expect(memory).to.have.property("id");
+      expect(memory?.data).to.equal("test data");
+      expect(memory?.roomId).to.equal(TEST_ROOM_ID);
+    });
+
+    it("should not create duplicate memory", async () => {
+      // Create first memory
+      const memory1 = await inMemoryAdapter.createMemory({
+        data: "test data",
+        roomId: TEST_ROOM_ID,
+        id: "test-id",
+      });
+
+      // Try to create duplicate
+      const memory2 = await inMemoryAdapter.createMemory({
+        data: "test data",
+        roomId: TEST_ROOM_ID,
+        id: "another-id",
+      });
+
+      expect(memory2?.id).to.equal(memory1?.id);
+    });
+
+    it("should get memory by ID", async () => {
+      await inMemoryAdapter.createMemory({
+        data: testMemory.data,
+        roomId: testMemory.roomId,
+        id: testMemory.id,
+        embedding: testMemory.embedding,
+      });
+
+      const result = await inMemoryAdapter.getMemoryById(
+        "test-id",
+        TEST_ROOM_ID
+      );
+      expect(result).to.have.property("id", "test-id");
+    });
+
+    it("should get memories by index", async () => {
+      // Create test memories
+      await inMemoryAdapter.createMemory({
+        data: "test data one",
+        roomId: TEST_ROOM_ID,
+        id: "test-id-1",
+      });
+      await inMemoryAdapter.createMemory({
+        data: "test data two",
+        roomId: TEST_ROOM_ID,
+        id: "test-id-2",
+      });
+
+      const results = await inMemoryAdapter.getMemoryByIndex("one", {
+        roomId: TEST_ROOM_ID,
+        limit: 10,
+      });
+
+      expect(results).to.be.an("array");
+      expect(results).to.have.lengthOf(1);
+      expect(results[0].data).to.include("one");
+    });
+
+    it("should get all memories", async () => {
+      // Create multiple memories
+      await inMemoryAdapter.createMemory({
+        data: "test data 1",
+        roomId: TEST_ROOM_ID,
+        id: "test-id-1",
+      });
+      await inMemoryAdapter.createMemory({
+        data: "test data 2",
+        roomId: TEST_ROOM_ID,
+        id: "test-id-2",
+      });
+
+      const results = await inMemoryAdapter.getAllMemories(TEST_ROOM_ID);
+      expect(results).to.be.an("array");
+      expect(results).to.have.lengthOf(2);
+    });
+
+    it("should clear memory by ID", async () => {
+      // Create a memory
+      await inMemoryAdapter.createMemory({
+        data: "test data",
+        roomId: TEST_ROOM_ID,
+        id: "test-id",
+      });
+
+      await inMemoryAdapter.clearMemoryById("test-id", TEST_ROOM_ID);
+      const result = await inMemoryAdapter.getMemoryById(
+        "test-id",
+        TEST_ROOM_ID
+      );
+      expect(result).to.be.null;
+    });
+
+    it("should clear all memories", async () => {
+      // Create multiple memories
+      await inMemoryAdapter.createMemory({
+        data: "test data 1",
+        roomId: TEST_ROOM_ID,
+        id: "test-id-1",
+      });
+      await inMemoryAdapter.createMemory({
+        data: "test data 2",
+        roomId: TEST_ROOM_ID,
+        id: "test-id-2",
+      });
+
+      await inMemoryAdapter.clearAllMemories();
+      const results = await inMemoryAdapter.getAllMemories(TEST_ROOM_ID);
+      expect(results).to.be.an("array");
+      expect(results).to.have.lengthOf(0);
+    });
+  });
+});