graphai 0.0.12 → 0.1.1

package/lib/graphai.js

@@ -1,301 +1,88 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GraphAI = exports.NodeState = void 0;
-var NodeState;
-(function (NodeState) {
-    NodeState["Waiting"] = "waiting";
-    NodeState["Executing"] = "executing";
-    NodeState["Failed"] = "failed";
-    NodeState["TimedOut"] = "timed-out";
-    NodeState["Completed"] = "completed";
-    NodeState["Injected"] = "injected";
-    NodeState["Dispatched"] = "dispatched";
-})(NodeState || (exports.NodeState = NodeState = {}));
-const parseNodeName = (name) => {
-    const parts = name.split(".");
-    if (parts.length == 1) {
-        return { sourceNodeId: parts[0] };
-    }
-    else {
-        return { sourceNodeId: parts[0], propId: parts[1] };
-    }
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-class Node {
-    constructor(nodeId, forkIndex, data, graph) {
-        this.inputProps = {}; // optional properties for input
-        this.waitlist = new Set(); // List of nodes which need data from this node.
-        this.state = NodeState.Waiting;
-        this.result = undefined;
-        this.retryCount = 0;
-        this.nodeId = nodeId;
-        this.forkIndex = forkIndex;
-        this.inputs = (data.inputs ?? []).map((input) => {
-            const { sourceNodeId, propId } = parseNodeName(input);
-            if (propId) {
-                this.inputProps[sourceNodeId] = propId;
-            }
-            return sourceNodeId;
-        });
-        this.pendings = new Set(this.inputs);
-        this.params = data.params ?? {};
-        this.agentId = data.agentId ?? graph.agentId;
-        this.fork = data.fork;
-        this.retryLimit = data.retry ?? 0;
-        this.timeout = data.timeout;
-        this.source = this.agentId === undefined;
-        this.outputs = data.outputs;
-        this.graph = graph;
-    }
-    asString() {
-        return `${this.nodeId}: ${this.state} ${[...this.waitlist]}`;
-    }
-    retry(state, error) {
-        if (this.retryCount < this.retryLimit) {
-            this.retryCount++;
-            this.execute();
-        }
-        else {
-            this.state = state;
-            this.result = undefined;
-            this.error = error;
-            this.transactionId = undefined; // This is necessary for timeout case
-            this.graph.removeRunning(this);
-        }
-    }
-    removePending(nodeId) {
-        this.pendings.delete(nodeId);
-        if (this.graph.isRunning) {
-            this.pushQueueIfReady();
-        }
-    }
-    pushQueueIfReady() {
-        if (this.pendings.size === 0 && !this.source) {
-            // If input property is specified, we need to ensure that the property value exists.
-            Object.keys(this.inputProps).forEach((nodeId) => {
-                const [result] = this.graph.resultsOf([nodeId]);
-                const propId = this.inputProps[nodeId];
-                if (!result || !(propId in result)) {
-                    return;
-                }
-            });
-            this.graph.pushQueue(this);
-        }
-    }
-    injectValue(value) {
-        if (this.source) {
-            const log = {
-                nodeId: this.nodeId,
-                retryCount: this.retryCount,
-                state: NodeState.Injected,
-                startTime: Date.now(),
-                endTime: Date.now(),
-                result: value,
-            };
-            this.graph.appendLog(log);
-            this.setResult(value, NodeState.Injected);
-        }
-        else {
-            console.error("- injectValue called on non-source node.", this.nodeId);
-        }
-    }
-    setResult(result, state) {
-        this.state = state;
-        this.result = result;
-        this.waitlist.forEach((nodeId) => {
-            const node = this.graph.nodes[nodeId];
-            // Todo: Avoid running before Run()
-            node.removePending(this.nodeId);
-        });
-    }
-    async execute() {
-        const results = this.graph.resultsOf(this.inputs);
-        this.inputs.forEach((nodeId, index) => {
-            const propId = this.inputProps[nodeId];
-            if (propId) {
-                results[index] = results[index][propId];
-            }
-        });
-        const transactionId = Date.now();
-        const log = {
-            nodeId: this.nodeId,
-            retryCount: this.retryCount > 0 ? this.retryCount : undefined,
-            state: NodeState.Executing,
-            startTime: transactionId,
-            agentId: this.agentId,
-            params: this.params,
-            inputs: results.length > 0 ? results : undefined,
-        };
-        this.graph.appendLog(log);
-        this.state = NodeState.Executing;
-        this.transactionId = transactionId;
-        if (this.timeout && this.timeout > 0) {
-            setTimeout(() => {
-                if (this.state === NodeState.Executing && this.transactionId === transactionId) {
-                    console.log(`-- ${this.nodeId}: timeout ${this.timeout}`);
-                    log.errorMessage = "Timeout";
-                    log.state = NodeState.TimedOut;
-                    log.endTime = Date.now();
-                    this.retry(NodeState.TimedOut, Error("Timeout"));
-                }
-            }, this.timeout);
-        }
-        try {
-            const callback = this.graph.getCallback(this.agentId);
-            const localLog = [];
-            const result = await callback({
-                nodeId: this.nodeId,
-                retry: this.retryCount,
-                params: this.params,
-                inputs: results,
-                forkIndex: this.forkIndex,
-                verbose: this.graph.verbose,
-                agents: this.graph.callbackDictonary,
-                log: localLog,
-            });
-            if (this.transactionId !== transactionId) {
-                console.log(`-- ${this.nodeId}: transactionId mismatch`);
-                return;
-            }
-            log.endTime = Date.now();
-            log.result = result;
-            if (localLog.length > 0) {
-                log.log = localLog;
-            }
-            const outputs = this.outputs;
-            if (outputs !== undefined) {
-                Object.keys(outputs).forEach((outputId) => {
-                    const nodeId = outputs[outputId];
-                    const value = result[outputId];
-                    if (value) {
-                        this.graph.injectValue(nodeId, value);
-                    }
-                    else {
-                        console.error("-- Invalid outputId", outputId, result);
-                    }
-                });
-                log.state = NodeState.Dispatched;
-                this.state = NodeState.Dispatched;
-                this.graph.removeRunning(this);
-                return;
-            }
-            log.state = NodeState.Completed;
-            this.setResult(result, NodeState.Completed);
-            this.graph.removeRunning(this);
-        }
-        catch (error) {
-            if (this.transactionId !== transactionId) {
-                console.log(`-- ${this.nodeId}: transactionId mismatch(error)`);
-                return;
-            }
-            log.state = NodeState.Failed;
-            log.endTime = Date.now();
-            if (error instanceof Error) {
-                log.errorMessage = error.message;
-                this.retry(NodeState.Failed, error);
-            }
-            else {
-                console.error(`-- ${this.nodeId}: Unexpecrted error was caught`);
-                log.errorMessage = "Unknown";
-                this.retry(NodeState.Failed, Error("Unknown"));
-            }
-        }
-    }
-}
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphAI = void 0;
+const type_1 = require("./type");
+const node_1 = require("./node");
+const utils_1 = require("./utils/utils");
+const validator_1 = require("./validator");
+const task_manager_1 = require("./task_manager");
+const crypto_1 = __importDefault(require("crypto"));
 const defaultConcurrency = 8;
 class GraphAI {
+    // This method is called when either the GraphAI obect was created,
+    // or we are about to start n-th iteration (n>2).
     createNodes(data) {
-        const nodeId2forkedNodeIds = {};
-        const forkedNodeId2Index = {};
-        const nodes = Object.keys(data.nodes).reduce((nodes, nodeId) => {
-            const fork = data.nodes[nodeId].fork;
-            if (fork) {
-                // For fork, change the nodeId and increase the node
-                nodeId2forkedNodeIds[nodeId] = new Array(fork).fill(undefined).map((_, i) => {
-                    const forkedNodeId = `${nodeId}_${i}`;
-                    nodes[forkedNodeId] = new Node(forkedNodeId, i, data.nodes[nodeId], this);
-                    // Data for pending and waiting
-                    forkedNodeId2Index[forkedNodeId] = i;
-                    return forkedNodeId;
-                });
+        const nodes = Object.keys(data.nodes).reduce((_nodes, nodeId) => {
+            const isStaticNode = "value" in data.nodes[nodeId];
+            if (isStaticNode) {
+                _nodes[nodeId] = new node_1.StaticNode(nodeId, data.nodes[nodeId], this);
             }
             else {
-                nodes[nodeId] = new Node(nodeId, undefined, data.nodes[nodeId], this);
+                const nodeData = data.nodes[nodeId];
+                _nodes[nodeId] = new node_1.ComputedNode(this.graphId, nodeId, nodeData, this);
             }
-            return nodes;
+            return _nodes;
         }, {});
-        // Generate the waitlist for each node, and update the pendings in case of forked node.
+        // Generate the waitlist for each node.
         Object.keys(nodes).forEach((nodeId) => {
             const node = nodes[nodeId];
-            node.pendings.forEach((pending) => {
-                // If the pending(previous) node is forking
-                if (nodeId2forkedNodeIds[pending]) {
-                    //  update node.pending and pending(previous) node.wailtlist
-                    if (node.fork) {
-                        //  1:1 if current nodes are also forking.
-                        const newPendingId = nodeId2forkedNodeIds[pending][forkedNodeId2Index[nodeId]];
-                        nodes[newPendingId].waitlist.add(nodeId); // previousNode
-                        node.pendings.add(newPendingId);
-                    }
-                    else {
-                        //  1:n if current node is not forking.
-                        nodeId2forkedNodeIds[pending].forEach((newPendingId) => {
-                            nodes[newPendingId].waitlist.add(nodeId); // previousNode
-                            node.pendings.add(newPendingId);
-                        });
-                    }
-                    node.pendings.delete(pending);
-                }
-                else {
+            if (node.isComputedNode) {
+                node.pendings.forEach((pending) => {
                     if (nodes[pending]) {
                         nodes[pending].waitlist.add(nodeId); // previousNode
                     }
                     else {
                         console.error(`--- invalid input ${pending} for node, ${nodeId}`);
                     }
-                }
-            });
-            node.inputs = Array.from(node.pendings); // for fork.
+                });
+            }
         });
         return nodes;
     }
     getValueFromResults(key, results) {
-        const { sourceNodeId, propId } = parseNodeName(key);
-        const result = results[sourceNodeId];
-        return result ? (propId ? result[propId] : result) : undefined;
+        const source = (0, utils_1.parseNodeName)(key);
+        const result = results[source.nodeId];
+        return result && source.propId ? result[source.propId] : result;
     }
+    // for static
     initializeNodes(previousResults) {
         // If the result property is specified, inject it.
         // If the previousResults exists (indicating we are in a loop),
-        // process the next property (nodeId or nodeId.propId).
+        // process the update property (nodeId or nodeId.propId).
         Object.keys(this.data.nodes).forEach((nodeId) => {
-            const node = this.data.nodes[nodeId];
-            const { value, next } = node;
-            if (value) {
-                this.injectValue(nodeId, value);
-            }
-            if (next && previousResults) {
-                const result = this.getValueFromResults(next, previousResults);
-                if (result) {
-                    this.injectValue(nodeId, result);
+            const node = this.nodes[nodeId];
+            if (node?.isStaticNode) {
+                const value = node?.value;
+                const update = node?.update;
+                if (value) {
+                    this.injectValue(nodeId, value, nodeId);
+                }
+                if (update && previousResults) {
+                    const result = this.getValueFromResults(update, previousResults);
+                    if (result) {
+                        this.injectValue(nodeId, result, update);
+                    }
                 }
             }
         });
     }
-    constructor(data, callbackDictonary) {
-        this.isRunning = false;
-        this.runningNodes = new Set();
-        this.nodeQueue = [];
-        this.repeatCount = 0;
+    constructor(data, callbackDictonary, taskManager = undefined) {
         this.logs = [];
+        this.onLogCallback = (__log, __isUpdate) => { };
+        this.repeatCount = 0;
+        this.graphId = crypto_1.default.randomUUID();
         this.data = data;
         this.callbackDictonary = callbackDictonary;
-        this.concurrency = data.concurrency ?? defaultConcurrency;
+        this.taskManager = taskManager ?? new task_manager_1.TaskManager(data.concurrency ?? defaultConcurrency);
         this.loop = data.loop;
-        this.agentId = data.agentId;
         this.verbose = data.verbose === true;
         this.onComplete = () => {
             console.error("-- SOMETHING IS WRONG: onComplete is called without run()");
         };
+        (0, validator_1.validateGraphData)(data, Object.keys(callbackDictonary));
         this.nodes = this.createNodes(data);
         this.initializeNodes();
     }
@@ -306,14 +93,18 @@ class GraphAI {
         throw new Error("No agent: " + agentId);
     }
     asString() {
-        return Object.keys(this.nodes)
-            .map((nodeId) => {
-            return this.nodes[nodeId].asString();
-        })
+        return Object.values(this.nodes)
+            .map((node) => node.asString())
             .join("\n");
     }
-    results() {
-        return Object.keys(this.nodes).reduce((results, nodeId) => {
+    // Public API
+    results(all) {
+        return Object.keys(this.nodes)
+            .filter((nodeId) => {
+            const node = this.nodes[nodeId];
+            return all || node.isResult;
+        })
+            .reduce((results, nodeId) => {
             const node = this.nodes[nodeId];
             if (node.result !== undefined) {
                 results[nodeId] = node.result;
@@ -321,11 +112,14 @@ class GraphAI {
             return results;
         }, {});
     }
+    // Public API
     errors() {
         return Object.keys(this.nodes).reduce((errors, nodeId) => {
             const node = this.nodes[nodeId];
-            if (node.error !== undefined) {
-                errors[nodeId] = node.error;
+            if (node.isComputedNode) {
+                if (node.error !== undefined) {
+                    errors[nodeId] = node.error;
+                }
             }
             return errors;
         }, {});
@@ -334,92 +128,116 @@ class GraphAI {
         // Nodes without pending data should run immediately.
         Object.keys(this.nodes).forEach((nodeId) => {
             const node = this.nodes[nodeId];
-            node.pushQueueIfReady();
+            if (node.isComputedNode) {
+                this.pushQueueIfReady(node);
+            }
         });
     }
-    async run() {
-        if (this.isRunning) {
+    pushQueueIfReady(node) {
+        if (node.isReadyNode()) {
+            this.pushQueue(node);
+        }
+    }
+    pushQueueIfReadyAndRunning(node) {
+        if (this.isRunning()) {
+            this.pushQueueIfReady(node);
+        }
+    }
+    // for computed
+    pushQueue(node) {
+        node.state = type_1.NodeState.Queued;
+        this.taskManager.addTask(node, this.graphId, (_node) => {
+            (0, utils_1.assert)(node.nodeId === _node.nodeId, "GraphAI.pushQueue node mismatch");
+            node.execute();
+        });
+    }
+    // Public API
+    async run(all = false) {
+        if (this.isRunning()) {
             console.error("-- Already Running");
         }
-        this.isRunning = true;
         this.pushReadyNodesIntoQueue();
         return new Promise((resolve, reject) => {
             this.onComplete = () => {
-                this.isRunning = false;
                 const errors = this.errors();
                 const nodeIds = Object.keys(errors);
                 if (nodeIds.length > 0) {
                     reject(errors[nodeIds[0]]);
                 }
                 else {
-                    resolve(this.results());
+                    resolve(this.results(all));
                 }
             };
         });
     }
-    runNode(node) {
-        this.runningNodes.add(node.nodeId);
-        node.execute();
-    }
-    pushQueue(node) {
-        if (this.runningNodes.size < this.concurrency) {
-            this.runNode(node);
-        }
-        else {
-            this.nodeQueue.push(node);
-        }
-    }
-    removeRunning(node) {
-        this.runningNodes.delete(node.nodeId);
-        if (this.nodeQueue.length > 0) {
-            const n = this.nodeQueue.shift();
-            if (n) {
-                this.runNode(n);
-            }
-        }
-        if (this.runningNodes.size === 0) {
-            this.repeatCount++;
-            const loop = this.loop;
-            if (loop && (loop.count === undefined || this.repeatCount < loop.count)) {
-                const results = this.results(); // results from previous loop
-                this.isRunning = false; // temporarily stop it
-                this.nodes = this.createNodes(this.data);
-                this.initializeNodes(results);
-                const checkWhileCondition = () => {
-                    if (loop.while) {
-                        const value = this.getValueFromResults(loop.while, this.results());
-                        // NOTE: We treat an empty array as false.
-                        return Array.isArray(value) ? value.length > 0 : !!value;
-                    }
-                    return true;
-                };
-                if (checkWhileCondition()) {
-                    this.isRunning = true; // restore it
-                    this.pushReadyNodesIntoQueue();
-                    return;
+    // Public only for testing
+    isRunning() {
+        return this.taskManager.isRunning(this.graphId);
+    }
+    // callback from execute
+    onExecutionComplete(node) {
+        this.taskManager.onComplete(node);
+        if (this.isRunning() || this.processLoopIfNecessary()) {
+            return; // continue running
+        }
+        this.onComplete(); // Nothing to run. Finish it.
+    }
+    // Must be called only from onExecutionComplete righ after removeRunning
+    // Check if there is any running computed nodes.
+    // In case of no running computed note, start the another iteration if ncessary (loop)
+    processLoopIfNecessary() {
+        this.repeatCount++;
+        const loop = this.loop;
+        if (loop && (loop.count === undefined || this.repeatCount < loop.count)) {
+            const results = this.results(true); // results from previous loop
+            this.nodes = this.createNodes(this.data);
+            this.initializeNodes(results);
+            // Notice that we need to check the while condition *after* calling initializeNodes.
+            if (loop.while) {
+                const value = this.getValueFromResults(loop.while, this.results(true));
+                // NOTE: We treat an empty array as false.
+                if (Array.isArray(value) ? value.length === 0 : !value) {
+                    return false; // while condition is not met
                 }
             }
-            this.onComplete();
+            this.pushReadyNodesIntoQueue();
+            return true; // Indicating that we are going to continue.
         }
+        return false;
+    }
+    setLoopLog(log) {
+        log.isLoop = !!this.loop;
+        log.repeatCount = this.repeatCount;
     }
     appendLog(log) {
         this.logs.push(log);
+        this.onLogCallback(log, false);
     }
+    updateLog(log) {
+        this.onLogCallback(log, true);
+    }
+    // Public API
     transactionLogs() {
         return this.logs;
     }
-    injectValue(nodeId, value) {
+    // Public API
+    injectValue(nodeId, value, injectFrom) {
         const node = this.nodes[nodeId];
-        if (node) {
-            node.injectValue(value);
+        if (node && node.isStaticNode) {
+            node.injectValue(value, injectFrom);
         }
         else {
-            console.error("-- Invalid nodeId", nodeId);
+            console.error("-- Inject Error: Invalid nodeId", nodeId);
+            console.error("InjectionTo can only specify static nodes");
         }
     }
-    resultsOf(nodeIds) {
-        return nodeIds.map((nodeId) => {
-            return this.nodes[nodeId].result;
+    resultsOf(sources, anyInput = false) {
+        return sources.map((source) => {
+            const { result } = this.nodes[source.nodeId];
+            if (source.propId) {
+                (0, utils_1.assert)((0, utils_1.isObject)(result), `resultsOf: result is not object. nodeId ${source.nodeId}`, anyInput);
+            }
+            return result && source.propId ? result[source.propId] : result;
         });
     }
 }

package/lib/index.d.ts

@@ -1,2 +1,4 @@
 import { GraphAI } from "./graphai";
 export { GraphAI };
+export { AgentFunction, AgentFunctionDictonary, GraphData, ResultDataDictonary, ResultData } from "./type";
+export type { TransactionLog } from "./transaction_log";

package/lib/log.d.ts

@@ -0,0 +1,22 @@
+import { ResultData, NodeDataParams, NodeState } from "./type";
+import type { GraphAI } from "./graphai";
+import type { ComputedNode, StaticNode } from "./node";
+export declare class TransactionLog {
+    nodeId: string;
+    state: NodeState;
+    startTime?: number;
+    endTime?: number;
+    retryCount?: number;
+    agentId?: string;
+    params?: NodeDataParams;
+    inputs?: Array<ResultData>;
+    errorMessage?: string;
+    result?: ResultData;
+    log?: TransactionLog[];
+    constructor(nodeId: string);
+    initForComputedNode(node: ComputedNode): void;
+    onInjected(node: StaticNode, graph: GraphAI): void;
+    onComplete(node: ComputedNode, graph: GraphAI, localLog: TransactionLog[]): void;
+    beforeExecute(node: ComputedNode, graph: GraphAI, transactionId: number, inputs: ResultData[]): void;
+    onError(node: ComputedNode, graph: GraphAI, errorMessage: string): void;
+}

package/lib/log.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionLog = void 0;
+const type_1 = require("./type");
+class TransactionLog {
+    constructor(nodeId) {
+        this.nodeId = nodeId;
+        this.state = type_1.NodeState.Waiting;
+    }
+    initForComputedNode(node) {
+        this.agentId = node.agentId;
+        this.params = node.params;
+    }
+    onInjected(node, graph) {
+        const isUpdating = "endTime" in this;
+        this.result = node.value;
+        this.state = node.state;
+        this.endTime = Date.now();
+        if (isUpdating) {
+            graph.updateLog(this);
+        }
+        else {
+            graph.appendLog(this);
+        }
+    }
+    onComplete(node, graph, localLog) {
+        this.result = node.result;
+        this.state = node.state;
+        this.endTime = Date.now();
+        if (localLog.length > 0) {
+            this.log = localLog;
+        }
+        graph.updateLog(this);
+    }
+    beforeExecute(node, graph, transactionId, inputs) {
+        this.state = node.state;
+        this.retryCount = node.retryCount > 0 ? node.retryCount : undefined;
+        this.startTime = transactionId;
+        this.inputs = inputs.length > 0 ? inputs : undefined;
+        graph.appendLog(this);
+    }
+    onError(node, graph, errorMessage) {
+        this.state = node.state;
+        this.errorMessage = errorMessage;
+        this.endTime = Date.now();
+        graph.updateLog(this);
+    }
+}
+exports.TransactionLog = TransactionLog;