@ai.ntellect/core 0.7.5 → 0.7.7

package/graph/node.ts

@@ -2,13 +2,22 @@ import { BehaviorSubject, Subject } from "rxjs";
 import { ZodSchema } from "zod";
 import { GraphContext, GraphEvent, Node } from "../types";
 import { GraphEventManager } from "./event-manager";
-import { GraphLogger } from "./logger";
 
 /**
  * Represents a node in the graph that can execute operations and manage state
  * @template T - The Zod schema type for validation
  */
+export interface NodeParams<T = any> {
+  [key: string]: T;
+}
+
+export interface GraphLogger {
+  addLog: (message: string, data?: any) => void;
+}
+
 export class GraphNode<T extends ZodSchema> {
+  private lastStateEvent: GraphEvent<T> | null = null;
+
   /**
    * Creates a new GraphNode instance
    * @param nodes - Map of all nodes in the graph
@@ -32,15 +41,22 @@ export class GraphNode<T extends ZodSchema> {
    * @private
    */
   private emitEvent(type: string, payload: any) {
-    this.logger.addLog(`📢 Event: ${type}`);
+    if (type === "nodeStateChanged") {
+      if (
+        this.lastStateEvent?.type === type &&
+        this.lastStateEvent.payload.property === payload.property &&
+        this.lastStateEvent.payload.newValue === payload.newValue &&
+        this.lastStateEvent.payload.nodeName === payload.nodeName
+      ) {
+        return;
+      }
+    }
+
     const event = {
       type,
       payload: {
         ...payload,
-        name:
-          type === "nodeStateChanged"
-            ? payload.name || payload.nodeName
-            : payload.name,
+        name: type === "nodeStateChanged" ? payload.nodeName : payload.name,
         context: { ...payload.context },
       },
       timestamp: Date.now(),
@@ -49,8 +65,8 @@ export class GraphNode<T extends ZodSchema> {
     this.eventSubject.next(event);
     this.eventManager.emitEvent(type, event);
 
-    // Update state subject only for state changes
     if (type === "nodeStateChanged") {
+      this.lastStateEvent = event;
       this.stateSubject.next({ ...payload.context });
     }
   }
@@ -59,125 +75,93 @@ 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
    */
-  async executeNode(
+  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.`);
 
-    this.logger.addLog(`🚀 Starting node "${nodeName}`);
-    this.emitEvent("nodeStarted", { name: nodeName, context });
+    // Créer une copie du contexte pour ce nœud
+    const nodeContext = { ...context };
+    this.emitEvent("nodeStarted", { name: nodeName, context: nodeContext });
 
     try {
-      // Vérifier la condition avant d'exécuter
-      if (node.condition && !node.condition(context)) {
-        this.logger.addLog(
-          `⏭️ Skipping node "${nodeName}" - condition not met`
-        );
-        return;
-      }
-
-      const contextProxy = new Proxy(context, {
+      const contextProxy = new Proxy(nodeContext, {
         set: (target, prop, value) => {
           const oldValue = target[prop];
           if (oldValue === value) return true;
 
           target[prop] = value;
+          // Mettre à jour le contexte global
+          context[prop as keyof typeof context] = value;
+
           this.emitEvent("nodeStateChanged", {
             nodeName,
             property: prop.toString(),
             oldValue,
             newValue: value,
-            context: target,
+            context: { ...target },
           });
-
           return true;
         },
-        get: (target, prop) => target[prop],
       });
 
-      // Exécuter le nœud
-      await node.execute(contextProxy, inputs);
+      if (node.condition && !node.condition(contextProxy, params)) {
+        return;
+      }
+
+      await this.executeWithRetry(node, contextProxy, nodeName, params);
+      this.emitEvent("nodeCompleted", { name: nodeName, context: nodeContext });
 
-      // Gérer la suite uniquement si pas déclenché par un événement
-      if (!triggeredByEvent) {
+      if (!triggeredByEvent && node.next) {
         const nextNodes =
-          typeof node.next === "function"
-            ? node.next(contextProxy)
-            : node.next || [];
-
+          typeof node.next === "function" ? node.next(contextProxy) : node.next;
         for (const nextNodeName of nextNodes) {
           await this.executeNode(nextNodeName, context, undefined, false);
         }
       }
-
-      this.logger.addLog(`✅ Node "${nodeName}" executed successfully`);
-      this.emitEvent("nodeCompleted", { name: nodeName, context });
     } catch (error) {
-      this.logger.addLog(
-        `❌ Error in node "${nodeName}": ${
-          error instanceof Error ? error.message : String(error)
-        }`
-      );
-      this.emitEvent("nodeError", { name: nodeName, error, context });
+      this.emitEvent("nodeError", {
+        name: nodeName,
+        error,
+        context: nodeContext,
+      });
       throw error;
     }
   }
 
   /**
-   * 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;
     }
   }
 
@@ -206,42 +190,41 @@ 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 | null = null;
+    let lastError: Error = new Error("Unknown error");
 
-    while (attempts < node.retry!.maxAttempts) {
+    while (attempts < (node.retry?.maxAttempts || 1)) {
       try {
-        this.logger.addLog(
-          `🔄 Attempt ${attempts + 1}/${node.retry!.maxAttempts}`
-        );
-        await node.execute(contextProxy, inputs);
+        // Valider les params uniquement si un schéma est défini
+        if (node.params) {
+          await this.validateParams(node, params, nodeName);
+        }
+
+        await node.execute(contextProxy, params);
         return;
       } catch (error: any) {
-        lastError = error instanceof Error ? error : new Error(error.message);
+        lastError =
+          error instanceof Error
+            ? error
+            : new Error(error?.message || "Unknown error");
         attempts++;
-        this.logger.addLog(
-          `❌ Attempt ${attempts} failed: ${lastError.message}`
-        );
 
-        if (attempts === node.retry!.maxAttempts) {
-          if (node.retry!.onRetryFailed && lastError) {
-            await this.handleRetryFailure(
-              node,
-              lastError,
-              contextProxy,
-              nodeName
-            );
+        if (attempts === (node.retry?.maxAttempts || 1)) {
+          if (node.retry?.onRetryFailed) {
+            await node.retry.onRetryFailed(lastError, contextProxy);
+            if (node.retry.continueOnFailed) return;
           }
           throw lastError;
         }
@@ -253,44 +236,6 @@ export class GraphNode<T extends ZodSchema> {
     }
   }
 
-  /**
-   * Handles the failure of retry attempts
-   * @param node - The node that failed
-   * @param error - The error that caused the failure
-   * @param context - The current graph context
-   * @param nodeName - The name of the node
-   * @private
-   */
-  private async handleRetryFailure(
-    node: Node<T, any>,
-    error: Error,
-    context: GraphContext<T>,
-    nodeName: string
-  ): Promise<void> {
-    this.logger.addLog(
-      `🔄 Executing retry failure handler for node "${nodeName}"`
-    );
-    try {
-      if (node.retry?.onRetryFailed) {
-        await node.retry.onRetryFailed(error, context);
-        if (node.retry.continueOnFailed) {
-          this.logger.addLog(
-            `✅ Retry failure handler succeeded - continuing execution`
-          );
-          return;
-        }
-        this.logger.addLog(
-          `⚠️ Retry failure handler executed but node will still fail`
-        );
-      }
-    } catch (handlerError: any) {
-      this.logger.addLog(
-        `❌ Retry failure handler failed: ${handlerError.message}`
-      );
-      throw handlerError;
-    }
-  }
-
   /**
    * Handles correlated events for a node
    * @param node - The node with correlated events

package/graph/observer.ts

@@ -56,7 +56,6 @@ export class GraphObserver<T extends ZodSchema> {
     } = {}
   ): GraphObservable<T> {
     const baseObservable = new Observable<any>((subscriber) => {
-      // Combine les événements avec l'état actuel
       const subscription = combineLatest([
         this.eventSubject.pipe(
           filter((event) => event.type === "nodeStateChanged"),

package/package.json

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

package/test/graph/controller.test.ts

@@ -0,0 +1,187 @@
+import { expect } from "chai";
+import { z } from "zod";
+import { GraphController } from "../../graph/controller";
+import { GraphFlow } from "../../graph/index";
+import { Node } from "../../types";
+
+describe("GraphController", () => {
+  const TestSchema = z.object({
+    counter: z.number(),
+    message: z.string(),
+  });
+
+  const createTestGraph = (name: string): GraphFlow<typeof TestSchema> => {
+    const nodes: Node<typeof TestSchema>[] = [
+      {
+        name: "start",
+        execute: async (context, params) => {
+          context.counter = params?.value ?? 0;
+          context.message = params?.prefix ? `${params.prefix}-${name}` : name;
+        },
+      },
+      {
+        name: "increment",
+        execute: async (context) => {
+          context.counter += 1;
+        },
+      },
+    ];
+
+    return new GraphFlow(name, {
+      name,
+      nodes,
+      schema: TestSchema,
+      context: { counter: 0, message: "" },
+    });
+  };
+
+  describe("Sequential Execution", () => {
+    it("should execute graphs sequentially with different params and params", async () => {
+      const graph1 = createTestGraph("graph1");
+      const graph2 = createTestGraph("graph2");
+      const graph3 = createTestGraph("graph3");
+
+      const params = [{ value: 10 }, { value: 20 }, { value: 30 }];
+
+      const params2 = [
+        { prefix: "test1" },
+        { prefix: "test2" },
+        { prefix: "test3" },
+      ];
+
+      const results = await GraphController.executeSequential(
+        [graph1, graph2, graph3],
+        ["start", "start", "start"],
+        params.map((value, i) => ({ ...value, prefix: params2[i].prefix }))
+      );
+
+      expect(results).to.have.length(3);
+      expect(results[0].counter).to.equal(10);
+      expect(results[1].counter).to.equal(20);
+      expect(results[2].counter).to.equal(30);
+      expect(results[0].message).to.equal("test1-graph1");
+      expect(results[1].message).to.equal("test2-graph2");
+      expect(results[2].message).to.equal("test3-graph3");
+    });
+
+    it("should handle missing params and params gracefully", async () => {
+      const graph1 = createTestGraph("graph1");
+      const graph2 = createTestGraph("graph2");
+
+      const results = await GraphController.executeSequential(
+        [graph1, graph2],
+        ["start", "start"]
+      );
+
+      expect(results).to.have.length(2);
+      expect(results[0].counter).to.equal(0);
+      expect(results[1].counter).to.equal(0);
+      expect(results[0].message).to.equal("graph1");
+      expect(results[1].message).to.equal("graph2");
+    });
+  });
+
+  describe("Parallel Execution", () => {
+    it("should execute graphs in parallel with concurrency limit", async () => {
+      const graphs = Array.from({ length: 5 }, (_, i) =>
+        createTestGraph(`graph${i + 1}`)
+      );
+
+      const params = Array.from({ length: 5 }, (_, i) => ({
+        value: (i + 1) * 10,
+        prefix: `test${i + 1}`,
+      }));
+
+      // Ajouter un délai dans l'exécution
+      const originalExecute = graphs[0].execute;
+      graphs[0].execute = async (...args) => {
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        return originalExecute.apply(graphs[0], args);
+      };
+
+      const startTime = Date.now();
+      const results = await GraphController.executeParallel(
+        graphs,
+        Array(5).fill("start"),
+        2,
+        params
+      );
+      const executionTime = Date.now() - startTime;
+
+      expect(executionTime).to.be.greaterThan(0);
+      expect(results).to.have.length(5);
+      results.forEach((result, i) => {
+        expect(result.counter).to.equal((i + 1) * 10);
+        expect(result.message).to.equal(`test${i + 1}-graph${i + 1}`);
+      });
+    });
+
+    it("should handle errors in parallel execution", async () => {
+      const errorGraph = new GraphFlow("errorGraph", {
+        name: "errorGraph",
+        nodes: [
+          {
+            name: "start",
+            execute: async () => {
+              throw new Error("Test error");
+            },
+          },
+        ],
+        schema: TestSchema,
+        context: { counter: 0, message: "" },
+      });
+
+      const successGraph = createTestGraph("successGraph");
+
+      try {
+        await GraphController.executeParallel(
+          [errorGraph, successGraph],
+          ["start", "start"],
+          2
+        );
+        expect.fail("Should have thrown an error");
+      } catch (error: any) {
+        expect(error.message).to.equal("Test error");
+      }
+    });
+  });
+
+  describe("Complex Workflows", () => {
+    it("should handle mixed sequential and parallel execution", async () => {
+      const graphs = Array.from({ length: 4 }, (_, i) =>
+        createTestGraph(`graph${i + 1}`)
+      );
+
+      // Exécuter les deux premiers graphes en parallèle
+      const parallelResults = await GraphController.executeParallel(
+        graphs.slice(0, 2),
+        ["start", "start"],
+        2,
+        [
+          { value: 10, prefix: "parallel1" },
+          { value: 20, prefix: "parallel2" },
+        ]
+      );
+
+      // Puis exécuter les deux suivants séquentiellement
+      const sequentialResults = await GraphController.executeSequential(
+        graphs.slice(2),
+        ["start", "start"],
+        [
+          { value: 30, prefix: "seq1" },
+          { value: 40, prefix: "seq2" },
+        ]
+      );
+
+      const allResults = [...parallelResults, ...sequentialResults];
+      expect(allResults).to.have.length(4);
+      expect(allResults.map((r) => r.counter)).to.deep.equal([10, 20, 30, 40]);
+      expect(allResults.map((r) => r.message)).to.deep.equal([
+        "parallel1-graph1",
+        "parallel2-graph2",
+        "seq1-graph3",
+        "seq2-graph4",
+      ]);
+    });
+  });
+});