@ai.ntellect/core 0.6.21 → 0.7.0

package/test/graph/observer.test.ts

@@ -0,0 +1,398 @@
+import { expect } from "chai";
+import { BehaviorSubject, Subject } from "rxjs";
+import { z } from "zod";
+import { GraphFlow } from "../../graph";
+import { GraphObserver } from "../../graph/observer";
+import { GraphContext, GraphEvent, Node } from "../../types";
+
+/**
+ * Test schema definition for observer tests
+ * Defines a schema with:
+ * - value: numeric value for tracking state changes
+ * - status: enum representing node execution status
+ */
+const TestSchema = z.object({
+  value: z.number().default(0),
+  status: z.enum(["pending", "completed", "failed"]).optional(),
+});
+
+/**
+ * Test suite for the GraphObserver implementation
+ * This suite validates the reactive observation capabilities:
+ * - State observation (global and node-specific)
+ * - Property observation (single and multiple)
+ * - Event observation and correlation
+ * - Workflow monitoring
+ * - Node execution triggers
+ */
+describe("GraphObserver", () => {
+  let graph: GraphFlow<typeof TestSchema>;
+  let eventSubject: Subject<GraphEvent<typeof TestSchema>>;
+  let stateSubject: BehaviorSubject<GraphContext<typeof TestSchema>>;
+  let destroySubject: Subject<void>;
+  let observer: GraphObserver<typeof TestSchema>;
+
+  beforeEach(() => {
+    graph = new GraphFlow("TestGraph", {
+      name: "TestGraph",
+      nodes: [],
+      context: { value: 0 },
+      schema: TestSchema,
+    });
+
+    // Initialize subjects
+    eventSubject = new Subject();
+    stateSubject = new BehaviorSubject(graph.getContext());
+    destroySubject = new Subject();
+
+    // Create observer instance
+    observer = new GraphObserver(
+      graph,
+      eventSubject,
+      stateSubject,
+      destroySubject
+    );
+  });
+
+  /**
+   * Test suite for state observation functionality
+   * Validates the ability to track and react to state changes
+   * in the graph context
+   */
+  describe("State Observation", () => {
+    /**
+     * Tests sequential state change observation
+     * Validates that:
+     * - All state changes are captured in order
+     * - Multiple state changes in a single node are tracked
+     * - Initial state is included in observations
+     */
+    it("should observe state changes", async () => {
+      const states: any[] = [];
+      const testNode: Node<typeof TestSchema> = {
+        name: "testNode",
+        execute: async (context) => {
+          context.value = 1;
+          context.value = 2;
+          context.value = 3;
+        },
+      };
+
+      graph.addNode(testNode);
+      const subscription = graph
+        .observe()
+        .state()
+        .subscribe((state) => {
+          if (state.value !== undefined) {
+            states.push(state.value);
+          }
+        });
+
+      await graph.execute("testNode");
+      await new Promise((resolve) => setTimeout(resolve, 50));
+      subscription.unsubscribe();
+
+      expect(states).to.deep.equal([0, 1, 2, 3]);
+    });
+
+    /**
+     * Tests node-specific state observation
+     * Validates that:
+     * - State changes for specific nodes are tracked
+     * - Status transitions are captured correctly
+     * - Async state changes are properly observed
+     */
+    it("should observe specific node state changes", async () => {
+      const states: any[] = [];
+      const testNode: Node<typeof TestSchema> = {
+        name: "testNode",
+        execute: async (context) => {
+          context.status = "pending";
+          await new Promise((resolve) => setTimeout(resolve, 10));
+          context.status = "completed";
+        },
+      };
+
+      graph.addNode(testNode);
+      const subscription = graph
+        .observe()
+        .node("testNode")
+        .subscribe((state) => state.status && states.push(state.status));
+
+      await graph.execute("testNode");
+      await new Promise((resolve) => setTimeout(resolve, 50));
+      subscription.unsubscribe();
+
+      expect(states).to.deep.equal(["pending", "completed"]);
+    });
+
+    /**
+     * Tests multi-node state observation
+     * Validates that:
+     * - Multiple nodes can be observed simultaneously
+     * - State changes are correctly attributed to nodes
+     * - Sequential execution is properly tracked
+     */
+    it("should observe multiple nodes", async () => {
+      const states: any[] = [];
+      const node1: Node<typeof TestSchema> = {
+        name: "node1",
+        execute: async (context) => {
+          context.value = 1;
+        },
+      };
+      const node2: Node<typeof TestSchema> = {
+        name: "node2",
+        execute: async (context) => {
+          context.value = 2;
+        },
+      };
+
+      graph.addNode(node1);
+      graph.addNode(node2);
+
+      const subscription = graph
+        .observe()
+        .nodes(["node1", "node2"])
+        .subscribe((state) => state.value && states.push(state.value));
+
+      await graph.execute("node1");
+      await new Promise((resolve) => setTimeout(resolve, 50));
+      await graph.execute("node2");
+      await new Promise((resolve) => setTimeout(resolve, 50));
+      subscription.unsubscribe();
+
+      expect(states).to.deep.equal([1, 2]);
+    });
+  });
+
+  /**
+   * Test suite for property observation functionality
+   * Validates the ability to track specific properties
+   * of the graph context
+   */
+  describe("Property Observation", () => {
+    /**
+     * Tests single property observation
+     * Validates that:
+     * - Individual property changes are tracked
+     * - Initial property value is captured
+     * - Property updates trigger observations
+     */
+    it("should observe single property", async () => {
+      const values: any[] = [];
+      const testNode: Node<typeof TestSchema> = {
+        name: "testNode",
+        execute: async (context) => {
+          context.value = 42;
+        },
+      };
+
+      graph.addNode(testNode);
+      const subscription = graph
+        .observe()
+        .property("value")
+        .subscribe((state) => values.push(state.value));
+
+      await graph.execute("testNode");
+      subscription.unsubscribe();
+
+      expect(values).to.deep.equal([0, 42]);
+    });
+
+    /**
+     * Tests multiple property observation
+     * Validates that:
+     * - Multiple properties can be tracked simultaneously
+     * - Changes to any observed property trigger updates
+     * - Final state contains all tracked properties
+     */
+    it("should observe multiple properties", async () => {
+      const values: any[] = [];
+      const testNode: Node<typeof TestSchema> = {
+        name: "testNode",
+        execute: async (context) => {
+          context.value = 42;
+          context.status = "completed";
+        },
+      };
+
+      graph.addNode(testNode);
+      const subscription = graph
+        .observe()
+        .property(["value", "status"])
+        .subscribe((change) => {
+          const { name, ...rest } = change;
+          values.push(rest);
+        });
+
+      await graph.execute("testNode");
+      await new Promise((resolve) => setTimeout(resolve, 50));
+      subscription.unsubscribe();
+
+      expect(values[values.length - 1]).to.deep.equal({
+        value: 42,
+        status: "completed",
+      });
+    });
+
+    /**
+     * Tests condition-based observation
+     * Validates that:
+     * - Multiple conditions can be combined
+     * - Observation completes when conditions are met
+     * - State reflects all required changes
+     */
+    it("should wait for multiple conditions", async () => {
+      const testNode: Node<typeof TestSchema> = {
+        name: "testNode",
+        execute: async (context) => {
+          context.value = 42;
+          context.status = "completed";
+        },
+      };
+
+      graph.addNode(testNode);
+      const promise = graph
+        .observe()
+        .until(
+          graph.observe().property(["value", "status"]),
+          (state) => state.value === 42 && state.status === "completed"
+        );
+
+      await graph.execute("testNode");
+      await promise;
+
+      const context = graph.getContext();
+      expect(context.value).to.equal(42);
+      expect(context.status).to.equal("completed");
+    });
+  });
+
+  /**
+   * Test suite for event observation functionality
+   * Validates the handling of events and event correlation
+   */
+  describe("Event Observation", () => {
+    /**
+     * Tests specific event observation
+     */
+    it("should observe specific events", async () => {
+      const events: GraphEvent<typeof TestSchema>[] = [];
+      const subscription = graph
+        .observe()
+        .event("testEvent")
+        .subscribe((e) => events.push(e));
+
+      await graph.emit("testEvent", { value: 1 });
+      await new Promise((resolve) => setTimeout(resolve, 100));
+      subscription.unsubscribe();
+
+      expect(events.length).to.equal(1);
+      expect(events[0].type).to.equal("testEvent");
+    });
+
+    /**
+     * Tests debounced event handling
+     */
+    it("should handle debounced events", async () => {
+      const events: GraphEvent<typeof TestSchema>[] = [];
+      const subscription = graph
+        .observe()
+        .event("event1")
+        .subscribe((e) => events.push(e));
+
+      await graph.emit("event1", { value: 1 });
+      await graph.emit("event1", { value: 2 });
+      await new Promise((resolve) => setTimeout(resolve, 100));
+      subscription.unsubscribe();
+
+      expect(events.length).to.equal(2);
+    });
+
+    /**
+     * Tests event correlation functionality
+     * Validates that:
+     * - Multiple events can be correlated
+     * - Correlation conditions are properly evaluated
+     * - Timeout handling works correctly
+     * - Events are captured in correct order
+     */
+    it("should wait for correlated events", async () => {
+      // Create test events
+      const eventA = {
+        type: "eventA",
+        payload: { eventPayload: { status: "success" } },
+        timestamp: Date.now(),
+      } as GraphEvent<typeof TestSchema>;
+
+      const eventB = {
+        type: "eventB",
+        payload: { eventPayload: { status: "success" } },
+        timestamp: Date.now(),
+      } as GraphEvent<typeof TestSchema>;
+
+      // Emit events after a short delay
+      setTimeout(() => {
+        eventSubject.next(eventA);
+        eventSubject.next(eventB);
+      }, 100);
+
+      const events = await observer.waitForCorrelatedEvents(
+        ["eventA", "eventB"],
+        2000,
+        (events) =>
+          events.every((e) => e.payload.eventPayload?.status === "success")
+      );
+
+      expect(events.length).to.equal(2);
+      expect(events[0].type).to.equal("eventA");
+      expect(events[1].type).to.equal("eventB");
+    });
+
+    afterEach(() => {
+      destroySubject.next();
+      destroySubject.complete();
+      eventSubject.complete();
+      stateSubject.complete();
+    });
+  });
+
+  /**
+   * Test suite for workflow observation functionality
+   * Validates the ability to monitor complete workflow execution
+   */
+  describe("Workflow Observation", () => {
+    /**
+     * Tests complete workflow observation
+     * Validates that:
+     * - Entire workflow execution is tracked
+     * - State transitions are captured
+     * - Final state reflects completed workflow
+     */
+    it("should observe complete workflow", async () => {
+      const states: any[] = [];
+      const node: Node<typeof TestSchema> = {
+        name: "testNode",
+        execute: async (context) => {
+          context.status = "pending";
+          await new Promise((resolve) => setTimeout(resolve, 10));
+          context.status = "completed";
+        },
+      };
+
+      graph.addNode(node);
+      const subscription = graph
+        .observe()
+        .node("testNode")
+        .subscribe((state) => states.push(state));
+
+      await graph.execute("testNode");
+      await new Promise((resolve) => setTimeout(resolve, 50));
+      subscription.unsubscribe();
+
+      expect(states.length).to.be.greaterThan(0);
+      expect(states[states.length - 1].status).to.equal("completed");
+    });
+  });
+});

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

