graphai 0.0.3 → 0.0.5

package/.github/workflows/node.js.yml

@@ -0,0 +1,27 @@
+# This workflow will do a clean installation of node dependencies, cache/restore them, build the source code and run tests across different versions of node
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-nodejs
+
+name: Node.js CI
+
+on:
+  pull_request
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [18.x, 20.x]
+        # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
+
+    steps:
+    - uses: actions/checkout@v4
+    - name: Use Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v4
+      with:
+        node-version: ${{ matrix.node-version }}
+        cache: 'npm'
+    - run: yarn install
+    - run: yarn test

package/README.md

@@ -1,6 +1,6 @@
 # GraphAI
 
-GraphAI is a TypeScript library, which makes it easy to create AI applications that need to make asynchronous AI API calls multiple times with some dependencies among them, such as giving the answer from one LLM call to another LLM call as a prompt. 
+GraphAI is an asynchronous data flow execution engine, which makes it easy to create AI applications that need to make asynchronous AI API calls multiple times with some dependencies among them, such as giving the answer from one LLM call to another LLM call as a prompt.
 
 You just need to describe dependencies among those API calls in a single graph definition file (in JSON or YAML), create a GraphAI object with it, and run it.
 
@@ -38,7 +38,6 @@ const nodeExecute = async (context: NodeExecuteContext) => {
   const graph = new GraphAI(graph_data, nodeExecute);
   const results = await graph.run();
   return results["taskC"];
-
 ```
 
 

package/lib/graphai.d.ts

@@ -5,24 +5,36 @@ export declare enum NodeState {
     TimedOut = 3,
     Completed = 4
 }
-type ResultData = Record<string, any>;
-export type NodeDataParams = Record<string, any>;
+type ResultData<ResultType = Record<string, any>> = ResultType | undefined;
+type ResultDataDictonary<ResultType = Record<string, any>> = Record<string, ResultData<ResultType>>;
+export type NodeDataParams<ParamsType = Record<string, any>> = ParamsType;
 type NodeData = {
     inputs: undefined | Array<string>;
     params: NodeDataParams;
     retry: undefined | number;
     timeout: undefined | number;
+    functionName: undefined | string;
 };
 type GraphData = {
     nodes: Record<string, NodeData>;
+    concurrency: number;
 };
-export type NodeExecuteContext = {
+type NodeExecuteContext<ResultType, ParamsType> = {
     nodeId: string;
     retry: number;
-    params: NodeDataParams;
-    payload: ResultData;
+    params: NodeDataParams<ParamsType>;
+    payload: ResultDataDictonary<ResultType>;
+};
+export type TransactionLog = {
+    nodeId: string;
+    state: NodeState;
+    startTime: undefined | number;
+    endTime: undefined | number;
+    retryCount: number;
+    error: undefined | Error;
+    result?: ResultData;
 };
-type NodeExecute = (context: NodeExecuteContext) => Promise<ResultData>;
+export type NodeExecute<ResultType = Record<string, any>, ParamsType = Record<string, any>> = (context: NodeExecuteContext<ResultType, ParamsType>) => Promise<ResultData<ResultType>>;
 declare class Node {
     nodeId: string;
     params: NodeDataParams;
@@ -30,29 +42,42 @@ declare class Node {
     pendings: Set<string>;
     waitlist: Set<string>;
     state: NodeState;
+    functionName: string;
     result: ResultData;
     retryLimit: number;
     retryCount: number;
     transactionId: undefined | number;
     timeout: number;
-    constructor(nodeId: string, data: NodeData);
+    error: undefined | Error;
+    private graph;
+    constructor(nodeId: string, data: NodeData, graph: GraphAI);
     asString(): string;
     private retry;
-    removePending(nodeId: string, graph: GraphAI): void;
-    payload(graph: GraphAI): ResultData;
-    executeIfReady(graph: GraphAI): void;
-    private execute;
+    removePending(nodeId: string): void;
+    payload(): ResultDataDictonary<Record<string, any>>;
+    pushQueueIfReady(): void;
+    execute(): Promise<void>;
 }
 type GraphNodes = Record<string, Node>;
+type NodeExecuteDictonary = Record<string, NodeExecute>;
 export declare class GraphAI {
     nodes: GraphNodes;
-    callback: NodeExecute;
+    callbackDictonary: NodeExecuteDictonary;
     private runningNodes;
+    private nodeQueue;
     private onComplete;
-    constructor(data: GraphData, callback: NodeExecute);
+    private concurrency;
+    private logs;
+    constructor(data: GraphData, callbackDictonary: NodeExecuteDictonary | NodeExecute);
+    getCallback(functionName: string): NodeExecute<Record<string, any>, Record<string, any>>;
     asString(): string;
+    results(): ResultDataDictonary<Record<string, any>>;
+    errors(): Record<string, Error>;
     run(): Promise<unknown>;
-    addRunning(node: Node): void;
+    private runNode;
+    pushQueue(node: Node): void;
     removeRunning(node: Node): void;
+    appendLog(log: TransactionLog): void;
+    transactionLogs(): TransactionLog[];
 }
 export {};

package/lib/graphai.js

@@ -10,90 +10,131 @@ var NodeState;
     NodeState[NodeState["Completed"] = 4] = "Completed";
 })(NodeState || (exports.NodeState = NodeState = {}));
 class Node {
-    constructor(nodeId, data) {
+    constructor(nodeId, data, graph) {
         this.nodeId = nodeId;
         this.inputs = data.inputs ?? [];
         this.pendings = new Set(this.inputs);
         this.params = data.params;
         this.waitlist = new Set();
         this.state = NodeState.Waiting;
-        this.result = {};
+        this.functionName = data.functionName ?? "default";
+        this.result = undefined;
         this.retryLimit = data.retry ?? 0;
         this.retryCount = 0;
         this.timeout = data.timeout ?? 0;
+        this.graph = graph;
     }
     asString() {
         return `${this.nodeId}: ${this.state} ${[...this.waitlist]}`;
     }
-    retry(graph, state, result) {
+    retry(state, error) {
         if (this.retryCount < this.retryLimit) {
             this.retryCount++;
-            this.execute(graph);
+            this.execute();
         }
         else {
             this.state = state;
-            this.result = result;
-            graph.removeRunning(this);
+            this.result = undefined;
+            this.error = error;
+            this.transactionId = 0; // This is necessary for timeout case
+            this.graph.removeRunning(this);
         }
     }
-    removePending(nodeId, graph) {
+    removePending(nodeId) {
         this.pendings.delete(nodeId);
-        this.executeIfReady(graph);
+        this.pushQueueIfReady();
     }
-    payload(graph) {
+    payload() {
         return this.inputs.reduce((results, nodeId) => {
-            results[nodeId] = graph.nodes[nodeId].result;
+            results[nodeId] = this.graph.nodes[nodeId].result;
             return results;
         }, {});
     }
-    executeIfReady(graph) {
-        if (this.pendings.size == 0) {
-            graph.addRunning(this);
-            this.execute(graph);
+    pushQueueIfReady() {
+        if (this.pendings.size === 0) {
+            this.graph.pushQueue(this);
         }
     }
-    async execute(graph) {
+    async execute() {
+        const log = {
+            nodeId: this.nodeId,
+            retryCount: this.retryCount,
+            state: NodeState.Executing,
+            startTime: Date.now(),
+            endTime: undefined,
+            error: undefined,
+        };
+        this.graph.appendLog(log);
         this.state = NodeState.Executing;
-        const transactionId = Date.now();
+        const transactionId = log.startTime;
         this.transactionId = transactionId;
         if (this.timeout > 0) {
             setTimeout(() => {
-                if (this.state == NodeState.Executing && this.transactionId == transactionId) {
-                    console.log("*** timeout", this.timeout);
-                    this.retry(graph, NodeState.TimedOut, {});
+                if (this.state === NodeState.Executing && this.transactionId === transactionId) {
+                    console.log(`-- ${this.nodeId}: timeout ${this.timeout}`);
+                    log.error = Error("Timeout");
+                    log.state = NodeState.TimedOut;
+                    log.endTime = Date.now();
+                    this.retry(NodeState.TimedOut, Error("Timeout"));
                 }
             }, this.timeout);
         }
         try {
-            const result = await graph.callback({ nodeId: this.nodeId, retry: this.retryCount, params: this.params, payload: this.payload(graph) });
+            const callback = this.graph.getCallback(this.functionName);
+            const result = await callback({
+                nodeId: this.nodeId,
+                retry: this.retryCount,
+                params: this.params,
+                payload: this.payload(),
+            });
             if (this.transactionId !== transactionId) {
-                console.log("****** tid mismatch (success)");
+                console.log(`-- ${this.nodeId}: transactionId mismatch`);
                 return;
             }
+            log.state = NodeState.Completed;
+            log.endTime = Date.now();
+            log.result = result;
             this.state = NodeState.Completed;
             this.result = result;
             this.waitlist.forEach((nodeId) => {
-                const node = graph.nodes[nodeId];
-                node.removePending(this.nodeId, graph);
+                const node = this.graph.nodes[nodeId];
+                node.removePending(this.nodeId);
             });
-            graph.removeRunning(this);
+            this.graph.removeRunning(this);
         }
-        catch (e) {
+        catch (error) {
             if (this.transactionId !== transactionId) {
-                console.log("****** tid mismatch (failed)");
+                console.log(`-- ${this.nodeId}: transactionId mismatch(error)`);
                 return;
             }
-            this.retry(graph, NodeState.Failed, {});
+            log.state = NodeState.Failed;
+            log.endTime = Date.now();
+            if (error instanceof Error) {
+                log.error = error;
+                this.retry(NodeState.Failed, error);
+            }
+            else {
+                console.error(`-- ${this.nodeId}: Unexpecrted error was caught`);
+                log.error = Error("Unknown");
+                this.retry(NodeState.Failed, Error("Unknown"));
+            }
         }
     }
 }
+const defaultConcurrency = 8;
 class GraphAI {
-    constructor(data, callback) {
-        this.callback = callback;
+    constructor(data, callbackDictonary) {
+        this.logs = [];
+        this.callbackDictonary = typeof callbackDictonary === "function" ? { default: callbackDictonary } : callbackDictonary;
+        if (this.callbackDictonary["default"] === undefined) {
+            throw new Error("No default function");
+        }
+        this.concurrency = data.concurrency ?? defaultConcurrency;
         this.runningNodes = new Set();
+        this.nodeQueue = [];
         this.onComplete = () => { };
         this.nodes = Object.keys(data.nodes).reduce((nodes, nodeId) => {
-            nodes[nodeId] = new Node(nodeId, data.nodes[nodeId]);
+            nodes[nodeId] = new Node(nodeId, data.nodes[nodeId], this);
             return nodes;
         }, {});
         // Generate the waitlist for each node
@@ -105,6 +146,12 @@ class GraphAI {
             });
         });
     }
+    getCallback(functionName) {
+        if (functionName && this.callbackDictonary[functionName]) {
+            return this.callbackDictonary[functionName];
+        }
+        return this.callbackDictonary["default"];
+    }
     asString() {
         return Object.keys(this.nodes)
             .map((nodeId) => {
@@ -112,30 +159,72 @@ class GraphAI {
         })
             .join("\n");
     }
+    results() {
+        return Object.keys(this.nodes).reduce((results, nodeId) => {
+            const node = this.nodes[nodeId];
+            if (node.result !== undefined) {
+                results[nodeId] = node.result;
+            }
+            return results;
+        }, {});
+    }
+    errors() {
+        return Object.keys(this.nodes).reduce((errors, nodeId) => {
+            const node = this.nodes[nodeId];
+            if (node.error !== undefined) {
+                errors[nodeId] = node.error;
+            }
+            return errors;
+        }, {});
+    }
     async run() {
         // Nodes without pending data should run immediately.
         Object.keys(this.nodes).forEach((nodeId) => {
             const node = this.nodes[nodeId];
-            node.executeIfReady(this);
+            node.pushQueueIfReady();
         });
         return new Promise((resolve, reject) => {
             this.onComplete = () => {
-                const results = Object.keys(this.nodes).reduce((results, nodeId) => {
-                    results[nodeId] = this.nodes[nodeId].result;
-                    return results;
-                }, {});
-                resolve(results);
+                const errors = this.errors();
+                const nodeIds = Object.keys(errors);
+                if (nodeIds.length > 0) {
+                    reject(errors[nodeIds[0]]);
+                }
+                else {
+                    resolve(this.results());
+                }
             };
         });
     }
-    addRunning(node) {
+    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.runningNodes.size == 0) {
+        if (this.nodeQueue.length > 0) {
+            const n = this.nodeQueue.shift();
+            if (n) {
+                this.runNode(n);
+            }
+        }
+        if (this.runningNodes.size === 0) {
             this.onComplete();
         }
     }
+    appendLog(log) {
+        this.logs.push(log);
+    }
+    transactionLogs() {
+        return this.logs;
+    }
 }
 exports.GraphAI = GraphAI;

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "graphai",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "description": "Asynchronous data flow execution engine to make it simple to build LLM apps.",
   "main": "lib/index.js",
   "scripts": {
     "build": "tsc",
     "eslint": "eslint --fix --ext src/**/*.{ts} tests/**/*.ts",
     "format": "prettier --write '{src,tests}/**/*.ts'",
-    "test": "node --test --require ts-node/register ./tests/sample_flow.ts"
+    "test": "node --test --require ts-node/register ./tests/test_*.ts",
+    "gpt": "npx ts-node ./samples/sample_gpt.ts"
   },
   "repository": {
     "type": "git",
@@ -25,13 +26,13 @@
     "@typescript-eslint/parser": "^6.8.0",
     "eslint": "^7.32.0 || ^8.2.0",
     "eslint-plugin-import": "^2.25.2",
+    "openai": "^4.12.4",
     "prettier": "^3.0.3",
-    "slashgpt": "^0.0.6",
+    "slashgpt": "^0.0.8",
     "ts-node": "^10.9.1",
     "typescript": "^5.2.2"
   },
   "dependencies": {
-    "openai": "^4.12.4",
     "yaml": "^2.3.3"
   },
   "types": "./lib/index.d.ts",

package/{tests → samples}/sample_gpt.ts

@@ -1,15 +1,15 @@
 import path from "path";
-import { GraphAI, NodeExecuteContext } from "../src/graphai";
+import { GraphAI, NodeExecute } from "../src/graphai";
 import { ChatSession, ChatConfig } from "slashgpt";
-import { readManifestData } from "../src/file_utils";
+import { readManifestData } from "../tests/file_utils";
 
 const config = new ChatConfig(path.resolve(__dirname));
 
-const testFunction = async (context: NodeExecuteContext) => {
-  console.log("executing", context.nodeId, context.params, context.payload);
+const testFunction: NodeExecute<Record<string, string>> = async (context) => {
+  console.log("executing", context.nodeId, context.params);
   const session = new ChatSession(config, context.params.manifest ?? {});
   const prompt = Object.keys(context.payload).reduce((prompt, key) => {
-    return prompt.replace("${" + key + "}", context.payload[key]["answer"]);
+    return prompt.replace("${" + key + "}", context.payload[key]!["answer"]);
   }, context.params.prompt);
   session.append_user_question(prompt);
 
@@ -31,7 +31,7 @@ const test = async (file: string) => {
 };
 
 const main = async () => {
-  await test("/graphs/sample3.yml");
+  await test("/graphs/slash_gpt.yml");
   console.log("COMPLETE 1");
 };
 main();

package/src/graphai.ts

@@ -7,28 +7,44 @@ export enum NodeState {
   TimedOut,
   Completed,
 }
-type ResultData = Record<string, any>;
-export type NodeDataParams = Record<string, any>; // App-specific parameters
+type ResultData<ResultType = Record<string, any>> = ResultType | undefined;
+type ResultDataDictonary<ResultType = Record<string, any>> = Record<string, ResultData<ResultType>>;
+
+export type NodeDataParams<ParamsType = Record<string, any>> = ParamsType; // App-specific parameters
 
 type NodeData = {
   inputs: undefined | Array<string>;
   params: NodeDataParams;
   retry: undefined | number;
   timeout: undefined | number; // msec
+  functionName: undefined | string;
 };
 
 type GraphData = {
   nodes: Record<string, NodeData>;
+  concurrency: number;
 };
 
-export type NodeExecuteContext = {
+type NodeExecuteContext<ResultType, ParamsType> = {
   nodeId: string;
   retry: number;
-  params: NodeDataParams;
-  payload: ResultData;
+  params: NodeDataParams<ParamsType>;
+  payload: ResultDataDictonary<ResultType>;
+};
+
+export type TransactionLog = {
+  nodeId: string;
+  state: NodeState;
+  startTime: undefined | number;
+  endTime: undefined | number;
+  retryCount: number;
+  error: undefined | Error;
+  result?: ResultData;
 };
 
-type NodeExecute = (context: NodeExecuteContext) => Promise<ResultData>;
+export type NodeExecute<ResultType = Record<string, any>, ParamsType = Record<string, any>> = (
+  context: NodeExecuteContext<ResultType, ParamsType>,
+) => Promise<ResultData<ResultType>>;
 
 class Node {
   public nodeId: string;
@@ -37,110 +53,160 @@ class Node {
   public pendings: Set<string>; // List of nodes this node is waiting data from.
   public waitlist: Set<string>; // List of nodes which need data from this node.
   public state: NodeState;
+  public functionName: string;
   public result: ResultData;
   public retryLimit: number;
   public retryCount: number;
   public transactionId: undefined | number; // To reject callbacks from timed-out transactions
   public timeout: number; // msec
+  public error: undefined | Error;
 
-  constructor(nodeId: string, data: NodeData) {
+  private graph: GraphAI;
+
+  constructor(nodeId: string, data: NodeData, graph: GraphAI) {
     this.nodeId = nodeId;
     this.inputs = data.inputs ?? [];
     this.pendings = new Set(this.inputs);
     this.params = data.params;
     this.waitlist = new Set<string>();
     this.state = NodeState.Waiting;
-    this.result = {};
+    this.functionName = data.functionName ?? "default";
+    this.result = undefined;
     this.retryLimit = data.retry ?? 0;
     this.retryCount = 0;
     this.timeout = data.timeout ?? 0;
+
+    this.graph = graph;
   }
 
   public asString() {
     return `${this.nodeId}: ${this.state} ${[...this.waitlist]}`;
   }
 
-  private retry(graph: GraphAI, state: NodeState, result: ResultData) {
+  private retry(state: NodeState, error: Error) {
     if (this.retryCount < this.retryLimit) {
       this.retryCount++;
-      this.execute(graph);
+      this.execute();
     } else {
       this.state = state;
-      this.result = result;
-      graph.removeRunning(this);
+      this.result = undefined;
+      this.error = error;
+      this.transactionId = 0; // This is necessary for timeout case
+      this.graph.removeRunning(this);
     }
   }
 
-  public removePending(nodeId: string, graph: GraphAI) {
+  public removePending(nodeId: string) {
     this.pendings.delete(nodeId);
-    this.executeIfReady(graph);
+    this.pushQueueIfReady();
   }
 
-  public payload(graph: GraphAI) {
-    return this.inputs.reduce((results: ResultData, nodeId) => {
-      results[nodeId] = graph.nodes[nodeId].result;
+  public payload() {
+    return this.inputs.reduce((results: ResultDataDictonary, nodeId) => {
+      results[nodeId] = this.graph.nodes[nodeId].result;
       return results;
     }, {});
   }
 
-  public executeIfReady(graph: GraphAI) {
-    if (this.pendings.size == 0) {
-      graph.addRunning(this);
-      this.execute(graph);
+  public pushQueueIfReady() {
+    if (this.pendings.size === 0) {
+      this.graph.pushQueue(this);
     }
   }
 
-  private async execute(graph: GraphAI) {
+  public async execute() {
+    const log: TransactionLog = {
+      nodeId: this.nodeId,
+      retryCount: this.retryCount,
+      state: NodeState.Executing,
+      startTime: Date.now(),
+      endTime: undefined,
+      error: undefined,
+    };
+    this.graph.appendLog(log);
     this.state = NodeState.Executing;
-    const transactionId = Date.now();
+    const transactionId = log.startTime;
     this.transactionId = transactionId;
 
     if (this.timeout > 0) {
       setTimeout(() => {
-        if (this.state == NodeState.Executing && this.transactionId == transactionId) {
-          console.log("*** timeout", this.timeout);
-          this.retry(graph, NodeState.TimedOut, {});
+        if (this.state === NodeState.Executing && this.transactionId === transactionId) {
+          console.log(`-- ${this.nodeId}: timeout ${this.timeout}`);
+          log.error = Error("Timeout");
+          log.state = NodeState.TimedOut;
+          log.endTime = Date.now();
+          this.retry(NodeState.TimedOut, Error("Timeout"));
         }
       }, this.timeout);
     }
 
     try {
-      const result = await graph.callback({ nodeId: this.nodeId, retry: this.retryCount, params: this.params, payload: this.payload(graph) });
+      const callback = this.graph.getCallback(this.functionName);
+      const result = await callback({
+        nodeId: this.nodeId,
+        retry: this.retryCount,
+        params: this.params,
+        payload: this.payload(),
+      });
       if (this.transactionId !== transactionId) {
-        console.log("****** tid mismatch (success)");
+        console.log(`-- ${this.nodeId}: transactionId mismatch`);
         return;
       }
+      log.state = NodeState.Completed;
+      log.endTime = Date.now();
+      log.result = result;
       this.state = NodeState.Completed;
       this.result = result;
       this.waitlist.forEach((nodeId) => {
-        const node = graph.nodes[nodeId];
-        node.removePending(this.nodeId, graph);
+        const node = this.graph.nodes[nodeId];
+        node.removePending(this.nodeId);
       });
-      graph.removeRunning(this);
-    } catch (e) {
+      this.graph.removeRunning(this);
+    } catch (error) {
       if (this.transactionId !== transactionId) {
-        console.log("****** tid mismatch (failed)");
+        console.log(`-- ${this.nodeId}: transactionId mismatch(error)`);
         return;
       }
-      this.retry(graph, NodeState.Failed, {});
+      log.state = NodeState.Failed;
+      log.endTime = Date.now();
+      if (error instanceof Error) {
+        log.error = error;
+        this.retry(NodeState.Failed, error);
+      } else {
+        console.error(`-- ${this.nodeId}: Unexpecrted error was caught`);
+        log.error = Error("Unknown");
+        this.retry(NodeState.Failed, Error("Unknown"));
+      }
     }
   }
 }
 
 type GraphNodes = Record<string, Node>;
 
+type NodeExecuteDictonary = Record<string, NodeExecute>;
+
+const defaultConcurrency = 8;
+
 export class GraphAI {
   public nodes: GraphNodes;
-  public callback: NodeExecute;
+  public callbackDictonary: NodeExecuteDictonary;
   private runningNodes: Set<string>;
+  private nodeQueue: Array<Node>;
   private onComplete: () => void;
+  private concurrency: number;
+  private logs: Array<TransactionLog> = [];
 
-  constructor(data: GraphData, callback: NodeExecute) {
-    this.callback = callback;
+  constructor(data: GraphData, callbackDictonary: NodeExecuteDictonary | NodeExecute) {
+    this.callbackDictonary = typeof callbackDictonary === "function" ? { default: callbackDictonary } : callbackDictonary;
+    if (this.callbackDictonary["default"] === undefined) {
+      throw new Error("No default function");
+    }
+    this.concurrency = data.concurrency ?? defaultConcurrency;
     this.runningNodes = new Set<string>();
+    this.nodeQueue = [];
     this.onComplete = () => {};
     this.nodes = Object.keys(data.nodes).reduce((nodes: GraphNodes, nodeId: string) => {
-      nodes[nodeId] = new Node(nodeId, data.nodes[nodeId]);
+      nodes[nodeId] = new Node(nodeId, data.nodes[nodeId], this);
       return nodes;
     }, {});
 
@@ -154,6 +220,13 @@ export class GraphAI {
     });
   }
 
+  public getCallback(functionName: string) {
+    if (functionName && this.callbackDictonary[functionName]) {
+      return this.callbackDictonary[functionName];
+    }
+    return this.callbackDictonary["default"];
+  }
+
   public asString() {
     return Object.keys(this.nodes)
       .map((nodeId) => {
@@ -162,32 +235,77 @@ export class GraphAI {
       .join("\n");
   }
 
+  public results() {
+    return Object.keys(this.nodes).reduce((results: ResultDataDictonary, nodeId) => {
+      const node = this.nodes[nodeId];
+      if (node.result !== undefined) {
+        results[nodeId] = node.result;
+      }
+      return results;
+    }, {});
+  }
+
+  public errors() {
+    return Object.keys(this.nodes).reduce((errors: Record<string, Error>, nodeId) => {
+      const node = this.nodes[nodeId];
+      if (node.error !== undefined) {
+        errors[nodeId] = node.error;
+      }
+      return errors;
+    }, {});
+  }
+
   public async run() {
     // Nodes without pending data should run immediately.
     Object.keys(this.nodes).forEach((nodeId) => {
       const node = this.nodes[nodeId];
-      node.executeIfReady(this);
+      node.pushQueueIfReady();
     });
 
     return new Promise((resolve, reject) => {
       this.onComplete = () => {
-        const results = Object.keys(this.nodes).reduce((results: ResultData, nodeId) => {
-          results[nodeId] = this.nodes[nodeId].result;
-          return results;
-        }, {});
-        resolve(results);
+        const errors = this.errors();
+        const nodeIds = Object.keys(errors);
+        if (nodeIds.length > 0) {
+          reject(errors[nodeIds[0]]);
+        } else {
+          resolve(this.results());
+        }
       };
     });
   }
 
-  public addRunning(node: Node) {
+  private runNode(node: Node) {
     this.runningNodes.add(node.nodeId);
+    node.execute();
+  }
+
+  public pushQueue(node: Node) {
+    if (this.runningNodes.size < this.concurrency) {
+      this.runNode(node);
+    } else {
+      this.nodeQueue.push(node);
+    }
   }
 
   public removeRunning(node: Node) {
     this.runningNodes.delete(node.nodeId);
-    if (this.runningNodes.size == 0) {
+    if (this.nodeQueue.length > 0) {
+      const n = this.nodeQueue.shift();
+      if (n) {
+        this.runNode(n);
+      }
+    }
+    if (this.runningNodes.size === 0) {
       this.onComplete();
     }
   }
+
+  public appendLog(log: TransactionLog) {
+    this.logs.push(log);
+  }
+
+  public transactionLogs() {
+    return this.logs;
+  }
 }

package/tests/graphs/test_error.yml

@@ -0,0 +1,22 @@
+nodes:
+  node1:
+    params:
+      delay: 500
+  node2:
+    params:
+      delay: 100
+  node3:
+    params:
+      delay: 500
+      fail: true
+    inputs: [node1, node2]
+  node4:
+    timeout: 200
+    retry: 2
+    params:
+      delay: 300
+    inputs: [node3]
+  node5:
+    params:
+      delay: 100
+    inputs: [node4]

package/tests/graphs/test_multiple_functions_1.yml

@@ -0,0 +1,27 @@
+nodes:
+  node1:
+    params:
+      delay: 500
+  node2:
+    params:
+      delay: 100
+  node3:
+    params:
+      delay: 500
+    inputs: [node1, node2]
+    functionName: test2
+  node4:
+    params:
+      delay: 100
+    inputs: [node3]
+  node5:
+    params:
+      delay: 500
+    inputs: [node2, node4]
+    functionName: test2
+  node6:
+    params:
+      delay: 100
+      number: 10
+    inputs: [node4]
+    functionName: numberTestFunction

package/tests/graphs/test_timeout.yml

@@ -0,0 +1,22 @@
+nodes:
+  node1:
+    params:
+      delay: 500
+  node2:
+    params:
+      delay: 100
+  node3:
+    params:
+      delay: 500
+      fail: true
+    inputs: [node1, node2]
+    retry: 2
+  node4:
+    timeout: 200
+    params:
+      delay: 300
+    inputs: [node3]
+  node5:
+    params:
+      delay: 100
+    inputs: [node4]

package/tests/test_multiple_functions.ts

@@ -0,0 +1,57 @@
+import path from "path";
+import { GraphAI, NodeExecute } from "../src/graphai";
+import { readManifestData } from "./file_utils";
+import { sleep } from "./utils";
+
+import test from "node:test";
+import assert from "node:assert";
+
+const testFunction1: NodeExecute<Record<string, string>> = async (context) => {
+  const { nodeId, retry, params } = context;
+  console.log("executing", nodeId, params);
+
+  const result = { [nodeId]: "output 1" };
+  console.log("completing", nodeId, result);
+  return result;
+};
+
+const testFunction2: NodeExecute<Record<string, string>> = async (context) => {
+  const { nodeId, retry, params } = context;
+  console.log("executing", nodeId, params);
+
+  const result = { [nodeId]: "output 2" };
+  console.log("completing", nodeId, result);
+  return result;
+};
+
+const numberTestFunction: NodeExecute<Record<string, number>, Record<"number", number>> = async (context) => {
+  const { nodeId, retry, params } = context;
+  console.log("executing", nodeId, params);
+
+  const result = { [nodeId]: params.number };
+  console.log("completing", nodeId, result);
+  return result;
+};
+
+const runTest = async (file: string) => {
+  const file_path = path.resolve(__dirname) + file;
+  const graph_data = readManifestData(file_path);
+
+  const graph = new GraphAI(graph_data, { default: testFunction1, test2: testFunction2, numberTestFunction });
+
+  const results = await graph.run();
+  console.log(results);
+  return results;
+};
+
+test("test sample1", async () => {
+  const result = await runTest("/graphs/test_multiple_functions_1.yml");
+  assert.deepStrictEqual(result, {
+    node1: { node1: "output 1" },
+    node2: { node2: "output 1" },
+    node3: { node3: "output 2" },
+    node4: { node4: "output 1" },
+    node5: { node5: "output 2" },
+    node6: { node6: 10 },
+  });
+});

package/tests/test_sample_flow.ts

@@ -0,0 +1,87 @@
+import path from "path";
+import { GraphAI, NodeExecute } from "../src/graphai";
+import { readManifestData } from "./file_utils";
+import { sleep } from "./utils";
+
+import test from "node:test";
+import assert from "node:assert";
+
+const testFunction: NodeExecute<Record<string, string>> = async (context) => {
+  const { nodeId, retry, params, payload } = context;
+  console.log("executing", nodeId);
+  await sleep(params.delay / (retry + 1));
+
+  if (params.fail && retry < 2) {
+    const result = { [nodeId]: "failed" };
+    console.log("failed (intentional)", nodeId, retry);
+    throw new Error("Intentional Failure");
+  } else {
+    const result = Object.keys(payload).reduce(
+      (result, key) => {
+        result = { ...result, ...payload[key] };
+        return result;
+      },
+      { [nodeId]: "output" },
+    );
+    console.log("completing", nodeId);
+    return result;
+  }
+};
+
+const runTest = async (file: string) => {
+  const file_path = path.resolve(__dirname) + file;
+  const graph_data = readManifestData(file_path);
+
+  const graph = new GraphAI(graph_data, testFunction);
+
+  try {
+    const results = await graph.run();
+    console.log(graph.transactionLogs());
+    return results;
+  } catch (error) {
+    if (error instanceof Error) {
+      console.log("Error:", error.message);
+    }
+    console.log(graph.transactionLogs());
+    return graph.results();
+  }
+};
+
+test("test base", async () => {
+  const result = await runTest("/graphs/test_base.yml");
+  assert.deepStrictEqual(result, {
+    node1: { node1: "output" },
+    node2: { node2: "output" },
+    node3: { node3: "output", node1: "output", node2: "output" },
+    node4: { node4: "output", node3: "output", node1: "output", node2: "output" },
+    node5: { node5: "output", node4: "output", node3: "output", node1: "output", node2: "output" },
+  });
+});
+
+test("test retry", async () => {
+  const result = await runTest("/graphs/test_retry.yml");
+  assert.deepStrictEqual(result, {
+    node1: { node1: "output" },
+    node2: { node2: "output" },
+    node3: { node3: "output", node1: "output", node2: "output" },
+    node4: { node4: "output", node3: "output", node1: "output", node2: "output" },
+    node5: { node5: "output", node4: "output", node3: "output", node1: "output", node2: "output" },
+  });
+});
+
+test("test error", async () => {
+  const result = await runTest("/graphs/test_error.yml");
+  assert.deepStrictEqual(result, {
+    node1: { node1: "output" },
+    node2: { node2: "output" },
+  });
+});
+
+test("test timeout", async () => {
+  const result = await runTest("/graphs/test_timeout.yml");
+  assert.deepStrictEqual(result, {
+    node1: { node1: "output" },
+    node2: { node2: "output" },
+    node3: { node3: "output", node1: "output", node2: "output" },
+  });
+});

package/lib/file_utils.d.ts

@@ -1,3 +0,0 @@
-export declare const readManifestData: (file: string) => any;
-export declare const readJsonManifest: (fileName: string) => any;
-export declare const readYamlManifest: (fileName: string) => any;

package/lib/file_utils.js

@@ -1,30 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.readYamlManifest = exports.readJsonManifest = exports.readManifestData = void 0;
-const fs_1 = __importDefault(require("fs"));
-const yaml_1 = __importDefault(require("yaml"));
-const readManifestData = (file) => {
-    if (file.endsWith(".yaml") || file.endsWith(".yml")) {
-        return (0, exports.readYamlManifest)(file);
-    }
-    if (file.endsWith(".json")) {
-        return (0, exports.readJsonManifest)(file);
-    }
-    throw new Error("No file exists " + file);
-};
-exports.readManifestData = readManifestData;
-const readJsonManifest = (fileName) => {
-    const manifest_file = fs_1.default.readFileSync(fileName, "utf8");
-    const manifest = JSON.parse(manifest_file);
-    return manifest;
-};
-exports.readJsonManifest = readJsonManifest;
-const readYamlManifest = (fileName) => {
-    const manifest_file = fs_1.default.readFileSync(fileName, "utf8");
-    const manifest = yaml_1.default.parse(manifest_file);
-    return manifest;
-};
-exports.readYamlManifest = readYamlManifest;

package/lib/flow.d.ts

@@ -1,51 +0,0 @@
-export declare enum NodeState {
-    Waiting = 0,
-    Executing = 1,
-    Failed = 2,
-    Completed = 3
-}
-type NodeData = {
-    inputs: undefined | Array<string>;
-    params: any;
-    retry: undefined | number;
-};
-type FlowData = {
-    nodes: Record<string, NodeData>;
-};
-export declare enum FlowCommand {
-    Log = 0,
-    Execute = 1,
-    OnComplete = 2
-}
-type FlowCallback = (params: Record<string, any>) => void;
-declare class Node {
-    key: string;
-    inputs: Array<string>;
-    pendings: Set<string>;
-    params: any;
-    waitlist: Set<string>;
-    state: NodeState;
-    result: Record<string, any>;
-    retryLimit: number;
-    retryCount: number;
-    constructor(key: string, data: NodeData);
-    asString(): string;
-    complete(result: Record<string, any>, nodes: Record<string, Node>, graph: GraphAI): void;
-    reportError(result: Record<string, any>, nodes: Record<string, Node>, graph: GraphAI): void;
-    removePending(key: string, graph: GraphAI): void;
-    payload(graph: GraphAI): Record<string, any>;
-    executeIfReady(graph: GraphAI): void;
-}
-export declare class GraphAI {
-    nodes: Record<string, Node>;
-    callback: FlowCallback;
-    private runningNodes;
-    constructor(data: FlowData, callback: FlowCallback);
-    asString(): string;
-    run(): void;
-    feed(key: string, result: Record<string, any>): void;
-    reportError(key: string, result: Record<string, any>): void;
-    add(node: Node): void;
-    remove(node: Node): void;
-}
-export {};

package/lib/flow.js

@@ -1,118 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GraphAI = exports.FlowCommand = exports.NodeState = void 0;
-var NodeState;
-(function (NodeState) {
-    NodeState[NodeState["Waiting"] = 0] = "Waiting";
-    NodeState[NodeState["Executing"] = 1] = "Executing";
-    NodeState[NodeState["Failed"] = 2] = "Failed";
-    NodeState[NodeState["Completed"] = 3] = "Completed";
-})(NodeState || (exports.NodeState = NodeState = {}));
-var FlowCommand;
-(function (FlowCommand) {
-    FlowCommand[FlowCommand["Log"] = 0] = "Log";
-    FlowCommand[FlowCommand["Execute"] = 1] = "Execute";
-    FlowCommand[FlowCommand["OnComplete"] = 2] = "OnComplete";
-})(FlowCommand || (exports.FlowCommand = FlowCommand = {}));
-class Node {
-    constructor(key, data) {
-        this.key = key;
-        this.inputs = data.inputs ?? [];
-        this.pendings = new Set(this.inputs);
-        this.params = data.params;
-        this.waitlist = new Set();
-        this.state = NodeState.Waiting;
-        this.result = {};
-        this.retryLimit = data.retry ?? 0;
-        this.retryCount = 0;
-    }
-    asString() {
-        return `${this.key}: ${this.state} ${[...this.waitlist]}`;
-    }
-    complete(result, nodes, graph) {
-        this.state = NodeState.Completed;
-        this.result = result;
-        this.waitlist.forEach(key => {
-            const node = nodes[key];
-            node.removePending(this.key, graph);
-        });
-        graph.remove(this);
-    }
-    reportError(result, nodes, graph) {
-        this.state = NodeState.Failed;
-        this.result = result;
-        if (this.retryCount < this.retryLimit) {
-            this.retryCount++;
-            this.state = NodeState.Executing;
-            graph.callback({ cmd: FlowCommand.Execute, node: this.key, params: this.params, retry: this.retryCount, payload: this.payload(graph) });
-        }
-        else {
-            graph.remove(this);
-        }
-    }
-    removePending(key, graph) {
-        this.pendings.delete(key);
-        this.executeIfReady(graph);
-    }
-    payload(graph) {
-        const foo = {};
-        return this.inputs.reduce((payload, key) => {
-            payload[key] = graph.nodes[key].result;
-            return payload;
-        }, foo);
-    }
-    executeIfReady(graph) {
-        if (this.pendings.size == 0) {
-            this.state = NodeState.Executing;
-            graph.add(this);
-            graph.callback({ cmd: FlowCommand.Execute, node: this.key, params: this.params, retry: 0, payload: this.payload(graph) });
-        }
-    }
-}
-class GraphAI {
-    constructor(data, callback) {
-        this.callback = callback;
-        this.runningNodes = new Set();
-        const foo = {}; // HACK: Work around
-        this.nodes = Object.keys(data.nodes).reduce((nodes, key) => {
-            nodes[key] = new Node(key, data.nodes[key]);
-            return nodes;
-        }, foo);
-        // Generate the waitlist for each node
-        Object.keys(this.nodes).forEach(key => {
-            const node = this.nodes[key];
-            node.pendings.forEach(pending => {
-                const node2 = this.nodes[pending];
-                node2.waitlist.add(key);
-            });
-        });
-    }
-    asString() {
-        return Object.keys(this.nodes).map((key) => { return this.nodes[key].asString(); }).join('\n');
-    }
-    run() {
-        // Nodes without pending data should run immediately.
-        Object.keys(this.nodes).forEach(key => {
-            const node = this.nodes[key];
-            node.executeIfReady(this);
-        });
-    }
-    feed(key, result) {
-        const node = this.nodes[key];
-        node.complete(result, this.nodes, this);
-    }
-    reportError(key, result) {
-        const node = this.nodes[key];
-        node.reportError(result, this.nodes, this);
-    }
-    add(node) {
-        this.runningNodes.add(node.key);
-    }
-    remove(node) {
-        this.runningNodes.delete(node.key);
-        if (this.runningNodes.size == 0) {
-            this.callback({ cmd: FlowCommand.OnComplete });
-        }
-    }
-}
-exports.GraphAI = GraphAI;

package/tests/sample_flow.ts

@@ -1,57 +0,0 @@
-import path from "path";
-import { GraphAI, NodeExecuteContext } from "../src/graphai";
-import { readManifestData } from "../src/file_utils";
-import { sleep } from "./utils";
-
-import test from "node:test";
-import assert from "node:assert";
-
-const testFunction = async (context: NodeExecuteContext) => {
-  const { nodeId, retry, params } = context;
-  console.log("executing", nodeId, params);
-  await sleep(params.delay / (retry + 1));
-
-  if (params.fail && retry < 2) {
-    const result = { [nodeId]: "failed" };
-    console.log("failed", nodeId, result, retry);
-    throw new Error("Intentional Failure");
-  } else {
-    const result = { [nodeId]: "output" };
-    console.log("completing", nodeId, result);
-    return result;
-  }
-};
-
-const runTest = async (file: string) => {
-  const file_path = path.resolve(__dirname) + file;
-  const graph_data = readManifestData(file_path);
-
-  const graph = new GraphAI(graph_data, testFunction);
-
-  const results = await graph.run();
-  console.log(results);
-  return results;
-};
-
-test("test sample1", async () => {
-  const result = await runTest("/graphs/sample1.yml");
-  assert.deepStrictEqual(result, {
-    node1: { node1: "output" },
-    node2: { node2: "output" },
-    node3: { node3: "output" },
-    node4: { node4: "output" },
-    node5: { node5: "output" },
-  });
-});
-
-test("test sample1", async () => {
-  const result = await runTest("/graphs/sample2.yml");
-  assert.deepStrictEqual(result, {
-    node1: { node1: "output" },
-    node2: { node2: "output" },
-    node3: { node3: "output" },
-    node4: { node4: "output" },
-    node5: { node5: "output" },
-  });
-  console.log("COMPLETE 2");
-});