graphai 0.1.1 → 0.1.2

package/README.md

@@ -2,47 +2,57 @@
 
 ## Overview
 
-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.
+GraphAI is an asynchronous data flow execution engine, which makes it easy to build *agentic* applications, which perform the orchestration of mutiple "AI agents". 
 
-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.
+*Agentic* applications need to make asynchronous API calls (such as OpenAI's chat-completion API, database query, web search, and etc.) multiple times and manage data dependencies among them, such as giving the answer from one LLM call to another LLM call as a prompt -- which will become quite difficult to manage in a traditional programing style as the complexity of the application increases, because of the asynchronous nature of those APIs.
 
-Here is an example:
+GraphAI allows developers to describe dependencies among those API calls in a single data flow graph (either in YAML or JSON), create a GraphAI instance with that graph, and let it run. The GraphAI engine will take care of all the complexity of concurrent asynchronous calls, data dependency management, error handling, retries and logging. 
+
+Here is an example graph, which uses the Wikipedia as the data source and perform an in-memory RAG.
 
 ```YAML
 nodes:
-  taskA:
-    agentId: sample
+  source: // Input data to this RAG application
+    value:
+      name: Sam Bankman-Fried
+      query: describe the final sentence by the court for Sam Bank-Fried
+  wikipedia: // Retrieve data from Wikipedia。
+    agentId: wikipediaAgent
+    inputs: [source.name]
+  chunks: // Break the text from Wikipedia into chunks(2048 character each with 512 overlap）
+    agentId: stringSplitterAgent
+    inputs: [wikipedia]
+  chunkEmbeddings: // Get embedding vector of each chunk
+    agentId: stringEmbeddingsAgent
+    inputs: [chunks]
+  topicEmbedding: // Get embedding vector of the question
+    agentId: stringEmbeddingsAgent
+    inputs: [source.query]
+  similarities: // Calculate the cosine similarity of each chunk
+    agentId: dotProductAgent
+    inputs: [chunkEmbeddings, topicEmbedding]
+  sortedChunks: // Sort chunks based on the similarity
+    agentId: sortByValuesAgent
+    inputs: [chunks, similarities]
+  referenceText: // Concatenate chunks up to the token limit (5000)
+    agentId: tokenBoundStringsAgent
+    inputs: [sortedChunks]
     params:
-      // agent-specific parameters for taskA
-  taskB:
-    agentId: sample
+      limit: 5000
+  prompt: // Generate a prompt with that reference text
+    agentId: stringTemplateAgent
+    inputs: [source, referenceText]
     params:
-      // agent-specific parameters for taskB
-  taskC:
-    agentId: sample
+      template: |-
+        Using the following document, ${0}
+        ${1}
+  query: // retrieves the answer from GPT3.5
+    agentId: slashGPTAgent
     params:
-      // agent-specific parameters for taskC
-    inputs: [taskA, taskB]
-```
-
-``` TypeScript
-const sampleAgentFunction = async (context: AgentFunctionContext) => {
-  const { 
-    nodeId, // taskA, taskB or taskC 
-    params, // agent-specific parameters specified in the graph definition file
-    inputs // inputs from previous nodes
-  } = context;
-  // Agent-specific code (such as calling OpenAI's chat.completions API)
-  ...
-  return result;
-}
-
-  ...
-  const file = fs.readFileSync(pathToYamlFile, "utf8");
-  const graphData = YAML.parse(file);
-  const graph = new GraphAI(graphData, { sample: sampleAgentFunction });
-  const results = await graph.run();
-  return results["taskC"];
+      manifest:
+        model: gpt-3.5-turbo
+    isResult: true // indicating this is the final result
+    inputs: [prompt]
 ```
 
 ## Background

package/lib/experimental_agents/data_agents/data_object_merge_template_agent.d.ts

@@ -1,2 +1,28 @@
 import { AgentFunction } from "../../graphai";
 export declare const dataObjectMergeTemplateAgent: AgentFunction;
+declare const dataObjectMergeTemplateAgentInfo: {
+    name: string;
+    agent: AgentFunction;
+    mock: AgentFunction;
+    samples: {
+        inputs: ({
+            a: number;
+            b: number;
+            c?: undefined;
+        } | {
+            a: number;
+            b: number;
+            c: number;
+        })[];
+        params: {};
+        result: {
+            a: number;
+            b: number;
+        };
+    }[];
+    description: string;
+    author: string;
+    repository: string;
+    license: string;
+};
+export default dataObjectMergeTemplateAgentInfo;

package/lib/experimental_agents/data_agents/data_object_merge_template_agent.js

@@ -11,3 +11,28 @@ const dataObjectMergeTemplateAgent = async ({ inputs }) => {
     }, {});
 };
 exports.dataObjectMergeTemplateAgent = dataObjectMergeTemplateAgent;
