graphai 0.0.7 → 0.0.9

package/README.md

@@ -4,7 +4,7 @@
 
 GraphAI is an asynchronous data flow execution engine, which makes it easy to create AI applications that need to make asynchronous AI API calls multiple times with some dependencies among them, such as giving the answer from one LLM call to another LLM call as a prompt.
 
-You just need to describe dependencies among those API calls in a single data flow graph (typically in YAML), create a GraphAI object with it, and run it.
+You just need to describe dependencies among those API calls in a single data flow graph, create a GraphAI object with that graph, and run it.
 
 Here is an example:
 
@@ -27,7 +27,7 @@ const sampleAgentFunction = async (context: AgentFunctionContext) => {
   const { 
     nodeId, // taskA, taskB or taskC 
     params, // agent-specific parameters specified in the graph definition file
-    payload // for taskC, { taskA: resultA, taskB: resultB }
+    inputs // inputs from previous nodes
   } = context;
   // Agent-specific code (such as calling OpenAI's chat.completions API)
   ...
@@ -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, retry, timeout, source, dispatch, 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
 
@@ -61,19 +71,19 @@ An agent is an abstract object, which takes some inputs and generates an output
 
 An agent function is a TypeScript function, which implements an agent. A DFG is associated one or more agent functions. If the DFG is associated with multiple agent functions, each node needs to be associated only one of them (either explicitly with 'agentId' or implicitly to the default Agent function).
 
-An agent function receives two set of parameters via AgentFunctionContext, agent specific parameters specified in the DFG and input data came from other nodes (payload).
-
-A regular agent function returns the data (type: ```Record<string, any>```), but a dispatcher agent function returns the date with outputID(s) (type: ```Record<string: Record<string, any>>```). 
+An agent function receives two set of parameters via AgentFunctionContext, agent specific parameters specified in the DFG and input data came from other nodes.
 
 ## 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'.
-- 'dispatch': An optinal property (type: ```Record<string, string>```) which indicates that the current node is a 'dispatcher node'. A dispatcher node is associated is a dispaher-style agent function, which has multiple possible 'outputs'.
+- '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.
-- 'payloadMapping': An optional property (type: ```Record<string, string>```), which maps input nodeIds to agent specific inputIDs.
+- '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/graphai.d.ts

@@ -12,13 +12,14 @@ type ResultDataDictonary<ResultType = Record<string, any>> = Record<string, Resu
 export type NodeDataParams<ParamsType = Record<string, any>> = ParamsType;
 type NodeData = {
     inputs?: Array<string>;
-    params: NodeDataParams;
-    payloadMapping?: Record<string, string>;
+    params?: NodeDataParams;
     retry?: number;
     timeout?: number;
     agentId?: string;
+    fork?: number;
     source?: boolean;
-    dispatch?: Record<string, string>;
+    result?: ResultData;
+    outputs?: Record<string, string>;
 };
 export type GraphData = {
     nodes: Record<string, NodeData>;
@@ -32,15 +33,16 @@ export type TransactionLog = {
     retryCount: number;
     agentId?: string;
     params?: NodeDataParams;
-    payload?: ResultDataDictonary<ResultData>;
+    inputs?: Array<ResultData>;
     errorMessage?: string;
     result?: ResultData;
 };
 export type AgentFunctionContext<ParamsType, ResultType, PreviousResultType> = {
     nodeId: string;
+    forkIndex?: number;
     retry: number;
     params: NodeDataParams<ParamsType>;
-    payload: ResultDataDictonary<PreviousResultType>;
+    inputs: Array<PreviousResultType>;
 };
 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 AgentFunctionDictonary = Record<string, AgentFunction<any, any, any>>;
@@ -48,11 +50,12 @@ declare class Node {
     nodeId: string;
     params: NodeDataParams;
     inputs: Array<string>;
-    payloadMapping: Record<string, string>;
     pendings: Set<string>;
     waitlist: Set<string>;
     state: NodeState;
-    agentId: string;
+    agentId?: string;
+    fork?: number;
+    forkIndex?: number;
     result: ResultData;
     retryLimit: number;
     retryCount: number;
@@ -60,13 +63,12 @@ declare class Node {
     timeout?: number;
     error?: Error;
     source: boolean;
-    dispatch?: Record<string, string>;
+    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;
-    payload(): ResultDataDictonary<Record<string, any>>;
     pushQueueIfReady(): void;
     injectResult(result: ResultData): void;
     private setResult;
@@ -83,7 +85,7 @@ export declare class GraphAI {
     private concurrency;
     private logs;
     constructor(data: GraphData, callbackDictonary: AgentFunctionDictonary | AgentFunction<any, any, any>);
-    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>;
@@ -94,5 +96,6 @@ export declare class GraphAI {
     appendLog(log: TransactionLog): void;
     transactionLogs(): TransactionLog[];
     injectResult(nodeId: string, result: ResultData): void;
+    resultsOf(nodeIds: Array<string>): ResultData<Record<string, any>>[];
 }
 export {};

package/lib/graphai.js

@@ -12,21 +12,22 @@ 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.payloadMapping = data.payloadMapping ?? {};
         this.pendings = new Set(this.inputs);
-        this.params = data.params;
-        this.agentId = data.agentId ?? "default";
+        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;
-        this.dispatch = data.dispatch;
+        this.outputs = data.outputs;
         this.graph = graph;
     }
     asString() {
@@ -51,17 +52,6 @@ class Node {
             this.pushQueueIfReady();
         }
     }
-    payload() {
-        return this.inputs.reduce((results, nodeId) => {
-            if (this.payloadMapping && this.payloadMapping[nodeId]) {
-                results[this.payloadMapping[nodeId]] = this.graph.nodes[nodeId].result;
-            }
-            else {
-                results[nodeId] = this.graph.nodes[nodeId].result;
-            }
-            return results;
-        }, {});
-    }
     pushQueueIfReady() {
         if (this.pendings.size === 0 && !this.source) {
             this.graph.pushQueue(this);
@@ -74,8 +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);
         }
@@ -93,19 +84,19 @@ class Node {
         });
     }
     async execute() {
-        const payload = this.payload();
+        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,
-            payload,
+            inputs: results,
         };
         this.graph.appendLog(log);
         this.state = NodeState.Executing;
-        const transactionId = log.startTime;
         this.transactionId = transactionId;
         if (this.timeout && this.timeout > 0) {
             setTimeout(() => {
@@ -124,7 +115,8 @@ class Node {
                 nodeId: this.nodeId,
                 retry: this.retryCount,
                 params: this.params,
-                payload,
+                inputs: results,
+                forkIndex: this.forkIndex,
             });
             if (this.transactionId !== transactionId) {
                 console.log(`-- ${this.nodeId}: transactionId mismatch`);
@@ -132,10 +124,10 @@ class Node {
             }
             log.endTime = Date.now();
             log.result = result;
-            const dispatch = this.dispatch;
-            if (dispatch !== undefined) {
+            const outputs = this.outputs;
+            if (outputs !== undefined) {
                 Object.keys(result).forEach((outputId) => {
-                    const nodeId = dispatch[outputId];
+                    const nodeId = outputs[outputId];
                     this.graph.injectResult(nodeId, result[outputId]);
                 });
                 log.state = NodeState.Dispatched;
@@ -173,32 +165,74 @@ class GraphAI {
         this.runningNodes = new Set();
         this.nodeQueue = [];
         this.logs = [];
-        this.callbackDictonary = typeof callbackDictonary === "function" ? { default: callbackDictonary } : callbackDictonary;
-        if (this.callbackDictonary["default"] === undefined) {
-            throw new Error("No default function");
-        }
+        this.callbackDictonary = typeof callbackDictonary === "function" ? { _default: callbackDictonary } : callbackDictonary;
         this.concurrency = data.concurrency ?? defaultConcurrency;
         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) {
-        if (agentId && this.callbackDictonary[agentId]) {
+    getCallback(_agentId) {
+        const agentId = _agentId ?? "_default";
+        if (this.callbackDictonary[agentId]) {
             return this.callbackDictonary[agentId];
         }
-        return this.callbackDictonary["default"];
+        throw new Error("No agent: " + agentId);
     }
     asString() {
         return Object.keys(this.nodes)
@@ -288,5 +322,10 @@ class GraphAI {
             console.error("-- Invalid nodeId", nodeId);
         }
     }
+    resultsOf(nodeIds) {
+        return nodeIds.map((nodeId) => {
+            return this.nodes[nodeId].result;
+        });
+    }
 }
 exports.GraphAI = GraphAI;

package/lib/graphai_cli.d.ts

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

package/lib/graphai_cli.js

@@ -0,0 +1,36 @@
+#!/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 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, { test: testAgent });
+        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.7",
+  "version": "0.0.9",
   "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

@@ -35,12 +35,11 @@ export const arxivAgent: AgentFunction<{ keywords: string[]; limit: number }, ar
 };
 
 export const arxiv2TextAgent: AgentFunction<{}, string, string[]> = async (context) => {
-  const result = (context?.payload?.inputData || [])
+  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;
 };

package/samples/agents/parroting_agent.ts

@@ -0,0 +1,5 @@
+import { AgentFunction } from "@/graphai";
+
+export const parrotingAgent: AgentFunction = async (context) => {
+  return context.params;
+};

package/samples/agents/slashgpt_agent.ts

@@ -4,18 +4,47 @@ import { ChatSession, ChatConfig, ManifestData } from "slashgpt";
 
 const config = new ChatConfig(path.resolve(__dirname));
 
-export const slashGPTAgent: AgentFunction<{ manifest: ManifestData; prompt: string }, { answer: string }> = async (context) => {
-  console.log("executing", context.nodeId, context);
-  const session = new ChatSession(config, context.params?.manifest ?? {});
+export const slashGPTFuncitons2TextAgent: AgentFunction<
+  { function_data_key: string; result_key: number },
+  string,
+  { function_data: { [key: string]: string[] } }
+> = async (context) => {
+  const { params } = context;
+  const result = (context?.inputs[0].function_data[params.function_data_key] || []).map((r: any) => {
+    const { title, description } = r;
+    return ["title:", title, "description:", description].join("\n");
+  });
 
-  const prompt = [context.params?.prompt, context.payload.inputData].join("\n\n");
+  return result[context.forkIndex ?? 0];
+};
+
+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(() => {});
-  const message = session.history.last_message();
+
+  // 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 };
+  const result = { answer: message.content, function_data: message.function_data };
   return result;
 };

package/samples/graphs/arxiv.yml

@@ -5,17 +5,13 @@ nodes:
         - llm
         - gpt
       limit: 10
-    functionName: arxivAgent
+    agentId: arxivAgent
   arxiv2TextAgent:
     inputs: [searchArxiv]
-    functionName: arxiv2TextAgent
-    payloadMapping:
-      searchArxiv: inputData
+    agentId: arxiv2TextAgent
   slashGPTAgent:
     inputs: [arxiv2TextAgent]
-    payloadMapping:
-      arxiv2TextAgent: inputData
-    functionName: slashGPTAgent
+    agentId: slashGPTAgent
     params:
       prompt: |
         与えられたそれぞれの論文の要点をまとめ、以下の項目で日本語で出力せよ。それぞれの項目は最大でも180文字以内に要約せよ。

package/samples/graphs/slash_gpt.yml

@@ -5,8 +5,15 @@ nodes:
   node2:
     inputs: [node1]
     params:
-      prompt: Please evaluate following business ideas. ${node1}
+      prompt: |
+        Please evaluate following business ideas.
+        ${0}
   node3:
     inputs: [node1, node2]
     params:
-      prompt: Please pick the winner of this business idea contest. ${node1} ${node2}
+      prompt:  |
+        Please pick the winner of this business idea contest.
+        [ideas]
+        ${0}
+        [evalutations]
+        ${1}

package/samples/interaction.ts

@@ -0,0 +1,49 @@
+import { GraphAI, GraphData } from "@/graphai";
+import * as readline from "readline";
+import path from "path";
+import * as fs from "fs";
+import { testAgent } from "~/agents/agents";
+
+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 runAgent = async (query: string) => {
+  console.log("query=", query);
+  graph_data.nodes.node1.result = { query };
+  const graph = new GraphAI(graph_data, testAgent);
+  // graph.injectResult("node1", { query });
+  const result = await graph.run();
+  const log_path = path.resolve(__dirname) + "/../tests/logs/interaction.log";
+  fs.writeFileSync(log_path, JSON.stringify(graph.transactionLogs(), null, 2));
+  console.log(result);
+};
+
+const main = async () => {
+  const query = await getUserInput("Please enter your question: ");
+  await runAgent(query);
+  console.log("COMPLETE 1");
+};
+
+main();

package/samples/sample_co2.ts

@@ -0,0 +1,85 @@
+import { GraphAI, AgentFunction } from "@/graphai";
+import { readGraphaiData } from "~/utils/file_utils";
+
+import { slashGPTAgent, slashGPTFuncitons2TextAgent } from "./agents/slashgpt_agent";
+
+const graph_data = {
+  nodes: {
+    slashGPTAgent: {
+      agentId: "slashGPTAgent",
+      params: {
+        function_result: true,
+        prompt: "世界で協力してco2を減らす方法を教えて下さい",
+        manifest: {
+          prompt: "あなたは世界経済の専門家です。ユーザの問い合わせについて考え、10この結果をfunctionsの結果に返してください。",
+          skip_function_result: true,
+          actions: {
+            your_ideas: {
+              type: "message_template",
+              message: "dummy",
+            },
+          },
+          functions: [
+            {
+              name: "your_ideas",
+              description: "Your answer to a user's inquiry",
+              parameters: {
+                type: "object",
+                properties: {
+                  methods: {
+                    type: "array",
+                    items: {
+                      type: "object",
+                      properties: {
+                        title: {
+                          type: "string",
+                          description: "title",
+                        },
+                        description: {
+                          type: "string",
+                          description: "description",
+                        },
+                      },
+                      required: ["title", "description"],
+                    },
+                  },
+                },
+              },
+            },
+          ],
+        },
+      },
+    },
+    function2prompt0: {
+      fork: 10,
+      params: {
+        function_data_key: "methods",
+        result_key: 0,
+      },
+      inputs: ["slashGPTAgent"],
+      agentId: "slashGPTFuncitons2TextAgent",
+    },
+    slashGPTAgent0: {
+      agentId: "slashGPTAgent",
+      fork: 10,
+      params: {
+        debug: true,
+        manifest: {
+          prompt: "ユーザの問い合わせにある文章の専門家です。専門家として、ユーザのアイデアに対して実現可能なシナリオを800文字で書いてください。",
+        },
+      },
+      inputs: ["function2prompt0"],
+    },
+  },
+};
+const runAgent = async () => {
+  const graph = new GraphAI(graph_data, { slashGPTAgent, slashGPTFuncitons2TextAgent });
+  const result = await graph.run();
+  console.log(result);
+};
+
+const main = async () => {
+  await runAgent();
+  console.log("COMPLETE 1");
+};
+main();

package/samples/sample_gpt.ts

@@ -1,15 +1,16 @@
 import path from "path";
+import * as fs from "fs";
 import { GraphAI, AgentFunction } from "@/graphai";
 import { ChatSession, ChatConfig, ManifestData } from "slashgpt";
 import { readGraphaiData } from "~/utils/file_utils";
 
 const config = new ChatConfig(path.resolve(__dirname));
 
-const slashGPTAgent: AgentFunction<{ manifest: ManifestData; prompt: string }, { answer: string }> = async (context) => {
+const slashGPTAgent: AgentFunction<{ manifest: ManifestData; prompt: string }, { content: string }> = async (context) => {
   console.log("executing", context.nodeId, context.params);
   const session = new ChatSession(config, context.params.manifest ?? {});
-  const prompt = Object.keys(context.payload).reduce((prompt, key) => {
-    return prompt.replace("${" + key + "}", context.payload[key]!["answer"]);
+  const prompt = context.inputs.reduce((prompt, input, index) => {
+    return prompt.replace("${" + index + "}", input["content"]);
   }, context.params.prompt);
   session.append_user_question(prompt);
 
@@ -18,20 +19,22 @@ const slashGPTAgent: AgentFunction<{ manifest: ManifestData; prompt: string }, {
   if (message === undefined) {
     throw new Error("No message in the history");
   }
-  const result = { answer: message.content };
-  return result;
+  return message;
 };
 
 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);
+  const results = (await graph.run()) as Record<string, any>;
+
+  const log_path = path.resolve(__dirname) + "/../tests/logs/" + path.basename(file_path).replace(/\.yml$/, ".log");
+  console.log(log_path);
+  fs.writeFileSync(log_path, JSON.stringify(graph.transactionLogs(), null, 2));
+  console.log(results["node3"]["content"]);
 };
 
 const main = async () => {
   await runAgent("/graphs/slash_gpt.yml");
-  console.log("COMPLETE 1");
 };
 main();

package/samples/sample_paper_ai.ts

@@ -7,14 +7,10 @@ import { readGraphaiData } from "~/utils/file_utils";
 import { slashGPTAgent } from "./agents/slashgpt_agent";
 import { arxivAgent, arxiv2TextAgent } from "./agents/arxiv_agent";
 
-export const parrotingAgent: AgentFunction = async (context) => {
-  return {};
-};
-
 const runAgent = async (file: string) => {
   const file_path = path.resolve(__dirname) + file;
   const graph_data = readGraphaiData(file_path);
-  const graph = new GraphAI(graph_data, { default: parrotingAgent, arxivAgent: arxivAgent, arxiv2TextAgent, slashGPTAgent });
+  const graph = new GraphAI(graph_data, { arxivAgent: arxivAgent, arxiv2TextAgent, slashGPTAgent });
   const result = await graph.run();
   console.log(result);
 };

package/src/graphai.ts

@@ -14,13 +14,14 @@ export type NodeDataParams<ParamsType = Record<string, any>> = ParamsType; // Ag
 
 type NodeData = {
   inputs?: Array<string>;
-  params: NodeDataParams;
-  payloadMapping?: Record<string, string>;
+  params?: NodeDataParams;
   retry?: number;
   timeout?: number; // msec
   agentId?: string;
+  fork?: number;
   source?: boolean;
-  dispatch?: Record<string, string>; // route to node
+  result?: ResultData; // preset result for source node.
+  outputs?: Record<string, string>; // mapping from routeId to nodeId
 };
 
 export type GraphData = {
@@ -36,16 +37,17 @@ export type TransactionLog = {
   retryCount: number;
   agentId?: string;
   params?: NodeDataParams;
-  payload?: ResultDataDictonary<ResultData>;
+  inputs?: Array<ResultData>;
   errorMessage?: string;
   result?: ResultData;
 };
 
 export type AgentFunctionContext<ParamsType, ResultType, PreviousResultType> = {
   nodeId: string;
+  forkIndex?: number;
   retry: number;
   params: NodeDataParams<ParamsType>;
-  payload: ResultDataDictonary<PreviousResultType>;
+  inputs: Array<PreviousResultType>;
 };
 
 export type AgentFunction<ParamsType = Record<string, any>, ResultType = Record<string, any>, PreviousResultType = Record<string, any>> = (
@@ -58,11 +60,12 @@ class Node {
   public nodeId: string;
   public params: NodeDataParams; // Agent-specific parameters
   public inputs: Array<string>; // List of nodes this node needs data from.
-  public payloadMapping: Record<string, string>;
   public pendings: Set<string>; // List of nodes this node is waiting data from.
   public waitlist = new Set<string>(); // List of nodes which need data from this node.
   public state = NodeState.Waiting;
-  public agentId: string;
+  public agentId?: string;
+  public fork?: number;
+  public forkIndex?: number;
   public result: ResultData = undefined;
   public retryLimit: number;
   public retryCount: number = 0;
@@ -70,21 +73,22 @@ class Node {
   public timeout?: number; // msec
   public error?: Error;
   public source: boolean;
-  public dispatch?: Record<string, string>; // outputId to nodeId mapping
+  public outputs?: Record<string, string>; // Mapping from routeId to nodeId
 
   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.payloadMapping = data.payloadMapping ?? {};
     this.pendings = new Set(this.inputs);
-    this.params = data.params;
-    this.agentId = data.agentId ?? "default";
+    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;
-    this.dispatch = data.dispatch;
+    this.outputs = data.outputs;
     this.graph = graph;
   }
 
@@ -112,17 +116,6 @@ class Node {
     }
   }
 
-  public payload() {
-    return this.inputs.reduce((results: ResultDataDictonary, nodeId) => {
-      if (this.payloadMapping && this.payloadMapping[nodeId]) {
-        results[this.payloadMapping[nodeId]] = this.graph.nodes[nodeId].result;
-      } else {
-        results[nodeId] = this.graph.nodes[nodeId].result;
-      }
-      return results;
-    }, {});
-  }
-
   public pushQueueIfReady() {
     if (this.pendings.size === 0 && !this.source) {
       this.graph.pushQueue(this);
@@ -136,8 +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 {
@@ -156,19 +150,19 @@ class Node {
   }
 
   public async execute() {
-    const payload = this.payload();
+    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,
-      payload,
+      inputs: results,
     };
     this.graph.appendLog(log);
     this.state = NodeState.Executing;
-    const transactionId = log.startTime;
     this.transactionId = transactionId;
 
     if (this.timeout && this.timeout > 0) {
@@ -189,7 +183,8 @@ class Node {
         nodeId: this.nodeId,
         retry: this.retryCount,
         params: this.params,
-        payload,
+        inputs: results,
+        forkIndex: this.forkIndex,
       });
       if (this.transactionId !== transactionId) {
         console.log(`-- ${this.nodeId}: transactionId mismatch`);
@@ -199,10 +194,10 @@ class Node {
       log.endTime = Date.now();
       log.result = result;
 
-      const dispatch = this.dispatch;
-      if (dispatch !== undefined) {
+      const outputs = this.outputs;
+      if (outputs !== undefined) {
         Object.keys(result).forEach((outputId) => {
-          const nodeId = dispatch[outputId];
+          const nodeId = outputs[outputId];
           this.graph.injectResult(nodeId, result[outputId]);
         });
         log.state = NodeState.Dispatched;
@@ -247,34 +242,75 @@ export class GraphAI {
   private logs: Array<TransactionLog> = [];
 
   constructor(data: GraphData, callbackDictonary: AgentFunctionDictonary | AgentFunction<any, any, any>) {
-    this.callbackDictonary = typeof callbackDictonary === "function" ? { default: callbackDictonary } : callbackDictonary;
-    if (this.callbackDictonary["default"] === undefined) {
-      throw new Error("No default function");
-    }
+    this.callbackDictonary = typeof callbackDictonary === "function" ? { _default: callbackDictonary } : callbackDictonary;
     this.concurrency = data.concurrency ?? defaultConcurrency;
     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) {
-    if (agentId && this.callbackDictonary[agentId]) {
+  public getCallback(_agentId?: string) {
+    const agentId = _agentId ?? "_default";
+    if (this.callbackDictonary[agentId]) {
       return this.callbackDictonary[agentId];
     }
-    return this.callbackDictonary["default"];
+    throw new Error("No agent: " + agentId);
   }
 
   public asString() {
@@ -372,4 +408,10 @@ export class GraphAI {
       console.error("-- Invalid nodeId", nodeId);
     }
   }
+
+  public resultsOf(nodeIds: Array<string>) {
+    return nodeIds.map((nodeId) => {
+      return this.nodes[nodeId].result;
+    });
+  }
 }

package/src/graphai_cli.ts

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+
+import { GraphAI, AgentFunction } from "./graphai";
+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, { test: testAgent });
+    const results = await graph.run();
+    console.log(results);
+  } catch (e) {
+    console.log("error", e);
+  }
+};
+
+main();

package/tests/agents/agents.ts

@@ -2,7 +2,7 @@ import { AgentFunction } from "@/graphai";
 import { sleep } from "~/utils/utils";
 
 export const testAgent: AgentFunction<{ delay: number; fail: boolean }> = async (context) => {
-  const { nodeId, retry, params, payload } = context;
+  const { nodeId, retry, params, inputs } = context;
   console.log("executing", nodeId);
   await sleep(params.delay / (retry + 1));
 
@@ -11,10 +11,9 @@ export const testAgent: AgentFunction<{ delay: number; fail: boolean }> = async
     console.log("failed (intentional)", nodeId, retry);
     throw new Error("Intentional Failure");
   } else {
-    const result = Object.keys(payload).reduce(
-      (result, key) => {
-        result = { ...result, ...payload[key] };
-        return result;
+    const result = inputs.reduce(
+      (result: Record<string, any>, input: Record<string, any>) => {
+        return { ...result, ...input };
       },
       { [nodeId]: "output" },
     );

package/tests/graphai/test_dispatch.ts

@@ -8,8 +8,8 @@ import { testAgent } from "~/agents/agents";
 import test from "node:test";
 import assert from "node:assert";
 
-const dispatchAgent: AgentFunction<{ delay: number; fail: boolean }> = async (context) => {
-  const { nodeId, retry, params, payload } = context;
+const dispatchAgent: AgentFunction<{ delay: number; fail: boolean }, Record<string, any>, Record<string, any>> = async (context) => {
+  const { nodeId, retry, params, inputs } = context;
   console.log("executing", nodeId);
   await sleep(params.delay / (retry + 1));
 
@@ -18,10 +18,9 @@ const dispatchAgent: AgentFunction<{ delay: number; fail: boolean }> = async (co
     console.log("failed (intentional)", nodeId, retry);
     throw new Error("Intentional Failure");
   } else {
-    const result = Object.keys(payload).reduce(
-      (result, key) => {
-        result = { ...result, ...payload[key] };
-        return result;
+    const result = inputs.reduce(
+      (result: Record<string, any>, input: Record<string, any>) => {
+        return { ...result, ...input };
       },
       { [nodeId]: "dispatch" },
     );
@@ -31,7 +30,7 @@ const dispatchAgent: AgentFunction<{ delay: number; fail: boolean }> = async (co
 };
 
 test("test dispatch", async () => {
-  const result = await fileTestRunner("/graphs/test_dispatch.yml", { default: testAgent, alt: dispatchAgent });
+  const result = await fileTestRunner("/graphs/test_dispatch.yml", { test: testAgent, alt: dispatchAgent });
   assert.deepStrictEqual(result, {
     node1: { node1: "output" },
     node20: { node2: "dispatch" },

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_http_client.ts

@@ -5,8 +5,8 @@ import test from "node:test";
 import assert from "node:assert";
 
 const httpClientAgent: AgentFunction<Record<string, string>> = async (context) => {
-  const { nodeId, retry, params, payload } = context;
-  console.log("executing", nodeId, params, payload);
+  const { nodeId, retry, params, inputs } = context;
+  console.log("executing", nodeId, params, inputs);
 
   const response = await fetch(params.url);
   const result = await response.json();
@@ -31,7 +31,7 @@ const graph_data = {
   },
 };
 
-test("test sample1", async () => {
+test("test http client", async () => {
   const result = await graphDataTestRunner("http.log", graph_data, httpClientAgent);
   assert.deepStrictEqual(result, {
     node1: { result: true, messages: ["hello"] },

package/tests/graphai/test_multiple_functions.ts

@@ -33,8 +33,8 @@ const numberTestAgent: AgentFunction<{ number: number }, { [key: string]: number
   return result;
 };
 
-test("test sample1", async () => {
-  const result = await fileTestRunner("/graphs/test_multiple_functions_1.yml", { default: testAgent1, test2: testAgent2, numberTestAgent });
+test("test multiple function", async () => {
+  const result = await fileTestRunner("/graphs/test_multiple_functions_1.yml", { test1: testAgent1, test2: testAgent2, numberTestAgent });
   assert.deepStrictEqual(result, {
     node1: { node1: "output 1" },
     node2: { node2: "output 1" },

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_dispatch.yml

@@ -2,23 +2,28 @@ nodes:
   node1:
     params:
       delay: 500
+    agentId: test
   node2:
     params:
       delay: 100
     agentId: alt
-    dispatch:
+    outputs:
       output1: node20
   node20:
     source: true
+    agentId: test
   node3:
     params:
       delay: 500
     inputs: [node1, node20]
+    agentId: test
   node4:
     params:
       delay: 100
     inputs: [node3]
+    agentId: test
   node5:
     params:
       delay: 500
     inputs: [node20, node4]
+    agentId: test

package/tests/graphs/test_multiple_functions_1.yml

@@ -2,9 +2,11 @@ nodes:
   node1:
     params:
       delay: 500
+    agentId: test1
   node2:
     params:
       delay: 100
+    agentId: test1
   node3:
     params:
       delay: 500
@@ -14,6 +16,7 @@ nodes:
     params:
       delay: 100
     inputs: [node3]
+    agentId: test1
   node5:
     params:
       delay: 500

package/tests/graphs/test_source2.yml

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