@ai.ntellect/core 0.6.9 → 0.6.11

package/dist/graph/engine.js

@@ -44,7 +44,7 @@ class GraphEngine {
             throw new Error("Cycle détecté dans le workflow");
         }
         if (options === null || options === void 0 ? void 0 : options.initialState) {
-            // this.setState(options.initialState);
+            this.setState(options.initialState);
         }
     }
     /**
@@ -257,11 +257,23 @@ class GraphEngine {
                         }
                         break;
                     }
-                    // Gestion des relations (branchements)
                     const relationsNodes = currentNode.relationships || [];
-                    if (relationsNodes.length > 1) {
+                    // Check condition for all relations
+                    let nextNodes = [];
+                    for (const relation of relationsNodes) {
+                        const nextNode = this.nodes.get(relation.name);
+                        if ((nextNode === null || nextNode === void 0 ? void 0 : nextNode.condition) && !nextNode.condition(this.currentState)) {
+                            // Skip this relation
+                            continue;
+                        }
+                        nextNodes.push({
+                            name: relation.name,
+                            condition: nextNode === null || nextNode === void 0 ? void 0 : nextNode.condition,
+                        });
+                    }
+                    if (nextNodes.length > 1) {
                         // Exécution parallèle des branches
-                        yield Promise.all(relationsNodes.map((relation) => this.execute(this.currentState, relation.name, onStream, onError)));
+                        yield Promise.all(nextNodes.map((relation) => this.execute(this.currentState, relation.name, onStream, onError)));
                         // Après exécution en parallèle, on arrête la boucle
                         break;
                     }

package/graph/engine.ts

@@ -68,7 +68,7 @@ export class GraphEngine<T> {
     }
 
     if (options?.initialState) {
-      // this.setState(options.initialState);
+      this.setState(options.initialState);
     }
   }
 
@@ -317,12 +317,24 @@ export class GraphEngine<T> {
           break;
         }
 
-        // Gestion des relations (branchements)
         const relationsNodes = currentNode.relationships || [];
-        if (relationsNodes.length > 1) {
+        // Check condition for all relations
+        let nextNodes = [];
+        for (const relation of relationsNodes) {
+          const nextNode = this.nodes.get(relation.name);
+          if (nextNode?.condition && !nextNode.condition(this.currentState)) {
+            // Skip this relation
+            continue;
+          }
+          nextNodes.push({
+            name: relation.name,
+            condition: nextNode?.condition,
+          });
+        }
+        if (nextNodes.length > 1) {
           // Exécution parallèle des branches
           await Promise.all(
-            relationsNodes.map((relation) =>
+            nextNodes.map((relation) =>
               this.execute(this.currentState, relation.name, onStream, onError)
             )
           );

package/package.json

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

package/test/graph/controller.test.ts

@@ -1,182 +0,0 @@
-import { GraphController } from "@/graph/controller";
-import { GraphDefinition } from "@/types";
-import { expect } from "chai";
-import { z } from "zod";
-
-describe("Controller", () => {
-  // Define test schema
-  const TestSchema = z.object({
-    status: z.string(),
-    count: z.number(),
-  });
-
-  type TestState = z.infer<typeof TestSchema>;
-
-  // Sample workflow definitions
-  const simpleWorkflow: GraphDefinition<TestState> = {
-    name: "simple-workflow",
-    entryNode: "start",
-    nodes: {
-      start: {
-        name: "start",
-        execute: async (state: any) => ({
-          ...state,
-          status: "completed",
-          count: state.count + 1,
-        }),
-        relationships: [],
-      },
-    },
-    schema: TestSchema,
-  };
-
-  const complexWorkflow: GraphDefinition<TestState> = {
-    name: "complex-workflow",
-    entryNode: "first",
-    nodes: {
-      first: {
-        name: "first",
-        execute: async (state: any) => ({
-          ...state,
-          status: "step1",
-          count: state.count + 2,
-        }),
-        relationships: [],
-      },
-    },
-    schema: TestSchema,
-  };
-
-  let controller: GraphController<TestState>;
-
-  beforeEach(() => {
-    controller = new GraphController<TestState>();
-  });
-
-  describe("Basic Execution", () => {
-    it("should execute a single workflow successfully", async () => {
-      const actions = [
-        {
-          name: "simple-workflow",
-          parameters: [
-            { name: "status", value: "initial" },
-            { name: "count", value: 0 },
-          ],
-        },
-      ];
-
-      const result = await controller.run(actions, [simpleWorkflow]);
-
-      expect(result.context).to.deep.equal({
-        status: "completed",
-        count: 1,
-      });
-    });
-
-    it("should handle multiple workflows", async () => {
-      const actions = [
-        {
-          name: "complex-workflow",
-          parameters: [
-            { name: "status", value: "initial" },
-            { name: "count", value: 0 },
-          ],
-        },
-      ];
-
-      const result = await controller.run(actions, [
-        simpleWorkflow,
-        complexWorkflow,
-      ]);
-
-      expect(result.context).to.deep.equal({
-        status: "step1",
-        count: 2,
-      });
-    });
-  });
-
-  describe("Error Handling", () => {
-    it("should throw error when no actions provided", async () => {
-      try {
-        await controller.run([], [simpleWorkflow]);
-        expect.fail("Should have thrown an error");
-      } catch (error) {
-        expect((error as Error).message).to.equal("No actions provided");
-      }
-    });
-
-    it("should throw error when workflow not found", async () => {
-      const actions = [
-        {
-          name: "non-existent-workflow",
-          parameters: [
-            { name: "status", value: "initial" },
-            { name: "count", value: 0 },
-          ],
-        },
-      ];
-
-      try {
-        await controller.run(actions, [simpleWorkflow]);
-        expect.fail("Should have thrown an error");
-      } catch (error) {
-        expect((error as Error).message).to.equal(
-          "Graph not found: non-existent-workflow"
-        );
-      }
-    });
-  });
-
-  describe("Parameter Handling", () => {
-    it("should correctly process workflow parameters", async () => {
-      const actions = [
-        {
-          name: "simple-workflow",
-          parameters: [
-            { name: "status", value: "custom-initial" },
-            { name: "count", value: 10 },
-          ],
-        },
-      ];
-
-      const result = await controller.run(actions, [simpleWorkflow]);
-
-      expect(result.context).to.deep.equal({
-        status: "completed",
-        count: 11,
-      });
-    });
-  });
-
-  describe("Multiple Actions", () => {
-    it("should process the first action only", async () => {
-      const actions = [
-        {
-          name: "simple-workflow",
-          parameters: [
-            { name: "status", value: "initial" },
-            { name: "count", value: 0 },
-          ],
-        },
-        {
-          name: "complex-workflow",
-          parameters: [
-            { name: "status", value: "initial" },
-            { name: "count", value: 5 },
-          ],
-        },
-      ];
-
-      const result = await controller.run(actions, [
-        simpleWorkflow,
-        complexWorkflow,
-      ]);
-
-      expect(result.context).to.deep.equal({
-        status: "completed",
-        count: 1,
-      });
-    });
-  });
-});