graphai 0.2.5 → 0.2.6

package/README.md

@@ -8,7 +8,7 @@ As Andrew Ng has described in his article, "[The batch: Issue 242](https://www.d
 
 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. 
+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, task priority management, map-reduce processing, error handling, retries and logging. 
 
 ## Declarative Data Flow Programming
 
@@ -20,10 +20,10 @@ nodes:
     value:
       name: Sam Bankman-Fried
       query: describe the final sentence by the court for Sam Bank-Fried
-  wikipedia: // Retrieve data from Wikipedia。
+  wikipedia: // Retrieve data from Wikipedia
     agentId: wikipediaAgent
     inputs: [source.name]
-  chunks: // Break the text from Wikipedia into chunks(2048 character each with 512 overlap）
+  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
@@ -35,7 +35,7 @@ nodes:
   similarities: // Calculate the cosine similarity of each chunk
     agentId: dotProductAgent
     inputs: [chunkEmbeddings, topicEmbedding]
-  sortedChunks: // Sort chunks based on the similarity
+  sortedChunks: // Sort chunks based on their similarities
     agentId: sortByValuesAgent
     inputs: [chunks, similarities]
   referenceText: // Concatenate chunks up to the token limit (5000)
@@ -61,17 +61,17 @@ nodes:
 
 ```mermaid
 flowchart TD
- source(source) -- name --> wikipedia
- source -- query --> topicEmbedding
- wikipedia --> chunks
- chunks --> chunksEmbeddings
- chunksEmbeddings --> similarities
+ source -- name --> wikipedia(wikipedia)
+ source -- query --> topicEmbedding(topicEmbedding)
+ wikipedia --> chunks(chunks)
+ chunks --> chunksEmbeddings(chunksEmbeddings)
+ chunksEmbeddings --> similarities(similarities)
  topicEmbedding --> similarities
- similarities --> sortedChunks
- sortedChunks --> resourceText
- source -- query --> prompt
+ similarities --> sortedChunks(sortedChunks)
+ sortedChunks --> resourceText(resourceText)
+ source -- query --> prompt(prompt)
  resourceText --> prompt
- prompt --> query
+ prompt --> query(query)
 ```
 
 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.
@@ -126,7 +126,9 @@ A *computed node* have following properties.
 - '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. 
+- '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.
+- 'isResult': An optional boolean value, which indicates that the return value of this node, should be included as a property of the return value from the run() method of the GraphUI instance.
+- 'priority': An optional number, which specifies the priority of the execution of the associated agent (the task). Default is 0, which means "neutral". Negative numbers are allowed as well.
 
 ### Static Node
 
@@ -137,7 +139,62 @@ A *static* node have following properties.
 
 ## Flow Control
 
