@ai.ntellect/core 0.7.6 → 0.7.8

package/graph/node.ts

@@ -1,6 +1,7 @@
+import { IEventEmitter } from "interfaces";
 import { BehaviorSubject, Subject } from "rxjs";
 import { ZodSchema } from "zod";
-import { GraphContext, GraphEvent } from "../types";
+import { GraphContext, GraphEvent, Node } from "../types";
 import { GraphEventManager } from "./event-manager";
 
 /**
@@ -11,39 +12,13 @@ export interface NodeParams<T = any> {
   [key: string]: T;
 }
 
-export interface Node<T extends ZodSchema, I = any> {
-  condition?: (context: GraphContext<T>, params?: NodeParams) => boolean;
-  execute: (
-    context: GraphContext<T>,
-    inputs: I,
-    params?: NodeParams
-  ) => Promise<void>;
-  next?: string[] | ((context: GraphContext<T>) => string[]);
-  inputs?: ZodSchema;
-  outputs?: ZodSchema;
-  retry?: {
-    maxAttempts: number;
-    delay?: number;
-    onRetryFailed?: (error: Error, context: GraphContext<T>) => Promise<void>;
-    continueOnFailed?: boolean;
-  };
-  correlateEvents?: {
-    events: string[];
-    timeout?: number;
-    correlation: (events: GraphEvent<T>[]) => boolean;
-  };
-  waitForEvents?: {
-    events: string[];
-    timeout: number;
-  };
-}
-
 export interface GraphLogger {
   addLog: (message: string, data?: any) => void;
 }
 
 export class GraphNode<T extends ZodSchema> {
   private lastStateEvent: GraphEvent<T> | null = null;
+  private eventEmitter: IEventEmitter;
 
   /**
    * Creates a new GraphNode instance
@@ -59,7 +34,9 @@ export class GraphNode<T extends ZodSchema> {
     private eventManager: GraphEventManager<T>,
     private eventSubject: Subject<GraphEvent<T>>,
     private stateSubject: BehaviorSubject<GraphContext<T>>
-  ) {}
+  ) {
+    this.eventEmitter = eventManager["eventEmitter"];
+  }
 
   /**
    * Emits an event with the specified type and payload
@@ -102,32 +79,49 @@ export class GraphNode<T extends ZodSchema> {
    * Executes a node with the given name and context
    * @param nodeName - The name of the node to execute
    * @param context - The current graph context
-   * @param inputs - Input data for the node
+   * @param params - Input data for the node
    * @param triggeredByEvent - Whether the execution was triggered by an event
    * @throws Error if the node is not found or execution fails
    */
   public async executeNode(
     nodeName: string,
     context: GraphContext<T>,
-    inputs: any,
+    params: any,
     triggeredByEvent: boolean = false
   ): Promise<void> {
     const node = this.nodes.get(nodeName);
     if (!node) throw new Error(`Node "${nodeName}" not found.`);
 
-    // Créer une copie du contexte pour ce nœud
     const nodeContext = { ...context };
     this.emitEvent("nodeStarted", { name: nodeName, context: nodeContext });
 
     try {
+      if (node.correlateEvents) {
+        await this.eventManager.waitForCorrelatedEvents(
+          node.correlateEvents.events,
+          node.correlateEvents.timeout || 30000,
+          (events) => {
+            return node.correlateEvents!.correlation(events);
+          }
+        );
+      }
+
+      // Ensuite, attendre les événements si waitForEvents est défini
+      if (node.waitForEvents) {
+        await this.eventManager.waitForEvents(
+          node.waitForEvents.events,
+          node.waitForEvents.timeout
+        );
+      }
+
       const contextProxy = new Proxy(nodeContext, {
-        set: (target, prop, value) => {
-          const oldValue = target[prop];
+        set: (target: any, prop: string | symbol, value: any) => {
+          const oldValue = target[prop.toString()];
           if (oldValue === value) return true;
 
-          target[prop] = value;
+          target[prop.toString()] = value;
           // Mettre à jour le contexte global
-          context[prop as keyof typeof context] = value;
+          context[prop.toString() as keyof typeof context] = value;
 
           this.emitEvent("nodeStateChanged", {
             nodeName,
@@ -140,11 +134,11 @@ export class GraphNode<T extends ZodSchema> {
         },
       });
 
-      if (node.condition && !node.condition(contextProxy, inputs)) {
+      if (node.condition && !node.condition(contextProxy, params)) {
         return;
       }
 
-      await this.executeWithRetry(node, contextProxy, inputs, nodeName);
+      await this.executeWithRetry(node, contextProxy, nodeName, params);
       this.emitEvent("nodeCompleted", { name: nodeName, context: nodeContext });
 
       if (!triggeredByEvent && node.next) {
@@ -165,52 +159,30 @@ export class GraphNode<T extends ZodSchema> {
   }
 
   /**
-   * Validates the inputs for a node using its schema
-   * @param node - The node whose inputs need validation
-   * @param inputs - The input data to validate
+   * Validates the params for a node using its schema
+   * @param node - The node whose params need validation
+   * @param params - The input data to validate
    * @param nodeName - The name of the node (for error messages)
    * @throws Error if validation fails
    * @private
    */
-  private async validateInputs(
+  private async validateParams(
     node: Node<T, any>,
-    inputs: any,
+    params: any,
     nodeName: string
   ): Promise<void> {
-    if (!inputs) {
-      throw new Error(`Inputs required for node "${nodeName}"`);
-    }
+    // Si pas de schéma de validation ou si le schéma est optionnel, accepter n'importe quels params
+    if (!node.params || node.params.isOptional?.()) return;
 
-    try {
-      return node.inputs!.parse(inputs);
-    } catch (error: any) {
-      throw new Error(
-        error.errors?.[0]?.message || error.message || "Input validation failed"
-      );
+    // Vérifier les params uniquement si un schéma est défini et non optionnel
+    if (!params) {
+      throw new Error(`Params required for node "${nodeName}"`);
     }
-  }
 
-  /**
-   * Validates the outputs of a node against its schema
-   * @param node - The node whose outputs need validation
-   * @param context - The current graph context
-   * @param nodeName - The name of the node (for error messages)
-   * @throws Error if validation fails
-   * @private
-   */
-  private async validateOutputs(
-    node: Node<T, any>,
-    context: GraphContext<T>,
-    nodeName: string
-  ): Promise<void> {
     try {
-      node.outputs!.parse(context);
+      return node.params.parse(params);
     } catch (error: any) {
-      throw new Error(
-        error.errors?.[0]?.message ||
-          error.message ||
-          "Output validation failed"
-      );
+      throw error;
     }
   }
 
@@ -239,44 +211,30 @@ export class GraphNode<T extends ZodSchema> {
    * Executes a node with retry logic
    * @param node - The node to execute
    * @param contextProxy - The proxied graph context
-   * @param inputs - Input data for the node
+   * @param params - Input data for the node
    * @param nodeName - The name of the node
+   * @param params - Parameters for the node
    * @throws Error if all retry attempts fail
    * @private
    */
   private async executeWithRetry(
     node: Node<T, any>,
     contextProxy: GraphContext<T>,
-    inputs: any,
-    nodeName: string
+    nodeName: string,
+    params?: NodeParams
   ): Promise<void> {
     let attempts = 0;
     let lastError: Error = new Error("Unknown error");
 
     while (attempts < (node.retry?.maxAttempts || 1)) {
       try {
-        // Validation des inputs
-        if (node.inputs) {
-          try {
-            node.inputs.parse(inputs);
-          } catch (error: any) {
-            const message = error.errors?.[0]?.message || error.message;
-            throw new Error(`Input validation failed: ${message}`);
-          }
+        if (node.params) {
+          await this.validateParams(node, params, nodeName);
         }
 
-        // Exécution du node
-        await node.execute(contextProxy, inputs);
-
-        // Validation des outputs
-        if (node.outputs) {
-          try {
-            node.outputs.parse(contextProxy);
-          } catch (error: any) {
-            const message = error.errors?.[0]?.message || error.message;
-            throw new Error(`Output validation failed: ${message}`);
-          }
-        }
+        await node.execute(contextProxy, params, {
+          eventEmitter: this.eventEmitter,
+        });
         return;
       } catch (error: any) {
         lastError =

package/graph/observer.ts

@@ -21,6 +21,15 @@ import { GraphObservable } from "../interfaces";
 import { GraphContext, GraphEvent } from "../types";
 import { GraphFlow } from "./index";
 
+interface ObserverOptions {
+  debounce?: number;
+  delay?: number;
+  stream?: boolean;
+  properties?: (string | number)[]; // Accepte uniquement string ou number comme clés
+  onStreamLetter?: (data: { letter: string; property: string }) => void;
+  onStreamComplete?: () => void;
+}
+
 /**
  * GraphObserver class provides reactive observation capabilities for a GraphFlow instance
  * It allows monitoring state changes, node updates, and specific events in the graph
@@ -45,16 +54,7 @@ export class GraphObserver<T extends ZodSchema> {
    * @param options.onStreamComplete Callback when streaming is complete
    * @returns An Observable that emits the complete graph context whenever it changes
    */
-  state(
-    options: {
-      debounce?: number;
-      delay?: number;
-      stream?: boolean;
-      properties?: (keyof GraphContext<T>)[];
-      onStreamLetter?: (data: { letter: string; property: string }) => void;
-      onStreamComplete?: () => void;
-    } = {}
-  ): GraphObservable<T> {
+  state(options: ObserverOptions = {}): GraphObservable<T> {
     const baseObservable = new Observable<any>((subscriber) => {
       const subscription = combineLatest([
         this.eventSubject.pipe(

package/interfaces/index.ts

@@ -6,6 +6,7 @@ import {
   GraphContext,
   GraphEvent,
   ScheduledRequest,
+  SchemaType,
 } from "../types";
 
 /* ======================== EMBEDDING SERVICE ======================== */
@@ -525,7 +526,9 @@ export interface GraphObservable<T extends ZodSchema> extends Observable<any> {
    * Observes specific properties of the graph context
    * @param prop - Property or array of properties to observe
    */
-  property(prop: string | string[]): Observable<any>;
+  property(
+    prop: keyof SchemaType<T> | Array<keyof SchemaType<T>>
+  ): Observable<any>;
 
   /**
    * Observes specific events in the graph

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai.ntellect/core",
-  "version": "0.7.6",
+  "version": "0.7.8",
   "description": "",
   "main": "dist/index.js",
   "scripts": {

package/test/graph/event-manager.test.ts

@@ -69,4 +69,50 @@ describe("GraphEventManager", () => {
     eventManager.setupEventListeners();
     expect(eventEmitter.listenerCount("customEvent")).to.equal(1);
   });
+
+  it("should handle timeout for correlated events", async () => {
+    const timeout = 100;
+
+    try {
+      // N'émettre qu'un seul événement pour provoquer le timeout
+      eventManager.emitEvent("event1", { data: "test1" });
+
+      await eventManager.waitForCorrelatedEvents(
+        ["event1", "event2"],
+        timeout,
+        () => false // La fonction de corrélation retourne toujours false pour forcer le timeout
+      );
+      throw new Error("Should have timed out");
+    } catch (error: any) {
+      expect(error.message).to.include("Timeout waiting for correlated events");
+    }
+  });
+
+  it("should wait for multiple events before continuing", async () => {
+    let receivedEvents = 0;
+    let resolvePromise: (value: unknown) => void;
+    const eventPromise = new Promise((resolve) => {
+      resolvePromise = resolve;
+    });
+
+    // Configurer les écouteurs d'événements AVANT d'émettre
+    eventEmitter.on("event1", () => {
+      receivedEvents++;
+      if (receivedEvents === 2) resolvePromise(true);
+    });
+    eventEmitter.on("event2", () => {
+      receivedEvents++;
+      if (receivedEvents === 2) resolvePromise(true);
+    });
+
+    // Émettre les événements AVANT de démarrer l'attente
+    eventManager.emitEvent("event1", { data: "test1" });
+    eventManager.emitEvent("event2", { data: "test2" });
+
+    // Démarrer l'attente
+    const waitPromise = eventManager.waitForEvents(["event1", "event2"], 1000);
+
+    await Promise.race([waitPromise, eventPromise]);
+    expect(receivedEvents).to.equal(2);
+  });
 });