graphai 0.0.1 → 0.0.3

package/README.md

@@ -1 +1,44 @@
-# dataflow
+# 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. 
+
+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.
+
+Here is an example:
+
+```YAML
+nodes:
+  taskA:
+    params:
+      // app-specific parameters for taskA
+  taskB:
+    params:
+      // app-specific parameters for taskB
+  taskC:
+    params:
+      // app-specific parameters for taskC
+    inputs: [taskA, taskB]
+```
+
+``` TypeScript
+const nodeExecute = async (context: NodeExecuteContext) => {
+  const { 
+    nodeId, // taskA, taskB or taskC 
+    params, // app-specific/task-specific parameters specified in the graph definition file
+    payload // for taskC, { taskA: resultA, taskB: resultB }
+  } = context;
+  // App-specific code (such as calling OpenAI's chat.completions API)
+  ...
+  return result;
+}
+
+  ...
+  const file = fs.readFileSync(pathToYamlFile, "utf8");
+  const graphdata = YAML.parse(file);
+  const graph = new GraphAI(graph_data, nodeExecute);
+  const results = await graph.run();
+  return results["taskC"];
+
+```
+
+

package/lib/flow.d.ts

@@ -30,13 +30,13 @@ declare class Node {
     retryCount: number;
     constructor(key: string, data: NodeData);
     asString(): string;
-    complete(result: Record<string, any>, nodes: Record<string, Node>, graph: Graph): void;
-    reportError(result: Record<string, any>, nodes: Record<string, Node>, graph: Graph): void;
-    removePending(key: string, graph: Graph): void;
-    payload(graph: Graph): Record<string, any>;
-    executeIfReady(graph: Graph): void;
+    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 Graph {
+export declare class GraphAI {
     nodes: Record<string, Node>;
     callback: FlowCallback;
     private runningNodes;

package/lib/flow.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Graph = exports.FlowCommand = exports.NodeState = void 0;
+exports.GraphAI = exports.FlowCommand = exports.NodeState = void 0;
 var NodeState;
 (function (NodeState) {
     NodeState[NodeState["Waiting"] = 0] = "Waiting";
@@ -69,7 +69,7 @@ class Node {
         }
     }
 }
-class Graph {
+class GraphAI {
     constructor(data, callback) {
         this.callback = callback;
         this.runningNodes = new Set();
@@ -115,4 +115,4 @@ class Graph {
         }
     }
 }
-exports.Graph = Graph;
+exports.GraphAI = GraphAI;

package/lib/graphai.d.ts

@@ -0,0 +1,58 @@
+export declare enum NodeState {
+    Waiting = 0,
+    Executing = 1,
+    Failed = 2,
+    TimedOut = 3,
+    Completed = 4
+}
+type ResultData = Record<string, any>;
+export type NodeDataParams = Record<string, any>;
+type NodeData = {
+    inputs: undefined | Array<string>;
+    params: NodeDataParams;
+    retry: undefined | number;
+    timeout: undefined | number;
+};
+type GraphData = {
+    nodes: Record<string, NodeData>;
+};
+export type NodeExecuteContext = {
+    nodeId: string;
+    retry: number;
+    params: NodeDataParams;
+    payload: ResultData;
+};
+type NodeExecute = (context: NodeExecuteContext) => Promise<ResultData>;
+declare class Node {
+    nodeId: string;
+    params: NodeDataParams;
+    inputs: Array<string>;
+    pendings: Set<string>;
+    waitlist: Set<string>;
+    state: NodeState;
+    result: ResultData;
+    retryLimit: number;
+    retryCount: number;
+    transactionId: undefined | number;
+    timeout: number;
+    constructor(nodeId: string, data: NodeData);
+    asString(): string;
+    private retry;
+    removePending(nodeId: string, graph: GraphAI): void;
+    payload(graph: GraphAI): ResultData;
+    executeIfReady(graph: GraphAI): void;
+    private execute;
+}
+type GraphNodes = Record<string, Node>;
+export declare class GraphAI {
+    nodes: GraphNodes;
+    callback: NodeExecute;
+    private runningNodes;
+    private onComplete;
+    constructor(data: GraphData, callback: NodeExecute);
+    asString(): string;
+    run(): Promise<unknown>;
+    addRunning(node: Node): void;
+    removeRunning(node: Node): void;
+}
+export {};

package/lib/graphai.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphAI = 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["TimedOut"] = 3] = "TimedOut";
+    NodeState[NodeState["Completed"] = 4] = "Completed";
+})(NodeState || (exports.NodeState = NodeState = {}));
+class Node {
+    constructor(nodeId, data) {
+        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.retryLimit = data.retry ?? 0;
+        this.retryCount = 0;
+        this.timeout = data.timeout ?? 0;
+    }
+    asString() {
+        return `${this.nodeId}: ${this.state} ${[...this.waitlist]}`;
+    }
+    retry(graph, state, result) {
+        if (this.retryCount < this.retryLimit) {
+            this.retryCount++;
+            this.execute(graph);
+        }
+        else {
+            this.state = state;
+            this.result = result;
+            graph.removeRunning(this);
+        }
+    }
+    removePending(nodeId, graph) {
+        this.pendings.delete(nodeId);
+        this.executeIfReady(graph);
+    }
+    payload(graph) {
+        return this.inputs.reduce((results, nodeId) => {
+            results[nodeId] = graph.nodes[nodeId].result;
+            return results;
+        }, {});
+    }
+    executeIfReady(graph) {
+        if (this.pendings.size == 0) {
+            graph.addRunning(this);
+            this.execute(graph);
+        }
+    }
+    async execute(graph) {
+        this.state = NodeState.Executing;
+        const transactionId = Date.now();
+        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, {});
+                }
+            }, this.timeout);
+        }
+        try {
+            const result = await graph.callback({ nodeId: this.nodeId, retry: this.retryCount, params: this.params, payload: this.payload(graph) });
+            if (this.transactionId !== transactionId) {
+                console.log("****** tid mismatch (success)");
+                return;
+            }
+            this.state = NodeState.Completed;
+            this.result = result;
+            this.waitlist.forEach((nodeId) => {
+                const node = graph.nodes[nodeId];
+                node.removePending(this.nodeId, graph);
+            });
+            graph.removeRunning(this);
+        }
+        catch (e) {
+            if (this.transactionId !== transactionId) {
+                console.log("****** tid mismatch (failed)");
+                return;
+            }
+            this.retry(graph, NodeState.Failed, {});
+        }
+    }
+}
+class GraphAI {
+    constructor(data, callback) {
+        this.callback = callback;
+        this.runningNodes = new Set();
+        this.onComplete = () => { };
+        this.nodes = Object.keys(data.nodes).reduce((nodes, nodeId) => {
+            nodes[nodeId] = new Node(nodeId, data.nodes[nodeId]);
+            return nodes;
+        }, {});
+        // Generate the waitlist for each node
+        Object.keys(this.nodes).forEach((nodeId) => {
+            const node = this.nodes[nodeId];
+            node.pendings.forEach((pending) => {
+                const node2 = this.nodes[pending];
+                node2.waitlist.add(nodeId);
+            });
+        });
+    }
+    asString() {
+        return Object.keys(this.nodes)
+            .map((nodeId) => {
+            return this.nodes[nodeId].asString();
+        })
+            .join("\n");
+    }
+    async run() {
+        // Nodes without pending data should run immediately.
+        Object.keys(this.nodes).forEach((nodeId) => {
+            const node = this.nodes[nodeId];
+            node.executeIfReady(this);
+        });
+        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);
+            };
+        });
+    }
+    addRunning(node) {
+        this.runningNodes.add(node.nodeId);
+    }
+    removeRunning(node) {
+        this.runningNodes.delete(node.nodeId);
+        if (this.runningNodes.size == 0) {
+            this.onComplete();
+        }
+    }
+}
+exports.GraphAI = GraphAI;