-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).
+Since the data-flow graph must be asyclic by design, we added a few mechanism to control data flows, [nesting](#nesting), [loop](#loop), [mapping](#mapping) and [condtional flow](#conditional-flow).
+
+### Nested Graph
+
+In order to make it easy to reuse some code, GraphAI supports nesting. It requires a special agent function, which creates an instance (or instances) of GraphAI object within the agent function and execute it. The system supports two types of nesting agent functions (nestAgent and mapAgent), but developers can create their own using the standard agent extension mechanism.
+
+A typical nesting graph looks like this:
+
+```YAML
+nodes:
+  question:
+    value: "Find out which materials we need to purchase this week for Joe Smith's residential house project."
+  projectId: // identifies the projectId from the question
+    agentId: "identifierAgent"
+    inputs: ["source"] // == "sourceNode.query"
+  database:
+    agentId: "nestedAgent"
+    inputs: ["question", "projectId"]
+    graph:
+      nodes:
+        schema: // retrieves the database schema for the apecified projectId
+          agentId: "schemaAgent"
+          inputs: ["$1"]
+        ... // issue query to the database and build an appropriate prompt with it.
+        query: // send the generated prompt to the LLM
+          agentId: "llama3Agent"
+          inputs: ["prompt"]
+          isResult: true
+  response: // Deliver the answer
+    agentid: "deliveryAgent"      
+    inputs: [database.query.$last.content]
+```
+
+The databaseQuery node (which is associated "nestedAgent") takes the data from "question" node abd "projectId" node, and make them available to inner nodes (nodes of the child graph) via phantom node, "$0" and "$1". After the completion of the child graph, the data from "query" node (which has "isResult" property) becomes available as a property of the output of "database" node.
+
+Here is the diagram of the parent graph.
+
+```mermaid
+flowchart LR
+ question --> projectId(projectId)
+ question --> database
+ projectId --> database
+ database[[database]] -- query --> response(responce)
+```
+
+Here is the diagram of the child graph. Notice that two phantom nodes are automatically created to allow inner nodes to access input data from the parent graph.
+
+```mermaid
+flowchart LR
+ $0 --> ...
+ $1 --> schema(schema)
+ schema --> ...(...)
+ ... --> query(query)
+```
+
+This mechanism does not only allows devleoper to reuse code, but also makes it possible to execute the child graph on another machine using a "remote" agent (which will be released later), enabling the *distributed execution* of nested graphs. 
 
 ### Loop
 
@@ -157,6 +214,7 @@ nodes:
   result:
     value: []
     update: reducer
+    isResult: true
   retriever:
     agentId: shift
     inputs: [people]
@@ -171,22 +229,78 @@ nodes:
     inputs: [result, query.content]
 ```
 
-### Nesting
+```mermaid
+flowchart LR
+ result --> reducer(reducer)
+ people --> retriever(retriever)
+ retriever -- item --> query(query)
+ query -- content --> reducer
+ retriever -. array .-> people
+ reducer -.-> result
+```
 
-To be filled.
+The *loop* mechanism is often used with a nested graph, which receives an array of data from a node of the parent graph and performs the "reduction" process of a *map-reduce* operation, just like the *reduce* method of JavaScript.
+
+Please notice that each iteration will be done sequencially unlike the *mapping* described below.
 
 ### Mapping
 
-To be filled.
+The mapAgent is one of nested agents, which receives an array of data as an input (inputs[0]) and performs the same operation (specified by its graph property) on each item concurrently.
+
+If the size of array is N, the mapAgent creates N instances of GraphAI object, and run them concurrently.
+
+After the completion of all of instances, the mapAgent returns an array of results, just like the map function of JavaScript. 
+
+The following graph will generate the same result (an array of answers) as the sample graph for the *loop*, but three queries will be issued concurretly. 
+
+```
+nodes:
+  people:
+    value: [Steve Jobs, Elon Musk, Nikola Tesla]
+  retriever:
+    agentId: "mapAgent"
+    inputs: ["people"]
+    graph:
+      nodes:
+        query:
+          agentId: slashgpt
+          params:
+            manifest:
+              prompt: Describe about the person in less than 100 words
+          inputs: ["$0"]
+```
+
+Here is the conceptual representation of this operation.
 
+```mermaid
+flowchart LR
+ people -- "[0]" --> query_0(query_0)
+ people -- "[1]" --> query_1(query_1)
+ people -- "[2]" --> query_2(query_2)
+ query_0 --> retriever[[retriever]]
+ query_1 --> retriever
+ query_2 --> retriever
+```
 ### Conditional Flow
 
 To be filled.
 
+## Concurrency
+
+It is possible to specify the maximum number of concurrent execution by setting the *concurrency* property of the graph at the top level. The default is 8.
+
+Since the task queue is shared between the parent graph and the children graph (uness the graph is running remotely), tasks created by the child graph will be bound by the same concurrency specified by the parent graph. 
+
+Since the task executing the nested graph will be in "running" state while tasks within the child graph are runnig, the concurrency limit will be incremented by one when we start running the child graph and restored when it is completed.
+
+By default, all the tasks will have a priority "0", which means neutral. By default, all the tasks will be executed in first-in first-out basis. 
+
+It is possible to change this priority by specifying Node's optional property "priority". The task with higher priority will be executed first. 
+
 ## GraphAI class
 
 ### ```constructor(data: GraphData, callbackDictonary: AgentFunctionDictonary)```
-Initializes a new instance of the GraphAI class with the specified graph data and a dictionary of callback functions.
+Initializes a new instance of the GraphAI object with the specified graph data and a dictionary of callback functions.
 
 - ```data: GraphData```: The graph data including nodes and optional concurrency limit.
 - ```callbackDictonary: AgentFunctionDictonary | AgentFunction<any, any, any>```: A dictionary mapping agent IDs to their respective callback functions, or a single default callback function to be used for all nodes.

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

@@ -0,0 +1,26 @@
+import { AgentFunction } from "../../graphai";
+export declare const copyAgent: AgentFunction;
+declare const copyAgentInfo: {
+    name: string;
+    agent: AgentFunction;
+    mock: AgentFunction;
+    samples: ({
+        inputs: {
+            color: string;
+            model: string;
+        }[];
+        result: {
+            color: string;
+            model: string;
+        };
+    } | {
+        inputs: string[];
+        result: string;
+    })[];
+    description: string;
+    category: string[];
+    author: string;
+    repository: string;
+    license: string;
+};
+export default copyAgentInfo;

package/lib/experimental_agents/data_agents/copy_agent.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.copyAgent = void 0;
+const copyAgent = async ({ inputs }) => {
+    const [input] = inputs;
+    return input;
+};
+exports.copyAgent = copyAgent;
+const copyAgentInfo = {
+    name: "copyAgent",
+    agent: exports.copyAgent,
+    mock: exports.copyAgent,
+    samples: [
+        {
+            inputs: [{ color: "red", model: "Model 3" }],
+            result: { color: "red", model: "Model 3" },
+        },
+        {
+            inputs: ["Hello World"],
+            result: "Hello World",
+        },
+    ],
+    description: "Returns inputs[0]",
+    category: ["data"],
+    author: "Receptron team",
+    repository: "https://github.com/receptron/graphai",
+    license: "MIT",
+};
+exports.default = copyAgentInfo;

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

@@ -2,3 +2,4 @@ export { totalAgent } from "../../experimental_agents/data_agents/total_agent";
 export { dataObjectMergeTemplateAgent } from "../../experimental_agents/data_agents/data_object_merge_template_agent";
 export { dataSumTemplateAgent } from "../../experimental_agents/data_agents/data_sum_template_agent";
 export { propertyFilterAgent } from "../../experimental_agents/data_agents/property_filter_agent";
+export { copyAgent } from "../../experimental_agents/data_agents/copy_agent";

package/lib/experimental_agents/data_agents/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.propertyFilterAgent = exports.dataSumTemplateAgent = exports.dataObjectMergeTemplateAgent = exports.totalAgent = void 0;
+exports.copyAgent = exports.propertyFilterAgent = exports.dataSumTemplateAgent = exports.dataObjectMergeTemplateAgent = exports.totalAgent = void 0;
 var total_agent_1 = require("../../experimental_agents/data_agents/total_agent");
 Object.defineProperty(exports, "totalAgent", { enumerable: true, get: function () { return total_agent_1.totalAgent; } });
 var data_object_merge_template_agent_1 = require("../../experimental_agents/data_agents/data_object_merge_template_agent");
@@ -9,3 +9,5 @@ var data_sum_template_agent_1 = require("../../experimental_agents/data_agents/d
 Object.defineProperty(exports, "dataSumTemplateAgent", { enumerable: true, get: function () { return data_sum_template_agent_1.dataSumTemplateAgent; } });
 var property_filter_agent_1 = require("../../experimental_agents/data_agents/property_filter_agent");
 Object.defineProperty(exports, "propertyFilterAgent", { enumerable: true, get: function () { return property_filter_agent_1.propertyFilterAgent; } });
+var copy_agent_1 = require("../../experimental_agents/data_agents/copy_agent");
+Object.defineProperty(exports, "copyAgent", { enumerable: true, get: function () { return copy_agent_1.copyAgent; } });

package/lib/experimental_agents/data_agents/property_filter_agent.js

@@ -1,9 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.propertyFilterAgent = void 0;
-const propertyFilterAgent = async ({ inputs, params }) => {
-    const [input] = inputs;
-    const { include, exclude } = params;
+const applyFilter = (input, include, exclude) => {
     const propIds = include ? include : Object.keys(input);
     const excludeSet = new Set(exclude ?? []);
     return propIds.reduce((tmp, propId) => {
@@ -13,6 +11,14 @@ const propertyFilterAgent = async ({ inputs, params }) => {
         return tmp;
     }, {});
 };
+const propertyFilterAgent = async ({ inputs, params }) => {
+    const [input] = inputs;
+    const { include, exclude } = params;
+    if (Array.isArray(input)) {
+        return input.map((item) => applyFilter(item, include, exclude));
+    }
+    return applyFilter(input, include, exclude);
+};
 exports.propertyFilterAgent = propertyFilterAgent;
 const inputs = [{ color: "red", model: "Model 3", type: "EV", maker: "Tesla", range: 300 }];
 const propertyFilterAgentInfo = {

package/lib/experimental_agents/graph_agents/map_agent.d.ts

@@ -1,14 +1,17 @@
 import { AgentFunction } from "../../graphai";
 export declare const mapAgent: AgentFunction<{
     injectionTo?: Array<string>;
+    limit?: number;
 }, Record<string, Array<any>>, any>;
 declare const mapAgentInfo: {
     name: string;
     agent: AgentFunction<{
         injectionTo?: string[] | undefined;
+        limit?: number | undefined;
     }, Record<string, any[]>, any>;
     mock: AgentFunction<{
         injectionTo?: string[] | undefined;
+        limit?: number | undefined;
     }, Record<string, any[]>, any>;
     samples: never[];
     description: string;

package/lib/experimental_agents/graph_agents/map_agent.js

@@ -10,7 +10,10 @@ const mapAgent = async ({ params, inputs, agents, log, taskManager, graphData })
         (0, utils_1.assert)(status.concurrency > status.running, `mapAgent: Concurrency is too low: ${status.concurrency}`);
     }
     const nestedGraphData = (0, nested_agent_1.getNestedGraphData)(graphData, inputs);
-    const input = Array.isArray(inputs[0]) ? inputs[0] : inputs;
+    const input = (Array.isArray(inputs[0]) ? inputs[0] : inputs).map((item) => item);
+    if (params.limit && params.limit < input.length) {
+        input.length = params.limit; // trim
+    }
     const injectionTo = params.injectionTo ??
         inputs.map((__input, index) => {
             return `$${index}`;
@@ -22,7 +25,7 @@ const mapAgent = async ({ params, inputs, agents, log, taskManager, graphData })
         }
     });
     const graphs = input.map((data) => {
-        const graphAI = new graphai_1.GraphAI(nestedGraphData, agents || {}, taskManager);
+        const graphAI = new graphai_1.GraphAI(nestedGraphData, agents || {}, { taskManager });
         // Only the first input will be mapped
         injectionTo.forEach((injectToNodeId, index) => {
             graphAI.injectValue(injectToNodeId, index === 0 ? data : inputs[index], "__mapAgent_inputs__");

package/lib/experimental_agents/graph_agents/nested_agent.js

@@ -37,7 +37,7 @@ const nestedAgent = async ({ params, inputs, agents, log, taskManager, graphData
             nestedGraphData.nodes[nodeId] = { value: {} };
         }
     });
-    const graphAI = new graphai_1.GraphAI(nestedGraphData, agents || {}, taskManager);
+    const graphAI = new graphai_1.GraphAI(nestedGraphData, agents || {}, { taskManager });
     try {
         // Inject inputs to specified source nodes
         injectionTo.forEach((injectToNodeId, index) => {

package/lib/experimental_agents/index.d.ts

@@ -6,6 +6,7 @@ export * from "./matrix_agents";
 export * from "./test_agents";
 export * from "./graph_agents";
 export * from "./llm_agents";
+export * from "./service_agents";
 export * from "./embedding_agent";
 export * from "./token_agent";
 export * from "./function_agent";

package/lib/experimental_agents/index.js

@@ -22,6 +22,7 @@ __exportStar(require("./matrix_agents"), exports);
 __exportStar(require("./test_agents"), exports);
 __exportStar(require("./graph_agents"), exports);
 __exportStar(require("./llm_agents"), exports);
+__exportStar(require("./service_agents"), exports);
 __exportStar(require("./embedding_agent"), exports);
 __exportStar(require("./token_agent"), exports);
 __exportStar(require("./function_agent"), exports);

package/lib/experimental_agents/llm_agents/groq_agent.js

@@ -13,7 +13,6 @@ const gloqAgent = async ({ params, inputs }) => {
         role: "user",
         content,
     });
-    console.log(messages);
     const result = await groq.chat.completions.create({
         messages,
         model: params.model,

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

@@ -0,0 +1,2 @@
+export { wikipediaAgent } from "../../experimental_agents/service_agents/wikipedia";
+export { rssAgent } from "../../experimental_agents/service_agents/rss_agent";

package/lib/experimental_agents/service_agents/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rssAgent = exports.wikipediaAgent = void 0;
+var wikipedia_1 = require("../../experimental_agents/service_agents/wikipedia");
+Object.defineProperty(exports, "wikipediaAgent", { enumerable: true, get: function () { return wikipedia_1.wikipediaAgent; } });
+var rss_agent_1 = require("../../experimental_agents/service_agents/rss_agent");
+Object.defineProperty(exports, "rssAgent", { enumerable: true, get: function () { return rss_agent_1.rssAgent; } });

package/lib/experimental_agents/service_agents/rss_agent.d.ts

@@ -0,0 +1,13 @@
+import { AgentFunction } from "../../graphai";
+export declare const rssAgent: AgentFunction<undefined, any, string>;
+declare const rssAgentInfo: {
+    name: string;
+    agent: AgentFunction<undefined, any, string>;
+    mock: AgentFunction<undefined, any, string>;
+    description: string;
+    category: string[];
+    author: string;
+    repository: string;
+    license: string;
+};
+export default rssAgentInfo;

package/lib/experimental_agents/service_agents/rss_agent.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rssAgent = void 0;
+const xml2js_1 = require("xml2js");
+const rssAgent = async ({ inputs }) => {
+    const url = inputs[0];
+    try {
+        const response = await fetch(url);
+        const xmlData = await response.text();
+        const jsonData = await (0, xml2js_1.parseStringPromise)(xmlData, { explicitArray: false, mergeAttrs: true });
+        return jsonData;
+    }
+    catch (error) {
+        console.log(error);
+        throw error;
+    }
+};
+exports.rssAgent = rssAgent;
+const rssAgentInfo = {
+    name: "rssAgent",
+    agent: exports.rssAgent,
+    mock: exports.rssAgent,
+    description: "Retrieves XML data from RSS feed and convert it to JSON",
+    category: ["data"],
+    author: "Receptron",
+    repository: "https://github.com/receptron/graphai",
+    license: "MIT",
+};
+exports.default = rssAgentInfo;

package/lib/experimental_agents/service_agents/wikipedia.d.ts

@@ -0,0 +1,22 @@
+import { AgentFunction } from "../../graphai";
+export declare const wikipediaAgent: AgentFunction<{
+    lang?: string;
+    summary?: boolean;
+}, Record<string, any> | undefined, string>;
+declare const wikipediaAgentInfo: {
+    name: string;
+    agent: AgentFunction<{
+        lang?: string | undefined;
+        summary?: boolean | undefined;
+    }, Record<string, any> | undefined, string>;
+    mock: AgentFunction<{
+        lang?: string | undefined;
+        summary?: boolean | undefined;
+    }, Record<string, any> | undefined, string>;
+    description: string;
+    category: string[];
+    author: string;
+    repository: string;
+    license: string;
+};
+export default wikipediaAgentInfo;

package/lib/experimental_agents/service_agents/wikipedia.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wikipediaAgent = void 0;
+const wikipedia_1 = __importDefault(require("wikipedia"));
+const wikipediaAgent = async ({ inputs, params }) => {
+    const { lang, summary } = params;
+    const query = inputs[0];
+    try {
+        if (lang) {
+            wikipedia_1.default.setLang(lang);
+        }
+        const search = await wikipedia_1.default.search(query);
+        const search_res = search.results[0];
+        const page = await wikipedia_1.default.page(search_res["title"]);
+        const content = await (summary ? page.summary() : page.content());
+        return { content, ...search.results[0] };
+    }
+    catch (error) {
+        console.log(error);
+        //=> Typeof wikiError
+    }
+    return;
+};
+exports.wikipediaAgent = wikipediaAgent;
+const wikipediaAgentInfo = {
+    name: "wikipediaAgent",
+    agent: exports.wikipediaAgent,
+    mock: exports.wikipediaAgent,
+    description: "Retrieves data from wikipedia",
+    category: ["data"],
+    author: "Receptron",
+    repository: "https://github.com/receptron/graphai",
+    license: "MIT",
+};
+exports.default = wikipediaAgentInfo;

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

@@ -4,3 +4,4 @@ export { copyMessageAgent } from "../../experimental_agents/test_agents/copy_mes
 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";
+export { streamMockAgent } from "../../experimental_agents/test_agents/stream_mock_agent";

package/lib/experimental_agents/test_agents/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.copy2ArrayAgent = exports.countingAgent = exports.mergeNodeIdAgent = exports.copyMessageAgent = exports.echoAgent = exports.bypassAgent = void 0;
+exports.streamMockAgent = 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");
@@ -13,3 +13,5 @@ var counting_agent_1 = require("../../experimental_agents/test_agents/counting_a
 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; } });
+var stream_mock_agent_1 = require("../../experimental_agents/test_agents/stream_mock_agent");
+Object.defineProperty(exports, "streamMockAgent", { enumerable: true, get: function () { return stream_mock_agent_1.streamMockAgent; } });

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

@@ -4,4 +4,5 @@ import countingAgent from "../../experimental_agents/test_agents/counting_agent"
 import copyMessageAgent from "../../experimental_agents/test_agents/copy_message_agent";
 import copy2ArrayAgent from "../../experimental_agents/test_agents/copy2array_agent";
 import mergeNodeIdAgent from "../../experimental_agents/test_agents/merge_node_id_agent";
-export { echoAgent, bypassAgent, countingAgent, copyMessageAgent, copy2ArrayAgent, mergeNodeIdAgent };
+import streamMockAgent from "../../experimental_agents/test_agents/stream_mock_agent";
+export { echoAgent, bypassAgent, countingAgent, copyMessageAgent, copy2ArrayAgent, mergeNodeIdAgent, streamMockAgent };

package/lib/experimental_agents/test_agents/packages.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.mergeNodeIdAgent = exports.copy2ArrayAgent = exports.copyMessageAgent = exports.countingAgent = exports.bypassAgent = exports.echoAgent = void 0;
+exports.streamMockAgent = exports.mergeNodeIdAgent = exports.copy2ArrayAgent = exports.copyMessageAgent = exports.countingAgent = exports.bypassAgent = exports.echoAgent = void 0;
 const echo_agent_1 = __importDefault(require("../../experimental_agents/test_agents/echo_agent"));
 exports.echoAgent = echo_agent_1.default;
 const bypass_agent_1 = __importDefault(require("../../experimental_agents/test_agents/bypass_agent"));
@@ -16,3 +16,5 @@ const copy2array_agent_1 = __importDefault(require("../../experimental_agents/te
 exports.copy2ArrayAgent = copy2array_agent_1.default;
 const merge_node_id_agent_1 = __importDefault(require("../../experimental_agents/test_agents/merge_node_id_agent"));
 exports.mergeNodeIdAgent = merge_node_id_agent_1.default;
+const stream_mock_agent_1 = __importDefault(require("../../experimental_agents/test_agents/stream_mock_agent"));
+exports.streamMockAgent = stream_mock_agent_1.default;

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

@@ -0,0 +1,5 @@
+import { AgentFunction } from "../../graphai";
+import { AgentFunctionInfo } from "../../type";
+export declare const streamMockAgent: AgentFunction;
+declare const streamMockAgentInfo: AgentFunctionInfo;
+export default streamMockAgentInfo;

package/lib/experimental_agents/test_agents/stream_mock_agent.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.streamMockAgent = void 0;
+const utils_1 = require("../../utils/utils");
+const streamMockAgent = async ({ params }) => {
+    const message = params.message;
+    for await (const token of message.split("")) {
+        if (params.streamCallback) {
+            params.streamCallback(token);
+        }
+        await (0, utils_1.sleep)(params.sleep || 100);
+    }
+    return params;
+};
+exports.streamMockAgent = streamMockAgent;
+// for test and document
+const streamMockAgentInfo = {
+    name: "streamMockAgent",
+    agent: exports.streamMockAgent,
+    mock: exports.streamMockAgent,
+    samples: [],
+    description: "Sstream mock agent",
+    category: [],
+    author: "xSatoshi Nakajima",
+    repository: "https://github.com/receptron/graphai",
+    license: "MIT",
+};
+exports.default = streamMockAgentInfo;

package/lib/graphai.d.ts

@@ -1,5 +1,5 @@
 export { AgentFunction, AgentFunctionDictonary, GraphData } from "./type";
-import { AgentFunctionDictonary, GraphData, DataSource, ResultDataDictonary, ResultData, DefaultResultData } from "./type";
+import { AgentFunctionDictonary, AgentFilterInfo, GraphData, DataSource, ResultDataDictonary, ResultData, DefaultResultData } from "./type";
 import { TransactionLog } from "./transaction_log";
 import { ComputedNode, StaticNode } from "./node";
 import { TaskManager } from "./task_manager";
@@ -12,6 +12,7 @@ export declare class GraphAI {
     private readonly logs;
     readonly callbackDictonary: AgentFunctionDictonary;
     readonly taskManager: TaskManager;
+    readonly agentFilters: AgentFilterInfo[];
     readonly retryLimit?: number;
     nodes: GraphNodes;
     onLogCallback: (__log: TransactionLog, __isUpdate: boolean) => void;
@@ -21,7 +22,10 @@ export declare class GraphAI {
     private createNodes;
     private getValueFromResults;
     private initializeNodes;
-    constructor(data: GraphData, callbackDictonary: AgentFunctionDictonary, taskManager?: TaskManager | undefined);
+    constructor(data: GraphData, callbackDictonary: AgentFunctionDictonary, options?: {
+        agentFilters?: AgentFilterInfo[] | undefined;
+        taskManager?: TaskManager | undefined;
+    });
     getCallback(agentId?: string): import("./type").AgentFunction<any, any, any>;
     asString(): string;
     results<T = DefaultResultData>(all: boolean): ResultDataDictonary<T>;

package/lib/graphai.js

@@ -65,7 +65,7 @@ class GraphAI {
             }
         });
     }
-    constructor(data, callbackDictonary, taskManager = undefined) {
+    constructor(data, callbackDictonary, options = { taskManager: undefined, agentFilters: [] }) {
         this.logs = [];
         this.onLogCallback = (__log, __isUpdate) => { };
         this.repeatCount = 0;
@@ -77,7 +77,8 @@ class GraphAI {
         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);
+        this.taskManager = options.taskManager ?? new task_manager_1.TaskManager(data.concurrency ?? defaultConcurrency);
+        this.agentFilters = options.agentFilters ?? [];
         this.loop = data.loop;
         this.verbose = data.verbose === true;
         this.onComplete = () => {

package/lib/node.d.ts

@@ -19,7 +19,7 @@ export declare class ComputedNode extends Node {
     readonly nestedGraph?: GraphData;
     readonly retryLimit: number;
     retryCount: number;
-    readonly agentId?: string;
+    readonly agentId: string;
     readonly timeout?: number;
     readonly priority: number;
     error?: Error;
@@ -37,6 +37,8 @@ export declare class ComputedNode extends Node {
     removePending(nodeId: string): void;
     private isCurrentTransaction;
     private executeTimeout;
+    private shouldApplyAgentFilter;
+    private agentFilterHandler;
     execute(): Promise<void>;
     private prepareExecute;
     private errorProcess;

package/lib/node.js

@@ -117,6 +117,34 @@ class ComputedNode extends Node {
             this.retry(type_1.NodeState.TimedOut, Error("Timeout"));
         }
     }
+    // Check if we need to apply this filter to this node or not.
+    shouldApplyAgentFilter(agentFilter) {
+        if (agentFilter.agentIds && Array.isArray(agentFilter.agentIds) && agentFilter.agentIds.length > 0) {
+            if (agentFilter.agentIds.includes(this.agentId)) {
+                return true;
+            }
+        }
+        if (agentFilter.nodeIds && Array.isArray(agentFilter.nodeIds) && agentFilter.nodeIds.length > 0) {
+            if (agentFilter.nodeIds.includes(this.nodeId)) {
+                return true;
+            }
+        }
+        return !agentFilter.agentIds && !agentFilter.nodeIds;
+    }
+    agentFilterHandler(context, agent) {
+        let index = 0;
+        const next = (context) => {
+            const agentFilter = this.graph.agentFilters[index++];
+            if (agentFilter) {
+                if (this.shouldApplyAgentFilter(agentFilter)) {
+                    return agentFilter.agent(context, next);
+                }
+                return next(context);
+            }
+            return agent(context);
+        };
+        return next(context);
+    }
     // This method is called when this computed node became ready to run.
     // It asynchronously calls the associated with agent function and set the result,
     // then it removes itself from the "running node" list of the graph.
@@ -154,7 +182,7 @@ class ComputedNode extends Node {
                 context.graphData = this.nestedGraph;
                 context.agents = this.graph.callbackDictonary;
             }
-            const result = await callback(context);
+            const result = await this.agentFilterHandler(context, callback);
             if (this.nestedGraph) {
                 this.graph.taskManager.restoreAfterNesting();
             }

package/lib/type.d.ts

@@ -49,7 +49,7 @@ export type GraphData = {
     verbose?: boolean;
     retry?: number;
 };
-export type AgentFunctionContext<ParamsType, InputDataType> = {
+export type AgentFunctionContext<ParamsType = DefaultParamsType, InputDataType = DefaultInputData> = {
     params: NodeDataParams<ParamsType>;
     inputs: Array<InputDataType>;
     debugInfo: {
@@ -63,6 +63,13 @@ export type AgentFunctionContext<ParamsType, InputDataType> = {
     taskManager?: TaskManager;
 };
 export type AgentFunction<ParamsType = DefaultParamsType, ResultType = DefaultResultData, InputDataType = DefaultInputData> = (context: AgentFunctionContext<ParamsType, InputDataType>) => Promise<ResultData<ResultType>>;
+export type AgentFilterFunction<ParamsType = DefaultParamsType, ResultType = DefaultResultData, InputDataType = DefaultInputData> = (context: AgentFunctionContext<ParamsType, InputDataType>, agent: AgentFunction) => Promise<ResultData<ResultType>>;
+export type AgentFilterInfo = {
+    name: string;
+    agent: AgentFilterFunction;
+    agentIds?: string[];
+    nodeIds?: string[];
+};
 export type AgentFunctionDictonary = Record<string, AgentFunction<any, any, any>>;
 export type AgentFunctionInfo = {
     name: string;

package/lib/utils/test_agents.js

@@ -18,4 +18,5 @@ exports.defaultTestAgents = {
     pushAgent: experimental_agents_1.pushAgent,
     popAgent: experimental_agents_1.popAgent,
     shiftAgent: experimental_agents_1.shiftAgent,
+    streamMockAgent: experimental_agents_1.streamMockAgent,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "graphai",
-  "version": "0.2.5",
+  "version": "0.2.6",
   "description": "Asynchronous data flow execution engine for agentic AI apps.",
   "main": "lib/index.js",
   "files": [
@@ -30,6 +30,7 @@
     "@inquirer/prompts": "^5.0.0",
     "@types/express": "^4.17.21",
     "@types/node": "^20.8.7",
+    "@types/xml2js": "^0.4.14",
     "@typescript-eslint/eslint-plugin": "^6.8.0",
     "@typescript-eslint/parser": "^6.8.0",
     "arxiv-api-ts": "^1.0.3",
@@ -48,6 +49,7 @@
     "tsconfig-paths": "^4.2.0",
     "typescript": "^5.2.2",
     "wikipedia": "^2.1.2",
+    "xml2js": "^0.6.2",
     "yaml": "^2.4.1"
   },
   "types": "./lib/index.d.ts",