graphai 0.1.0 → 0.1.1

package/lib/graphai.js

@@ -1,78 +1,51 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 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 forkedNodeId2NodeId = {}; // for sources
         const nodes = Object.keys(data.nodes).reduce((_nodes, nodeId) => {
-            const fork = data.nodes[nodeId].fork;
-            const isStaticNode = (data.nodes[nodeId].agentId ?? data.agentId) === undefined;
-            const node = isStaticNode ? node_1.StaticNode : node_1.ComputedNode;
-            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;
-                    forkedNodeId2NodeId[forkedNodeId] = nodeId;
-                    return forkedNodeId;
-                });
+            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;
         }, {});
-        // 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.
-            node.sources = node.inputs.reduce((sources, input) => {
-                const refNodeId = forkedNodeId2NodeId[input] ?? input;
-                sources[input] = { nodeId: input, propId: node.sources[refNodeId].propId };
-                return sources;
-            }, {});
+                });
+            }
         });
         return nodes;
     }
     getValueFromResults(key, results) {
         const source = (0, utils_1.parseNodeName)(key);
         const result = results[source.nodeId];
-        return result ? (source.propId ? result[source.propId] : result) : undefined;
+        return result && source.propId ? result[source.propId] : result;
     }
     // for static
     initializeNodes(previousResults) {
@@ -85,32 +58,31 @@ class GraphAI {
                 const value = node?.value;
                 const update = node?.update;
                 if (value) {
-                    this.injectValue(nodeId, value);
+                    this.injectValue(nodeId, value, nodeId);
                 }
                 if (update && previousResults) {
                     const result = this.getValueFromResults(update, previousResults);
                     if (result) {
-                        this.injectValue(nodeId, result);
+                        this.injectValue(nodeId, result, update);
                     }
                 }
             }
         });
     }
-    constructor(data, callbackDictonary) {
-        this.isRunning = false;
-        this.runningNodes = new Set();
-        this.nodeQueue = []; // for Computed Node
-        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();
     }
@@ -121,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;
@@ -136,6 +112,7 @@ class GraphAI {
             return results;
         }, {});
     }
+    // Public API
     errors() {
         return Object.keys(this.nodes).reduce((errors, nodeId) => {
             const node = this.nodes[nodeId];
@@ -152,96 +129,114 @@ class GraphAI {
         Object.keys(this.nodes).forEach((nodeId) => {
             const node = this.nodes[nodeId];
             if (node.isComputedNode) {
-                node.pushQueueIfReady();
+                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));
                 }
             };
         });
     }
