graphai 0.0.11 → 0.0.12

package/README.md

@@ -55,7 +55,7 @@ Furthermore, GraphAI's robust mechanisms for error handling, retry strategies, t
 ## Quick Install
 
 ```
-pip install graphai
+npm install graphai
 ```
 
 or
@@ -114,12 +114,41 @@ Key principles:
 
 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, outputs, retry, timeout, source, agentId, result, fork) that dictate the node's behavior and its relationship with other nodes.
+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, outputs, retry, timeout, source, agentId, fork, value) that dictate the node's behavior and its relationship with other nodes.
 
 ### DFG Structure
 
 - '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.
+- 'agentId': An optional property, which specifies the default agent for all the nodes.
+- 'loop': An optional property, which specifies if the graph needs to be executed multiple times. The loop is an JavaScript object, which has two optinoal properties. The *count* property specifies the number of times the graph needs to be executed and the *while* property specifies the condition required to contineu the loop in the form of node name (nodeId) or its property (nodeId.propId). Unlike JavaScript, an empty array will be treated as false.
+
+```
+loop:
+  while: people
+nodes:
+  people:
+    value:
+      - Steve Jobs
+      - Elon Musk
+      - Nikola Tesla
+    next: retriever.array
+  result:
+    value: []
+    next: reducer
+  retriever:
+    agentId: shift
+    inputs: [people]
+  query:
+    agentId: slashgpt
+    params:
+      manifest:
+        prompt: 指定した人について日本語で４００字以内で答えて
+    inputs: [retriever.item]
+  reducer:
+    agentId: push
+    inputs: [result, query.content]
+```
 
 ## Agent
 
@@ -133,19 +162,26 @@ An agent function receives two set of parameters via AgentFunctionContext, agent
 
 ## Node Structure
 