@@ -1,7 +1,8 @@
 import { expect } from "chai";
 import sinon from "sinon";
 import { Agenda } from "../../../modules/agenda";
-import { NodeCronAdapter } from "../../../modules/agenda/adapters/cron/node-cron";
+import { NodeCronAdapter } from "../../../modules/agenda/adapters/node-cron";
+import { Memory } from "../../../modules/memory";
 import { InMemoryAdapter } from "../../../modules/memory/adapters/in-memory";
 
 before(function () {
@@ -14,8 +15,9 @@ describe("Agenda Service", () => {
 
   beforeEach(() => {
     const cronService = new NodeCronAdapter();
-    const jobStorage = new InMemoryAdapter();
-    agenda = new Agenda(cronService, jobStorage);
+    const inMemory = new InMemoryAdapter();
+    const memory = new Memory(inMemory);
+    agenda = new Agenda(cronService, memory);
   });
 
   afterEach(async () => {
@@ -42,9 +44,9 @@ describe("Agenda Service", () => {
       scheduledIds.push(id); // Track the ID
 
       expect(id).to.be.a("string");
-      expect(agenda.getScheduledRequests()).to.have.lengthOf(1);
+      expect(await agenda.getScheduledRequests()).to.have.lengthOf(1);
 
-      const scheduledRequest = agenda.getScheduledRequests()[0];
+      const scheduledRequest = (await agenda.getScheduledRequests())[0];
       expect(scheduledRequest.originalRequest).to.equal(
         request.originalRequest
       );
@@ -103,13 +105,11 @@ describe("Agenda Service", () => {
 
       const id = await agenda.scheduleRequest(request);
       scheduledIds.push(id);
-      const requests = await agenda.getScheduledRequests();
-      expect(requests).to.have.lengthOf(1);
+      expect(await agenda.getScheduledRequests()).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);
+      expect(await agenda.getScheduledRequests()).to.have.lengthOf(0);
     });
 
     it("should return false when cancelling non-existent request", async () => {
@@ -139,6 +139,28 @@ describe("Agenda Service", () => {
       expect(scheduledRequests[0].originalRequest).to.equal("request 1");
       expect(scheduledRequests[1].originalRequest).to.equal("request 2");
     });
+
+    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);
+      }
+
+      expect(await agenda.getScheduledRequests()).to.have.lengthOf(2);
+
+      await agenda.stopAll();
+      expect(await agenda.getScheduledRequests()).to.have.lengthOf(0);
+    });
   });
 
   describe("Global Management", () => {
@@ -158,12 +180,10 @@ describe("Agenda Service", () => {
         await agenda.scheduleRequest(request);
       }
 
-      const initialRequests = await agenda.getScheduledRequests();
-      expect(initialRequests).to.have.lengthOf(2);
+      expect(await agenda.getScheduledRequests()).to.have.lengthOf(2);
 
       await agenda.stopAll();
-      const remainingRequests = await agenda.getScheduledRequests();
-      expect(remainingRequests).to.have.lengthOf(0);
+      expect(await agenda.getScheduledRequests()).to.have.lengthOf(0);
     });
   });
 
@@ -223,7 +243,7 @@ describe("Agenda Service", () => {
       }
 
       expect(onExecutedSpy.calledOnce).to.be.true;
-      expect(agenda.getScheduledRequests()).to.have.lengthOf(0);
+      expect(await agenda.getScheduledRequests()).to.have.lengthOf(0);
     });
 
     it("should log execution status", async function () {
@@ -270,8 +290,9 @@ describe("Agenda Service", () => {
 let globalAgenda: Agenda;
 before(() => {
   const cronService = new NodeCronAdapter();
-  const jobStorage = new InMemoryAdapter();
-  globalAgenda = new Agenda(cronService, jobStorage);
+  const inMemoryAdapter = new InMemoryAdapter();
+  const memory = new Memory(inMemoryAdapter);
+  globalAgenda = new Agenda(cronService, memory);
 });
 
 after(async () => {

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

@@ -1,6 +1,6 @@
 import { expect } from "chai";
-import { InMemoryAdapter } from "../../../memory/adapters/in-memory";
-import { BaseMemoryType } from "../../../types";
+import { InMemoryAdapter } from "../../../../modules/memory/adapters/in-memory";
+import { BaseMemoryType } from "../../../../types";
 
 describe("InMemoryAdapter", () => {
   let inMemoryAdapter: InMemoryAdapter;

package/test/modules/memory/adapters/meilisearch.test.ts

@@ -1,8 +1,7 @@
 import { expect } from "chai";
 import dotenv from "dotenv";
-import { MeilisearchAdapter } from "../../../memory/adapters/meilisearch";
-import { BaseMemoryType } from "../../../types";
-
+import { MeilisearchAdapter } from "../../../../modules/memory/adapters/meilisearch";
+import { BaseMemoryType } from "../../../../types";
 // Load environment variables
 dotenv.config();
 
@@ -126,7 +125,6 @@ describe("MeilisearchAdapter", () => {
 
       try {
         await meilisearchAdapter.init(TEST_ROOM_ID);
-        await meilisearchAdapter.initializeStorage(TEST_ROOM_ID);
       } catch (error) {
         console.error("Failed to initialize:", error);
         throw error;
@@ -134,14 +132,14 @@ describe("MeilisearchAdapter", () => {
     });
 
     it("should create memory", async () => {
-      const result = await meilisearchAdapter.createMemory({
+      const input = {
+        id: "test-id",
+        roomId: "test-room",
         data: "test data",
-        roomId: TEST_ROOM_ID,
-      });
+      };
 
-      expect(result).to.exist;
-      expect(result?.data).to.equal("test data");
-      expect(result?.embedding).to.be.null;
+      const result = await meilisearchAdapter.createMemory(input);
+      expect(result?.embedding).to.be.undefined;
     });
 
     it("should search memories", async () => {
@@ -161,27 +159,34 @@ describe("MeilisearchAdapter", () => {
     });
 
     it("should handle memory retrieval by ID", async () => {
+      const testDate = new Date("2025-02-11T08:24:38.251Z");
+
+      const mockData = {
+        id: "test-id",
+        roomId: "test-room",
+        data: "test data",
+        createdAt: testDate.toISOString(),
+        embedding: undefined,
+      };
+
       global.fetch = async (input: RequestInfo | URL) => {
         const url = input.toString();
-        if (url.includes(`/indexes/${TEST_ROOM_ID}/documents/test-id`)) {
-          return new Response(
-            JSON.stringify({
-              ...testMemory,
-              createdAt: testMemory.createdAt.toISOString(),
-            })
-          );
+        if (url.includes(`/indexes/test-room/documents/test-id`)) {
+          return new Response(JSON.stringify(mockData));
         }
         return new Response(JSON.stringify({}));
       };
 
       const result = await meilisearchAdapter.getMemoryById(
         "test-id",
-        TEST_ROOM_ID
+        "test-room"
       );
-      if (result) {
-        result.createdAt = new Date(result.createdAt);
-      }
-      expect(result).to.deep.equal(testMemory);
+
+      expect(result?.id).to.equal(mockData.id);
+      expect(result?.roomId).to.equal(mockData.roomId);
+      expect(result?.data).to.equal(mockData.data);
+      expect(result?.createdAt).to.equal(mockData.createdAt); // Compare directement les strings
+      expect(result?.embedding).to.be.undefined;
     });
 
     it("should handle non-existent memory", async () => {
@@ -276,8 +281,7 @@ describe("MeilisearchAdapter", () => {
         return new Response(JSON.stringify({}));
       };
 
-      await expect(meilisearchAdapter.initializeStorage(TEST_ROOM_ID)).to.not
-        .throw;
+      await expect(meilisearchAdapter.init(TEST_ROOM_ID)).to.not.throw;
     });
   });
 });

package/test/modules/memory/base.test.ts

@@ -201,14 +201,14 @@ describe("Memory", () => {
   describe("Edge Cases", () => {
     it("should handle undefined embedding", async () => {
       const input = {
-        data: "test data",
-        query: "test query",
+        id: "test-id",
         roomId: "test-room",
+        data: "test data",
         embedding: undefined,
       };
 
       const result = await memory.createMemory(input);
-      expect(result?.embedding).to.be.null;
+      expect(result?.embedding).to.be.undefined;
     });
 
     it("should handle empty query results", async () => {

package/tsconfig.json

@@ -7,7 +7,9 @@
     "strict": true,
     "skipLibCheck": true,
     "baseUrl": ".",
-    "outDir": "./dist"
+    "outDir": "./dist",
+    "types": ["node", "mocha"]
   },
-  "exclude": ["node_modules", "examples", "test", "app"]
+  "include": ["src/**/*", "graph/**/*", "types/**/*", "interfaces/**/*"],
+  "exclude": ["node_modules", "dist", "test", "examples"]
 }

package/types/index.ts

@@ -94,10 +94,18 @@ export interface Node<T extends ZodSchema, I = any> {
   condition?: (context: GraphContext<T>) => boolean;
   /** Array of next node names */
   next?: string[] | ((context: GraphContext<T>) => string[]);
-  /** Array of event names */
+  /** Array of event names that trigger this node */
   events?: string[];
-  /** Wait for event */
+  /** Wait for a single event before continuing */
   waitForEvent?: boolean;
+  /** Wait for multiple events configuration */
+  waitForEvents?: WaitForEvents;
+  /** Event correlation configuration */
+  correlateEvents?: {
+    events: string[];
+    correlation: (events: GraphEvent<T>[]) => boolean;
+    timeout?: number;
+  };
   /** Retry configuration */
   retry?: {
     /** Maximum number of retry attempts */
@@ -164,3 +172,16 @@ export type MeilisearchSettings = {
   /** Array of sortable attributes */
   sortableAttributes?: string[];
 };
+
+export interface GraphEvent<T extends ZodSchema> {
+  type: string;
+  payload?: any;
+  timestamp: number;
+}
+
+export interface WaitForEvents {
+  events: string[];
+  timeout?: number;
+  strategy: "all" | "any" | "race";
+  onSuccess?: <T extends ZodSchema>(context: GraphContext<T>) => Promise<void>;
+}