package/lib/index.d.ts

@@ -1,2 +1,2 @@
-import { Graph } from "./flow";
-export { Graph };
+import { GraphAI } from "./graphai";
+export { GraphAI };

package/lib/index.js

@@ -1,5 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Graph = void 0;
-const flow_1 = require("./flow");
-Object.defineProperty(exports, "Graph", { enumerable: true, get: function () { return flow_1.Graph; } });
+exports.GraphAI = void 0;
+const graphai_1 = require("./graphai");
+Object.defineProperty(exports, "GraphAI", { enumerable: true, get: function () { return graphai_1.GraphAI; } });

package/package.json

@@ -1,24 +1,24 @@
 {
   "name": "graphai",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "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": "echo \"Error: no test specified\" && exit 1"
+    "test": "node --test --require ts-node/register ./tests/sample_flow.ts"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/snakajima/dataflow"
+    "url": "git+https://github.com/snakajima/graphai"
   },
   "author": "Satoshi Nakajima",
   "license": "MIT",
   "bugs": {
-    "url": "https://github.com/snakajima/dataflow/issues"
+    "url": "https://github.com/snakajima/graphai/issues"
   },
-  "homepage": "https://github.com/snakajima/dataflow#readme",
+  "homepage": "https://github.com/snakajima/graphai#readme",
   "devDependencies": {
     "@types/node": "^20.8.7",
     "@typescript-eslint/eslint-plugin": "^6.8.0",
@@ -26,6 +26,7 @@
     "eslint": "^7.32.0 || ^8.2.0",
     "eslint-plugin-import": "^2.25.2",
     "prettier": "^3.0.3",
+    "slashgpt": "^0.0.6",
     "ts-node": "^10.9.1",
     "typescript": "^5.2.2"
   },