+// for test and document
+const sampleInputs = [
+    { a: 1, b: 1 },
+    { a: 2, b: 2 },
+    { a: 3, b: 0, c: 5 },
+];
+const sampleParams = {};
+const sampleResult = { a: 6, b: 3 };
+const dataObjectMergeTemplateAgentInfo = {
+    name: "dataObjectMergeTemplateAgent",
+    agent: exports.dataObjectMergeTemplateAgent,
+    mock: exports.dataObjectMergeTemplateAgent,
+    samples: [
+        {
+            inputs: sampleInputs,
+            params: sampleParams,
+            result: sampleResult,
+        },
+    ],
+    description: "Merge object",
+    author: "Satoshi Nakajima",
+    repository: "https://github.com/receptron/graphai",
+    license: "MIT",
+};
+exports.default = dataObjectMergeTemplateAgentInfo;

package/lib/experimental_agents/data_agents/data_sum_template_agent.js

@@ -24,7 +24,7 @@ const dataSumTemplateAgentInfo = {
     ],
     description: "Returns the sum of input values",
     author: "Satoshi Nakajima",
-    repository: "https://github.com/snakajima/graphai",
+    repository: "https://github.com/receptron/graphai",
     license: "MIT",
 };
 exports.default = dataSumTemplateAgentInfo;

package/lib/experimental_agents/index.d.ts

@@ -5,7 +5,7 @@ export * from "./data_agents";
 export * from "./nested_agent";
 export * from "./array_agents";
 export * from "./embedding_agent";
-export * from "./matrix_agent";
+export * from "./matrix_agents";
 export * from "./token_agent";
 export * from "./test_agents";
 export * from "./map_agent";

package/lib/experimental_agents/index.js

@@ -21,7 +21,7 @@ __exportStar(require("./data_agents"), exports);
 __exportStar(require("./nested_agent"), exports);
 __exportStar(require("./array_agents"), exports);
 __exportStar(require("./embedding_agent"), exports);
-__exportStar(require("./matrix_agent"), exports);
+__exportStar(require("./matrix_agents"), exports);
 __exportStar(require("./token_agent"), exports);
 __exportStar(require("./test_agents"), exports);
 __exportStar(require("./map_agent"), exports);

package/lib/experimental_agents/matrix_agents/dot_product_agent.d.ts

@@ -0,0 +1,4 @@
+import { AgentFunction } from "../../graphai";
+export declare const dotProductAgent: AgentFunction<Record<string, any>, {
+    contents: Array<number>;
+}, Array<Array<number>>>;

package/lib/experimental_agents/{matrix_agent.js → matrix_agents/dot_product_agent.js}

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sortByValuesAgent = exports.dotProductAgent = void 0;
+exports.dotProductAgent = void 0;
 // This agent calculates the dot product of an array of vectors (A[]) and a vector (B),
 // typically used to calculate cosine similarity of embedding vectors.
 // Inputs:
@@ -22,29 +22,3 @@ const dotProductAgent = async ({ inputs }) => {
     return { contents };
 };
 exports.dotProductAgent = dotProductAgent;
-// This agent returned a sorted array of one array (A) based on another array (B).
-// The default sorting order is "decendant".
-//
-// Parameters:
-//  acendant: Specifies if the sorting order should be acendant. The default is "false" (decendant).
-// Inputs:
-//  inputs[0]: Array<any>; // array to be sorted
-//  inputs[1]: Array<number>; // array of numbers for sorting
-//
-const sortByValuesAgent = async ({ params, inputs }) => {
-    const direction = params?.assendant ?? false ? -1 : 1;
-    const sources = inputs[0];
-    const values = inputs[1];
-    const joined = sources.map((item, index) => {
-        return { item, value: values[index] };
-    });
-    const contents = joined
-        .sort((a, b) => {
-        return (b.value - a.value) * direction;
-    })
-        .map((a) => {
-        return a.item;
-    });
-    return { contents };
-};
-exports.sortByValuesAgent = sortByValuesAgent;

package/lib/experimental_agents/matrix_agents/index.d.ts

