@ai.ntellect/core 0.6.19 → 0.6.20

package/graph/controller.ts

@@ -15,17 +15,17 @@ export class GraphController {
    * @returns Map containing results of each graph execution, keyed by graph name and index
    * @template T - Zod schema type for graph context validation
    */
-  static async executeSequential<T extends ZodSchema>(
-    graphs: GraphFlow<T>[],
+  static async executeSequential<T extends ZodSchema[]>(
+    graphs: { [K in keyof T]: GraphFlow<T[K]> },
     startNodes: string[],
-    inputContexts?: Partial<GraphContext<T>>[]
-  ): Promise<Map<string, GraphContext<T>>> {
-    const results = new Map<string, GraphContext<T>>();
+    inputs: any[]
+  ): Promise<any[]> {
+    const results = new Map<string, GraphContext<T[keyof T]>>();
     for (let i = 0; i < graphs.length; i++) {
-      const result = await graphs[i].execute(startNodes[i], inputContexts?.[i]);
+      const result = await graphs[i].execute(startNodes[i], inputs[i]);
       results.set(`${graphs[i].name}-${i}`, result);
     }
-    return results;
+    return Array.from(results.values());
   }
 
   /**
@@ -38,34 +38,25 @@ export class GraphController {
    * @returns Map containing results of each graph execution, keyed by graph name
    * @template T - Zod schema type for graph context validation
    */
-  static async executeParallel<T extends ZodSchema>(
-    graphs: GraphFlow<T>[],
+  static async executeParallel<T extends ZodSchema[]>(
+    graphs: { [K in keyof T]: GraphFlow<T[K]> },
     startNodes: string[],
-    inputContexts?: Partial<GraphContext<T>>[],
-    inputs?: any[],
-    concurrencyLimit?: number
-  ): Promise<Map<string, GraphContext<T>>> {
-    const results = new Map<string, GraphContext<T>>();
-
-    if (inputContexts) {
-      inputContexts = inputContexts.map((ctx) => ctx || {});
-    }
+    concurrency: number,
+    inputs: any[]
+  ): Promise<any[]> {
+    const results = new Map<string, GraphContext<T[keyof T]>>();
 
     if (inputs) {
       inputs = inputs.map((input) => input || {});
     }
 
-    if (concurrencyLimit) {
-      for (let i = 0; i < graphs.length; i += concurrencyLimit) {
+    if (concurrency) {
+      for (let i = 0; i < graphs.length; i += concurrency) {
         const batchResults = await Promise.all(
           graphs
-            .slice(i, i + concurrencyLimit)
+            .slice(i, i + concurrency)
             .map((graph, index) =>
-              graph.execute(
-                startNodes[i + index],
-                inputContexts?.[i + index] || {},
-                inputs?.[i + index]
-              )
+              graph.execute(startNodes[i + index], inputs?.[i + index])
             )
         );
         batchResults.forEach((result, index) => {
@@ -75,17 +66,13 @@ export class GraphController {
     } else {
       const allResults = await Promise.all(
         graphs.map((graph, index) =>
-          graph.execute(
-            startNodes[index],
-            inputContexts?.[index] || {},
-            inputs?.[index] || {}
-          )
+          graph.execute(startNodes[index], inputs?.[index] || {})
         )
       );
       allResults.forEach((result, index) => {
         results.set(`${graphs[index].name}`, result);
       });
     }
-    return results;
+    return Array.from(results.values());
   }
 }

package/graph/index.ts

@@ -1,6 +1,6 @@
 import { EventEmitter } from "events";
+import { IEventEmitter } from "interfaces";
 import { ZodSchema } from "zod";
-import { IEventEmitter } from "../interfaces";
 import { GraphContext, GraphDefinition, Node } from "../types";
 
 /**
@@ -17,26 +17,37 @@ import { GraphContext, GraphDefinition, Node } from "../types";
  * @template T - Extends ZodSchema for type validation
  */
 export class GraphFlow<T extends ZodSchema> {
-  private nodes: Map<string, Node<T>>;
+  private nodes: Map<string, Node<T, any>>;
   private context: GraphContext<T>;
   public validator?: T;
   private eventEmitter: IEventEmitter;
   private globalErrorHandler?: (error: Error, context: GraphContext<T>) => void;
   private graphEvents?: string[];
   private entryNode?: string;
+  private logs: string[] = [];
+  private verbose: boolean = false;
 
   /**
    * Creates a new instance of GraphFlow
    * @param {string} name - The name of the graph flow
    * @param {GraphDefinition<T>} config - Configuration object containing nodes, schema, context, and error handlers
+   * @param {Object} options - Optional options for the graph flow
    */
-  constructor(public name: string, config: GraphDefinition<T>) {
-    this.nodes = new Map(config.nodes.map((node) => [node.name, node]));
+  constructor(
+    public name: string,
+    config: GraphDefinition<T>,
+    options: { verbose?: boolean } = {}
+  ) {
+    this.nodes = new Map(
+      config.nodes.map((node: Node<T, any>) => [node.name, node])
+    );
     this.validator = config.schema;
     this.context = config.schema.parse(config.context) as GraphContext<T>;
     this.globalErrorHandler = config.onError;
-    this.eventEmitter = config.eventEmitter || new EventEmitter();
+    this.eventEmitter =
+      config.eventEmitter || (new EventEmitter() as IEventEmitter);
     this.graphEvents = config.events;
+    this.verbose = options.verbose ?? false;
 
     this.setupEventListeners();
     this.setupGraphEventListeners();
@@ -105,6 +116,30 @@ export class GraphFlow<T extends ZodSchema> {
     }
   }
 
+  private addLog(message: string): void {
+    const logMessage = `[${new Date().toISOString()}] ${message}`;
+    this.logs.push(logMessage);
+    if (this.verbose) {
+      console.log(`[${this.name}] ${message}`);
+    }
+  }
+
+  /**
+   * Enable or disable verbose logging
+   * @param {boolean} enabled - Whether to enable verbose logging
+   */
+  public setVerbose(enabled: boolean): void {
+    this.verbose = enabled;
+  }
+
+  /**
+   * Get current verbose setting
+   * @returns {boolean} Current verbose setting
+   */
+  public isVerbose(): boolean {
+    return this.verbose;
+  }
+
   /**
    * Executes a specific node in the graph
    * @private
@@ -117,96 +152,201 @@ export class GraphFlow<T extends ZodSchema> {
   private async executeNode(
     nodeName: string,
     context: GraphContext<T>,
-    inputs?: any,
+    inputs: any,
     triggeredByEvent: boolean = false
   ): Promise<void> {
     const node = this.nodes.get(nodeName);
-    if (!node) throw new Error(`❌ Node "${nodeName}" not found.`);
+    if (!node) throw new Error(`Node "${nodeName}" not found.`);
 
-    if (node.condition && !node.condition(context)) {
-      return;
-    }
+    this.addLog(`🚀 Starting node "${nodeName}"`);
+    this.eventEmitter.emit("nodeStarted", { name: nodeName });
 
-    let attempts = 0;
-    const maxAttempts = node.retry?.maxAttempts || 1;
-    const delay = node.retry?.delay || 0;
-
-    while (attempts < maxAttempts) {
-      try {
-        let validatedInputs;
-        if (node.inputs) {
-          if (!inputs) {
-            throw new Error(
-              `❌ Inputs required for node "${nodeName}" but received: ${inputs}`
-            );
-          }
-          validatedInputs = node.inputs.parse(inputs);
+    try {
+      const localContext = structuredClone(context);
+
+      if (node.condition && !node.condition(localContext)) {
+        this.addLog(`⏭️ Skipping node "${nodeName}" - condition not met`);
+        return;
+      }
+
+      // Validate inputs
+      if (node.inputs) {
+        if (!inputs) {
+          this.addLog(`❌ Missing required inputs for node "${nodeName}"`);
+          throw new Error(`Inputs required for node "${nodeName}"`);
         }
+        this.addLog(`📥 Validating inputs for node "${nodeName}"`);
+        inputs = node.inputs.parse(inputs);
+      }
 
-        this.eventEmitter.emit("nodeStarted", { name: nodeName, context });
+      // Handle retry logic
+      if (node.retry && node.retry.maxAttempts > 0) {
+        let attempts = 0;
+        let lastError: Error | null = null;
 
-        // Execute the node
-        await node.execute(context, validatedInputs);
+        while (attempts < node.retry.maxAttempts) {
+          try {
+            this.addLog(`🔄 Attempt ${attempts + 1}/${node.retry.maxAttempts}`);
+            await node.execute(localContext, inputs);
+            lastError = null;
+            break;
+          } catch (error: any) {
+            lastError = error as Error;
+            attempts++;
+            this.addLog(`❌ Attempt ${attempts} failed: ${error.message}`);
+
+            if (attempts === node.retry.maxAttempts) {
+              // Si toutes les tentatives ont échoué et qu'il y a un gestionnaire d'échec
+              if (node.retry.onRetryFailed) {
+                this.addLog(
+                  `🔄 Executing retry failure handler for node "${nodeName}"`
+                );
+                try {
+                  await node.retry.onRetryFailed(lastError, localContext);
+                  // Si le gestionnaire d'échec réussit, on continue l'exécution
+                  // SEULEMENT si le gestionnaire a explicitement retourné true
+                  if (node.retry.continueOnFailed) {
+                    this.addLog(
+                      `✅ Retry failure handler succeeded for node "${nodeName}" - continuing execution`
+                    );
+                    break;
+                  } else {
+                    this.addLog(
+                      `⚠️ Retry failure handler executed but node "${nodeName}" will still fail`
+                    );
+                    throw lastError;
+                  }
+                } catch (handlerError: any) {
+                  this.addLog(
+                    `❌ Retry failure handler failed for node "${nodeName}": ${handlerError.message}`
+                  );
+                  throw handlerError;
+                }
+              }
+              // Si pas de gestionnaire d'échec ou si le gestionnaire a échoué
+              throw lastError;
+            }
 
-        if (node.outputs) {
-          node.outputs.parse(context);
+            if (attempts < node.retry.maxAttempts) {
+              this.addLog(
+                `⏳ Waiting ${node.retry.delay}ms before next attempt`
+              );
+              await new Promise((resolve) =>
+                setTimeout(resolve, node.retry?.delay || 0)
+              );
+            }
+          }
         }
+      } else {
+        await node.execute(localContext, inputs);
+      }
 
-        this.validateContext(context);
-        this.eventEmitter.emit("nodeCompleted", { name: nodeName, context });
+      // Validate outputs
+      if (node.outputs) {
+        this.addLog(`📤 Validating outputs for node "${nodeName}"`);
+        node.outputs.parse(localContext);
+      }
 
-        // IMPORTANT: Si le nœud est déclenché par un événement et a des événements définis,
-        // on arrête ici et on ne suit pas la chaîne next
-        if (triggeredByEvent && node.events && node.events.length > 0) {
-          this.context = structuredClone(context);
-          return;
-        }
+      Object.assign(context, localContext);
 
-        // Gérer les nœuds suivants
-        if (node.next && node.next.length > 0) {
-          const branchContexts: GraphContext<T>[] = [];
+      this.addLog(
+        `✅ Node "${nodeName}" executed successfully ${JSON.stringify(context)}`
+      );
+      this.eventEmitter.emit("nodeCompleted", { name: nodeName });
 
-          // Exécuter toutes les branches valides
-          for (const nextNodeName of node.next) {
-            const nextNode = this.nodes.get(nextNodeName);
-            if (!nextNode) continue;
+      // Handle waitForEvent
+      if (node.waitForEvent && !triggeredByEvent) {
+        this.addLog(
+          `⏳ Node "${nodeName}" waiting for events: ${node.events?.join(", ")}`
+        );
 
-            const branchContext = structuredClone(context);
+        await new Promise<void>((resolve) => {
+          const eventHandler = () => {
+            this.addLog(`🚀 Event received for node "${nodeName}"`);
+            resolve();
+          };
 
-            // Si le nœud a une condition et qu'elle n'est pas remplie, passer au suivant
-            if (nextNode.condition && !nextNode.condition(branchContext)) {
-              continue;
-            }
+          node.events?.forEach((event) => {
+            this.eventEmitter.once(event, eventHandler);
+          });
+        });
 
-            await this.executeNode(nextNodeName, branchContext);
-            branchContexts.push(branchContext);
-          }
+        const nextNodes =
+          typeof node.next === "function"
+            ? node.next(context)
+            : node.next || [];
+
+        if (nextNodes.length > 0) {
+          this.addLog(`➡️ Executing next nodes: ${nextNodes.join(", ")}`);
 
-          // Fusionner les résultats des branches dans l'ordre
-          if (branchContexts.length > 0) {
-            const finalContext = branchContexts[branchContexts.length - 1];
-            Object.assign(context, finalContext);
+          // Créer un contexte unique pour toutes les branches
+          const branchContext = structuredClone(context);
+
+          // Exécuter les branches séquentiellement avec le même contexte
+          for (const nextNodeName of nextNodes) {
+            this.addLog(`🔄 Starting branch for node "${nextNodeName}"`);
+            const nextNode = this.nodes.get(nextNodeName);
+            if (nextNode) {
+              // Utiliser le même contexte pour toutes les branches
+              await this.executeNode(
+                nextNodeName,
+                branchContext,
+                undefined,
+                nextNode.waitForEvent
+              );
+            }
+            this.addLog(`✅ Branch "${nextNodeName}" completed`);
           }
+
+          // Mettre à jour le contexte global avec le résultat final des branches
+          Object.assign(context, branchContext);
+          this.context = structuredClone(context);
+
+          this.eventEmitter.emit("graphCompleted", {
+            name: this.name,
+            context: this.context,
+          });
+
+          return;
         }
+      }
 
-        // Mettre à jour le contexte global
-        this.context = structuredClone(context);
-        return;
-      } catch (error) {
-        attempts++;
-        if (attempts >= maxAttempts) {
-          this.eventEmitter.emit("nodeError", { nodeName, error });
-          node.onError?.(error as Error);
-          this.globalErrorHandler?.(error as Error, context);
-          throw error;
+      // Execute next nodes
+      const nextNodes =
+        typeof node.next === "function"
+          ? node.next(localContext)
+          : node.next || [];
+
+      if (nextNodes.length > 0) {
+        this.addLog(`➡️ Executing next nodes: ${nextNodes.join(", ")}`);
+
+        // Créer un contexte unique pour toutes les branches
+        const branchContext = structuredClone(context);
+
+        // Exécuter les branches séquentiellement avec le même contexte
+        for (const nextNodeName of nextNodes) {
+          this.addLog(`🔄 Starting branch for node "${nextNodeName}"`);
+          const nextNode = this.nodes.get(nextNodeName);
+          if (nextNode) {
+            // Utiliser le même contexte pour toutes les branches
+            await this.executeNode(
+              nextNodeName,
+              branchContext,
+              undefined,
+              nextNode.waitForEvent
+            );
+          }
+          this.addLog(`✅ Branch "${nextNodeName}" completed`);
         }
 
-        console.warn(
-          `[Graph ${this.name}] Retry attempt ${attempts} for node ${nodeName}`,
-          { error }
-        );
-        await new Promise((resolve) => setTimeout(resolve, delay));
+        // Mettre à jour le contexte global avec le résultat final des branches
+        Object.assign(context, branchContext);
+        this.context = structuredClone(context);
       }
+    } catch (error: any) {
+      this.addLog(`❌ Error in node "${nodeName}": ${error.message}`);
+      this.eventEmitter.emit("nodeError", { name: nodeName, error });
+      throw error;
     }
   }
 
@@ -231,37 +371,32 @@ export class GraphFlow<T extends ZodSchema> {
    */
   async execute(
     startNode: string,
-    inputContext?: Partial<GraphContext<T>>,
-    inputParams?: any
+    inputParams?: any,
+    inputContext?: Partial<GraphContext<T>>
   ): Promise<GraphContext<T>> {
-    // Fresh local context from the global
-    const context = this.createNewContext();
-    if (inputContext) Object.assign(context, inputContext);
+    if (inputParams) {
+      // Merge inputParams into context
+      Object.assign(this.context, inputParams);
+    }
+
+    if (inputContext) {
+      Object.assign(this.context, inputContext);
+    }
 
-    // Emit "graphStarted"
     this.eventEmitter.emit("graphStarted", { name: this.name });
 
     try {
-      // Because we're calling explicitly, it's NOT triggered by an event
-      await this.executeNode(
-        startNode,
-        context,
-        inputParams,
-        /* triggeredByEvent= */ false
-      );
+      await this.executeNode(startNode, this.context, inputParams, false);
 
-      // Emit "graphCompleted"
       this.eventEmitter.emit("graphCompleted", {
         name: this.name,
         context: this.context,
       });
 
-      // Return a snapshot of the final global context
-      return structuredClone(this.context);
+      return this.getContext();
     } catch (error) {
-      // Emit "graphError"
       this.eventEmitter.emit("graphError", { name: this.name, error });
-      this.globalErrorHandler?.(error as Error, context);
+      this.globalErrorHandler?.(error as Error, this.context);
       throw error;
     }
   }
@@ -276,15 +411,29 @@ export class GraphFlow<T extends ZodSchema> {
     eventName: string,
     data?: Partial<GraphContext<T>>
   ): Promise<GraphContext<T>> {
-    // Merge data into a fresh copy of the global context if desired
-    const context = this.createNewContext();
-    if (data) Object.assign(context, data);
+    const workingContext = structuredClone(this.context);
 
-    // Just emit the event; the node-based event listeners in setupEventListeners()
-    // will handle calling "executeNode(...)"
-    this.eventEmitter.emit(eventName, context);
+    if (data) {
+      Object.assign(workingContext, data);
+    }
+
+    const eventNodes = Array.from(this.nodes.values()).filter((node) =>
+      node.events?.includes(eventName)
+    );
+
+    // Execute event nodes sequentially with shared context
+    for (const node of eventNodes) {
+      await this.executeNode(node.name, workingContext, undefined, true);
+    }
+
+    // Update global context after all event nodes are executed
+    this.context = structuredClone(workingContext);
+
+    this.eventEmitter.emit("graphCompleted", {
+      name: this.name,
+      context: this.context,
+    });
 
-    // Return the updated global context
     return this.getContext();
   }
 
@@ -351,10 +500,10 @@ export class GraphFlow<T extends ZodSchema> {
   }
 
   /**
-   * Returns the current context
-   * @returns {GraphContext<T>} Current graph context
+   * Gets a copy of the current context
+   * @returns {GraphContext<T>} A deep copy of the current context
    */
-  getContext(): GraphContext<T> {
+  public getContext(): GraphContext<T> {
     return structuredClone(this.context);
   }
 
@@ -372,7 +521,7 @@ export class GraphFlow<T extends ZodSchema> {
    * @param {Node<T>} node - Node to add
    * @throws {Error} If node with same name already exists
    */
-  addNode(node: Node<T>): void {
+  addNode(node: Node<T, any>): void {
     this.nodes.set(node.name, node);
     if (node.events && node.events.length > 0) {
       for (const evt of node.events) {
@@ -423,7 +572,7 @@ export class GraphFlow<T extends ZodSchema> {
    * Returns all nodes in the graph
    * @returns {Node<T>[]} Array of all nodes
    */
-  getNodes(): Node<T>[] {
+  getNodes(): Node<T, any>[] {
     return Array.from(this.nodes.values());
   }
 
@@ -465,4 +614,12 @@ export class GraphFlow<T extends ZodSchema> {
       });
     }
   }
+
+  getLogs(): string[] {
+    return [...this.logs];
+  }
+
+  clearLogs(): void {
+    this.logs = [];
+  }
 }

package/graph.ts

@@ -0,0 +1,74 @@
+import { Node } from "types";
+import { z } from "zod";
+import { GraphController, GraphFlow } from "./index";
+
+// 🏗 Définition des schémas pour chaque graphe
+const schemaA = z.object({
+  input: z.string(),
+  result: z.string().optional(),
+});
+
+const schemaB = z.object({
+  number: z.number(),
+  result: z.number().optional(),
+});
+
+// 🔹 **Graph A** : Convertit une chaîne en majuscules
+const processText: Node<typeof schemaA> = {
+  name: "processText",
+  execute: async (context) => {
+    context.result = context.input.toUpperCase();
+    console.log("📢 Graphe A : Texte transformé →", context.result);
+  },
+};
+
+// 🔹 **Graph B** : Multiplie un nombre par 10
+const multiplyNumber: Node<typeof schemaB> = {
+  name: "multiplyNumber",
+  execute: async (context) => {
+    context.result = context.number * 10;
+    console.log("🔢 Graphe B : Nombre multiplié →", context.result);
+  },
+};
+
+// 🔗 **Création des graphes**
+const graphA = new GraphFlow("GraphA", {
+  name: "GraphA",
+  nodes: [processText],
+  context: { input: "" },
+  schema: schemaA,
+});
+
+const graphB = new GraphFlow("GraphB", {
+  name: "GraphB",
+  nodes: [multiplyNumber],
+  context: { number: 0 },
+  schema: schemaB,
+});
+
+(async () => {
+  try {
+    console.log("🚀 **Exécution Séquentielle** des graphes...");
+    const sequentialResults = await GraphController.executeSequential(
+      [graphA, graphB],
+      ["processText", "multiplyNumber"],
+      [{ input: "hello world" }, { number: 5 }]
+    );
+
+    console.log("🟢 **Résultats Séquentiels :**", sequentialResults);
+
+    console.log(
+      "\n⚡ **Exécution Parallèle** avec limitation de concurrence..."
+    );
+    const parallelResults = await GraphController.executeParallel(
+      [graphA, graphB],
+      ["processText", "multiplyNumber"],
+      1, // ⚠️ Limite de concurrence (1 à la fois)
+      [{ input: "parallel execution" }, { number: 7 }]
+    );
+
+    console.log("🟢 **Résultats Parallèles :**", parallelResults);
+  } catch (error) {
+    console.error("❌ Erreur lors de l’exécution :", error);
+  }
+})();

package/index.ts

@@ -11,8 +11,8 @@
  * - Utility functions for action schema generation and header building
  */
 
-export * from "./graph";
 export * from "./graph/controller";
+export * from "./graph/index";
 export * from "./modules/memory";
 export * from "./modules/memory/adapters/meilisearch";
 export * from "./modules/memory/adapters/redis";

package/interfaces/index.ts

@@ -331,6 +331,13 @@ export interface IEventEmitter {
    * @returns {Function[]} Array of listener functions
    */
   rawListeners(event: string): Function[];
+
+  /**
+   * Registers an event listener that will be called only once
+   * @param {string} event - Event name
+   * @param {Function} listener - Event handler
+   */
+  once(event: string, listener: (...args: any[]) => void): void;
 }
 
 /**

package/package.json

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

package/test/graph/index.test.ts

@@ -2,9 +2,8 @@ import { expect } from "chai";
 import EventEmitter from "events";
 import sinon from "sinon";
 import { z } from "zod";
-import { GraphFlow } from "../../graph";
+import { GraphFlow } from "../../graph/index";
 import { GraphDefinition, Node } from "../../types";
-
 /**
  * ✅ Define a valid schema using Zod.
  */
@@ -23,13 +22,17 @@ describe("Graph", function () {
 
   beforeEach(() => {
     eventEmitter = new EventEmitter();
-    graph = new GraphFlow("TestGraph", {
-      name: "TestGraph",
-      nodes: [],
-      context: { value: 0 },
-      schema: TestSchema,
-      eventEmitter: eventEmitter,
-    });
+    graph = new GraphFlow(
+      "TestGraph",
+      {
+        name: "TestGraph",
+        nodes: [],
+        context: { value: 0 },
+        schema: TestSchema,
+        eventEmitter: eventEmitter,
+      },
+      { verbose: true }
+    );
   });
 
   /**
@@ -39,7 +42,7 @@ describe("Graph", function () {
     const simpleNode: Node<TestSchema> = {
       name: "simpleNode",
       execute: async (context) => {
-        context.value += 1;
+        context.value = (context.value ?? 0) + 1;
       },
       next: [],
     };
@@ -64,7 +67,7 @@ describe("Graph", function () {
     const testNode: Node<TestSchema> = {
       name: "testNode",
       execute: async (context) => {
-        context.value += 1;
+        context.value = (context.value ?? 0) + 1;
       },
       next: [],
     };
@@ -101,35 +104,6 @@ describe("Graph", function () {
     expect(nodeErrorSpy.calledOnce).to.be.true;
   });
 
-  /**
-   * ✅ Ensure a node requiring user confirmation waits before execution.
-   */
-  it("should execute a node requiring user confirmation", async function () {
-    const confirmationNode: Node<TestSchema> = {
-      name: "waitUserConfirmation",
-      execute: async (context) => {
-        return new Promise<void>((resolve) => {
-          graph.on("userConfirmed", () => {
-            context.value += 1;
-            resolve();
-          });
-        });
-      },
-      next: [],
-    };
-
-    graph.addNode(confirmationNode);
-    const executionPromise = graph.execute("waitUserConfirmation");
-
-    setTimeout(() => {
-      graph.emit("userConfirmed");
-    }, 100);
-
-    await executionPromise;
-    const context = graph.getContext();
-    expect(context.value).to.equal(1);
-  });
-
   /**
    * ✅ Ensure that context validation using Zod works correctly.
    */
@@ -140,7 +114,7 @@ describe("Graph", function () {
       const simpleNode: Node<TestSchema> = {
         name: "simpleNode",
         execute: async (context) => {
-          context.value += 1;
+          context.value = (context.value ?? 0) + 1;
         },
         next: [],
       };
@@ -158,7 +132,7 @@ describe("Graph", function () {
    * ✅ Ensure a node with validated inputs and outputs executes correctly.
    */
   it("should execute a node with validated inputs and outputs", async function () {
-    const paramNode: Node<TestSchema> = {
+    const paramNode: Node<TestSchema, { increment: number }> = {
       name: "paramNode",
       inputs: z.object({
         increment: z.number(),
@@ -167,13 +141,13 @@ describe("Graph", function () {
         value: z.number().min(5),
       }),
       execute: async (context, inputs: { increment: number }) => {
-        context.value += inputs.increment;
+        context.value = (context.value ?? 0) + inputs.increment;
       },
       next: [],
     };
 
     graph.addNode(paramNode);
-    await graph.execute("paramNode", {}, { increment: 5 });
+    await graph.execute("paramNode", { increment: 5 });
 
     const context = graph.getContext();
     expect(context.value).to.equal(5);
@@ -185,9 +159,9 @@ describe("Graph", function () {
   it("should not execute a node when condition is false", async function () {
     const conditionalNode: Node<TestSchema> = {
       name: "conditionalNode",
-      condition: (context) => context.value > 0,
+      condition: (context) => (context.value ?? 0) > 0,
       execute: async (context) => {
-        context.value += 10;
+        context.value = (context.value ?? 0) + 10;
       },
       next: [],
     };
@@ -212,7 +186,7 @@ describe("Graph", function () {
         if (attemptCount < 3) {
           throw new Error("Temporary failure");
         }
-        context.value += 1;
+        context.value = (context.value ?? 0) + 1;
       },
       next: [],
     };
@@ -235,7 +209,7 @@ describe("Graph", function () {
       name: "eventNode",
       events: ["customEvent"],
       execute: async (context) => {
-        context.value += 1;
+        context.value = (context.value ?? 0) + 1;
       },
       next: [],
     };
@@ -304,13 +278,13 @@ describe("Graph", function () {
    * ✅ Test input validation failure
    */
   it("should throw error when node input validation fails", async function () {
-    const nodeWithInput: Node<TestSchema> = {
+    const nodeWithInput: Node<TestSchema, { amount: number }> = {
       name: "inputNode",
       inputs: z.object({
         amount: z.number().min(0),
       }),
       execute: async (context, inputs: { amount: number }) => {
-        context.value += inputs.amount;
+        context.value = (context.value ?? 0) + inputs.amount;
       },
       next: [],
     };
@@ -318,7 +292,7 @@ describe("Graph", function () {
     graph.addNode(nodeWithInput);
 
     try {
-      await graph.execute("inputNode", {}, { amount: -1 });
+      await graph.execute("inputNode", { amount: -1 });
       expect.fail("Should have thrown an error");
     } catch (error) {
       expect((error as Error).message).to.include(
@@ -358,7 +332,7 @@ describe("Graph", function () {
    * ✅ Test successful input and output validation
    */
   it("should successfully validate both inputs and outputs", async function () {
-    const validatedNode: Node<TestSchema> = {
+    const validatedNode: Node<TestSchema, { increment: number }> = {
       name: "validatedNode",
       inputs: z.object({
         increment: z.number().min(0).max(5),
@@ -367,7 +341,7 @@ describe("Graph", function () {
         value: z.number().min(0).max(10),
       }),
       execute: async (context, inputs: { increment: number }) => {
-        context.value += inputs.increment;
+        context.value = (context.value ?? 0) + inputs.increment;
       },
       next: [],
     };
@@ -375,12 +349,12 @@ describe("Graph", function () {
     graph.addNode(validatedNode);
 
     // Test with valid input that produces valid output
-    await graph.execute("validatedNode", {}, { increment: 3 });
+    await graph.execute("validatedNode", { increment: 3 });
     expect(graph.getContext().value).to.equal(3);
 
     // Test with valid input that would produce invalid output
     try {
-      await graph.execute("validatedNode", { value: 7 }, { increment: 5 });
+      await graph.execute("validatedNode", { increment: 5 }, { value: 7 });
       expect.fail("Should have thrown an error");
     } catch (error) {
       expect((error as Error).message).to.include(
@@ -393,7 +367,7 @@ describe("Graph", function () {
    * ✅ Test missing required inputs
    */
   it("should throw error when required inputs are missing", async function () {
-    const nodeWithRequiredInput: Node<TestSchema> = {
+    const nodeWithRequiredInput: Node<TestSchema, { required: string }> = {
       name: "requiredInputNode",
       inputs: z.object({
         required: z.string(),
@@ -419,7 +393,7 @@ describe("Graph", function () {
     const nodeA: Node<TestSchema> = {
       name: "nodeA",
       execute: async (context) => {
-        context.value += 1;
+        context.value = (context.value ?? 0) + 1;
       },
       next: ["nodeB1", "nodeB2"],
     };
@@ -427,7 +401,7 @@ describe("Graph", function () {
     const nodeB1: Node<TestSchema> = {
       name: "nodeB1",
       execute: async (context) => {
-        context.value *= 2;
+        context.value = (context.value ?? 0) * 2;
       },
       next: ["nodeC"],
     };
@@ -435,7 +409,7 @@ describe("Graph", function () {
     const nodeB2: Node<TestSchema> = {
       name: "nodeB2",
       execute: async (context) => {
-        context.value += 3;
+        context.value = (context.value ?? 0) + 3;
       },
       next: ["nodeC"],
     };
@@ -444,7 +418,7 @@ describe("Graph", function () {
       name: "nodeC",
       execute: async (context) => {
         // Créer une copie du contexte pour éviter les modifications concurrentes
-        const newValue = context.value + 5;
+        const newValue = (context.value ?? 0) + 5;
         context.value = newValue;
       },
     };
@@ -462,25 +436,25 @@ describe("Graph", function () {
     const startNode: Node<TestSchema> = {
       name: "start",
       execute: async (context) => {
-        context.value = 5;
+        context.value = (context.value ?? 0) + 5;
       },
       next: ["branchA", "branchB"],
     };
 
     const branchA: Node<TestSchema> = {
       name: "branchA",
-      condition: (context) => context.value < 10,
+      condition: (context) => (context.value ?? 0) < 10,
       execute: async (context) => {
-        context.value *= 2;
+        context.value = (context.value ?? 0) * 2;
       },
       next: ["end"],
     };
 
     const branchB: Node<TestSchema> = {
       name: "branchB",
-      condition: (context) => context.value >= 10,
+      condition: (context) => (context.value ?? 0) >= 10,
       execute: async (context) => {
-        context.value += 10;
+        context.value = (context.value ?? 0) + 10;
       },
       next: ["end"],
     };
@@ -488,7 +462,7 @@ describe("Graph", function () {
     const endNode: Node<TestSchema> = {
       name: "end",
       execute: async (context) => {
-        context.value = context.value + 1;
+        context.value = (context.value ?? 0) + 1;
       },
     };
 
@@ -496,6 +470,13 @@ describe("Graph", function () {
       graph.addNode(node)
     );
 
+    await graph.load({
+      name: "TestGraph",
+      nodes: [startNode, branchA, branchB, endNode],
+      context: { value: 0 },
+      schema: TestSchema,
+    });
+
     await graph.execute("start");
     expect(graph.getContext().value).to.equal(11);
   });
@@ -520,7 +501,7 @@ describe("Graph", function () {
       name: "process",
       events: ["processData"],
       execute: async (context) => {
-        context.value *= 2;
+        context.value = (context.value ?? 0) * 2;
       },
       next: ["finalize"],
     };
@@ -529,7 +510,7 @@ describe("Graph", function () {
       name: "finalize",
       events: ["complete"],
       execute: async (context) => {
-        context.value += 3;
+        context.value = (context.value ?? 0) + 3;
         eventCounter.count++;
       },
     };
@@ -573,7 +554,7 @@ describe("Graph", function () {
     const cycleNode: Node<TestSchema> = {
       name: "cycle",
       execute: async (context) => {
-        context.value += 1;
+        context.value = (context.value ?? 0) + 1;
         iterationCount.count++;
       },
       next: ["checkExit"],
@@ -581,9 +562,10 @@ describe("Graph", function () {
 
     const checkExitNode: Node<TestSchema> = {
       name: "checkExit",
-      execute: async (context) => {},
-      condition: (context) => context.value < 5,
-      next: ["cycle"],
+      execute: async () => {},
+      next: (context) => {
+        return (context.value ?? 0) < 5 ? ["cycle"] : [];
+      },
     };
 
     [cycleNode, checkExitNode].forEach((node) => graph.addNode(node));
@@ -593,54 +575,4 @@ describe("Graph", function () {
     expect(graph.getContext().value).to.equal(5);
     expect(iterationCount.count).to.equal(5);
   });
-
-  /**
-   * ✅ Test executing entire graph when triggered by event
-   */
-  it("should execute entire graph when triggered by event", async function () {
-    const nodeA: Node<TestSchema> = {
-      name: "nodeA",
-      execute: async (context) => {
-        context.value += 1;
-      },
-      next: ["nodeB"],
-    };
-
-    const nodeB: Node<TestSchema> = {
-      name: "nodeB",
-      execute: async (context) => {
-        context.value *= 2;
-      },
-      next: [],
-    };
-
-    const graphDefinition: GraphDefinition<TestSchema> = {
-      name: "EventGraph",
-      nodes: [nodeA, nodeB],
-      context: { value: 0 },
-      schema: TestSchema,
-      entryNode: "nodeA",
-      events: ["startGraph"],
-    };
-
-    graph.load(graphDefinition);
-
-    // Use a promise to ensure the event is properly handled
-    await new Promise<void>((resolve, reject) => {
-      const timeout = setTimeout(
-        () => reject(new Error("Graph event did not complete")),
-        1500
-      );
-
-      graph.on("graphCompleted", () => {
-        clearTimeout(timeout);
-        resolve();
-      });
-
-      graph.emit("startGraph").catch(reject);
-    });
-
-    const context = graph.getContext();
-    expect(context.value).to.equal(2); // (0 + 1) * 2
-  });
 });

package/types/index.ts

@@ -1,3 +1,4 @@
+import { EventEmitter } from "events";
 import { IEventEmitter } from "interfaces";
 import { ZodSchema } from "zod";
 
@@ -62,7 +63,7 @@ export type ScheduledRequest = {
  * Utility type for extracting schema type from Zod schema
  * @template T - Zod schema type
  */
-export type SchemaType<T> = T extends ZodSchema<infer U> ? Required<U> : never;
+export type SchemaType<T> = T extends ZodSchema<infer U> ? U : never;
 
 /**
  * Type for graph context based on schema
@@ -74,28 +75,39 @@ export type GraphContext<T> = SchemaType<T>;
  * Interface representing a node in the graph
  * @interface
  * @template T - Schema type
+ * @template I - Input schema type
+ * @template O - Output schema type
  */
-export interface Node<T> {
+export interface Node<T extends ZodSchema, I = any> {
   /** Name of the node */
   name: string;
   /** Schema for node inputs */
-  inputs?: ZodSchema;
+  inputs?: I extends void ? never : ZodSchema<I>;
   /** Schema for node outputs */
   outputs?: ZodSchema;
   /** Execute function for the node */
-  execute: (context: GraphContext<T>, inputs?: any) => Promise<void>;
+  execute: (
+    context: GraphContext<T>,
+    inputs: I extends void ? never : I
+  ) => Promise<void>;
   /** Optional condition for node execution */
   condition?: (context: GraphContext<T>) => boolean;
   /** Array of next node names */
-  next?: string[];
+  next?: string[] | ((context: GraphContext<T>) => string[]);
   /** Array of event names */
   events?: string[];
+  /** Wait for event */
+  waitForEvent?: boolean;
   /** Retry configuration */
   retry?: {
     /** Maximum number of retry attempts */
     maxAttempts: number;
     /** Delay between retries in milliseconds */
     delay: number;
+    /** Error handler function */
+    onRetryFailed?: (error: Error, context: GraphContext<T>) => Promise<void>;
+    /** Continue execution on failed retry */
+    continueOnFailed?: boolean;
   };
   /** Error handler function */
   onError?: (error: Error) => void;
@@ -106,11 +118,11 @@ export interface Node<T> {
  * @interface
  * @template T - Schema type
  */
-export interface GraphDefinition<T> {
+export interface GraphDefinition<T extends ZodSchema> {
   /** Name of the graph */
   name: string;
   /** Array of nodes in the graph */
-  nodes: Node<T>[];
+  nodes: Node<T, any>[];
   /** Initial context */
   context: SchemaType<T>;
   /** Schema for validation */
@@ -120,7 +132,7 @@ export interface GraphDefinition<T> {
   /** Entry node name */
   entryNode?: string;
   /** Event emitter instance */
-  eventEmitter?: IEventEmitter;
+  eventEmitter?: IEventEmitter | EventEmitter;
   /** Array of events */
   events?: string[];
 }