@ai.ntellect/core 0.6.20 → 0.6.21

package/test/graph/index.test.ts

@@ -2,8 +2,10 @@ import { expect } from "chai";
 import EventEmitter from "events";
 import sinon from "sinon";
 import { z } from "zod";
+import { GraphController } from "../../graph/controller";
 import { GraphFlow } from "../../graph/index";
 import { GraphDefinition, Node } from "../../types";
+
 /**
  * ✅ Define a valid schema using Zod.
  */
@@ -389,7 +391,7 @@ describe("Graph", function () {
   /**
    * ✅ Test complex workflow with multiple branches
    */
-  it("should execute a complex workflow with multiple branches", async function () {
+  it("should execute a complex workflow with multiple nodes and accumulate the value", async function () {
     const nodeA: Node<TestSchema> = {
       name: "nodeA",
       execute: async (context) => {
@@ -417,16 +419,14 @@ describe("Graph", function () {
     const nodeC: Node<TestSchema> = {
       name: "nodeC",
       execute: async (context) => {
-        // Créer une copie du contexte pour éviter les modifications concurrentes
-        const newValue = (context.value ?? 0) + 5;
-        context.value = newValue;
+        context.value = (context.value ?? 0) + 5;
       },
     };
 
     [nodeA, nodeB1, nodeB2, nodeC].forEach((node) => graph.addNode(node));
 
     await graph.execute("nodeA");
-    expect(graph.getContext().value).to.equal(9);
+    expect(graph.getContext().value).to.equal(15);
   });
 
   /**
@@ -438,141 +438,152 @@ describe("Graph", function () {
       execute: async (context) => {
         context.value = (context.value ?? 0) + 5;
       },
-      next: ["branchA", "branchB"],
-    };
-
-    const branchA: Node<TestSchema> = {
-      name: "branchA",
-      condition: (context) => (context.value ?? 0) < 10,
-      execute: async (context) => {
-        context.value = (context.value ?? 0) * 2;
-      },
-      next: ["end"],
-    };
-
-    const branchB: Node<TestSchema> = {
-      name: "branchB",
-      condition: (context) => (context.value ?? 0) >= 10,
-      execute: async (context) => {
-        context.value = (context.value ?? 0) + 10;
-      },
       next: ["end"],
     };
 
     const endNode: Node<TestSchema> = {
       name: "end",
       execute: async (context) => {
-        context.value = (context.value ?? 0) + 1;
+        if ((context.value ?? 0) < 10) {
+          context.value = (context.value ?? 0) * 2;
+        } else {
+          context.value = (context.value ?? 0) + 1;
+        }
       },
     };
 
-    [startNode, branchA, branchB, endNode].forEach((node) =>
-      graph.addNode(node)
-    );
-
-    await graph.load({
-      name: "TestGraph",
-      nodes: [startNode, branchA, branchB, endNode],
-      context: { value: 0 },
-      schema: TestSchema,
-    });
+    [startNode, endNode].forEach((node) => graph.addNode(node));
 
     await graph.execute("start");
-    expect(graph.getContext().value).to.equal(11);
+    expect(graph.getContext().value).to.equal(10);
   });
 
   /**
-   * ✅ Test complex event-driven workflow
+   * ✅ Test parallel workflow using GraphController
    */
-  it("should handle complex event-driven workflows", async function () {
-    this.timeout(5000); // Augmenter le timeout pour les tests asynchrones
-    const eventCounter = { count: 0 };
+  it("should handle parallel workflows using GraphController", async function () {
+    // Graph 1
+    const graph1 = new GraphFlow(
+      "Graph1",
+      {
+        name: "Graph1",
+        nodes: [],
+        context: { value: 0 },
+        schema: TestSchema,
+      },
+      { verbose: true }
+    );
 
-    const startNode: Node<TestSchema> = {
-      name: "start",
-      events: ["startWorkflow"],
+    const processNode1: Node<TestSchema> = {
+      name: "process1",
       execute: async (context) => {
         context.value = 1;
       },
-      next: ["process"],
+      next: ["finalize1"],
     };
 
-    const processNode: Node<TestSchema> = {
-      name: "process",
-      events: ["processData"],
+    const finalizeNode1: Node<TestSchema> = {
+      name: "finalize1",
       execute: async (context) => {
         context.value = (context.value ?? 0) * 2;
       },
-      next: ["finalize"],
     };
 
-    const finalizeNode: Node<TestSchema> = {
-      name: "finalize",
-      events: ["complete"],
-      execute: async (context) => {
-        context.value = (context.value ?? 0) + 3;
-        eventCounter.count++;
+    // Graph 2
+    const graph2 = new GraphFlow(
+      "Graph2",
+      {
+        name: "Graph2",
+        nodes: [],
+        context: { value: 0 },
+        schema: TestSchema,
       },
-    };
-
-    [startNode, processNode, finalizeNode].forEach((node) =>
-      graph.addNode(node)
+      { verbose: true }
     );
 
-    // Test sequential event triggering
-    await graph.emit("startWorkflow");
-    await graph.emit("processData");
-    await graph.emit("complete");
+    const processNode2: Node<TestSchema> = {
+      name: "process2",
+      execute: async (context) => {
+        context.value = 2;
+      },
+      next: ["finalize2"],
+    };
 
-    expect(graph.getContext().value).to.equal(5); // (1 * 2) + 3
-    expect(eventCounter.count).to.equal(1);
+    const finalizeNode2: Node<TestSchema> = {
+      name: "finalize2",
+      execute: async (context) => {
+        context.value = (context.value ?? 0) + 3;
+      },
+    };
 
-    // Reset context for concurrent test
-    graph.load({
-      name: "TestGraph",
-      nodes: [startNode, processNode, finalizeNode],
-      context: { value: 0 },
-      schema: TestSchema,
-    });
+    graph1.addNode(processNode1);
+    graph1.addNode(finalizeNode1);
+    graph2.addNode(processNode2);
+    graph2.addNode(finalizeNode2);
 
-    // Test concurrent event handling
-    await Promise.all([
-      graph.emit("startWorkflow"),
-      graph.emit("processData"),
-      graph.emit("complete"),
-    ]);
+    const results = await GraphController.executeParallel(
+      [graph1, graph2],
+      ["process1", "process2"],
+      2,
+      [{}, {}]
+    );
 
-    expect(eventCounter.count).to.equal(2);
+    expect(results[0].value).to.equal(2); // Graph1: 1 * 2
+    expect(results[1].value).to.equal(5); // Graph2: 2 + 3
   });
 
   /**
-   * ✅ Test cyclic workflow with conditional exit
+   * ✅ Test sequential workflow using GraphController
    */
-  it("should handle cyclic workflows with conditional exit", async function () {
-    const iterationCount = { count: 0 };
+  it("should handle sequential workflows using GraphController", async function () {
+    // Graph 1
+    const graph1 = new GraphFlow(
+      "Graph1",
+      {
+        name: "Graph1",
+        nodes: [],
+        context: { value: 1 },
+        schema: TestSchema,
+      },
+      { verbose: true }
+    );
 
-    const cycleNode: Node<TestSchema> = {
-      name: "cycle",
+    const startNode1: Node<TestSchema> = {
+      name: "start1",
       execute: async (context) => {
-        context.value = (context.value ?? 0) + 1;
-        iterationCount.count++;
+        context.value = (context.value ?? 0) * 2;
       },
-      next: ["checkExit"],
     };
 
-    const checkExitNode: Node<TestSchema> = {
-      name: "checkExit",
-      execute: async () => {},
-      next: (context) => {
-        return (context.value ?? 0) < 5 ? ["cycle"] : [];
+    // Graph 2
+    const graph2 = new GraphFlow(
+      "Graph2",
+      {
+        name: "Graph2",
+        nodes: [],
+        context: { value: 3 },
+        schema: TestSchema,
+      },
+      { verbose: true }
+    );
+
+    const startNode2: Node<TestSchema> = {
+      name: "start2",
+      execute: async (context) => {
+        context.value = (context.value ?? 0) + 2;
       },
     };
 
-    [cycleNode, checkExitNode].forEach((node) => graph.addNode(node));
+    graph1.addNode(startNode1);
+    graph2.addNode(startNode2);
 
-    await graph.execute("cycle");
+    const results = await GraphController.executeSequential(
+      [graph1, graph2],
+      ["start1", "start2"],
+      [{}, {}]
+    );
 
-    expect(graph.getContext().value).to.equal(5);
-    expect(iterationCount.count).to.equal(5);
+    expect(results[0].value).to.equal(2); // Graph1: 1 * 2
+    expect(results[1].value).to.equal(5); // Graph2: 3 + 2
   });
 });

package/utils/generate-action-schema.ts

@@ -1,13 +1,14 @@
 import { z } from "zod";
-import { Node } from "../types";
+import { GraphFlow } from "../graph/index";
 
-export const generateActionSchema = (nodes: Node<any>[]) => {
-  return nodes
-    .map((node) => {
-      const schemaStr = node.inputs
-        ? getSchemaString(node.inputs)
+export const generateActionSchema = (graphs: GraphFlow<any>[]) => {
+  return graphs
+    .map((graph) => {
+      const rootNode = Array.from(graph.nodes.values())[0];
+      const schemaStr = rootNode.inputs
+        ? getSchemaString(rootNode.inputs)
         : "No parameters";
-      return `Workflow: ${node.name}\nParameters: ${schemaStr}`;
+      return `Workflow: ${graph.name}\nParameters: ${schemaStr}`;
     })
     .join("\n\n");
 };

package/.env.example

@@ -1,2 +0,0 @@
-OPENAI_API_KEY=
-REDIS_URL=

package/graph.ts

@@ -1,74 +0,0 @@
-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);
-  }
-})();