-- 'inputs': An optional list of node identifiers that the current node depends on. This establishes a flow where the current node can only be executed after the completion of the nodes listed under 'inputs'. If this list is empty and the 'source' property is not set, the associated Agent Function will be immediatley executed. 
-- 'source': An optional flag, which specifies if the node is a 'source node' or not. A souce node is a special node, which receives data from either an external code (via GraphAI's injectResult method) or from a 'dispatcher node'.
-- 'result': An optional object, which injects the result into the source node (equivalent to calling the injectResult method).
+There are two types of Node, *computed nodes* and *static nodes*. A *computed node* is associated with an *agent function*, which receives some inputs, performs some computations asynchronously then returns the result (output). A *static node* is a placeholder of a value (just like a variable in programming language), which is injected by an external program, or is retrived from a *data source* (in case of interations). 
+
+A *computed node* have following properties.
+
+- 'agentId': An **required** property, which specifies the id of the *agent function*.
+- 'inputs': An optional list of *data sources* that the current node depends on. This establishes a flow where the current node can only be executed after the completion of the nodes listed under 'inputs'. If this list is empty, the associated *agent function* will be immediatley executed. 
 - '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.
-- 'agentId': An optional parameter, which specifies the id of the agent, when the graph is associated with multiple agents.
+- 'params': An optional property to the associated agent function, which are agent specific.
 - 'fork': An optional paramter, which specifies the number of concurrent transactions to be created for the current node.
-- 'outputs': An optinal property, which specifies the mapping from outputId to nodeId. If this property is set, the node become a special node called "dispatcher". A dispatcher node injects result(s) into specified nodes, enabling the dynamic flow of data.
+- 'outputs' (MAY BECOME OBSOLETE): An optinal property, which specifies the mapping from outputId to nodeId. If this property is set, the node become a special node called *dispatcher*. A *dispatcher* node injects result(s) into specified static nodes, enabling the dynamic flow of data.
+
+A *static* node have following properties.
+
+- 'value': An optional property, which specifies the value of this static node (equivalent to calling the injectValue method from outside).
+- 'next': An optional property, which specifies the *data source* after each iteration.
 
 ## GraphAI class
 
-### ```constructor(data: GraphData, callbackDictonary: AgentFunctionDictonary | AgentFunction<any, any, any>)```
+### ```constructor(data: GraphData, callbackDictonary: AgentFunctionDictonary)```
 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.
@@ -172,7 +208,7 @@ 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.
+Injects a result into a specified node. This is used to manually set the result of a static node, allowing dependent nodes to proceed with execution.
 
-- ```nodeId: string```: The ID of the source node into which the result is to be injected.
+- ```nodeId: string```: The ID of the static node into which the result is to be injected.
 - ```result: ResultData```: The result to be injected into the specified node.

package/lib/experimental_agents/array_agents.d.ts

@@ -0,0 +1,4 @@
+import { AgentFunction } from "../graphai";
+export declare const pushAgent: AgentFunction<Record<string, any>, Record<string, any>, Record<string, any>>;
+export declare const popAgent: AgentFunction<Record<string, any>, Record<string, any>, Record<string, any>>;
+export declare const shiftAgent: AgentFunction<Record<string, any>, Record<string, any>, Record<string, any>>;

package/lib/experimental_agents/array_agents.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shiftAgent = exports.popAgent = exports.pushAgent = void 0;
+const deepmerge_1 = __importDefault(require("deepmerge"));
+const pushAgent = async ({ inputs }) => {
+    const [array, item] = (0, deepmerge_1.default)({ inputs }, {}).inputs;
+    // TODO: Validation
+    array.push(item);
+    return array;
+};
+exports.pushAgent = pushAgent;
+const popAgent = async (context) => {
+    const { inputs } = context;
+    const [array] = (0, deepmerge_1.default)({ inputs }, {}).inputs;
+    // TODO: Varidation
+    const item = array.pop();
+    return { array, item };
+};
+exports.popAgent = popAgent;
+const shiftAgent = async (context) => {
+    const { inputs } = context;
+    const [array] = (0, deepmerge_1.default)({ inputs }, {}).inputs;
+    // TODO: Varidation
+    const item = array.shift();
+    return { array, item };
+};
+exports.shiftAgent = shiftAgent;

package/lib/experimental_agents/index.d.ts

@@ -3,3 +3,4 @@ export * from "./slashgpt_agent";
 export * from "./sleeper_agent";
 export * from "./data_agent";
 export * from "./nested_agent";
+export * from "./array_agents";

package/lib/experimental_agents/index.js

@@ -19,3 +19,4 @@ __exportStar(require("./slashgpt_agent"), exports);
 __exportStar(require("./sleeper_agent"), exports);
 __exportStar(require("./data_agent"), exports);
 __exportStar(require("./nested_agent"), exports);
+__exportStar(require("./array_agents"), exports);

package/lib/experimental_agents/nested_agent.js

@@ -2,17 +2,19 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.nestedAgent = void 0;
 const graphai_1 = require("../graphai");
-const nestedAgent = async ({ params, inputs, agents }) => {
+const nestedAgent = async ({ params, inputs, agents, log }) => {
     const graph = new graphai_1.GraphAI(params.graph, agents);
     try {
         // Inject inputs to specified source nodes
         (params.inputNodes ?? []).forEach((nodeId, index) => {
-            graph.injectResult(nodeId, inputs[index]);
+            graph.injectValue(nodeId, inputs[index]);
         });
         const results = await graph.run();
+        log.push(...graph.transactionLogs());
         return results[params.nodeId];
     }
     catch (error) {
+        log.push(...graph.transactionLogs());
         if (error instanceof Error) {
             console.log("Error:", error.message);
         }

package/lib/experimental_agents/slashgpt_agent.js

@@ -14,6 +14,9 @@ const slashGPTAgent = async ({ nodeId, params, inputs, verbose }) => {
     const session = new slashgpt_1.ChatSession(config, params.manifest ?? {});
     const query = params?.query ? [params.query] : [];
     const contents = query.concat(inputs.map((input) => {
+        if (typeof input === "string") {
+            return input;
+        }
         return input.content;
     }));
     session.append_user_question(contents.join("\n"));

package/lib/experimental_agents/sleeper_agent.d.ts

@@ -1,10 +1,10 @@
 import { AgentFunction } from "../graphai";
 export declare const sleeperAgent: AgentFunction<{
     duration: number;
-    result?: Record<string, any>;
+    value?: Record<string, any>;
 }>;
 export declare const sleeperAgentDebug: AgentFunction<{
     duration: number;
-    result?: Record<string, any>;
+    value?: Record<string, any>;
     fail?: boolean;
 }>;

package/lib/experimental_agents/sleeper_agent.js

@@ -11,7 +11,7 @@ const sleeperAgent = async (context) => {
     await (0, utils_1.sleep)(params.duration);
     return inputs.reduce((result, input) => {
         return (0, deepmerge_1.default)(result, input);
-    }, params.result ?? {});
+    }, params.value ?? {});
 };
 exports.sleeperAgent = sleeperAgent;
 const sleeperAgentDebug = async (context) => {
@@ -23,6 +23,6 @@ const sleeperAgentDebug = async (context) => {
     }
     return inputs.reduce((result, input) => {
         return (0, deepmerge_1.default)(result, input);
-    }, params.result ?? {});
+    }, params.value ?? {});
 };
 exports.sleeperAgentDebug = sleeperAgentDebug;

package/lib/graphai.d.ts

@@ -18,12 +18,19 @@ type NodeData = {
     agentId?: string;
     fork?: number;
     source?: boolean;
-    result?: ResultData;
+    value?: ResultData;
+    next?: string;
     outputs?: Record<string, string>;
 };
+type LoopData = {
+    count?: number;
+    while?: string;
+};
 export type GraphData = {
+    agentId?: string;
     nodes: Record<string, NodeData>;
     concurrency?: number;
+    loop?: LoopData;
     verbose?: boolean;
 };
 export type TransactionLog = {
@@ -31,14 +38,15 @@ export type TransactionLog = {
     state: NodeState;
     startTime: number;
     endTime?: number;
-    retryCount: number;
+    retryCount?: number;
     agentId?: string;
     params?: NodeDataParams;
     inputs?: Array<ResultData>;
     errorMessage?: string;
     result?: ResultData;
+    log?: TransactionLog[];
 };
-export type AgentFunctionContext<ParamsType, ResultType, PreviousResultType> = {
+export type AgentFunctionContext<ParamsType, PreviousResultType> = {
     nodeId: string;
     forkIndex?: number;
     retry: number;
@@ -46,13 +54,15 @@ export type AgentFunctionContext<ParamsType, ResultType, PreviousResultType> = {
     inputs: Array<PreviousResultType>;
     verbose: boolean;
     agents: CallbackDictonaryArgs;
+    log: TransactionLog[];
 };
-export type AgentFunction<ParamsType = Record<string, any>, ResultType = Record<string, any>, PreviousResultType = Record<string, any>> = (context: AgentFunctionContext<ParamsType, ResultType, PreviousResultType>) => Promise<ResultData<ResultType>>;
+export type AgentFunction<ParamsType = Record<string, any>, ResultType = Record<string, any>, PreviousResultType = Record<string, any>> = (context: AgentFunctionContext<ParamsType, PreviousResultType>) => Promise<ResultData<ResultType>>;
 export type AgentFunctionDictonary = Record<string, AgentFunction<any, any, any>>;
 declare class Node {
     nodeId: string;
     params: NodeDataParams;
     inputs: Array<string>;
+    inputProps: Record<string, string>;
     pendings: Set<string>;
     waitlist: Set<string>;
     state: NodeState;
@@ -73,34 +83,42 @@ declare class Node {
     private retry;
     removePending(nodeId: string): void;
     pushQueueIfReady(): void;
-    injectResult(result: ResultData): void;
+    injectValue(value: ResultData): void;
     private setResult;
     execute(): Promise<void>;
 }
 type GraphNodes = Record<string, Node>;
-export type CallbackDictonaryArgs = AgentFunctionDictonary | AgentFunction<any, any, any>;
+export type CallbackDictonaryArgs = AgentFunctionDictonary;
 export declare class GraphAI {
+    private data;
     nodes: GraphNodes;
+    agentId?: string;
     callbackDictonary: AgentFunctionDictonary;
     isRunning: boolean;
     private runningNodes;
     private nodeQueue;
     private onComplete;
     private concurrency;
+    private loop?;
+    private repeatCount;
     verbose: boolean;
     private logs;
+    private createNodes;
+    private getValueFromResults;
+    private initializeNodes;
     constructor(data: GraphData, callbackDictonary: CallbackDictonaryArgs);
-    getCallback(_agentId?: string): AgentFunction<any, any, any>;
+    getCallback(agentId?: string): AgentFunction<any, any, any>;
     asString(): string;
     results(): ResultDataDictonary<Record<string, any>>;
     errors(): Record<string, Error>;
+    private pushReadyNodesIntoQueue;
     run(): Promise<ResultDataDictonary>;
     private runNode;
     pushQueue(node: Node): void;
     removeRunning(node: Node): void;
     appendLog(log: TransactionLog): void;
     transactionLogs(): TransactionLog[];
-    injectResult(nodeId: string, result: ResultData): void;
+    injectValue(nodeId: string, value: ResultData): void;
     resultsOf(nodeIds: Array<string>): ResultData<Record<string, any>>[];
 }
 export {};

package/lib/graphai.js

@@ -11,22 +11,38 @@ var NodeState;
     NodeState["Injected"] = "injected";
     NodeState["Dispatched"] = "dispatched";
 })(NodeState || (exports.NodeState = NodeState = {}));
+const parseNodeName = (name) => {
+    const parts = name.split(".");
+    if (parts.length == 1) {
+        return { sourceNodeId: parts[0] };
+    }
+    else {
+        return { sourceNodeId: parts[0], propId: parts[1] };
+    }
+};
 class Node {
     constructor(nodeId, forkIndex, data, graph) {
+        this.inputProps = {}; // optional properties for input
         this.waitlist = new Set(); // List of nodes which need data from this node.
         this.state = NodeState.Waiting;
         this.result = undefined;
         this.retryCount = 0;
         this.nodeId = nodeId;
         this.forkIndex = forkIndex;
-        this.inputs = data.inputs ?? [];
+        this.inputs = (data.inputs ?? []).map((input) => {
+            const { sourceNodeId, propId } = parseNodeName(input);
+            if (propId) {
+                this.inputProps[sourceNodeId] = propId;
+            }
+            return sourceNodeId;
+        });
         this.pendings = new Set(this.inputs);
         this.params = data.params ?? {};
-        this.agentId = data.agentId;
+        this.agentId = data.agentId ?? graph.agentId;
         this.fork = data.fork;
         this.retryLimit = data.retry ?? 0;
         this.timeout = data.timeout;
-        this.source = data.source === true;
+        this.source = this.agentId === undefined;
         this.outputs = data.outputs;
         this.graph = graph;
     }
@@ -54,10 +70,18 @@ class Node {
     }
     pushQueueIfReady() {
         if (this.pendings.size === 0 && !this.source) {
+            // If input property is specified, we need to ensure that the property value exists.
+            Object.keys(this.inputProps).forEach((nodeId) => {
+                const [result] = this.graph.resultsOf([nodeId]);
+                const propId = this.inputProps[nodeId];
+                if (!result || !(propId in result)) {
+                    return;
+                }
+            });
             this.graph.pushQueue(this);
         }
     }
-    injectResult(result) {
+    injectValue(value) {
         if (this.source) {
             const log = {
                 nodeId: this.nodeId,
@@ -65,13 +89,13 @@ class Node {
                 state: NodeState.Injected,
                 startTime: Date.now(),
                 endTime: Date.now(),
-                result,
+                result: value,
             };
             this.graph.appendLog(log);
-            this.setResult(result, NodeState.Injected);
+            this.setResult(value, NodeState.Injected);
         }
         else {
-            console.error("- injectResult called on non-source node.", this.nodeId);
+            console.error("- injectValue called on non-source node.", this.nodeId);
         }
     }
     setResult(result, state) {
@@ -85,15 +109,21 @@ class Node {
     }
     async execute() {
         const results = this.graph.resultsOf(this.inputs);
+        this.inputs.forEach((nodeId, index) => {
+            const propId = this.inputProps[nodeId];
+            if (propId) {
+                results[index] = results[index][propId];
+            }
+        });
         const transactionId = Date.now();
         const log = {
             nodeId: this.nodeId,
-            retryCount: this.retryCount,
+            retryCount: this.retryCount > 0 ? this.retryCount : undefined,
             state: NodeState.Executing,
             startTime: transactionId,
             agentId: this.agentId,
             params: this.params,
-            inputs: results,
+            inputs: results.length > 0 ? results : undefined,
         };
         this.graph.appendLog(log);
         this.state = NodeState.Executing;
@@ -111,6 +141,7 @@ class Node {
         }
         try {
             const callback = this.graph.getCallback(this.agentId);
+            const localLog = [];
             const result = await callback({
                 nodeId: this.nodeId,
                 retry: this.retryCount,
@@ -119,6 +150,7 @@ class Node {
                 forkIndex: this.forkIndex,
                 verbose: this.graph.verbose,
                 agents: this.graph.callbackDictonary,
+                log: localLog,
             });
             if (this.transactionId !== transactionId) {
                 console.log(`-- ${this.nodeId}: transactionId mismatch`);
@@ -126,11 +158,20 @@ class Node {
             }
             log.endTime = Date.now();
             log.result = result;
+            if (localLog.length > 0) {
+                log.log = localLog;
+            }
             const outputs = this.outputs;
             if (outputs !== undefined) {
-                Object.keys(result).forEach((outputId) => {
+                Object.keys(outputs).forEach((outputId) => {
                     const nodeId = outputs[outputId];
-                    this.graph.injectResult(nodeId, result[outputId]);
+                    const value = result[outputId];
+                    if (value) {
+                        this.graph.injectValue(nodeId, value);
+                    }
+                    else {
+                        console.error("-- Invalid outputId", outputId, result);
+                    }
                 });
                 log.state = NodeState.Dispatched;
                 this.state = NodeState.Dispatched;
@@ -162,21 +203,10 @@ class Node {
 }
 const defaultConcurrency = 8;
 class GraphAI {
-    constructor(data, callbackDictonary) {
-        this.isRunning = false;
-        this.runningNodes = new Set();
-        this.nodeQueue = [];
-        this.logs = [];
-        this.callbackDictonary = typeof callbackDictonary === "function" ? { _default: callbackDictonary } : callbackDictonary;
-        this.concurrency = data.concurrency ?? defaultConcurrency;
-        this.verbose = data.verbose === true;
-        this.onComplete = () => {
-            console.error("-- SOMETHING IS WRONG: onComplete is called without run()");
-        };
+    createNodes(data) {
         const nodeId2forkedNodeIds = {};
         const forkedNodeId2Index = {};
-        // Create node instances from data.nodes
-        this.nodes = Object.keys(data.nodes).reduce((nodes, nodeId) => {
+        const nodes = Object.keys(data.nodes).reduce((nodes, nodeId) => {
             const fork = data.nodes[nodeId].fork;
             if (fork) {
                 // For fork, change the nodeId and increase the node
@@ -194,8 +224,8 @@ class GraphAI {
             return nodes;
         }, {});
         // Generate the waitlist for each node, and update the pendings in case of forked node.
-        Object.keys(this.nodes).forEach((nodeId) => {
-            const node = this.nodes[nodeId];
+        Object.keys(nodes).forEach((nodeId) => {
+            const node = nodes[nodeId];
             node.pendings.forEach((pending) => {
                 // If the pending(previous) node is forking
                 if (nodeId2forkedNodeIds[pending]) {
@@ -203,36 +233,74 @@ class GraphAI {
                     if (node.fork) {
                         //  1:1 if current nodes are also forking.
                         const newPendingId = nodeId2forkedNodeIds[pending][forkedNodeId2Index[nodeId]];
-                        this.nodes[newPendingId].waitlist.add(nodeId); // previousNode
+                        nodes[newPendingId].waitlist.add(nodeId); // previousNode
                         node.pendings.add(newPendingId);
                     }
                     else {
                         //  1:n if current node is not forking.
                         nodeId2forkedNodeIds[pending].forEach((newPendingId) => {
-                            this.nodes[newPendingId].waitlist.add(nodeId); // previousNode
+                            nodes[newPendingId].waitlist.add(nodeId); // previousNode
                             node.pendings.add(newPendingId);
                         });
                     }
                     node.pendings.delete(pending);
                 }
                 else {
-                    this.nodes[pending].waitlist.add(nodeId); // previousNode
+                    if (nodes[pending]) {
+                        nodes[pending].waitlist.add(nodeId); // previousNode
+                    }
+                    else {
+                        console.error(`--- invalid input ${pending} for node, ${nodeId}`);
+                    }
                 }
             });
             node.inputs = Array.from(node.pendings); // for fork.
         });
+        return nodes;
+    }
+    getValueFromResults(key, results) {
+        const { sourceNodeId, propId } = parseNodeName(key);
+        const result = results[sourceNodeId];
+        return result ? (propId ? result[propId] : result) : undefined;
+    }
+    initializeNodes(previousResults) {
         // If the result property is specified, inject it.
-        // NOTE: This must be done at the end of this constructor
-        Object.keys(data.nodes).forEach((nodeId) => {
-            const result = data.nodes[nodeId].result;
-            if (result) {
-                this.injectResult(nodeId, result);
+        // If the previousResults exists (indicating we are in a loop),
+        // process the next property (nodeId or nodeId.propId).
+        Object.keys(this.data.nodes).forEach((nodeId) => {
+            const node = this.data.nodes[nodeId];
+            const { value, next } = node;
+            if (value) {
+                this.injectValue(nodeId, value);
+            }
+            if (next && previousResults) {
+                const result = this.getValueFromResults(next, previousResults);
+                if (result) {
+                    this.injectValue(nodeId, result);
+                }
             }
         });
     }
-    getCallback(_agentId) {
-        const agentId = _agentId ?? "_default";
-        if (this.callbackDictonary[agentId]) {
+    constructor(data, callbackDictonary) {
+        this.isRunning = false;
+        this.runningNodes = new Set();
+        this.nodeQueue = [];
+        this.repeatCount = 0;
+        this.logs = [];
+        this.data = data;
+        this.callbackDictonary = callbackDictonary;
+        this.concurrency = 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()");
+        };
+        this.nodes = this.createNodes(data);
+        this.initializeNodes();
+    }
+    getCallback(agentId) {
+        if (agentId && this.callbackDictonary[agentId]) {
             return this.callbackDictonary[agentId];
         }
         throw new Error("No agent: " + agentId);
@@ -262,16 +330,19 @@ class GraphAI {
             return errors;
         }, {});
     }
-    async run() {
-        if (this.isRunning) {
-            console.error("-- Already Running");
-        }
-        this.isRunning = true;
+    pushReadyNodesIntoQueue() {
         // Nodes without pending data should run immediately.
         Object.keys(this.nodes).forEach((nodeId) => {
             const node = this.nodes[nodeId];
             node.pushQueueIfReady();
         });
+    }
+    async run() {
+        if (this.isRunning) {
+            console.error("-- Already Running");
+        }
+        this.isRunning = true;
+        this.pushReadyNodesIntoQueue();
         return new Promise((resolve, reject) => {
             this.onComplete = () => {
                 this.isRunning = false;
@@ -307,6 +378,27 @@ class GraphAI {
             }
         }
         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();
         }
     }
@@ -316,10 +408,10 @@ class GraphAI {
     transactionLogs() {
         return this.logs;
     }
-    injectResult(nodeId, result) {
+    injectValue(nodeId, value) {
         const node = this.nodes[nodeId];
         if (node) {
-            node.injectResult(result);
+            node.injectValue(value);
         }
         else {
             console.error("-- Invalid nodeId", nodeId);

package/lib/graphai_cli.js

@@ -9,7 +9,7 @@ const experimental_agents_1 = require("./experimental_agents");
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const yaml_1 = __importDefault(require("yaml"));
-const testAgent = async (context) => {
+const testAgent = async () => {
     return {};
 };
 const main = async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "graphai",
-  "version": "0.0.11",
+  "version": "0.0.12",
   "description": "Asynchronous data flow execution engine to make it simple to build LLM apps.",
   "main": "lib/index.js",
   "bin": {
@@ -11,7 +11,7 @@
   ],
   "scripts": {
     "build": "tsc && tsc-alias",
-    "eslint": "eslint --fix --ext src/**/*.{ts} tests/**/*.ts",
+    "eslint": "eslint --fix --ext .ts ./src ./tests ./samples",
     "format": "prettier --write '{src,tests,samples}/**/*.ts' .eslintrc.js",
     "test": "node --test  -r tsconfig-paths/register --require ts-node/register ./tests/**/test_*.ts",
     "cli": "npx ts-node  -r tsconfig-paths/register ./src/graphai_cli.ts",