@@ -0,0 +1,2 @@
+export { dotProductAgent } from "../../experimental_agents/matrix_agents/dot_product_agent";
+export { sortByValuesAgent } from "../../experimental_agents/matrix_agents/sort_by_values_agent";

package/lib/experimental_agents/matrix_agents/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sortByValuesAgent = exports.dotProductAgent = void 0;
+var dot_product_agent_1 = require("../../experimental_agents/matrix_agents/dot_product_agent");
+Object.defineProperty(exports, "dotProductAgent", { enumerable: true, get: function () { return dot_product_agent_1.dotProductAgent; } });
+var sort_by_values_agent_1 = require("../../experimental_agents/matrix_agents/sort_by_values_agent");
+Object.defineProperty(exports, "sortByValuesAgent", { enumerable: true, get: function () { return sort_by_values_agent_1.sortByValuesAgent; } });

package/lib/experimental_agents/matrix_agents/sort_by_values_agent.d.ts

@@ -0,0 +1,6 @@
+import { AgentFunction } from "../../graphai";
+export declare const sortByValuesAgent: AgentFunction<{
+    assendant?: boolean;
+}, {
+    contents: Array<any>;
+}, Array<any>>;

package/lib/experimental_agents/matrix_agents/sort_by_values_agent.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sortByValuesAgent = void 0;
+// This agent returned a sorted array of one array (A) based on another array (B).
+// The default sorting order is "decendant".
+//
+// Parameters:
+//  acendant: Specifies if the sorting order should be acendant. The default is "false" (decendant).
+// Inputs:
+//  inputs[0]: Array<any>; // array to be sorted
+//  inputs[1]: Array<number>; // array of numbers for sorting
+//
+const sortByValuesAgent = async ({ params, inputs }) => {
+    const direction = params?.assendant ?? false ? -1 : 1;
+    const sources = inputs[0];
+    const values = inputs[1];
+    const joined = sources.map((item, index) => {
+        return { item, value: values[index] };
+    });
+    const contents = joined
+        .sort((a, b) => {
+        return (b.value - a.value) * direction;
+    })
+        .map((a) => {
+        return a.item;
+    });
+    return { contents };
+};
+exports.sortByValuesAgent = sortByValuesAgent;

package/lib/experimental_agents/nested_agent.d.ts

@@ -1,6 +1,5 @@
 import { GraphData, AgentFunction } from "../graphai";
 export declare const nestedAgent: AgentFunction<{
     graph: GraphData;
-    resultFrom: string;
     injectionTo?: Array<string>;
 }>;

package/lib/experimental_agents/nested_agent.js

