graphai 0.1.1 → 0.2.0

package/README.md

@@ -2,58 +2,79 @@
 
 ## 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 allows developers to build *agentic applications* by describing *agent workflows* as declarative data flow graphs in YAML or JSON. 
 
-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.
+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.' 
+
+Such *agentic applications* need to make multiple asynchronous API calls (such as OpenAI's chat-completion API, database query, web search, and etc.) and manage data dependencies among them, such as giving the answer from one LLM call to another -- 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.
+
+GraphAI allows developers to describe dependencies among those agents (asynchronous API calls) in a data flow graph in YAML or JSON, which is called *declarative data flow programming* . The GraphAI engine will take care of all the complexity of concurrent asynchronous calls, data dependency management, error handling, retries and logging. 
+
+## Declarative Data Flow Programming
 
-Here is an example:
+Here is a simple example, which uses the Wikipedia as the data source and perform an in-memory RAG (Retrieval-Augmented Generation).
 
 ```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]
+      manifest:
+        model: gpt-3.5-turbo
+    isResult: true // indicating this is the final result
+    inputs: [prompt]
 ```
 
-``` 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"];
+```mermaid
+flowchart TD
+ source(source) -- name --> wikipedia
+ source -- query --> topicEmbedding
+ wikipedia --> chunks
+ chunks --> chunksEmbeddings
+ chunksEmbeddings --> similarities
+ topicEmbedding --> similarities
+ similarities --> sortedChunks
+ sortedChunks --> resourceText
+ source -- query --> prompt
+ resourceText --> prompt
+ prompt --> query
 ```
 
-## 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 acyclic 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.
+Notice that the conversion of the querty text into an embedding vector and text chunks into an array of embedding vectors can be done concurrently because there is no dependency between them. GraphAI will automatically recognize it and execute them concurrently. This kind of *concurrent programing* is very difficult in traditional programming style, and GraphAI's *data flow programming* style is much better alternative.
 
 ## Quick Install
 
@@ -67,75 +88,71 @@ or
 yarn add graphai
 ```
 
-## Collaboration
+## Data Flow Graph
 
-Step 1. Install git, node and yarn
+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.
 
-Step 2. Clone the project and install necessary node modules
+A DFG consists of a collection of [nodes](#node), which contains a series of nested properties representing individual nodes in the data flow. Each node is identified by a unique key, *nodeId* (e.g., node1, node2) and can contain several predefined properties (such as params, inputs, and value) that dictate the node's behavior and its relationship with other nodes. There are two types of nodes, [computed nodes](#computed-node) and [static nodes](#static-node), which are described below.
 
-```
-git clone git@github.com:snakajima/graphai.git
-cd graphai
-yarn install
-```
+Connections between nodes will be established by references from one not to another, using either its "inputs" or "update" property. The values of those properties are *data sources*. A *data souce* is specified by either the nodeId (e.g., "node1"), or nodeId + propertyId ("node1.item").
 
-Step 3. Set the environment variable OPENAI_API_KEY to your own key (=sk-...)
+### DFG Structure
 
-You need to set ANTHROPIC_API_KEY as well, if you want to use Claude.
+- 'nodes': A list of node. Required.
+- 'concurrency': An optional property, which specifies the maximum number of concurrent operations (agent functions to be executed at the same time). The default is 8.
+- 'loop': An optional property, which specifies if the graph needs to be executed multiple times. See the [Loop section below](#loop) for details.
 
-Step 4. Run the test script
+## Agent
 
-Start web server for http agent
+An *agent* is an abstract object which takes some inputs and generates an output asynchronously. It could be an LLM (such as GPT-4), a media generator, a database, or a REST API over HTTP. A node associated with an agent (specified by 'agentId' property) is called [computed node](#computed-node), which takes a set of inputs from other nodes, lets the agent to process it, and pushes the returned value to other nodes.
 
-```
-cd tests/http-server/docs/
-npx http-server
-```
+### Agent function
 
-then run the test
+An agent function is a TypeScript function, which implements a particular *agent*. An *agent function* receives two set of parameters via AgentFunctionContext:
 
-```
-npm run test
-```
+- params: agent specific parameters specified in the DFG (specified by the "params" property of the node)
+- inputs: a set of inputs came from other nodes (specified by "inputs" property of the node).
 
-Step 5. Run one of sample scripts
+## Node
 
-```
-npm run sample ./samples/home.ts
-```
+There are two types of Node, *computed nodes* and *static nodes*. A *computed node* is associated with an *agent function*, which receives some inputs, performs some computations asynchronously then returns the result (output). A *static node* is a placeholder of a value (just like a variable in programming language), which is specified by the *value* property, injected by an external program, or is updated at the end of iteration (see the [loop](#loop)). 
 
-Step 6. Write some code and send pull requests
+### Computed Node
 
-Key principles:
+A *computed node* have following properties.
 
-1. Keep the core (Node and GraphAI classes) small and simple.
-2. Enhance the platform by adding 'agents' (plug ins).
-3. Simple but effective test scripts make it easy to maintain.
-4. Run "npm run format" before submitting pull requests. 
+- 'agentId': An **required** property, which specifies the id of the *agent function*.
+- 'params': An optional agent-specific property to control the behavior of the associated agent function. 
+- 'inputs': An optional list of *data sources* that the current node receives the data from. This establishes a data flow where the current node can only be executed after the completion of the nodes listed under 'inputs'. If this list is empty, the associated *agent function* will be immediatley executed. 
+- 'anyInput': An optiona boolean flag, which indicates that the associated *agent function* will be called when at least one of input data became available. Otherwise, it will wait until all the data became available.
+- 'retry': An optional number, which specifies the maximum number of retries to be made. If the last attempt fails, the error 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. The returned value received after the time out will be discarded. 
 
-## Data Flow Graph
+### Static Node
 
-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 *static* node have following properties.
 
-A DFG consists of a collection of 'nodes', which contains a series of nested properties representing individual nodes in the data flow. Each node is identified by a unique key, *nodeId* (e.g., node1, node2) and can contain several predefined properties (params, inputs, anyInput, retry, timeout, agentId, fork, value, update) that dictate the node's behavior and its relationship with other nodes.
+- 'value': An **required** property, which specifies the initial value of this static node (equivalent to calling the injectValue method from outside).
+- 'update': An optional property, which specifies the *data source* after each iteration. See the [loop](#loop) for details.
 
-Connections between nodes will be established by references from one not to another, using either its "inputs" or "update" property. The values of those properties are *data sources*. A *data souce* is specified by either the nodeId (e.g., "node1"), or nodeId + propertyId ("node1.item").
+## Flow Control
 
-### DFG Structure
+Since the data-flow graph must be asyclic by design, we added a few mechanism to control data flows, [loop](#loop), [nesting](#nesting), [mapping](#mapping) and [condtional flow](#conditional-flow).
 
-- 'nodes': A list of node. Required.
-- 'concurrency': An optional property, which specifies the maximum number of concurrent operations (agent functions to be executed at the same time). The default is 8.
-- 'loop': An optional property, which specifies if the graph needs to be executed multiple times. The loop is an JavaScript object, which has two optinoal properties. The *count* property specifies the number of times the graph needs to be executed and the *while* property specifies the condition required to contineu the loop in the form of node name (nodeId) or its property (nodeId.propId). Unlike JavaScript, an empty array will be treated as false.
+### Loop
+
+The loop is an optioal property of a graph, which has two optional properties. The *count* property specifies the number of times the graph needs to be executed and the *while* property specifies the condition required to contineu the loop in the form of node name (nodeId) or its property (nodeId.propId). Unlike JavaScript, an empty array will be treated as false.
+
+Here is an example, which performs an LLM query for each person in the list and create the list of answers. The "people" node (static), is initialized with an array of names, and the "retriever" node (computed) retrieves one name at a time, and send it to the "query" node (computed) to perform an LLM query. The "reducer" append it the array retrieved form the "result" node (static node, which is initialized as an empty array). 
+
+The "update" property of two static nodes ("people" and "result"), updates those properties based on the results from the previous itelation. This loop continues until the value of "people" node become an empty array.
 
 ```
 loop:
   while: people
 nodes:
   people:
-    value:
-      - Steve Jobs
-      - Elon Musk
-      - Nikola Tesla
+    value: [Steve Jobs, Elon Musk, Nikola Tesla]
     update: retriever.array
   result:
     value: []
@@ -147,41 +164,24 @@ nodes:
     agentId: slashgpt
     params:
       manifest:
-        prompt: 指定した人について日本語で４００字以内で答えて
+        prompt: Describe about the person in less than 100 words
     inputs: [retriever.item]
   reducer:
     agentId: push
     inputs: [result, query.content]
 ```
 
-## Agent
-
-An agent is an abstract object, which takes some inputs and generates an output asynchronously. It could be an LLM (such as GPT-4), an image/video/music generator, a database, or a REST API over HTTP. Each node (except 'source node') is associated with an agent function, which takes data flow into the node as inputs, and generates an output.
+### Nesting
 
-## Agent function
+To be filled.
 
-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).
+### Mapping
 
-An agent function receives two set of parameters via AgentFunctionContext, agent specific parameters specified in the DFG and input data came from other nodes.
+To be filled.
 
-## Node Structure
+### Conditional Flow
 
-There are two types of Node, *computed nodes* and *static nodes*. A *computed node* is associated with an *agent function*, which receives some inputs, performs some computations asynchronously then returns the result (output). A *static node* is a placeholder of a value (just like a variable in programming language), which is injected by an external program, or is retrived from a *data source* (in case of interations). 
-
-A *computed node* have following properties.
-
-- 'agentId': An **required** property, which specifies the id of the *agent function*.
-- 'inputs': An optional list of *data sources* that the current node depends on. This establishes a flow where the current node can only be executed after the completion of the nodes listed under 'inputs'. If this list is empty, the associated *agent function* will be immediatley executed. 
-- 'anyInput': An optiona boolean flag, which indicates that the associated *agent function* will be called when at least one of input data became available. Otherwise, it will wait until all the data became available.
-- '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 property to the associated agent function, which are agent specific.
-- 'fork': An optional paramter, which specifies the number of concurrent transactions to be created for the current node.
-
-A *static* node have following properties.
-
-- 'value': An **required** property, which specifies the initial value of this static node (equivalent to calling the injectValue method from outside).
-- 'update': An optional property, which specifies the *data source* after each iteration.
+To be filled.
 
 ## GraphAI class
 
@@ -216,3 +216,42 @@ Injects a result into a specified node. This is used to manually set the result
 
 - ```nodeId: string```: The ID of the static node into which the result is to be injected.
 - ```result: ResultData```: The result to be injected into the specified node.
+
+## Collaboration
+
+Step 1. Install git, node and yarn
+
+Step 2. Clone the project and install necessary node modules
+
+```
+git clone git@github.com:snakajima/graphai.git
+cd graphai
+yarn install
+```
+
+Step 3. Set the environment variable OPENAI_API_KEY to your own key (=sk-...)
+
+You need to set ANTHROPIC_API_KEY as well, if you want to use Claude.
+
+Step 4. Run the test script
+
+Run the test
+
+```
+npm run test
+```
+
+Step 5. Run one of sample scripts
+
+```
+npm run sample ./samples/home.ts
+```
+
+Step 6. Write some code and send pull requests
+
+Key principles:
+
+1. Keep the core (Node and GraphAI classes) small and simple.
+2. Enhance the platform by adding 'agents' (plug ins).
+3. Simple but effective test scripts make it easy to maintain.
+4. Run "npm run format" before submitting pull requests. 

package/lib/experimental_agents/array_agents/packages.d.ts

@@ -0,0 +1,4 @@
+import pushAgent from "../../experimental_agents/array_agents/push_agent";
+import popAgent from "../../experimental_agents/array_agents/pop_agent";
+import shiftAgent from "../../experimental_agents/array_agents/shift_agent";
+export { pushAgent, popAgent, shiftAgent };

package/lib/experimental_agents/array_agents/packages.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shiftAgent = exports.popAgent = exports.pushAgent = void 0;
+const push_agent_1 = __importDefault(require("../../experimental_agents/array_agents/push_agent"));
+exports.pushAgent = push_agent_1.default;
+const pop_agent_1 = __importDefault(require("../../experimental_agents/array_agents/pop_agent"));
+exports.popAgent = pop_agent_1.default;
+const shift_agent_1 = __importDefault(require("../../experimental_agents/array_agents/shift_agent"));
+exports.shiftAgent = shift_agent_1.default;

package/lib/experimental_agents/array_agents/pop_agent.d.ts

@@ -1,2 +1,28 @@
 import { AgentFunction } from "../../graphai";
 export declare const popAgent: AgentFunction<Record<string, any>, Record<string, any>, Record<string, any>>;
+declare const popAgentInfo: {
+    name: string;
+    agent: AgentFunction<Record<string, any>, Record<string, any>, Record<string, any>>;
+    mock: AgentFunction<Record<string, any>, Record<string, any>, Record<string, any>>;
+    samples: ({
+        inputs: string[][];
+        params: {};
+        result: {
+            array: string[];
+            item: string;
+        };
+    } | {
+        inputs: (string[] | number[])[];
+        params: {};
+        result: {
+            array: number[];
+            item: number;
+        };
+    })[];
+    description: string;
+    category: string[];
+    author: string;
+    repository: string;
+    license: string;
+};
+export default popAgentInfo;

package/lib/experimental_agents/array_agents/pop_agent.js

@@ -13,3 +13,43 @@ const popAgent = async (context) => {
     return { array, item };
 };
 exports.popAgent = popAgent;
+const popAgentInfo = {
+    name: "popAgent",
+    agent: exports.popAgent,
+    mock: exports.popAgent,
+    samples: [
+        {
+            inputs: [[1, 2, 3]],
+            params: {},
+            result: {
+                array: [1, 2],
+                item: 3,
+            },
+        },
+        {
+            inputs: [["a", "b", "c"]],
+            params: {},
+            result: {
+                array: ["a", "b"],
+                item: "c",
+            },
+        },
+        {
+            inputs: [
+                [1, 2, 3],
+                ["a", "b", "c"],
+            ],
+            params: {},
+            result: {
+                array: [1, 2],
+                item: 3,
+            },
+        },
+    ],
+    description: "Pop Agent",
+    category: ["array"],
+    author: "Receptron team",
+    repository: "https://github.com/receptron/graphai",
+    license: "MIT",
+};
+exports.default = popAgentInfo;

package/lib/experimental_agents/array_agents/push_agent.d.ts

@@ -1,2 +1,18 @@
 import { AgentFunction } from "../../graphai";
 export declare const pushAgent: AgentFunction<Record<string, any>, Record<string, any>, Record<string, any>>;
+declare const pushAgentInfo: {
+    name: string;
+    agent: AgentFunction<Record<string, any>, Record<string, any>, Record<string, any>>;
+    mock: AgentFunction<Record<string, any>, Record<string, any>, Record<string, any>>;
+    samples: {
+        inputs: (number | number[])[];
+        params: {};
+        result: number[];
+    }[];
+    description: string;
+    category: never[];
+    author: string;
+    repository: string;
+    license: string;
+};
+export default pushAgentInfo;

package/lib/experimental_agents/array_agents/push_agent.js

@@ -12,3 +12,21 @@ const pushAgent = async ({ inputs }) => {
     return array;
 };
 exports.pushAgent = pushAgent;
+const pushAgentInfo = {
+    name: "pushAgent",
+    agent: exports.pushAgent,
+    mock: exports.pushAgent,
+    samples: [
+        {
+            inputs: [[1, 2], 3],
+            params: {},
+            result: [1, 2, 3],
+        },
+    ],
+    description: "push Agent",
+    category: [],
+    author: "Receptron team",
+    repository: "https://github.com/receptron/graphai",
+    license: "MIT",
+};
+exports.default = pushAgentInfo;

package/lib/experimental_agents/array_agents/shift_agent.d.ts

@@ -1,2 +1,28 @@
 import { AgentFunction } from "../../graphai";
 export declare const shiftAgent: AgentFunction<Record<string, any>, Record<string, any>, Record<string, any>>;
+declare const shiftAgentInfo: {
+    name: string;
+    agent: AgentFunction<Record<string, any>, Record<string, any>, Record<string, any>>;
+    mock: AgentFunction<Record<string, any>, Record<string, any>, Record<string, any>>;
+    samples: ({
+        inputs: number[][];
+        params: {};
+        result: {
+            array: number[];
+            item: number;
+        };
+    } | {
+        inputs: string[][];
+        params: {};
+        result: {
+            array: string[];
+            item: string;
+        };
+    })[];
+    description: string;
+    category: never[];
+    author: string;
+    repository: string;
+    license: string;
+};
+export default shiftAgentInfo;

package/lib/experimental_agents/array_agents/shift_agent.js

@@ -13,3 +13,32 @@ const shiftAgent = async (context) => {
     return { array, item };
 };
 exports.shiftAgent = shiftAgent;
+const shiftAgentInfo = {
+    name: "shiftAgent",
+    agent: exports.shiftAgent,
+    mock: exports.shiftAgent,
+    samples: [
+        {
+            inputs: [[1, 2, 3]],
+            params: {},
+            result: {
+                array: [2, 3],
+                item: 1,
+            },
+        },
+        {
+            inputs: [["a", "b", "c"]],
+            params: {},
+            result: {
+                array: ["b", "c"],
+                item: "a",
+            },
+        },
+    ],
+    description: "shift Agent",
+    category: [],
+    author: "Receptron team",
+    repository: "https://github.com/receptron/graphai",
+    license: "MIT",
+};
+exports.default = shiftAgentInfo;

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

@@ -1,2 +1,83 @@
 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;
+            c: number;
+        };
+    } | {
+        inputs: ({
+            a: {
+                b: {
+                    c: {
+                        d: string;
+                    };
+                };
+            };
+            b?: undefined;
+        } | {
+            b: {
+                c: {
+                    d: {
+                        e: string;
+                    };
+                };
+                d?: undefined;
+            };
+            a?: undefined;
+        } | {
+            b: {
+                d: {
+                    e: {
+                        f: string;
+                    };
+                };
+                c?: undefined;
+            };
+            a?: undefined;
+        })[];
+        params: {};
+        result: {
+            a: {
+                b: {
+                    c: {
+                        d: string;
+                    };
+                };
+            };
+            b: {
+                c: {
+                    d: {
+                        e: string;
+                    };
+                };
+                d: {
+                    e: {
+                        f: string;
+                    };
+                };
+            };
+        };
+    })[];
+    description: string;
+    category: never[];
+    author: string;
+    repository: string;
+    license: string;
+};
+export default dataObjectMergeTemplateAgentInfo;

package/lib/experimental_agents/data_agents/data_object_merge_template_agent.js

@@ -11,3 +11,40 @@ 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: 3, b: 0, c: 5 };
+const dataObjectMergeTemplateAgentInfo = {
+    name: "dataObjectMergeTemplateAgent",
+    agent: exports.dataObjectMergeTemplateAgent,
+    mock: exports.dataObjectMergeTemplateAgent,
+    samples: [
+        {
+            inputs: sampleInputs,
+            params: sampleParams,
+            result: sampleResult,
+        },
+        {
+            inputs: [{ a: { b: { c: { d: "e" } } } }, { b: { c: { d: { e: "f" } } } }, { b: { d: { e: { f: "g" } } } }],
+            params: {},
+            result: {
+                a: { b: { c: { d: "e" } } },
+                b: {
+                    c: { d: { e: "f" } },
+                    d: { e: { f: "g" } },
+                },
+            },
+        },
+    ],
+    description: "Merge object",
+    category: [],
+    author: "Satoshi Nakajima",
+    repository: "https://github.com/receptron/graphai",
+    license: "MIT",
+};
+exports.default = dataObjectMergeTemplateAgentInfo;

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

@@ -10,6 +10,7 @@ declare const dataSumTemplateAgentInfo: {
         result: number;
     }[];
     description: string;
+    category: never[];
     author: string;
     repository: string;
     license: string;