graphai 0.0.6 → 0.0.7

package/README.md

@@ -36,26 +36,26 @@ const sampleAgentFunction = async (context: AgentFunctionContext) => {
 
   ...
   const file = fs.readFileSync(pathToYamlFile, "utf8");
-  const graphdata = YAML.parse(file);
-  const graph = new GraphAI(graph_data, sampleAgentFunction);
+  const graphData = YAML.parse(file);
+  const graph = new GraphAI(graphData, sampleAgentFunction);
   const results = await graph.run();
   return results["taskC"];
 ```
 
 ## Data Flow Graph
 
-A Data Flow Graph (DFG) is a JSON object, which defines the flow of data. It is typically described in YAML file and loaded at runtime.
+A Data Flow Graph (DFG) is a JavaScript object, which defines the flow of data. It is typically described in YAML file and loaded at runtime.
 
 A DFG consists of a collection of 'nodes', which contains a series of nested keys representing individual nodes in the data flow. Each node is identified by a unique key (e.g., node1, node2) and can contain several predefined keys (params, inputs, retry, timeout, source, dispatch, agentId) that dictate the node's behavior and its relationship with other nodes.
 
 ### DFG Structure
 
-- 'nodes': A list of node.
-- 'concurrency': An optional number, which specifies the maximum number of concurrent operations (agent functions to be executed at the same time). The default is 8.
+- 'nodes': A list of node. Required.
+- 'concurrency': An optional property, which specifies the maximum number of concurrent operations (agent functions to be executed at the same time). The default is 8.
 
 ## Agent
 
-An agent is an abstract object, which takes some inputs and generates an output asynchronously. It could be an LLM (such as GPT-4), an image/video/music generation, a database, or a REST API over HTTP. Each node (except 'source node') is associated with an agent function, which takes data flow into the node as inputs, and generates an output.
+An agent is an abstract object, which takes some inputs and generates an output asynchronously. It could be an LLM (such as GPT-4), an image/video/music generator, a database, or a REST API over HTTP. Each node (except 'source node') is associated with an agent function, which takes data flow into the node as inputs, and generates an output.
 
 ## Agent function
 
@@ -73,4 +73,38 @@ A regular agent function returns the data (type: ```Record<string, any>```), but
 - 'retry': An optional number, which specifies the maximum number of retries to be made. If the last attempt fails, that return value will be recorded.
 - 'timeout': An optional number, which specifies the maximum waittime in msec. If the associated agent function does not return the value in time, the "Timeout" error will be recorded and the returned value will be discarded. 
 - 'params': An optional parameters to the associated agent function, which are agent specific.
-- 'payloadMapping': An optional property (type: ```Record<string, string>```), which maps input nodeIds to agent specific inputIDs.  
+- 'payloadMapping': An optional property (type: ```Record<string, string>```), which maps input nodeIds to agent specific inputIDs.
+
+## GraphAI class
+
+### ```constructor(data: GraphData, callbackDictonary: AgentFunctionDictonary | AgentFunction<any, any, any>)```
+Initializes a new instance of the GraphAI class with the specified graph data and a dictionary of callback functions.
+
+- ```data: GraphData```: The graph data including nodes and optional concurrency limit.
+- ```callbackDictonary: AgentFunctionDictonary | AgentFunction<any, any, any>```: A dictionary mapping agent IDs to their respective callback functions, or a single default callback function to be used for all nodes.
+
+### ```async run(): Promise<ResultDataDictonary<ResultData>>```
+Executes the graph asynchronously, starting with nodes that have no dependencies or whose dependencies have been met. The method continues to execute nodes as their dependencies are satisfied until all nodes have been executed or an error occurs.
+
+Returns: A promise that resolves with the results of all executed nodes or rejects with the first encountered error.
+
+### ```results(): ResultDataDictonary<ResultData>```
+Compiles and returns the results of all executed nodes in the graph.
+
+Returns: A dictionary mapping node IDs to their results. Only includes nodes that have completed execution and produced a result.
+
+### ```errors(): Record<string, Error>```
+Compiles and returns the errors from all nodes that encountered an error during execution.
+
+Returns: A dictionary mapping node IDs to the errors they encountered. Only includes nodes that have executed and encountered an error. It does not include any errors which have been retried.
+
+### ```transactionLogs(): Array<TransactionLog>```
+Retrieves all transaction logs recorded during the execution of the graph.
+
+Returns: An array of transaction logs detailing the execution states and outcomes of the nodes within the graph.
+
+### ```injectResult(nodeId: string, result: ResultData): void```
+Injects a result into a specified node. This is used to manually set the result of a source node, allowing dependent nodes to proceed with execution.
+
+- ```nodeId: string```: The ID of the source node into which the result is to be injected.
+- ```result: ResultData```: The result to be injected into the specified node.

package/lib/graphai.d.ts

@@ -1,11 +1,11 @@
 export declare enum NodeState {
-    Waiting = 0,
-    Executing = 1,
-    Failed = 2,
-    TimedOut = 3,
-    Completed = 4,
-    Injected = 5,
-    Dispatched = 6
+    Waiting = "waiting",
+    Executing = "executing",
+    Failed = "failed",
+    TimedOut = "timed-out",
+    Completed = "completed",
+    Injected = "injected",
+    Dispatched = "dispatched"
 }
 type ResultData<ResultType = Record<string, any>> = ResultType | undefined;
 type ResultDataDictonary<ResultType = Record<string, any>> = Record<string, ResultData<ResultType>>;

package/lib/graphai.js

@@ -3,13 +3,13 @@ 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[NodeState["Injected"] = 5] = "Injected";
-    NodeState[NodeState["Dispatched"] = 6] = "Dispatched";
+    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 = {}));
 class Node {
     constructor(nodeId, data, graph) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "graphai",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "description": "Asynchronous data flow execution engine to make it simple to build LLM apps.",
   "main": "lib/index.js",
   "scripts": {

package/src/graphai.ts

@@ -1,11 +1,11 @@
 export enum NodeState {
-  Waiting,
-  Executing,
-  Failed,
-  TimedOut,
-  Completed,
-  Injected,
-  Dispatched,
+  Waiting = "waiting",
+  Executing = "executing",
+  Failed = "failed",
+  TimedOut = "timed-out",
+  Completed = "completed",
+  Injected = "injected",
+  Dispatched = "dispatched",
 }
 type ResultData<ResultType = Record<string, any>> = ResultType | undefined;
 type ResultDataDictonary<ResultType = Record<string, any>> = Record<string, ResultData<ResultType>>;