graphai 2.0.4 → 2.0.6

package/lib/bundle.esm.js

@@ -653,7 +653,7 @@ class ComputedNode extends Node {
             this.updateState(NodeState.Abort);
         }
         if (this.debugInfo && this.debugInfo.subGraphs) {
-            this.debugInfo.subGraphs.forEach((graph) => graph.abort());
+            this.debugInfo.subGraphs.forEach((graph) => graph.abort(true));
         }
     }
     isReadyNode() {
@@ -930,10 +930,13 @@ class StaticNode extends Node {
         this.isResult = data.isResult ?? false;
         this.console = data.console ?? {};
     }
-    injectValue(value, injectFrom) {
-        this.state = NodeState.Injected;
+    updateValue(value, injectFrom) {
         this.value = value;
-        this.result = value;
+        this.log.onInjected(this, this.graph, injectFrom);
+    }
+    setResultValue(injectFrom) {
+        this.state = NodeState.Injected;
+        this.result = this.value;
         this.log.onInjected(this, this.graph, injectFrom);
         this.onSetResult();
     }
@@ -1232,6 +1235,10 @@ class TaskManager {
             ...nodes,
         };
     }
+    reset() {
+        this.taskQueue.length = 0;
+        this.runningNodes.clear();
+    }
 }
 
 const defaultConcurrency = 8;
@@ -1246,7 +1253,8 @@ class GraphAI {
                 _nodes[nodeId] = new ComputedNode(this.graphId, nodeId, nodeData, this);
             }
             else {
-                _nodes[nodeId] = new StaticNode(nodeId, nodeData, this);
+                const updateValue = this.staticNodeInitData[nodeId];
+                _nodes[nodeId] = new StaticNode(nodeId, updateValue !== undefined ? { ...nodeData, value: updateValue } : nodeData, this);
             }
             return _nodes;
         }, {});
@@ -1270,7 +1278,7 @@ class GraphAI {
         return getDataFromSource(source.nodeId ? results[source.nodeId] : undefined, source, this.propFunctions);
     }
     // for static
-    initializeStaticNodes(enableConsoleLog = false) {
+    setStaticNodeResults(enableConsoleLog = false) {
         // If the result property is specified, inject it.
         // If the previousResults exists (indicating we are in a loop),
         // process the update property (nodeId or nodeId.propId).
@@ -1279,7 +1287,7 @@ class GraphAI {
             if (node?.isStaticNode) {
                 const value = node?.value;
                 if (value !== undefined) {
-                    this.injectValue(nodeId, value, nodeId);
+                    node.setResultValue(nodeId);
                 }
                 if (enableConsoleLog) {
                     node.consoleLog();
@@ -1297,7 +1305,7 @@ class GraphAI {
                 const update = node?.update;
                 if (update && previousResults) {
                     const result = this.getValueFromResults(update, previousResults);
-                    this.injectValue(nodeId, result, update.nodeId);
+                    this.updateStaticNodeValue(nodeId, result, update.nodeId);
                 }
                 if (enableConsoleLog) {
                     node.consoleLog();
@@ -1313,6 +1321,7 @@ class GraphAI {
         graphLoader: undefined,
         forceLoop: false,
     }) {
+        this.staticNodeInitData = {};
         this.logs = [];
         this.config = {};
         this.onLogCallback = (__log, __isUpdate) => { };
@@ -1350,7 +1359,6 @@ class GraphAI {
             },
         };
         this.nodes = this.createNodes(this.graphData);
-        this.initializeStaticNodes(true);
     }
     getAgentFunctionInfo(agentId) {
         if (agentId && this.agentFunctionInfoDictionary[agentId]) {
@@ -1427,6 +1435,7 @@ class GraphAI {
     }
     // Public API
     async run(all = false) {
+        this.setStaticNodeResults();
         if (Object.values(this.nodes)
             .filter((node) => node.isStaticNode)
             .some((node) => node.result === undefined && node.update === undefined)) {
@@ -1453,14 +1462,18 @@ class GraphAI {
             };
         });
     }
-    abort() {
+    abort(isChild = false) {
         if (this.isRunning()) {
             this.resetPending();
+            // Stop All Running node.
         }
         // For an agent like an event agent, where an external promise remains unresolved,
         // aborting and then retrying can cause nodes or the graph to execute again.
         // To prevent this, the transactionId is updated to ensure the retry fails.
         Object.values(this.nodes).forEach((node) => node.isComputedNode && (node.transactionId = undefined));
+        if (!isChild) {
+            this.taskManager.reset();
+        }
         this.onComplete(this.isRunning());
     }
     resetPending() {
@@ -1498,6 +1511,7 @@ class GraphAI {
         // We need to update static nodes, before checking the condition
         const previousResults = this.results(true, true); // results from previous loop
         this.updateStaticNodes(previousResults);
+        this.setStaticNodeResults();
         if (loop.count === undefined || this.repeatCount < loop.count) {
             if (loop.while) {
                 const source = parseNodeName(loop.while);
@@ -1507,8 +1521,9 @@ class GraphAI {
                     return false; // while condition is not met
                 }
             }
-            this.initializeGraphAI();
+            this.nodes = this.createNodes(this.graphData);
             this.updateStaticNodes(previousResults, true);
+            this.setStaticNodeResults();
             this.pushReadyNodesIntoQueue();
             return true; // Indicating that we are going to continue.
         }
@@ -1519,7 +1534,7 @@ class GraphAI {
             throw new Error("This GraphAI instance is running");
         }
         this.nodes = this.createNodes(this.graphData);
-        this.initializeStaticNodes();
+        this.setStaticNodeResults();
     }
     setPreviousResults(previousResults) {
         this.updateStaticNodes(previousResults);
@@ -1549,9 +1564,13 @@ class GraphAI {
     }
     // Public API
     injectValue(nodeId, value, injectFrom) {
+        this.staticNodeInitData[nodeId] = value;
+        this.updateStaticNodeValue(nodeId, value, injectFrom);
+    }
+    updateStaticNodeValue(nodeId, value, injectFrom) {
         const node = this.nodes[nodeId];
         if (node && node.isStaticNode) {
-            node.injectValue(value, injectFrom);
+            node.updateValue(value, injectFrom);
         }
         else {
             throw new Error(`injectValue with Invalid nodeId, ${nodeId}`);