package/src/graphai.ts

@@ -0,0 +1,193 @@
+import { AssertionError } from "assert";
+
+export enum NodeState {
+  Waiting,
+  Executing,
+  Failed,
+  TimedOut,
+  Completed,
+}
+type ResultData = Record<string, any>;
+export type NodeDataParams = Record<string, any>; // App-specific parameters
+
+type NodeData = {
+  inputs: undefined | Array<string>;
+  params: NodeDataParams;
+  retry: undefined | number;
+  timeout: undefined | number; // msec
+};
+
+type GraphData = {
+  nodes: Record<string, NodeData>;
+};
+
+export type NodeExecuteContext = {
+  nodeId: string;
+  retry: number;
+  params: NodeDataParams;
+  payload: ResultData;
+};
+
+type NodeExecute = (context: NodeExecuteContext) => Promise<ResultData>;
+
+class Node {
+  public nodeId: string;
+  public params: NodeDataParams; // App-specific parameters
+  public inputs: Array<string>; // List of nodes this node needs data from.
+  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 result: ResultData;
+  public retryLimit: number;
+  public retryCount: number;
+  public transactionId: undefined | number; // To reject callbacks from timed-out transactions
+  public timeout: number; // msec
+
+  constructor(nodeId: string, data: NodeData) {
+    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.retryLimit = data.retry ?? 0;
+    this.retryCount = 0;
+    this.timeout = data.timeout ?? 0;
+  }
+
+  public asString() {
+    return `${this.nodeId}: ${this.state} ${[...this.waitlist]}`;
+  }
+
+  private retry(graph: GraphAI, state: NodeState, result: ResultData) {
+    if (this.retryCount < this.retryLimit) {
+      this.retryCount++;
+      this.execute(graph);
+    } else {
+      this.state = state;
+      this.result = result;
+      graph.removeRunning(this);
+    }
+  }
+
+  public removePending(nodeId: string, graph: GraphAI) {
+    this.pendings.delete(nodeId);
+    this.executeIfReady(graph);
+  }
+
+  public payload(graph: GraphAI) {
+    return this.inputs.reduce((results: ResultData, nodeId) => {
+      results[nodeId] = graph.nodes[nodeId].result;
+      return results;
+    }, {});
+  }
+
+  public executeIfReady(graph: GraphAI) {
+    if (this.pendings.size == 0) {
+      graph.addRunning(this);
+      this.execute(graph);
+    }
+  }
+
+  private async execute(graph: GraphAI) {
+    this.state = NodeState.Executing;
+    const transactionId = Date.now();
+    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, {});
+        }
+      }, this.timeout);
+    }
+
+    try {
+      const result = await graph.callback({ nodeId: this.nodeId, retry: this.retryCount, params: this.params, payload: this.payload(graph) });
+      if (this.transactionId !== transactionId) {
+        console.log("****** tid mismatch (success)");
+        return;
+      }
+      this.state = NodeState.Completed;
+      this.result = result;
+      this.waitlist.forEach((nodeId) => {
+        const node = graph.nodes[nodeId];
+        node.removePending(this.nodeId, graph);
+      });
+      graph.removeRunning(this);
+    } catch (e) {
+      if (this.transactionId !== transactionId) {
+        console.log("****** tid mismatch (failed)");
+        return;
+      }
+      this.retry(graph, NodeState.Failed, {});
+    }
+  }
+}
+
+type GraphNodes = Record<string, Node>;
+
+export class GraphAI {
+  public nodes: GraphNodes;
+  public callback: NodeExecute;
+  private runningNodes: Set<string>;
+  private onComplete: () => void;
+
+  constructor(data: GraphData, callback: NodeExecute) {
+    this.callback = callback;
+    this.runningNodes = new Set<string>();
+    this.onComplete = () => {};
+    this.nodes = Object.keys(data.nodes).reduce((nodes: GraphNodes, nodeId: string) => {
+      nodes[nodeId] = new Node(nodeId, data.nodes[nodeId]);
+      return nodes;
+    }, {});
+
+    // Generate the waitlist for each node
+    Object.keys(this.nodes).forEach((nodeId) => {
+      const node = this.nodes[nodeId];
+      node.pendings.forEach((pending) => {
+        const node2 = this.nodes[pending];
+        node2.waitlist.add(nodeId);
+      });
+    });
+  }
+
+  public asString() {
+    return Object.keys(this.nodes)
+      .map((nodeId) => {
+        return this.nodes[nodeId].asString();
+      })
+      .join("\n");
+  }
+
+  public async run() {
+    // Nodes without pending data should run immediately.
+    Object.keys(this.nodes).forEach((nodeId) => {
+      const node = this.nodes[nodeId];
+      node.executeIfReady(this);
+    });
+
+    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);
+      };
+    });
+  }
+
+  public addRunning(node: Node) {
+    this.runningNodes.add(node.nodeId);
+  }
+
+  public removeRunning(node: Node) {
+    this.runningNodes.delete(node.nodeId);
+    if (this.runningNodes.size == 0) {
+      this.onComplete();
+    }
+  }
+}

