graphai 0.0.8 → 0.0.10

package/README.md

@@ -42,11 +42,21 @@ const sampleAgentFunction = async (context: AgentFunctionContext) => {
   return results["taskC"];
 ```
 
+## Background
+
+As Andrew Ng has described in his article, "[The batch: Issue 242](https://www.deeplearning.ai/the-batch/issue-242/)", better results can often be achieved by making multiple calls to a Large Language Model (LLM) and allowing it to incrementally build towards a higher-quality output. Dr. Ng refers to this approach as 'agentic workflows.' 
+
+Building applications that employ these workflows, however, is challenging due to the complexities of managing multiple asynchronous API calls, including error handling, timeouts, retries, and logging. 
+
+GraphAI is designed to simplify this process by decoupling the complexity of multiple asynchronous calls from the application's core logic. It enables developers to model these calls and their dependencies within a single Data Flow Graph, enhancing development and debugging processes. 
+
+Furthermore, GraphAI's robust mechanisms for error handling, retry strategies, timeouts, and logging empower developers to concentrate on refining the application logic.
+
 ## Data Flow Graph
 
 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) 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, result, fork) that dictate the node's behavior and its relationship with other nodes.
 
 ### DFG Structure
 
@@ -67,10 +77,13 @@ An agent function receives two set of parameters via AgentFunctionContext, agent
 
 - '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'.
-- '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.
+- 'result': An optional object, which injects the result into the source node (equivalent to calling the injectResult method).
 - '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.
+- '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.
 
 ## GraphAI class
 

package/lib/experimental_agents/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./string_agent";
+export * from "./slashgpt_agent";

package/lib/experimental_agents/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./string_agent"), exports);
+__exportStar(require("./slashgpt_agent"), exports);

package/lib/experimental_agents/slashgpt_agent.d.ts

@@ -0,0 +1,9 @@
+import { AgentFunction } from "../graphai";
+import { ManifestData } from "slashgpt";
+export declare const slashGPTAgent: AgentFunction<{
+    manifest: ManifestData;
+    query?: string;
+    function_result?: boolean;
+}, {
+    content: string;
+}>;

package/lib/experimental_agents/slashgpt_agent.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.slashGPTAgent = void 0;
+const path_1 = __importDefault(require("path"));
+const slashgpt_1 = require("slashgpt");
+const config = new slashgpt_1.ChatConfig(path_1.default.resolve(__dirname));
+const slashGPTAgent = async (context) => {
+    console.log("executing", context.nodeId, context.params);
+    const session = new slashgpt_1.ChatSession(config, context.params.manifest ?? {});
+    const query = context.params?.query ? [context.params.query] : [];
+    const contents = query.concat(context.inputs.map((input) => {
+        return input.content;
+    }));
+    session.append_user_question(contents.join("\n"));
+    await session.call_loop(() => { });
+    const message = (() => {
+        if (context.params?.function_result) {
+            return session.history.messages().find((m) => m.role === "function_result");
+        }
+        return session.history.last_message();
+    })();
+    if (message === undefined) {
+        throw new Error("No message in the history");
+    }
+    return message;
+};
+exports.slashGPTAgent = slashGPTAgent;

package/lib/experimental_agents/string_agent.d.ts

@@ -0,0 +1,7 @@
+import { AgentFunction } from "../graphai";
+export declare const stringTemplateAgent: AgentFunction<{
+    template: string;
+    inputKey?: string;
+}, {
+    content: string;
+}>;

package/lib/experimental_agents/string_agent.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringTemplateAgent = void 0;
+const stringTemplateAgent = async (context) => {
+    console.log("executing", context.nodeId, context.params);
+    const content = context.inputs.reduce((template, input, index) => {
+        return template.replace("${" + index + "}", input[context.params.inputKey ?? "content"]);
+    }, context.params.template);
+    return { content };
+};
+exports.stringTemplateAgent = stringTemplateAgent;

package/lib/graphai.d.ts

@@ -12,11 +12,13 @@ type ResultDataDictonary<ResultType = Record<string, any>> = Record<string, Resu
 export type NodeDataParams<ParamsType = Record<string, any>> = ParamsType;
 type NodeData = {
     inputs?: Array<string>;
-    params: NodeDataParams;
+    params?: NodeDataParams;
     retry?: number;
     timeout?: number;
     agentId?: string;
+    fork?: number;
     source?: boolean;
+    result?: ResultData;
     outputs?: Record<string, string>;
 };
 export type GraphData = {
@@ -37,6 +39,7 @@ export type TransactionLog = {
 };
 export type AgentFunctionContext<ParamsType, ResultType, PreviousResultType> = {
     nodeId: string;
+    forkIndex?: number;
     retry: number;
     params: NodeDataParams<ParamsType>;
     inputs: Array<PreviousResultType>;
@@ -51,6 +54,8 @@ declare class Node {
     waitlist: Set<string>;
     state: NodeState;
     agentId?: string;
+    fork?: number;
+    forkIndex?: number;
     result: ResultData;
     retryLimit: number;
     retryCount: number;
@@ -60,7 +65,7 @@ declare class Node {
     source: boolean;
     outputs?: Record<string, string>;
     private graph;
-    constructor(nodeId: string, data: NodeData, graph: GraphAI);
+    constructor(nodeId: string, forkIndex: number | undefined, data: NodeData, graph: GraphAI);
     asString(): string;
     private retry;
     removePending(nodeId: string): void;
@@ -84,7 +89,7 @@ export declare class GraphAI {
     asString(): string;
     results(): ResultDataDictonary<Record<string, any>>;
     errors(): Record<string, Error>;
-    run(): Promise<unknown>;
+    run(): Promise<ResultDataDictonary>;
     private runNode;
     pushQueue(node: Node): void;
     removeRunning(node: Node): void;

package/lib/graphai.js

@@ -12,16 +12,18 @@ var NodeState;
     NodeState["Dispatched"] = "dispatched";
 })(NodeState || (exports.NodeState = NodeState = {}));
 class Node {
-    constructor(nodeId, data, graph) {
+    constructor(nodeId, forkIndex, data, graph) {
         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.pendings = new Set(this.inputs);
-        this.params = data.params;
+        this.params = data.params ?? {};
         this.agentId = data.agentId;
+        this.fork = data.fork;
         this.retryLimit = data.retry ?? 0;
         this.timeout = data.timeout;
         this.source = data.source === true;
@@ -62,9 +64,9 @@ class Node {
                 retryCount: this.retryCount,
                 state: NodeState.Injected,
                 startTime: Date.now(),
+                endTime: Date.now(),
                 result,
             };
-            log.endTime = log.startTime;
             this.graph.appendLog(log);
             this.setResult(result, NodeState.Injected);
         }
@@ -82,21 +84,19 @@ class Node {
         });
     }
     async execute() {
+        const results = this.graph.resultsOf(this.inputs);
+        const transactionId = Date.now();
         const log = {
             nodeId: this.nodeId,
             retryCount: this.retryCount,
             state: NodeState.Executing,
-            startTime: Date.now(),
+            startTime: transactionId,
             agentId: this.agentId,
             params: this.params,
+            inputs: results,
         };
-        const results = this.graph.resultsOf(this.inputs);
-        if (results.length > 0) {
-            log.inputs = results;
-        }
         this.graph.appendLog(log);
         this.state = NodeState.Executing;
-        const transactionId = log.startTime;
         this.transactionId = transactionId;
         if (this.timeout && this.timeout > 0) {
             setTimeout(() => {
@@ -116,6 +116,7 @@ class Node {
                 retry: this.retryCount,
                 params: this.params,
                 inputs: results,
+                forkIndex: this.forkIndex,
             });
             if (this.transactionId !== transactionId) {
                 console.log(`-- ${this.nodeId}: transactionId mismatch`);
@@ -169,22 +170,65 @@ class GraphAI {
         this.onComplete = () => {
             console.error("-- SOMETHING IS WRONG: onComplete is called without run()");
         };
+        const nodeId2forkedNodeIds = {};
+        const forkedNodeId2Index = {};
+        // Create node instances from data.nodes
         this.nodes = Object.keys(data.nodes).reduce((nodes, nodeId) => {
-            nodes[nodeId] = new Node(nodeId, data.nodes[nodeId], this);
+            const fork = data.nodes[nodeId].fork;
+            if (fork) {
+                // For fork, change the nodeId and increase the node
+                nodeId2forkedNodeIds[nodeId] = new Array(fork).fill(undefined).map((_, i) => {
+                    const forkedNodeId = `${nodeId}_${i}`;
+                    nodes[forkedNodeId] = new Node(forkedNodeId, i, data.nodes[nodeId], this);
+                    // Data for pending and waiting
+                    forkedNodeId2Index[forkedNodeId] = i;
+                    return forkedNodeId;
+                });
+            }
+            else {
+                nodes[nodeId] = new Node(nodeId, undefined, data.nodes[nodeId], this);
+            }
             return nodes;
         }, {});
-        // Generate the waitlist for each node
+        // 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];
             node.pendings.forEach((pending) => {
-                const node2 = this.nodes[pending];
-                node2.waitlist.add(nodeId);
+                // If the pending(previous) node is forking
+                if (nodeId2forkedNodeIds[pending]) {
+                    //  update node.pending and pending(previous) node.wailtlist
+                    if (node.fork) {
+                        //  1:1 if current nodes are also forking.
+                        const newPendingId = nodeId2forkedNodeIds[pending][forkedNodeId2Index[nodeId]];
+                        this.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
+                            node.pendings.add(newPendingId);
+                        });
+                    }
+                    node.pendings.delete(pending);
+                }
+                else {
+                    this.nodes[pending].waitlist.add(nodeId); // previousNode
+                }
             });
+            node.inputs = Array.from(node.pendings); // for fork.
+        });
+        // 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);
+            }
         });
     }
     getCallback(_agentId) {
         const agentId = _agentId ?? "_default";
-        console.log(agentId);
         if (this.callbackDictonary[agentId]) {
             return this.callbackDictonary[agentId];
         }

package/lib/graphai_cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/lib/graphai_cli.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const graphai_1 = require("./graphai");
+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) => {
+    return {};
+};
+const main = async () => {
+    const file = process.argv[2];
+    if (file === undefined) {
+        console.log("no file");
+        return;
+    }
+    const file_path = path_1.default.resolve(process.cwd() + "/" + file);
+    if (!fs_1.default.existsSync(file_path)) {
+        console.log("no file");
+        return;
+    }
+    try {
+        const graph_data_file = fs_1.default.readFileSync(file_path, "utf8");
+        const graph_data = yaml_1.default.parse(graph_data_file);
+        const graph = new graphai_1.GraphAI(graph_data, { testAgent, slashGPTAgent: experimental_agents_1.slashGPTAgent, stringTemplateAgent: experimental_agents_1.stringTemplateAgent });
+        const results = await graph.run();
+        console.log(results);
+    }
+    catch (e) {
+        console.log("error", e);
+    }
+};
+main();

package/package.json

@@ -1,14 +1,16 @@
 {
   "name": "graphai",
-  "version": "0.0.8",
+  "version": "0.0.10",
   "description": "Asynchronous data flow execution engine to make it simple to build LLM apps.",
   "main": "lib/index.js",
+  "bin": "lib/graphai_cli.js",
   "scripts": {
     "build": "tsc && tsc-alias",
     "eslint": "eslint --fix --ext src/**/*.{ts} tests/**/*.ts",
     "format": "prettier --write '{src,tests,samples}/**/*.ts' .eslintrc.js",
     "test": "node --test  -r tsconfig-paths/register --require ts-node/register ./tests/**/test_*.ts",
-    "gpt": "npx ts-node  -r tsconfig-paths/register ./samples/sample_gpt.ts"
+    "cli": "npx ts-node  -r tsconfig-paths/register ./src/graphai_cli.ts",
+    "sample": "npx ts-node  -r tsconfig-paths/register"
   },
   "repository": {
     "type": "git",

package/samples/agents/arxiv_agent.ts

@@ -34,12 +34,12 @@ export const arxivAgent: AgentFunction<{ keywords: string[]; limit: number }, ar
   return result;
 };
 
-export const arxiv2TextAgent: AgentFunction<{}, string, string[]> = async (context) => {
+export const arxiv2TextAgent: AgentFunction<{}, Record<string, any>, string[]> = async (context) => {
   const result = (context.inputs[0] || [])
     .map((r: any) => {
       const { id, title, summary } = r;
       return ["id:", id, "title:", title, "summary:", summary].join("\n");
     })
     .join("\n\n\n");
-  return result;
+  return { content: result };
 };

package/samples/agents/slashgpt_agent.ts

@@ -6,7 +6,7 @@ const config = new ChatConfig(path.resolve(__dirname));
 
 export const slashGPTFuncitons2TextAgent: AgentFunction<
   { function_data_key: string; result_key: number },
-  string,
+  Record<string, string>,
   { function_data: { [key: string]: string[] } }
 > = async (context) => {
   const { params } = context;
@@ -14,36 +14,6 @@ export const slashGPTFuncitons2TextAgent: AgentFunction<
     const { title, description } = r;
     return ["title:", title, "description:", description].join("\n");
   });
-  return result[params.result_key];
-};
-
-export const slashGPTAgent: AgentFunction<
-  { manifest: ManifestData; prompt: string; function_result?: boolean; debug?: boolean },
-  { answer: string },
-  string
-> = async (context) => {
-  const { params } = context;
-  if (params.debug) {
-    console.log("executing", context.nodeId, context);
-  }
-  const session = new ChatSession(config, params?.manifest ?? {});
-
-  const prompt = params?.prompt ?? [context.inputs].filter((a) => a !== undefined).join("\n\n");
-  // console.log(prompt);
-  session.append_user_question(prompt);
-
-  await session.call_loop(() => {});
 
-  // console.log(session.history)
-  const message = (() => {
-    if (params.function_result) {
-      return session.history.messages().find((m) => m.role === "function_result");
-    }
-    return session.history.last_message();
-  })();
-  if (message === undefined) {
-    throw new Error("No message in the history");
-  }
-  const result = { answer: message.content, function_data: message.function_data };
-  return result;
+  return { content: result[context.forkIndex ?? 0] };
 };

package/samples/graphs/arxiv.yml

@@ -13,7 +13,7 @@ nodes:
     inputs: [arxiv2TextAgent]
     agentId: slashGPTAgent
     params:
-      prompt: |
+      query: |
         与えられたそれぞれの論文の要点をまとめ、以下の項目で日本語で出力せよ。それぞれの項目は最大でも180文字以内に要約せよ。
         ```
         論文名:タイトルの日本語訳

package/samples/graphs/slash_gpt.yml

@@ -1,19 +1,28 @@
 nodes:
   node1:
+    agentId: slashgpt
     params:
-      prompt: Come up with ten business ideas for AI startup
+      query: Come up with ten business ideas for AI startup
   node2:
+    agentId: stringTemplate
     inputs: [node1]
     params:
-      prompt: |
+      template: |
         Please evaluate following business ideas.
         ${0}
   node3:
-    inputs: [node1, node2]
+    agentId: slashgpt
+    inputs: [node2]
+  node4:
+    agentId: stringTemplate
+    inputs: [node1, node3]
     params:
-      prompt:  |
+      template:  |
         Please pick the winner of this business idea contest.
         [ideas]
         ${0}
         [evalutations]
         ${1}
+  node5:
+    agentId: slashgpt
+    inputs: [node4]

package/samples/home.json

@@ -0,0 +1,112 @@
+[
+  {
+      "name": "fill_bath",
+      "description": "Fill the bath tub",
+      "parameters": {
+          "type": "object",
+          "properties": {
+              "temperature": {
+                  "type": "number",
+                  "description": "Water temperature in celsius. If omitted, 41 degree"
+              },
+              "at": {
+                  "type": "string",
+                  "description": "Time to fill. If omitted immediately."
+              }
+          },
+          "required": []
+      }
+  },
+  {
+      "name": "set_temperature",
+      "description": "Set the temperature",
+      "parameters": {
+          "type": "object",
+          "properties": {
+              "temperature": {
+                  "type": "number",
+                  "description": "Room temperature in celsius."
+              },
+              "location": {
+                  "type": "string",
+                  "enum": ["kitchen", "living room", "master bedroom", "bedroom 2", "bedroom 3", "all bedrooms"],
+                  "description": "The room to set the temperature."
+              }
+          },
+          "required": ["temperature", "location"]
+      }
+  },
+  {
+      "name": "start_sprinkler",
+      "description": "Start the sprinkler system",
+      "parameters": {
+          "type": "object",
+          "properties": {
+              "location": {
+                  "type": "string",
+                  "enum": ["all", "lawn", "vegetable garden", "front yard"],
+                  "description": "Specify the location to water."
+              }
+          },
+          "required": ["location"]
+      }
+  },
+  {
+      "name": "take_picture",
+      "description": "Take a picture and send it",
+      "parameters": {
+          "type": "object",
+          "properties": {
+              "location": {
+                  "type": "string",
+                  "enum": ["entrance", "backyard", "kitchen", "living room"],
+                  "description": "Specify the camera location to use."
+              }
+          },
+          "required": ["location"]
+      }
+  },
+  {
+      "name": "play_music",
+      "description": "Play music",
+      "parameters": {
+          "type": "object",
+          "properties": {
+              "location": {
+                  "type": "string",
+                  "enum": ["living room", "master bedroom"],
+                  "description": "Location to play a music."
+              },
+              "music": {
+                  "type": "string",
+                  "description": "Music to play, such as artist, title and playlist."
+              }
+          },
+          "required": ["location"]
+      }
+  },
+  {
+      "name": "control_light",
+      "description": "Turn on/off various lights",
+      "parameters": {
+          "type": "object",
+          "properties": {
+              "location": {
+                  "type": "string",
+                  "enum": ["kitchen", "living room", "master bedroom", "bedroom 2", "bedroom 3", "front gate"],
+                  "description": "Specify the location to control the light."
+              },
+              "switch": {
+                  "type": "string",
+                  "enum": ["on", "off"],
+                  "description": "Specify the light switch."
+              },
+              "dim": {
+                  "type": "number",
+                  "description": "Specify the dim level between 0 and 1.0. The 'switch' parameter must be 'on'."
+              }
+          },
+          "required": ["location", "switch"]
+      }
+  }
+]

package/samples/home.ts

@@ -0,0 +1,51 @@
+import { GraphAI, GraphData } from "@/graphai";
+import path from "path";
+import * as fs from "fs";
+import { slashGPTAgent } from "@/experimental_agents";
+
+const home_actions = {
+  fill_bath: { type: "message_template", message: "Success. I started filling the bath tab." },
+  set_temperature: { type: "message_template", message: "Success. I set the temperature to {temperature} for {location}" },
+  start_sprinkler: { type: "message_template", message: "Success. I started the sprinkler for {location}" },
+  take_picture: { type: "message_template", message: "Success. I took a picture of {location}" },
+  play_music: { type: "message_template", message: "Success. I started playing {music} in {location}" },
+  control_light: { type: "message_template", message: "Success. The light switch of {location} is now {switch}." },
+};
+
+const fileName = path.resolve(__dirname) + "/home.json";
+const json_file = fs.readFileSync(fileName, "utf8");
+const home_functions = JSON.parse(json_file);
+
+const graph_data: GraphData = {
+  nodes: {
+    node1: {
+      source: true,
+      result: { content: "Turn on the light in the kitchen" },
+    },
+    node2: {
+      inputs: ["node1"],
+      params: {
+        manifest: {
+          skip_function_result: true,
+          actions: home_actions,
+          functions: home_functions,
+        },
+      },
+    },
+  },
+};
+
+const runAgent = async () => {
+  const graph = new GraphAI(graph_data, slashGPTAgent);
+  const result = await graph.run();
+  const log_path = path.resolve(__dirname) + "/../tests/logs/home.log";
+  fs.writeFileSync(log_path, JSON.stringify(graph.transactionLogs(), null, 2));
+  console.log(result["node2"]!.content);
+};
+
+const main = async () => {
+  await runAgent();
+  console.log("COMPLETE 1");
+};
+
+main();

package/samples/interaction.ts

@@ -0,0 +1,42 @@
+import { GraphAI, GraphData } from "@/graphai";
+import * as readline from "readline";
+import { testAgent } from "~/agents/agents";
+import { graphDataTestRunner } from "~/utils/runner";
+
+const getUserInput = async (question: string): Promise<string> => {
+  return new Promise((resolve, reject) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer);
+    });
+  });
+};
+
+const graph_data: GraphData = {
+  nodes: {
+    node1: {
+      source: true,
+    },
+    node2: {
+      inputs: ["node1"],
+    },
+  },
+};
+
+const main = async () => {
+  const query = await getUserInput("Please enter your question: ");
+  console.log("query=", query);
+  graph_data.nodes.node1.result = { query };
+
+  const result = await graphDataTestRunner("interaction.yaml", graph_data, testAgent);
+  console.log(result);
+
+  console.log("COMPLETE 1");
+};
+
+main();