@@ -9,15 +9,25 @@ const nestedAgent = async ({ params, inputs, agents, log, taskManager, graphData
         (0, utils_1.assert)(status.concurrency > status.running, `nestedAgent: Concurrency is too low: ${status.concurrency}`);
     }
     (0, utils_1.assert)(graphData !== undefined, "nestedAgent: graphData is required");
+    const injectionTo = params.injectionTo ??
+        inputs.map((__input, index) => {
+            return `$${index}`;
+        });
+    injectionTo.forEach((nodeId) => {
+        if (graphData.nodes[nodeId] === undefined) {
+            // If the input node does not exist, automatically create a static node
+            graphData.nodes[nodeId] = { value: {} };
+        }
+    });
     const graphAI = new graphai_1.GraphAI(graphData, agents || {}, taskManager);
     try {
         // Inject inputs to specified source nodes
-        (params.injectionTo ?? []).forEach((injectToNodeId, index) => {
+        injectionTo.forEach((injectToNodeId, index) => {
             graphAI.injectValue(injectToNodeId, inputs[index]);
         });
-        const results = await graphAI.run(true);
+        const results = await graphAI.run(false);
         log?.push(...graphAI.transactionLogs());
-        return results[params.resultFrom];
+        return results;
     }
     catch (error) {
         log?.push(...graphAI.transactionLogs());

package/lib/experimental_agents/string_agents/string_splitter_agent.d.ts

@@ -5,3 +5,35 @@ export declare const stringSplitterAgent: AgentFunction<{
 }, {
     contents: Array<string>;
 }, string>;
+declare const stringSplitterAgentInfo: {
+    name: string;
+    agent: AgentFunction<{
+        chunkSize?: number | undefined;
+        overlap?: number | undefined;
+    }, {
+        contents: Array<string>;
+    }, string>;
+    mock: AgentFunction<{
+        chunkSize?: number | undefined;
+        overlap?: number | undefined;
+    }, {
+        contents: Array<string>;
+    }, string>;
+    samples: {
+        inputs: string[];
+        params: {
+            chunkSize: number;
+        };
+        result: {
+            contents: string[];
+            count: number;
+            chunkSize: number;
+            overlap: number;
+        };
+    }[];
+    description: string;
+    author: string;
+    repository: string;
+    license: string;
+};
+export default stringSplitterAgentInfo;

package/lib/experimental_agents/string_agents/string_splitter_agent.js

@@ -22,3 +22,43 @@ const stringSplitterAgent = async ({ params, inputs }) => {
     return { contents, count, chunkSize, overlap };
 };
 exports.stringSplitterAgent = stringSplitterAgent;
+// for test and document
+const sampleInput = [
+    "Here's to the crazy ones, the misfits, the rebels, the troublemakers, the round pegs in the square holes ... the ones who see things differently -- they're not fond of rules, and they have no respect for the status quo. ... You can quote them, disagree with them, glorify or vilify them, but the only thing you can't do is ignore them because they change things. ... They push the human race forward, and while some may see them as the crazy ones, we see genius, because the people who are crazy enough to think that they can change the world, are the ones who do.",
+];
+const sampleParams = { chunkSize: 64 };
+const sampleResult = {
+    contents: [
+        "Here's to the crazy ones, the misfits, the rebels, the troublema",
+        "roublemakers, the round pegs in the square holes ... the ones wh",
+        " ones who see things differently -- they're not fond of rules, a",
+        "rules, and they have no respect for the status quo. ... You can ",
+        "You can quote them, disagree with them, glorify or vilify them, ",
+        "y them, but the only thing you can't do is ignore them because t",
+        "ecause they change things. ... They push the human race forward,",
+        "forward, and while some may see them as the crazy ones, we see g",
+        "we see genius, because the people who are crazy enough to think ",
+        "o think that they can change the world, are the ones who do.",
+        " do.",
+    ],
+    count: 11,
+    chunkSize: 64,
+    overlap: 8,
+};
+const stringSplitterAgentInfo = {
+    name: "stringSplitterAgent",
+    agent: exports.stringSplitterAgent,
+    mock: exports.stringSplitterAgent,
+    samples: [
+        {
+            inputs: sampleInput,
+            params: sampleParams,
+            result: sampleResult,
+        },
+    ],
+    description: "This agent strip one long string into chunks using following parameters",
+    author: "Satoshi Nakajima",
+    repository: "https://github.com/receptron/graphai",
+    license: "MIT",
+};
+exports.default = stringSplitterAgentInfo;

package/lib/experimental_agents/string_agents/string_template_agent.d.ts

@@ -2,3 +2,26 @@ import { AgentFunction } from "../../graphai";
 export declare const stringTemplateAgent: AgentFunction<{
     template: string;
 }, Record<string, any> | string, string>;
+declare const stringTemplateAgentInfo: {
+    name: string;
+    agent: AgentFunction<{
+        template: string;
+    }, string | Record<string, any>, string>;
+    mock: AgentFunction<{
+        template: string;
+    }, string | Record<string, any>, string>;
+    samples: {
+        inputs: string[];
+        params: {
+            template: string;
+        };
+        result: {
+            content: string;
+        };
+    }[];
+    description: string;
+    author: string;
+    repository: string;
+    license: string;
+};
+export default stringTemplateAgentInfo;

package/lib/experimental_agents/string_agents/string_template_agent.js

@@ -10,3 +10,24 @@ const stringTemplateAgent = async ({ params, inputs }) => {
     return { content };
 };
 exports.stringTemplateAgent = stringTemplateAgent;
+const sampleInput = ["hello", "test"];
+const sampleParams = { template: "${0}: ${1}" };
+const sampleResult = { content: "hello: test" };
+// for test and document
+const stringTemplateAgentInfo = {
+    name: "stringTemplateAgent",
+    agent: exports.stringTemplateAgent,
+    mock: exports.stringTemplateAgent,
+    samples: [
+        {
+            inputs: sampleInput,
+            params: sampleParams,
+            result: sampleResult,
+        },
+    ],
+    description: "Template agent",
+    author: "Satoshi Nakajima",
+    repository: "https://github.com/receptron/graphai",
+    license: "MIT",
+};
+exports.default = stringTemplateAgentInfo;

package/lib/experimental_agents/test_agents/copy2array_agent.d.ts

@@ -0,0 +1,2 @@
+import { AgentFunction } from "../../graphai";
+export declare const copy2ArrayAgent: AgentFunction;

package/lib/experimental_agents/test_agents/copy2array_agent.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.copy2ArrayAgent = void 0;
+const copy2ArrayAgent = async ({ inputs }) => {
+    return new Array(10).fill(undefined).map(() => {
+        return inputs[0];
+    });
+};
+exports.copy2ArrayAgent = copy2ArrayAgent;

package/lib/experimental_agents/test_agents/index.d.ts

@@ -3,3 +3,4 @@ export { echoAgent } from "../../experimental_agents/test_agents/echo_agent";
 export { copyMessageAgent } from "../../experimental_agents/test_agents/copy_message_agent";
 export { mergeNodeIdAgent } from "../../experimental_agents/test_agents/merge_node_id_agent";
 export { countingAgent } from "../../experimental_agents/test_agents/counting_agent";
+export { copy2ArrayAgent } from "../../experimental_agents/test_agents/copy2array_agent";

package/lib/experimental_agents/test_agents/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.countingAgent = exports.mergeNodeIdAgent = exports.copyMessageAgent = exports.echoAgent = exports.bypassAgent = void 0;
+exports.copy2ArrayAgent = exports.countingAgent = exports.mergeNodeIdAgent = exports.copyMessageAgent = exports.echoAgent = exports.bypassAgent = void 0;
 var bypass_agent_1 = require("../../experimental_agents/test_agents/bypass_agent");
 Object.defineProperty(exports, "bypassAgent", { enumerable: true, get: function () { return bypass_agent_1.bypassAgent; } });
 var echo_agent_1 = require("../../experimental_agents/test_agents/echo_agent");
@@ -11,3 +11,5 @@ var merge_node_id_agent_1 = require("../../experimental_agents/test_agents/merge
 Object.defineProperty(exports, "mergeNodeIdAgent", { enumerable: true, get: function () { return merge_node_id_agent_1.mergeNodeIdAgent; } });
 var counting_agent_1 = require("../../experimental_agents/test_agents/counting_agent");
 Object.defineProperty(exports, "countingAgent", { enumerable: true, get: function () { return counting_agent_1.countingAgent; } });
+var copy2array_agent_1 = require("../../experimental_agents/test_agents/copy2array_agent");
+Object.defineProperty(exports, "copy2ArrayAgent", { enumerable: true, get: function () { return copy2array_agent_1.copy2ArrayAgent; } });

package/lib/graphai.js

@@ -1,7 +1,4 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GraphAI = void 0;
 const type_1 = require("./type");
@@ -9,7 +6,6 @@ const node_1 = require("./node");
 const utils_1 = require("./utils/utils");
 const validator_1 = require("./validator");
 const task_manager_1 = require("./task_manager");
-const crypto_1 = __importDefault(require("crypto"));
 const defaultConcurrency = 8;
 class GraphAI {
     // This method is called when either the GraphAI obect was created,
@@ -73,7 +69,7 @@ class GraphAI {
         this.logs = [];
         this.onLogCallback = (__log, __isUpdate) => { };
         this.repeatCount = 0;
-        this.graphId = crypto_1.default.randomUUID();
+        this.graphId = URL.createObjectURL(new Blob()).slice(-36);
         this.data = data;
         this.callbackDictonary = callbackDictonary;
         this.taskManager = taskManager ?? new task_manager_1.TaskManager(data.concurrency ?? defaultConcurrency);

package/lib/node.d.ts

@@ -23,9 +23,8 @@ export declare class ComputedNode extends Node {
     readonly timeout?: number;
     error?: Error;
     transactionId: undefined | number;
-    sources: Record<string, DataSource>;
     readonly anyInput: boolean;
-    inputs: Array<string>;
+    dataSources: Array<DataSource>;
     pendings: Set<string>;
     readonly isStaticNode = false;
     readonly isComputedNode = true;

package/lib/node.js

@@ -33,7 +33,6 @@ class ComputedNode extends Node {
     constructor(graphId, nodeId, data, graph) {
         super(nodeId, graph);
         this.retryCount = 0;
-        this.sources = {}; // data sources.
         this.isStaticNode = false;
         this.isComputedNode = true;
         this.graphId = graphId;
@@ -44,13 +43,8 @@ class ComputedNode extends Node {
         this.timeout = data.timeout;
         this.isResult = data.isResult ?? false;
         this.anyInput = data.anyInput ?? false;
-        this.sources = (data.inputs ?? []).reduce((tmp, input) => {
-            const source = (0, utils_1.parseNodeName)(input);
-            tmp[source.nodeId] = source;
-            return tmp;
-        }, {});
-        this.inputs = Object.keys(this.sources);
-        this.pendings = new Set(this.inputs);
+        this.dataSources = (data.inputs ?? []).map(utils_1.parseNodeName);
+        this.pendings = new Set(this.dataSources.map((source) => source.nodeId));
         this.log.initForComputedNode(this);
     }
     isReadyNode() {
@@ -58,8 +52,7 @@ class ComputedNode extends Node {
             // Count the number of data actually available.
             // We care it only when this.anyInput is true.
             // Notice that this logic enables dynamic data-flows.
-            const counter = this.inputs.reduce((count, nodeId) => {
-                const source = this.sources[nodeId];
+            const counter = this.dataSources.reduce((count, source) => {
                 const [result] = this.graph.resultsOf([source], this.anyInput);
                 return result === undefined ? count : count + 1;
             }, 0);
@@ -90,8 +83,10 @@ class ComputedNode extends Node {
     // which this node needs data from.
     removePending(nodeId) {
         if (this.anyInput) {
-            const [result] = this.graph.resultsOf([this.sources[nodeId]], this.anyInput);
-            if (result) {
+            const results = this.graph.resultsOf(this.dataSources, this.anyInput).filter((result) => {
+                return result !== undefined;
+            });
+            if (results.length > 0) {
                 this.pendings.clear();
             }
         }
@@ -116,11 +111,7 @@ class ComputedNode extends Node {
     // then it removes itself from the "running node" list of the graph.
     // Notice that setting the result of this node may make other nodes ready to run.
     async execute() {
-        const previousResults = this.graph
-            .resultsOf(this.inputs.map((input) => {
-            return this.sources[input];
-        }), this.anyInput)
-            .filter((result) => {
+        const previousResults = this.graph.resultsOf(this.dataSources, this.anyInput).filter((result) => {
             // Remove undefined if anyInput flag is set.
             return !this.anyInput || result !== undefined;
         });

package/lib/transaction_log.js

@@ -40,7 +40,7 @@ class TransactionLog {
         this.state = node.state;
         this.retryCount = node.retryCount > 0 ? node.retryCount : undefined;
         this.startTime = transactionId;
-        this.inputs = node.inputs;
+        this.inputs = node.dataSources.map((source) => source.nodeId);
         this.inputsData = inputs.length > 0 ? inputs : undefined;
         graph.setLoopLog(this);
         graph.appendLog(this);

package/lib/utils/test_agents.d.ts

@@ -0,0 +1,2 @@
+import { AgentFunctionDictonary } from "../graphai";
+export declare const defaultTestAgents: AgentFunctionDictonary;

package/lib/utils/test_agents.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultTestAgents = void 0;
+const experimental_agents_1 = require("../experimental_agents");
+exports.defaultTestAgents = {
+    bypassAgent: experimental_agents_1.bypassAgent,
+    echoAgent: experimental_agents_1.echoAgent,
+    copyMessageAgent: experimental_agents_1.copyMessageAgent,
+    mergeNodeIdAgent: experimental_agents_1.mergeNodeIdAgent,
+    sleeperAgent: experimental_agents_1.sleeperAgent,
+    sleeperAgentDebug: experimental_agents_1.sleeperAgentDebug,
+    stringTemplateAgent: experimental_agents_1.stringTemplateAgent,
+    nestedAgent: experimental_agents_1.nestedAgent,
+    mapAgent: experimental_agents_1.mapAgent,
+    totalAgent: experimental_agents_1.totalAgent,
+    countingAgent: experimental_agents_1.countingAgent,
+    copy2ArrayAgent: experimental_agents_1.copy2ArrayAgent,
+    pushAgent: experimental_agents_1.pushAgent,
+    popAgent: experimental_agents_1.popAgent,
+};

package/lib/utils/test_utils.d.ts

@@ -0,0 +1,12 @@
+import { AgentFunctionInfo } from "../type";
+export declare const defaultTestContext: {
+    debugInfo: {
+        nodeId: string;
+        retry: number;
+        verbose: boolean;
+    };
+    params: {};
+    agents: {};
+    log: never[];
+};
+export declare const agentTestRunner: (agentInfo: AgentFunctionInfo) => Promise<void>;

package/lib/utils/test_utils.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.agentTestRunner = exports.defaultTestContext = void 0;
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_test_1 = __importDefault(require("node:test"));
+exports.defaultTestContext = {
+    debugInfo: {
+        nodeId: "test",
+        retry: 0,
+        verbose: true,
+    },
+    params: {},
+    agents: {},
+    log: [],
+};
+// for agent
+const agentTestRunner = async (agentInfo) => {
+    (0, node_test_1.default)(`test ${agentInfo.name}`, async () => {
+        const { agent, samples } = agentInfo;
+        for await (const sample of samples) {
+            const { params, inputs, result } = sample;
+            const actual = await agent({
+                ...exports.defaultTestContext,
+                params,
+                inputs,
+            });
+            node_assert_1.default.deepStrictEqual(result, actual);
+        }
+    });
+};
+exports.agentTestRunner = agentTestRunner;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "graphai",
-  "version": "0.1.1",
-  "description": "Asynchronous data flow execution engine to make it simple to build LLM apps.",
+  "version": "0.1.2",
+  "description": "Asynchronous data flow execution engine for agentic AI apps.",
   "main": "lib/index.js",
   "files": [
     "./lib"
@@ -17,14 +17,14 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/snakajima/graphai"
+    "url": "git+https://github.com/receptron/graphai"
   },
-  "author": "Satoshi Nakajima",
+  "author": "Satoshi Nakajima, Isamu Arimoto",
   "license": "MIT",
   "bugs": {
-    "url": "https://github.com/snakajima/graphai/issues"
+    "url": "https://github.com/receptron/graphai/issues"
   },
-  "homepage": "https://github.com/snakajima/graphai#readme",
+  "homepage": "https://github.com/receptron/graphai#readme",
   "devDependencies": {
     "@inquirer/prompts": "^5.0.0",
     "@types/express": "^4.17.21",
@@ -45,10 +45,8 @@
     "tsc-alias": "^1.8.8",
     "tsconfig-paths": "^4.2.0",
     "typescript": "^5.2.2",
-    "wikipedia": "^2.1.2"
-  },
-  "dependencies": {
-    "yaml": "^2.3.3"
+    "wikipedia": "^2.1.2",
+    "yaml": "^2.4.1"
   },
   "types": "./lib/index.d.ts",
   "directories": {

package/lib/experimental_agents/matrix_agent.d.ts

@@ -1,9 +0,0 @@
-import { AgentFunction } from "../graphai";
-export declare const dotProductAgent: AgentFunction<Record<string, any>, {
-    contents: Array<number>;
-}, Array<Array<number>>>;
-export declare const sortByValuesAgent: AgentFunction<{
-    assendant?: boolean;
-}, {
-    contents: Array<any>;
-}, Array<any>>;

package/lib/experimental_agents/test_agents/echo_fork_index_agent.d.ts

@@ -1,2 +0,0 @@
-import { AgentFunction } from "../../graphai";
-export declare const echoForkIndexAgent: AgentFunction;

package/lib/experimental_agents/test_agents/echo_fork_index_agent.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.echoForkIndexAgent = void 0;
-const echoForkIndexAgent = async ({ debugInfo: { forkIndex } }) => {
-    return { forkIndex };
-};
-exports.echoForkIndexAgent = echoForkIndexAgent;

package/lib/log.d.ts

@@ -1,22 +0,0 @@
-import { ResultData, NodeDataParams, NodeState } from "./type";
-import type { GraphAI } from "./graphai";
-import type { ComputedNode, StaticNode } from "./node";
-export declare class TransactionLog {
-    nodeId: string;
-    state: NodeState;
-    startTime?: number;
-    endTime?: number;
-    retryCount?: number;
-    agentId?: string;
-    params?: NodeDataParams;
-    inputs?: Array<ResultData>;
-    errorMessage?: string;
-    result?: ResultData;
-    log?: TransactionLog[];
-    constructor(nodeId: string);
-    initForComputedNode(node: ComputedNode): void;
-    onInjected(node: StaticNode, graph: GraphAI): void;
-    onComplete(node: ComputedNode, graph: GraphAI, localLog: TransactionLog[]): void;
-    beforeExecute(node: ComputedNode, graph: GraphAI, transactionId: number, inputs: ResultData[]): void;
-    onError(node: ComputedNode, graph: GraphAI, errorMessage: string): void;
-}

package/lib/log.js

@@ -1,49 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TransactionLog = void 0;
-const type_1 = require("./type");
-class TransactionLog {
-    constructor(nodeId) {
-        this.nodeId = nodeId;
-        this.state = type_1.NodeState.Waiting;
-    }
-    initForComputedNode(node) {
-        this.agentId = node.agentId;
-        this.params = node.params;
-    }
-    onInjected(node, graph) {
-        const isUpdating = "endTime" in this;
-        this.result = node.value;
-        this.state = node.state;
-        this.endTime = Date.now();
-        if (isUpdating) {
-            graph.updateLog(this);
-        }
-        else {
-            graph.appendLog(this);
-        }
-    }
-    onComplete(node, graph, localLog) {
-        this.result = node.result;
-        this.state = node.state;
-        this.endTime = Date.now();
-        if (localLog.length > 0) {
-            this.log = localLog;
-        }
-        graph.updateLog(this);
-    }
-    beforeExecute(node, graph, transactionId, inputs) {
-        this.state = node.state;
-        this.retryCount = node.retryCount > 0 ? node.retryCount : undefined;
-        this.startTime = transactionId;
-        this.inputs = inputs.length > 0 ? inputs : undefined;
-        graph.appendLog(this);
-    }
-    onError(node, graph, errorMessage) {
-        this.state = node.state;
-        this.errorMessage = errorMessage;
-        this.endTime = Date.now();
-        graph.updateLog(this);
-    }
-}
-exports.TransactionLog = TransactionLog;

package/lib/task.d.ts

@@ -1,18 +0,0 @@
-import { ComputedNode } from "./node";
-export declare class TaskManager {
-    private concurrency;
-    private taskQueue;
-    private runningNodes;
-    constructor(concurrency: number);
-    private dequeueTaskIfPossible;
-    addTask(node: ComputedNode, callback: (node: ComputedNode) => void): void;
-    onComplete(node: ComputedNode): void;
-    prepareForNesting(): void;
-    getStatus(verbose?: boolean): {
-        runningNodes?: string[] | undefined;
-        queuedNodes?: string[] | undefined;
-        concurrency: number;
-        queue: number;
-        running: number;
-    };
-}

package/lib/task.js

@@ -1,63 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TaskManager = void 0;
-const utils_1 = require("./utils/utils");
-// TaskManage object controls the concurrency of ComputedNode execution.
-//
-// NOTE: A TaskManager instance will be shared between parent graph and its children
-// when nested agents are involved.
-class TaskManager {
-    constructor(concurrency) {
-        this.taskQueue = [];
-        this.runningNodes = new Set();
-        this.concurrency = concurrency;
-    }
-    // This internal method dequeus a task from the task queue
-    // and call the associated callback method, if the number of
-    // running task is lower than the spcified limit.
-    dequeueTaskIfPossible() {
-        if (this.runningNodes.size < this.concurrency) {
-            const task = this.taskQueue.shift();
-            if (task) {
-                this.runningNodes.add(task.node);
-                task.callback(task.node);
-            }
-        }
-    }
-    // Node will call this method to put itself in the execution queue.
-    // We call the associated callback function when it is dequeued.
-    addTask(node, callback) {
-        this.taskQueue.push({ node, callback });
-        this.dequeueTaskIfPossible();
-    }
-    // Node MUST call this method once the execution of agent function is completed
-    // either successfully or not.
-    onComplete(node) {
-        (0, utils_1.assert)(this.runningNodes.has(node), `TaskManager.onComplete node(${node.nodeId}) is not in list`);
-        this.runningNodes.delete(node);
-        this.dequeueTaskIfPossible();
-    }
-    // Node will call this method before it hands the task manager from the graph
-    // to a nested agent. We need to make it sure that there is enough room to run
-    // computed nodes inside the nested graph to avoid a deadlock.
-    prepareForNesting() {
-        if (this.runningNodes.size === this.concurrency) {
-            this.concurrency++;
-            console.warn("WARNING: increasing concurrenty to", this.concurrency);
-        }
-    }
-    getStatus(verbose = false) {
-        return {
-            concurrency: this.concurrency,
-            queue: this.taskQueue.length,
-            running: this.runningNodes.size,
-            ...(verbose
-                ? {
-                    runningNodes: Array.from(this.runningNodes).map((node) => node.nodeId),
-                    queuedNodes: this.taskQueue.map((task) => task.node.nodeId),
-                }
-                : {}),
-        };
-    }
-}
-exports.TaskManager = TaskManager;