package/src/index.ts

@@ -1,3 +1,3 @@
-import { Graph } from "./flow";
+import { GraphAI } from "./graphai";
 
-export { Graph };
+export { GraphAI };

package/tests/graphs/sample2.yml

@@ -12,6 +12,12 @@ nodes:
     inputs: [node1, node2]
     retry: 2
   node4:
+    timeout: 200
+    retry: 2
     params:
-      delay: 100
+      delay: 300
     inputs: [node3]
+  node5:
+    params:
+      delay: 100
+    inputs: [node4]

package/tests/graphs/sample3.yml

@@ -0,0 +1,12 @@
+nodes:
+  node1:
+    params:
+      prompt: Come up with ten business ideas for AI startup
+  node2:
+    inputs: [node1]
+    params:
+      prompt: Please evaluate following business ideas. ${node1}
+  node3:
+    inputs: [node1, node2]
+    params:
+      prompt: Please pick the winner of this business idea contest. ${node1} ${node2}

package/tests/sample_flow.ts

@@ -1,39 +1,57 @@
 import path from "path";
-import { Graph, FlowCommand } from "../src/flow";
-
+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));
 
-const test = async (file: string) => {
+  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);
-  return new Promise((resolve, reject) => {
-    const graph = new Graph(graph_data, async (params) => {
-      if (params.cmd == FlowCommand.Execute) {
-          const node = params.node;
-          console.log("executing", node, params.params, params.payload)
-          setTimeout(() => {
-            if (params.params.fail && params.retry < 2) {
-              const result = { [node]:"failed" };
-              console.log("failed", node, result, params.retry)
-              graph.reportError(node, result);
-            } else {
-              const result = { [node]:"output" };
-              console.log("completing", node, result)
-              graph.feed(node, result)
-            }
-          }, params.params.delay);
-      } else if (params.cmd == FlowCommand.OnComplete) {
-        resolve(graph);
-      }
-    });
-    graph.run();
+
+  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" },
   });
-}
+});
 
-const main = async () => {
-  await test("/graphs/sample1.yml");
-  console.log("COMPLETE 1");
-  await test("/graphs/sample2.yml");
+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");
-};
-main();
+});

package/tests/sample_gpt.ts