package/samples/runner.ts

@@ -0,0 +1,15 @@
+import path from "path";
+
+import { GraphAI, AgentFunctionDictonary, AgentFunction } from "@/graphai";
+import { readGraphaiData } from "~/utils/file_utils";
+import { graphDataTestRunner } from "~/utils/runner";
+
+export const fileTestRunner = async (
+  file: string,
+  callbackDictonary: AgentFunctionDictonary | AgentFunction<any, any, any>,
+  callback: (graph: GraphAI) => void = () => {},
+) => {
+  const file_path = path.resolve(__dirname) + file;
+  const graph_data = readGraphaiData(file_path);
+  return await graphDataTestRunner(file, graph_data, callbackDictonary, callback);
+};

package/samples/sample_co2.ts

@@ -1,7 +1,7 @@
-import { GraphAI, AgentFunction } from "@/graphai";
-import { readGraphaiData } from "~/utils/file_utils";
+import { slashGPTFuncitons2TextAgent } from "./agents/slashgpt_agent";
+import { slashGPTAgent } from "@/experimental_agents";
 
-import { slashGPTAgent, slashGPTFuncitons2TextAgent } from "./agents/slashgpt_agent";
+import { graphDataTestRunner } from "~/utils/runner";
 
 const graph_data = {
   nodes: {
@@ -9,7 +9,7 @@ const graph_data = {
       agentId: "slashGPTAgent",
       params: {
         function_result: true,
-        prompt: "世界で協力してco2を減らす方法を教えて下さい",
+        query: "世界で協力してco2を減らす方法を教えて下さい",
         manifest: {
           prompt: "あなたは世界経済の専門家です。ユーザの問い合わせについて考え、10この結果をfunctionsの結果に返してください。",
           skip_function_result: true,
@@ -51,6 +51,7 @@ const graph_data = {
       },
     },
     function2prompt0: {
+      fork: 10,
       params: {
         function_data_key: "methods",
         result_key: 0,
@@ -60,6 +61,7 @@ const graph_data = {
     },
     slashGPTAgent0: {
       agentId: "slashGPTAgent",
+      fork: 10,
       params: {
         debug: true,
         manifest: {
@@ -68,36 +70,11 @@ const graph_data = {
       },
       inputs: ["function2prompt0"],
     },
-    // 1
-    function2prompt1: {
-      params: {
-        debug: true,
-        function_data_key: "methods",
-        result_key: 1,
-      },
-      inputs: ["slashGPTAgent"],
-      agentId: "slashGPTFuncitons2TextAgent",
-    },
-    slashGPTAgent1: {
-      agentId: "slashGPTAgent",
-      params: {
-        debug: true,
-        manifest: {
-          prompt: "ユーザの問い合わせにある文章の専門家です。専門家として、ユーザのアイデアに対して実現可能なシナリオを800文字で書いてください。",
-        },
-      },
-      inputs: ["function2prompt1"],
-    },
   },
 };
-const runAgent = async () => {
-  const graph = new GraphAI(graph_data, { slashGPTAgent, slashGPTFuncitons2TextAgent });
-  const result = await graph.run();
-  console.log(result);
-};
 
 const main = async () => {
-  await runAgent();
+  const result = await graphDataTestRunner("sample_co2.yaml", graph_data, { slashGPTAgent, slashGPTFuncitons2TextAgent });
   console.log("COMPLETE 1");
 };
 main();

package/samples/sample_gpt.ts

@@ -1,37 +1,8 @@
-import path from "path";
-import { GraphAI, AgentFunction } from "@/graphai";
-import { ChatSession, ChatConfig, ManifestData } from "slashgpt";
-import { readGraphaiData } from "~/utils/file_utils";
+import { fileTestRunner } from "./runner";
 
-const config = new ChatConfig(path.resolve(__dirname));
-
-const slashGPTAgent: AgentFunction<{ manifest: ManifestData; prompt: string }, { answer: string }> = async (context) => {
-  console.log("executing", context.nodeId, context.params);
-  const session = new ChatSession(config, context.params.manifest ?? {});
-  const prompt = context.inputs.reduce((prompt, input, index) => {
-    return prompt.replace("${" + index + "}", input["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 };
-  return result;
-};
-
-const runAgent = async (file: string) => {
-  const file_path = path.resolve(__dirname) + file;
-  const graph_data = readGraphaiData(file_path);
-  const graph = new GraphAI(graph_data, slashGPTAgent);
-  const result = await graph.run();
-  console.log(result);
-};
+import { stringTemplateAgent, slashGPTAgent } from "@/experimental_agents";
 
 const main = async () => {
-  await runAgent("/graphs/slash_gpt.yml");
-  console.log("COMPLETE 1");
+  await fileTestRunner("/graphs/slash_gpt.yml", { slashgpt: slashGPTAgent, stringTemplate: stringTemplateAgent });
 };
 main();

package/samples/sample_paper_ai.ts

@@ -1,22 +1,10 @@
-import path from "path";
-import search from "arXiv-api-ts";
+import { fileTestRunner } from "./runner";
 
-import { GraphAI, AgentFunction } from "@/graphai";
-import { readGraphaiData } from "~/utils/file_utils";
-
-import { slashGPTAgent } from "./agents/slashgpt_agent";
+import { slashGPTAgent } from "@/experimental_agents";
 import { arxivAgent, arxiv2TextAgent } from "./agents/arxiv_agent";
 
-const runAgent = async (file: string) => {
-  const file_path = path.resolve(__dirname) + file;
-  const graph_data = readGraphaiData(file_path);
-  const graph = new GraphAI(graph_data, { arxivAgent: arxivAgent, arxiv2TextAgent, slashGPTAgent });
-  const result = await graph.run();
-  console.log(result);
-};
-
 const main = async () => {
-  await runAgent("/graphs/arxiv.yml");
+  await fileTestRunner("/graphs/arxiv.yml", { arxivAgent: arxivAgent, arxiv2TextAgent, slashGPTAgent });
   console.log("COMPLETE 1");
 };
 main();

package/src/experimental_agents/index.ts

@@ -0,0 +1,2 @@
+export * from "./string_agent";
+export * from "./slashgpt_agent";

package/src/experimental_agents/slashgpt_agent.ts

@@ -0,0 +1,30 @@
+import path from "path";
+import { AgentFunction } from "@/graphai";
+import { ChatSession, ChatConfig, ManifestData } from "slashgpt";
+
+const config = new ChatConfig(path.resolve(__dirname));
+
+export const slashGPTAgent: AgentFunction<{ manifest: ManifestData; query?: string; function_result?: boolean }, { content: string }> = async (context) => {
+  console.log("executing", context.nodeId, context.params);
+  const session = new ChatSession(config, context.params.manifest ?? {});
+
+  const query = context.params?.query ? [context.params.query] : [];
+  const contents = query.concat(
+    context.inputs.map((input) => {
+      return input.content;
+    }),
+  );
+
+  session.append_user_question(contents.join("\n"));
+  await session.call_loop(() => {});
+  const message = (() => {
+    if (context.params?.function_result) {
+      return session.history.messages().find((m) => m.role === "function_result");
+    }
+    return session.history.last_message();
+  })();
+  if (message === undefined) {
+    throw new Error("No message in the history");
+  }
+  return message;
+};

package/src/experimental_agents/string_agent.ts

@@ -0,0 +1,10 @@
+import { AgentFunction } from "@/graphai";
+
+export const stringTemplateAgent: AgentFunction<{ template: string; inputKey?: string }, { content: string }> = async (context) => {
+  console.log("executing", context.nodeId, context.params);
+  const content = context.inputs.reduce((template, input, index) => {
+    return template.replace("${" + index + "}", input[context.params.inputKey ?? "content"]);
+  }, context.params.template);
+
+  return { content };
+};

package/src/graphai.ts

@@ -14,11 +14,13 @@ export type NodeDataParams<ParamsType = Record<string, any>> = ParamsType; // Ag
 
 type NodeData = {
   inputs?: Array<string>;
-  params: NodeDataParams;
+  params?: NodeDataParams;
   retry?: number;
   timeout?: number; // msec
   agentId?: string;
+  fork?: number;
   source?: boolean;
+  result?: ResultData; // preset result for source node.
   outputs?: Record<string, string>; // mapping from routeId to nodeId
 };
 
@@ -42,6 +44,7 @@ export type TransactionLog = {
 
 export type AgentFunctionContext<ParamsType, ResultType, PreviousResultType> = {
   nodeId: string;
+  forkIndex?: number;
   retry: number;
   params: NodeDataParams<ParamsType>;
   inputs: Array<PreviousResultType>;
@@ -61,6 +64,8 @@ class Node {
   public waitlist = new Set<string>(); // List of nodes which need data from this node.
   public state = NodeState.Waiting;
   public agentId?: string;
+  public fork?: number;
+  public forkIndex?: number;
   public result: ResultData = undefined;
   public retryLimit: number;
   public retryCount: number = 0;
@@ -72,12 +77,14 @@ class Node {
 
   private graph: GraphAI;
 
-  constructor(nodeId: string, data: NodeData, graph: GraphAI) {
+  constructor(nodeId: string, forkIndex: number | undefined, data: NodeData, graph: GraphAI) {
     this.nodeId = nodeId;
+    this.forkIndex = forkIndex;
     this.inputs = data.inputs ?? [];
     this.pendings = new Set(this.inputs);
-    this.params = data.params;
+    this.params = data.params ?? {};
     this.agentId = data.agentId;
+    this.fork = data.fork;
     this.retryLimit = data.retry ?? 0;
     this.timeout = data.timeout;
     this.source = data.source === true;
@@ -122,9 +129,9 @@ class Node {
         retryCount: this.retryCount,
         state: NodeState.Injected,
         startTime: Date.now(),
+        endTime: Date.now(),
         result,
       };
-      log.endTime = log.startTime;
       this.graph.appendLog(log);
       this.setResult(result, NodeState.Injected);
     } else {
@@ -143,21 +150,19 @@ class Node {
   }
 
   public async execute() {
+    const results = this.graph.resultsOf(this.inputs);
+    const transactionId = Date.now();
     const log: TransactionLog = {
       nodeId: this.nodeId,
       retryCount: this.retryCount,
       state: NodeState.Executing,
-      startTime: Date.now(),
+      startTime: transactionId,
       agentId: this.agentId,
       params: this.params,
+      inputs: results,
     };
-    const results = this.graph.resultsOf(this.inputs);
-    if (results.length > 0) {
-      log.inputs = results;
-    }
     this.graph.appendLog(log);
     this.state = NodeState.Executing;
-    const transactionId = log.startTime;
     this.transactionId = transactionId;
 
     if (this.timeout && this.timeout > 0) {
@@ -179,6 +184,7 @@ class Node {
         retry: this.retryCount,
         params: this.params,
         inputs: results,
+        forkIndex: this.forkIndex,
       });
       if (this.transactionId !== transactionId) {
         console.log(`-- ${this.nodeId}: transactionId mismatch`);
@@ -241,24 +247,66 @@ export class GraphAI {
     this.onComplete = () => {
       console.error("-- SOMETHING IS WRONG: onComplete is called without run()");
     };
+    const nodeId2forkedNodeIds: Record<string, string[]> = {};
+    const forkedNodeId2Index: Record<string, number> = {};
+
+    // Create node instances from data.nodes
     this.nodes = Object.keys(data.nodes).reduce((nodes: GraphNodes, nodeId: string) => {
-      nodes[nodeId] = new Node(nodeId, data.nodes[nodeId], this);
+      const fork = data.nodes[nodeId].fork;
+      if (fork) {
+        // For fork, change the nodeId and increase the node
+        nodeId2forkedNodeIds[nodeId] = new Array(fork).fill(undefined).map((_, i) => {
+          const forkedNodeId = `${nodeId}_${i}`;
+          nodes[forkedNodeId] = new Node(forkedNodeId, i, data.nodes[nodeId], this);
+          // Data for pending and waiting
+          forkedNodeId2Index[forkedNodeId] = i;
+          return forkedNodeId;
+        });
+      } else {
+        nodes[nodeId] = new Node(nodeId, undefined, data.nodes[nodeId], this);
+      }
       return nodes;
     }, {});
 
-    // Generate the waitlist for each node
+    // 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];
       node.pendings.forEach((pending) => {
-        const node2 = this.nodes[pending];
-        node2.waitlist.add(nodeId);
+        // If the pending(previous) node is forking
+        if (nodeId2forkedNodeIds[pending]) {
+          //  update node.pending and pending(previous) node.wailtlist
+          if (node.fork) {
+            //  1:1 if current nodes are also forking.
+            const newPendingId = nodeId2forkedNodeIds[pending][forkedNodeId2Index[nodeId]];
+            this.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
+              node.pendings.add(newPendingId);
+            });
+          }
+          node.pendings.delete(pending);
+        } else {
+          this.nodes[pending].waitlist.add(nodeId); // previousNode
+        }
       });
+      node.inputs = Array.from(node.pendings); // for fork.
+    });
+
+    // 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);
+      }
     });
   }
 
   public getCallback(_agentId?: string) {
     const agentId = _agentId ?? "_default";
-    console.log(agentId);
     if (this.callbackDictonary[agentId]) {
       return this.callbackDictonary[agentId];
     }
@@ -293,7 +341,7 @@ export class GraphAI {
     }, {});
   }
 
-  public async run() {
+  public async run(): Promise<ResultDataDictonary> {
     if (this.isRunning) {
       console.error("-- Already Running");
     }

package/src/graphai_cli.ts

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+
+import { GraphAI, AgentFunction } from "./graphai";
+import { slashGPTAgent, stringTemplateAgent } from "./experimental_agents";
+
+import fs from "fs";
+import path from "path";
+import YAML from "yaml";
+
+const testAgent: AgentFunction<{ delay: number; fail: boolean }> = async (context) => {
+  return {};
+};
+
+const main = async () => {
+  const file = process.argv[2];
+  if (file === undefined) {
+    console.log("no file");
+    return;
+  }
+  const file_path = path.resolve(process.cwd() + "/" + file);
+  if (!fs.existsSync(file_path)) {
+    console.log("no file");
+    return;
+  }
+  try {
+    const graph_data_file = fs.readFileSync(file_path, "utf8");
+    const graph_data = YAML.parse(graph_data_file);
+
+    const graph = new GraphAI(graph_data, { testAgent, slashGPTAgent, stringTemplateAgent });
+    const results = await graph.run();
+    console.log(results);
+  } catch (e) {
+    console.log("error", e);
+  }
+};
+
+main();

package/tests/agents/test_string_agent.ts

@@ -0,0 +1,28 @@
+import { stringTemplateAgent } from "@/experimental_agents";
+
+import test from "node:test";
+import assert from "node:assert";
+
+test("test stringTemplateAgent simple", async () => {
+  const result = await stringTemplateAgent({
+    nodeId: "test",
+    retry: 0,
+    params: { template: "${0}: ${1}" },
+    inputs: [{ content: "hello" }, { content: "test" }] as any,
+  });
+  assert.deepStrictEqual(result, {
+    content: "hello: test",
+  });
+});
+
+test("test stringTemplateAgent simple", async () => {
+  const result = await stringTemplateAgent({
+    nodeId: "test",
+    retry: 0,
+    params: { template: "${0}: ${1}", inputKey: "key" },
+    inputs: [{ key: "hello" }, { key: "test" }],
+  });
+  assert.deepStrictEqual(result, {
+    content: "hello: test",
+  });
+});

package/tests/graphai/test_fork.ts

@@ -0,0 +1,106 @@
+import { GraphAI, AgentFunction } from "@/graphai";
+import { testAgent } from "~/agents/agents";
+import { graphDataTestRunner } from "~/utils/runner";
+
+import test from "node:test";
+import assert from "node:assert";
+
+const testAgent1: AgentFunction = async (context) => {
+  const { nodeId, retry, params, inputs } = context;
+  console.log("executing", nodeId, params, inputs);
+
+  const result = {
+    [nodeId]: [nodeId, inputs.map((a) => Object.values(a).flat())]
+      .flat()
+      .filter((a) => !!a)
+      .join(":"),
+  };
+  console.log("completing", nodeId, result);
+  return result;
+};
+
+test("test base", async () => {
+  const forkGraph = {
+    nodes: {
+      node1: {
+        params: {},
+      },
+      node2: {
+        params: {},
+        fork: 10,
+        inputs: ["node1"],
+      },
+      node3: {
+        params: {},
+        // fork: 10,
+        inputs: ["node2"],
+      },
+    },
+  };
+
+  const result = await graphDataTestRunner("fork.yml", forkGraph, testAgent1);
+  // console.log(result);
+  assert.deepStrictEqual(result, {
+    node1: { node1: "node1" },
+    node2_0: { node2_0: "node2_0:node1" },
+    node2_1: { node2_1: "node2_1:node1" },
+    node2_2: { node2_2: "node2_2:node1" },
+    node2_3: { node2_3: "node2_3:node1" },
+    node2_4: { node2_4: "node2_4:node1" },
+    node2_5: { node2_5: "node2_5:node1" },
+    node2_6: { node2_6: "node2_6:node1" },
+    node2_7: { node2_7: "node2_7:node1" },
+    node2_8: { node2_8: "node2_8:node1" },
+    node2_9: { node2_9: "node2_9:node1" },
+    node3: {
+      node3:
+        "node3:node2_0:node1:node2_1:node1:node2_2:node1:node2_3:node1:node2_4:node1:node2_5:node1:node2_6:node1:node2_7:node1:node2_8:node1:node2_9:node1",
+    },
+  });
+});
+
+test("test base", async () => {
+  const forkGraph = {
+    nodes: {
+      node1: {
+        params: {},
+      },
+      node2: {
+        params: {},
+        fork: 10,
+        inputs: ["node1"],
+      },
+      node3: {
+        params: {},
+        fork: 10,
+        inputs: ["node2"],
+      },
+    },
+  };
+
+  const result = await graphDataTestRunner("fork.yml", forkGraph, testAgent1);
+  // console.log(result);
+  assert.deepStrictEqual(result, {
+    node1: { node1: "node1" },
+    node2_0: { node2_0: "node2_0:node1" },
+    node2_1: { node2_1: "node2_1:node1" },
+    node2_2: { node2_2: "node2_2:node1" },
+    node2_3: { node2_3: "node2_3:node1" },
+    node2_4: { node2_4: "node2_4:node1" },
+    node2_5: { node2_5: "node2_5:node1" },
+    node2_6: { node2_6: "node2_6:node1" },
+    node2_7: { node2_7: "node2_7:node1" },
+    node2_8: { node2_8: "node2_8:node1" },
+    node2_9: { node2_9: "node2_9:node1" },
+    node3_0: { node3_0: "node3_0:node2_0:node1" },
+    node3_1: { node3_1: "node3_1:node2_1:node1" },
+    node3_2: { node3_2: "node3_2:node2_2:node1" },
+    node3_3: { node3_3: "node3_3:node2_3:node1" },
+    node3_4: { node3_4: "node3_4:node2_4:node1" },
+    node3_5: { node3_5: "node3_5:node2_5:node1" },
+    node3_6: { node3_6: "node3_6:node2_6:node1" },
+    node3_7: { node3_7: "node3_7:node2_7:node1" },
+    node3_8: { node3_8: "node3_8:node2_8:node1" },
+    node3_9: { node3_9: "node3_9:node2_9:node1" },
+  });
+});

package/tests/graphai/test_sample_flow.ts

@@ -60,13 +60,12 @@ test("test source", async () => {
 test("test source2", async () => {
   const result = await fileTestRunner("/graphs/test_source2.yml", testAgent, (graph: GraphAI) => {
     graph.injectResult("node1", { node1: "injected" });
-    graph.injectResult("node2", { node2: "injected" });
   });
   assert.deepStrictEqual(result, {
     node1: { node1: "injected" },
-    node2: { node2: "injected" },
-    node3: { node3: "output", node1: "injected", node2: "injected" },
-    node4: { node4: "output", node3: "output", node1: "injected", node2: "injected" },
-    node5: { node5: "output", node4: "output", node3: "output", node1: "injected", node2: "injected" },
+    node2: { node2: "preset" },
+    node3: { node3: "output", node1: "injected", node2: "preset" },
+    node4: { node4: "output", node3: "output", node1: "injected", node2: "preset" },
+    node5: { node5: "output", node4: "output", node3: "output", node1: "injected", node2: "preset" },
   });
 });

package/tests/graphs/test_cli.yaml

@@ -0,0 +1,4 @@
+nodes:
+  node1:
+    agentId: test
+    

package/tests/graphs/test_source2.yml

@@ -3,6 +3,8 @@ nodes:
     source: true
   node2:
     source: true
+    result:
+      node2: preset
   node3:
     params:
       delay: 500