-    // for computed
-    runNode(node) {
-        this.runningNodes.add(node.nodeId);
-        node.execute();
-    }
-    // for computed
-    pushQueue(node) {
-        if (this.runningNodes.size < this.concurrency) {
-            this.runNode(node);
-        }
-        else {
-            this.nodeQueue.push(node);
-        }
+    // Public only for testing
+    isRunning() {
+        return this.taskManager.isRunning(this.graphId);
     }
-    // for completed
-    removeRunning(node) {
-        this.runningNodes.delete(node.nodeId);
-        if (this.nodeQueue.length > 0) {
-            const n = this.nodeQueue.shift();
-            if (n) {
-                this.runNode(n);
-            }
+    // callback from execute
+    onExecutionComplete(node) {
+        this.taskManager.onComplete(node);
+        if (this.isRunning() || this.processLoopIfNecessary()) {
+            return; // continue running
         }
-        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;
+        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.isStaticNode) {
-            node.injectValue(value);
+            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(sources) {
+    resultsOf(sources, anyInput = false) {
         return sources.map((source) => {
-            const result = this.nodes[source.nodeId].result;
+            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

@@ -1,6 +1,22 @@
-import { ResultData, TransactionLog, NodeDataParams } from "./type";
-export declare const injectValueLog: (nodeId: string, value: ResultData) => TransactionLog;
-export declare const executeLog: (nodeId: string, retryCount: number, transactionId: number, agentId: string | undefined, params: NodeDataParams, results: ResultData[]) => TransactionLog;
-export declare const timeoutLog: (log: TransactionLog) => void;
-export declare const callbackLog: (log: TransactionLog, result: ResultData, localLog: TransactionLog[]) => void;
-export declare const errorLog: (log: TransactionLog, errorMessage: string) => void;
+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

@@ -1,48 +1,49 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.errorLog = exports.callbackLog = exports.timeoutLog = exports.executeLog = exports.injectValueLog = void 0;
+exports.TransactionLog = void 0;
 const type_1 = require("./type");
-const injectValueLog = (nodeId, value) => {
-    const log = {
-        nodeId,
-        state: type_1.NodeState.Injected,
-        startTime: Date.now(),
-        endTime: Date.now(),
-        result: value,
-    };
-    return log;
-};
-exports.injectValueLog = injectValueLog;
-const executeLog = (nodeId, retryCount, transactionId, agentId, params, results) => {
-    const log = {
-        nodeId,
-        retryCount: retryCount > 0 ? retryCount : undefined,
-        state: type_1.NodeState.Executing,
-        startTime: transactionId,
-        agentId,
-        params,
-        inputs: results.length > 0 ? results : undefined,
-    };
-    return log;
-};
-exports.executeLog = executeLog;
-const timeoutLog = (log) => {
-    log.errorMessage = "Timeout";
-    log.state = type_1.NodeState.TimedOut;
-    log.endTime = Date.now();
-};
-exports.timeoutLog = timeoutLog;
-const callbackLog = (log, result, localLog) => {
-    log.endTime = Date.now();
-    log.result = result;
-    if (localLog.length > 0) {
-        log.log = localLog;
+class TransactionLog {
+    constructor(nodeId) {
+        this.nodeId = nodeId;
+        this.state = type_1.NodeState.Waiting;
     }
-};
-exports.callbackLog = callbackLog;
-const errorLog = (log, errorMessage) => {
-    log.state = type_1.NodeState.Failed;
-    log.endTime = Date.now();
-    log.errorMessage = errorMessage;
-};
-exports.errorLog = errorLog;
+    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;

package/lib/node.d.ts

@@ -1,44 +1,50 @@
-import type { NodeDataParams, ResultData, DataSource, NodeData } from "./type";
-import type { GraphAI } from "./graphai";
-import { NodeState } from "./type";
+import type { GraphAI, GraphData } from "./graphai";
+import { NodeDataParams, ResultData, DataSource, ComputedNodeData, StaticNodeData, NodeState } from "./type";
+import { TransactionLog } from "./transaction_log";
 export declare class Node {
-    nodeId: string;
-    sources: Record<string, DataSource>;
-    anyInput: boolean;
-    inputs: Array<string>;
-    pendings: Set<string>;
-    waitlist: Set<string>;
+    readonly nodeId: string;
+    readonly waitlist: Set<string>;
     state: NodeState;
-    fork?: number;
-    forkIndex?: number;
-    result: ResultData;
-    transactionId: undefined | number;
+    result: ResultData | undefined;
     protected graph: GraphAI;
-    constructor(nodeId: string, forkIndex: number | undefined, data: NodeData, graph: GraphAI);
+    protected log: TransactionLog;
+    constructor(nodeId: string, graph: GraphAI);
     asString(): string;
-    removePending(nodeId: string): void;
-    protected setResult(result: ResultData, state: NodeState): void;
+    protected onSetResult(): void;
 }
 export declare class ComputedNode extends Node {
-    params: NodeDataParams;
-    retryLimit: number;
+    readonly graphId: string;
+    readonly isResult: boolean;
+    readonly params: NodeDataParams;
+    readonly nestedGraph?: GraphData;
+    readonly retryLimit: number;
     retryCount: number;
-    agentId?: string;
-    timeout?: number;
+    readonly agentId?: string;
+    readonly timeout?: number;
     error?: Error;
+    transactionId: undefined | number;
+    sources: Record<string, DataSource>;
+    readonly anyInput: boolean;
+    inputs: Array<string>;
+    pendings: Set<string>;
     readonly isStaticNode = false;
     readonly isComputedNode = true;
-    constructor(nodeId: string, forkIndex: number | undefined, data: NodeData, graph: GraphAI);
-    pushQueueIfReady(): void;
+    constructor(graphId: string, nodeId: string, data: ComputedNodeData, graph: GraphAI);
+    isReadyNode(): boolean;
     private retry;
     removePending(nodeId: string): void;
+    private isCurrentTransaction;
+    private executeTimeout;
     execute(): Promise<void>;
+    private prepareExecute;
+    private errorProcess;
 }
 export declare class StaticNode extends Node {
     value?: ResultData;
-    update?: string;
+    readonly update?: string;
+    readonly isResult: boolean;
     readonly isStaticNode = true;
     readonly isComputedNode = false;
-    constructor(nodeId: string, forkIndex: number | undefined, data: NodeData, graph: GraphAI);
-    injectValue(value: ResultData): void;
+    constructor(nodeId: string, data: StaticNodeData, graph: GraphAI);
+    injectValue(value: ResultData, injectFrom?: string): void;
 }