@@ -0,0 +1,37 @@
+import path from "path";
+import { GraphAI, NodeExecuteContext } from "../src/graphai";
+import { ChatSession, ChatConfig } from "slashgpt";
+import { readManifestData } from "../src/file_utils";
+
+const config = new ChatConfig(path.resolve(__dirname));
+
+const testFunction = async (context: NodeExecuteContext) => {
+  console.log("executing", context.nodeId, context.params, context.payload);
+  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"]);
+  }, context.params.prompt);
+  session.append_user_question(prompt);
+
+  await session.call_loop(() => {});
+  const message = session.history.last_message();
+  if (message === undefined) {
+    throw new Error("No message in the history");
+  }
+  const result = { answer: message.content };
+  console.log(result);
+  return result;
+};
+
+const test = async (file: string) => {
+  const file_path = path.resolve(__dirname) + file;
+  const graph_data = readManifestData(file_path);
+  const graph = new GraphAI(graph_data, testFunction);
+  await graph.run();
+};
+
+const main = async () => {
+  await test("/graphs/sample3.yml");
+  console.log("COMPLETE 1");
+};
+main();

package/tests/utils.ts

@@ -0,0 +1,3 @@
+export const sleep = async (milliseconds: number) => {
+  return await new Promise((resolve) => setTimeout(resolve, milliseconds));
+};

package/src/flow.ts

@@ -1,152 +0,0 @@
-export enum NodeState {
-  Waiting,
-  Executing,
-  Failed,
-  Completed
-}
-
-type NodeData = {
-  inputs: undefined | Array<string>;
-  params: any; // Application specific parameters
-  retry: undefined | number;
-}
-
-type FlowData = {
-  nodes: Record<string, NodeData>;
-};
-
-export enum FlowCommand {
-  Log,
-  Execute,
-  OnComplete
-}
-
-type FlowCallback = (params: Record<string, any>) => void;
-
-class Node {
-  public key: string;
-  public inputs: Array<string>;
-  public pendings: Set<string>;
-  public params: any;
-  public waitlist: Set<string>;
-  public state: NodeState;
-  public result: Record<string, any>;
-  public retryLimit: number;
-  public retryCount: number;
-  constructor(key: string, data: NodeData) {
-    this.key = key;
-    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.retryLimit = data.retry ?? 0;
-    this.retryCount = 0;
-  }
-
-  public asString() {
-    return `${this.key}: ${this.state} ${[...this.waitlist]}`    
-  }
-
-  public complete(result: Record<string, any>, nodes: Record<string, Node>, graph: Graph) {
-    this.state = NodeState.Completed;
-    this.result = result;
-    this.waitlist.forEach(key => {
-      const node = nodes[key];
-      node.removePending(this.key, graph);
-    });
-    graph.remove(this);
-  }
-
-  public reportError(result: Record<string, any>, nodes: Record<string, Node>, graph: 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);
-    }
-  }
-
-  public removePending(key: string, graph: Graph) {
-    this.pendings.delete(key);
-    this.executeIfReady(graph);
-  }
-
-  public payload(graph: Graph) {
-    const foo: Record<string, any> = {};
-    return this.inputs.reduce((payload, key) => {
-      payload[key] = graph.nodes[key].result;       
-      return payload;
-    }, foo);    
-  }
-
-  public executeIfReady(graph: 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) });
-    }
-  }
-}
-
-export class Graph {
-  public nodes: Record<string, Node>
-  public callback: FlowCallback;
-  private runningNodes: Set<string>;
-
-  constructor(data: FlowData, callback: FlowCallback) {
-    this.callback = callback;
-    this.runningNodes = new Set<string>();
-    const foo: Record<string, Node> = {}; // 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);
-      });
-    });
-  }
-
-  public asString() {
-    return Object.keys(this.nodes).map((key) => { return this.nodes[key].asString() }).join('\n');
-  }
-
-  public run() {
-    // Nodes without pending data should run immediately.
-    Object.keys(this.nodes).forEach(key => {
-      const node = this.nodes[key];
-      node.executeIfReady(this);
-    });
-  }
-
-  public feed(key: string, result: Record<string, any>) {
-    const node = this.nodes[key];
-    node.complete(result, this.nodes, this);
-  }
-
-  public reportError(key: string, result: Record<string, any>) {
-    const node = this.nodes[key];
-    node.reportError(result, this.nodes, this);
-  }
-
-  public add(node: Node) {
-    this.runningNodes.add(node.key);
-  }
-
-  public remove(node: Node) {
-    this.runningNodes.delete(node.key);
-    if (this.runningNodes.size == 0) {
-      this.callback({cmd: FlowCommand.OnComplete});
-    }
-  }
-}