@ai.ntellect/core 0.7.13 → 0.8.0

package/graph/event-manager.ts

@@ -1,7 +1,12 @@
 import { Observable, Subject, filter } from "rxjs";
 import { ZodSchema } from "zod";
 import { IEventEmitter } from "../interfaces";
-import { GraphContext, GraphEvent, GraphNodeConfig } from "../types";
+import {
+  EventConfig,
+  GraphContext,
+  GraphEvent,
+  GraphNodeConfig,
+} from "../types";
 import { GraphNode } from "./node";
 
 /**
@@ -17,6 +22,7 @@ export class GraphEventManager<T extends ZodSchema> {
   private graphEvents?: string[];
   private entryNode?: string;
   private globalErrorHandler?: (error: Error, context: GraphContext<T>) => void;
+  private lastEvents = new Map<string, any>();
 
   /**
    * Creates a new GraphEventManager instance
@@ -72,14 +78,12 @@ export class GraphEventManager<T extends ZodSchema> {
     payload?: P,
     context?: GraphContext<T>
   ): void {
-    // Éviter la double imbrication des événements
     const event = {
       type,
       payload,
       timestamp: Date.now(),
     };
 
-    // Émettre l'événement une seule fois
     this.eventSubject.next(event);
     this.eventEmitter.emit(type, payload);
   }
@@ -248,6 +252,7 @@ export class GraphEventManager<T extends ZodSchema> {
    * @param data - Optional data to include with the event
    */
   emit(eventName: string, data?: any): void {
+    this.lastEvents.set(eventName, data);
     this.eventEmitter.emit(eventName, data);
   }
 
@@ -285,20 +290,9 @@ export class GraphEventManager<T extends ZodSchema> {
       throw new Error(`Node "${nodeName}" not found`);
     }
 
-    // Attendre les événements si waitForEvents est configuré
-    if (node.waitForEvents) {
-      try {
-        await this.waitForEvents(
-          node.waitForEvents.events,
-          node.waitForEvents.timeout
-        );
-      } catch (error) {
-        throw new Error(
-          `Timeout waiting for events in node "${nodeName}": ${
-            (error as Error).message
-          }`
-        );
-      }
+    // Remplacer le code existant de gestion d'événements
+    if (node.when) {
+      await this.handleNodeEvents(nodeName, node.when);
     }
 
     return this.nodeExecutor.executeNode(
@@ -309,21 +303,54 @@ export class GraphEventManager<T extends ZodSchema> {
     );
   }
 
-  async waitForCorrelatedEvents(
+  /**
+   * Waits for correlated events to occur and validates them using a correlation function
+   */
+  waitForCorrelatedEvents(
     eventTypes: string[],
     timeoutMs: number,
     correlationFn: (events: GraphEvent<T>[]) => boolean
   ): Promise<GraphEvent<T>[]> {
     return new Promise((resolve, reject) => {
       const receivedEvents = new Map<string, GraphEvent<T>>();
+      const eventHandlers = new Map();
       let isResolved = false;
 
+      const cleanup = () => {
+        eventHandlers.forEach((handler, event) => {
+          this.eventEmitter.removeListener(event, handler);
+        });
+      };
+
+      eventTypes.forEach((eventType) => {
+        const handler = (eventData: any) => {
+          if (!isResolved) {
+            const event: GraphEvent<T> = {
+              type: eventType,
+              payload: eventData,
+              timestamp: Date.now(),
+            };
+            receivedEvents.set(eventType, event);
+
+            if (eventTypes.every((type) => receivedEvents.has(type))) {
+              const events = Array.from(receivedEvents.values());
+              if (correlationFn(events)) {
+                isResolved = true;
+                clearTimeout(timeoutId);
+                cleanup();
+                resolve(events);
+              }
+            }
+          }
+        };
+
+        eventHandlers.set(eventType, handler);
+        this.eventEmitter.on(eventType, handler);
+      });
+
       const timeoutId = setTimeout(() => {
         if (!isResolved) {
-          isResolved = true;
-          eventTypes.forEach((type) => {
-            this.eventEmitter.removeAllListeners(type);
-          });
+          cleanup();
           reject(
             new Error(
               `Timeout waiting for correlated events: ${eventTypes.join(", ")}`
@@ -331,33 +358,99 @@ export class GraphEventManager<T extends ZodSchema> {
           );
         }
       }, timeoutMs);
+    });
+  }
+
+  /**
+   * Handles events based on the node's event handler configuration
+   */
+  async handleNodeEvents(
+    nodeName: string,
+    config: EventConfig
+  ): Promise<any[]> {
+    const { events, timeout = 30000, strategy } = config;
+
+    return new Promise((resolve, reject) => {
+      const receivedEvents = new Map<string, any>();
+      const eventHandlers = new Map();
+      let isResolved = false;
 
-      const checkCorrelation = () => {
-        if (eventTypes.every((type) => receivedEvents.has(type))) {
-          const events = Array.from(receivedEvents.values());
-          if (correlationFn(events)) {
-            if (!isResolved) {
+      // Ajouter les événements déjà reçus
+      events.forEach((event: string) => {
+        const existingEvent = this.lastEvents.get(event);
+        if (existingEvent) {
+          receivedEvents.set(event, {
+            type: event,
+            payload: existingEvent,
+            timestamp: Date.now(),
+          });
+        }
+      });
+
+      // Vérifier si on a déjà tous les événements nécessaires
+      const checkEvents = () => {
+        if (isResolved) return;
+
+        const eventsList = Array.from(receivedEvents.values());
+
+        switch (strategy.type) {
+          case "single":
+            if (receivedEvents.size > 0) {
+              resolve(eventsList);
               isResolved = true;
-              clearTimeout(timeoutId);
-              eventTypes.forEach((type) => {
-                this.eventEmitter.removeAllListeners(type);
-              });
-              resolve(events);
             }
-          }
+            break;
+
+          case "all":
+          case "correlate":
+            const allReceived = events.every((e: string) =>
+              receivedEvents.has(e)
+            );
+            if (allReceived) {
+              if (strategy.type === "correlate") {
+                const correlated = strategy.correlation?.(eventsList);
+                if (!correlated) return;
+              }
+              resolve(eventsList);
+              isResolved = true;
+            }
+            break;
+        }
+
+        if (isResolved) {
+          cleanup();
         }
       };
 
-      eventTypes.forEach((eventType) => {
-        this.eventEmitter.on(eventType, (eventData: any) => {
-          receivedEvents.set(eventType, {
-            type: eventType,
-            payload: eventData,
-            timestamp: Date.now(),
-          });
-          checkCorrelation();
-        });
+      events.forEach((event: string) => {
+        if (!receivedEvents.has(event)) {
+          const handler = (eventData: any) => {
+            receivedEvents.set(event, {
+              type: event,
+              payload: eventData,
+              timestamp: Date.now(),
+            });
+            checkEvents();
+          };
+          eventHandlers.set(event, handler);
+          this.eventEmitter.on(event, handler);
+        }
       });
+
+      const cleanup = () => {
+        eventHandlers.forEach((handler, event) => {
+          this.eventEmitter.removeListener(event, handler);
+        });
+      };
+
+      checkEvents();
+
+      const timeoutId = setTimeout(() => {
+        if (!isResolved) {
+          cleanup();
+          reject(new Error(`Timeout waiting for events: ${events.join(", ")}`));
+        }
+      }, timeout);
     });
   }
 }

package/graph/index.ts

@@ -1,7 +1,8 @@
 import { EventEmitter } from "events";
 import { BehaviorSubject, Subject } from "rxjs";
 import { ZodSchema } from "zod";
-import { GraphObservable, IEventEmitter } from "../interfaces";
+import { GraphObservable, IEventEmitter, NLPNodeConfig } from "../interfaces";
+import { NLPNode } from "../modules/nlp";
 import {
   GraphConfig,
   GraphContext,
@@ -16,7 +17,7 @@ import { GraphVisualizer } from "./visualizer";
 
 /**
  * @module GraphFlow
- * @description A flexible workflow engine that manages the execution of nodes in a graph-like structure.
+ * @description A workflow engine that manages the execution of nodes in a graph-like structure.
  *
  * Key features:
  * - Multiple branches support
@@ -46,6 +47,8 @@ export class GraphFlow<T extends ZodSchema> {
   private eventManager: GraphEventManager<T>;
   private nodeExecutor: GraphNode<T>;
 
+  private nlpNodes: Map<string, NLPNode<T>> = new Map();
+
   /**
    * Creates a new instance of GraphFlow
    * @param {string} name - The name of the graph flow
@@ -96,7 +99,8 @@ export class GraphFlow<T extends ZodSchema> {
       this,
       this.eventSubject,
       this.stateSubject,
-      this.destroySubject
+      this.destroySubject,
+      this.eventManager
     );
   }
 
@@ -165,6 +169,9 @@ export class GraphFlow<T extends ZodSchema> {
     inputs: any,
     triggeredByEvent: boolean = false
   ): Promise<void> {
+    const node = this.nodes.get(nodeName);
+    if (!node) throw new Error(`Node "${nodeName}" not found`);
+
     return this.nodeExecutor.executeNode(
       nodeName,
       context,
@@ -270,7 +277,7 @@ export class GraphFlow<T extends ZodSchema> {
    * @param {Partial<GraphContext<T>>} data - Optional data to merge with context
    * @returns {Promise<void>}
    */
-  public async emit(
+  public emit(
     eventName: string,
     data?: Partial<GraphContext<T>>
   ): Promise<void> {
@@ -280,7 +287,8 @@ export class GraphFlow<T extends ZodSchema> {
       timestamp: Date.now(),
     };
     this.eventSubject.next(event);
-    await new Promise((resolve) => setTimeout(resolve, 0));
+    this.eventManager.emit(eventName, data);
+    return Promise.resolve();
   }
 
   /**
@@ -406,4 +414,49 @@ export class GraphFlow<T extends ZodSchema> {
   public createVisualizer(): GraphVisualizer<T> {
     return new GraphVisualizer(this.nodes);
   }
+
+  /**
+   * Gets the schema for the current graph
+   * @returns {T} The schema for the current graph
+   */
+  public getSchema(): T {
+    return this.validator as T;
+  }
+
+  /**
+   * Adds a new NLP node to the graph
+   * @param {NLPNodeConfig<T>} config - Configuration for the NLP node
+   * @returns {Promise<void>}
+   */
+  public async addNLPNode(config: NLPNodeConfig<T>) {
+    const node = new NLPNode(config);
+    await node.initialize();
+    this.nlpNodes.set(config.name, node);
+
+    this.addNode({
+      name: config.name,
+      execute: async (context, input) => {
+        if (!input?.input) return;
+        const result = await node.process(input.input);
+        console.log("GraphFlow NLP result:", result);
+        Object.assign(context, { nlpResult: result });
+      },
+      next: config.next,
+    });
+  }
+
+  /**
+   * Processes natural language input using a specific NLP node
+   * @param {string} text - The input text to process
+   * @param {string} nodeName - The name of the NLP node to use
+   * @returns {Promise<GraphContext<T>>} The result of the NLP node execution
+   */
+  public async processNaturalLanguage(text: string, nodeName: string) {
+    const node = this.nlpNodes.get(nodeName);
+    if (!node) {
+      throw new Error(`NLP node "${nodeName}" not found`);
+    }
+
+    return this.execute(nodeName, { input: text });
+  }
 }

package/graph/node.ts

@@ -96,22 +96,8 @@ export class GraphNode<T extends ZodSchema> {
     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
-        );
+      if (node.when) {
+        await this.eventManager.handleNodeEvents(nodeName, node.when);
       }
 
       const contextProxy = new Proxy(nodeContext, {
@@ -206,27 +192,6 @@ export class GraphNode<T extends ZodSchema> {
     }
   }
 
-  /**
-   * Handles event-related operations for a node
-   * @param node - The node whose events need handling
-   * @param nodeName - The name of the node
-   * @param context - The current graph context
-   * @private
-   */
-  private async handleEvents(
-    node: GraphNodeConfig<T, any>,
-    nodeName: string,
-    context: GraphContext<T>
-  ): Promise<void> {
-    if (node.correlateEvents) {
-      await this.handleCorrelatedEvents(node, nodeName);
-    }
-
-    if (node.waitForEvents) {
-      await this.handleWaitForEvents(node, nodeName);
-    }
-  }
-
   /**
    * Executes a node with retry logic
    * @param node - The node to execute
@@ -277,71 +242,4 @@ export class GraphNode<T extends ZodSchema> {
       }
     }
   }
-
-  /**
-   * Handles correlated events for a node
-   * @param node - The node with correlated events
-   * @param nodeName - The name of the node
-   * @throws Error if correlation fails or timeout occurs
-   * @private
-   */
-  private async handleCorrelatedEvents(
-    node: GraphNodeConfig<T, any>,
-    nodeName: string
-  ): Promise<void> {
-    if (node.correlateEvents) {
-      const { events, timeout, correlation } = node.correlateEvents;
-      this.logger.addLog(
-        `⏳ Node "${nodeName}" waiting for correlated events: ${events.join(
-          ", "
-        )}`
-      );
-
-      try {
-        // Attendre les événements
-        const receivedEvents = await this.eventManager.waitForEvents(
-          events,
-          timeout
-        );
-
-        // Vérifier la corrélation
-        if (!correlation(receivedEvents)) {
-          this.logger.addLog(
-            `❌ Event correlation failed for node "${nodeName}"`
-          );
-          throw new Error(`Event correlation failed for node "${nodeName}"`);
-        }
-
-        this.logger.addLog(
-          `✅ Event correlation succeeded for node "${nodeName}"`
-        );
-      } catch (error) {
-        this.logger.addLog(
-          `❌ Error waiting for events: ${(error as Error).message}`
-        );
-        throw error;
-      }
-    }
-  }
-
-  /**
-   * Handles waiting for events
-   * @param node - The node waiting for events
-   * @param nodeName - The name of the node
-   * @throws Error if timeout occurs
-   * @private
-   */
-  private async handleWaitForEvents(
-    node: GraphNodeConfig<T, any>,
-    nodeName: string
-  ): Promise<void> {
-    if (node.waitForEvents) {
-      const { events, timeout } = node.waitForEvents;
-      this.logger.addLog(
-        `⏳ Node "${nodeName}" waiting for events: ${events.join(", ")}`
-      );
-      await this.eventManager.waitForEvents(events, timeout);
-      this.logger.addLog(`✅ All events received for node "${nodeName}"`);
-    }
-  }
 }