graphai 0.2.7 → 0.2.8

package/README.md

@@ -21,37 +21,37 @@ nodes:
       name: Sam Bankman-Fried
       query: describe the final sentence by the court for Sam Bank-Fried
   wikipedia: // Retrieve data from Wikipedia
-    agentId: wikipediaAgent
+    agent: wikipediaAgent
     inputs: [source.name]
   chunks: // Break the text from Wikipedia into chunks (2048 character each with 512 overlap）
-    agentId: stringSplitterAgent
+    agent: stringSplitterAgent
     inputs: [wikipedia]
   chunkEmbeddings: // Get embedding vector of each chunk
-    agentId: stringEmbeddingsAgent
+    agent: stringEmbeddingsAgent
     inputs: [chunks]
   topicEmbedding: // Get embedding vector of the question
-    agentId: stringEmbeddingsAgent
+    agent: stringEmbeddingsAgent
     inputs: [source.query]
   similarities: // Calculate the cosine similarity of each chunk
-    agentId: dotProductAgent
+    agent: dotProductAgent
     inputs: [chunkEmbeddings, topicEmbedding]
   sortedChunks: // Sort chunks based on their similarities
-    agentId: sortByValuesAgent
+    agent: sortByValuesAgent
     inputs: [chunks, similarities]
   referenceText: // Concatenate chunks up to the token limit (5000)
-    agentId: tokenBoundStringsAgent
+    agent: tokenBoundStringsAgent
     inputs: [sortedChunks]
     params:
       limit: 5000
   prompt: // Generate a prompt with that reference text
-    agentId: stringTemplateAgent
+    agent: stringTemplateAgent
     inputs: [source, referenceText]
     params:
       template: |-
         Using the following document, ${0}
         ${1}
   query: // retrieves the answer from GPT3.5
-    agentId: slashGPTAgent
+    agent: slashGPTAgent
     params:
       manifest:
         model: gpt-3.5-turbo
@@ -64,8 +64,8 @@ flowchart TD
  source -- name --> wikipedia(wikipedia)
  source -- query --> topicEmbedding(topicEmbedding)
  wikipedia --> chunks(chunks)
- chunks --> chunksEmbeddings(chunksEmbeddings)
- chunksEmbeddings --> similarities(similarities)
+ chunks --> chunkEmbeddings(chunkEmbeddings)
+ chunkEmbeddings --> similarities(similarities)
  topicEmbedding --> similarities
  similarities --> sortedChunks(sortedChunks)
  sortedChunks --> resourceText(resourceText)
@@ -74,7 +74,7 @@ flowchart TD
  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.
+Notice that the conversion of the query 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
 
@@ -94,52 +94,82 @@ A Data Flow Graph (DFG) is a JavaScript object, which defines the flow of data.
 
 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.
 
-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").
+### Data Source
+
+Connections between nodes will be established by references from one node 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 (e.g., "node1.item"), index (e.g., "node1.$0", "node2.$last") or combinations (e.g., "node1.messages.$0.content").
 
 ### DFG Structure
 
-- '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.
+- *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 (iterations). See the [Loop section below](#loop) for details.
 
 ## 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.
+An *agent* is an abstract object which takes some inputs and generates an output asynchronously. It could be an LLM call (such as GPT-4), a media generator, a database access, or a REST API over HTTP. A node associated with an agent (specified by the *agent*'* property) is called [computed node](#computed-node), which takes a set of *inputs* from *data sources*, asks the *agent function* to process it, and makes the returned value available to other nodes.
 
 ### Agent function
 
-An agent function is a TypeScript function, which implements a particular *agent*. An *agent function* receives two set of parameters via AgentFunctionContext:
+An *agent function* is a TypeScript function, which implements a particular *agent*, performing some computations for the associated *computed node*. An *agent function* receives a *context* (type AgentFunctionContext), which has following properties:
+
+- *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).
+- *debugInfo*: a set of information for debugging purposes.
+
+There are additional optional parameters for developers of nested agents and agent filters.
+
+- *graphData*: an optional GraphData (for nested agents)
+- *agents*: AgentFunctionDictonary (for nested agents)
+- *taskManager*: TaskManager (for nested agents)
+- *log*: TransactionLog[] (for nested agents)
+- *filterParams*: agent filter parameters (for agent filters)
+
+### Inline Agent Function
 
-- 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).
+An *inline agent function* is a simplified version of *agent function*, which is embedded in the graph (available only when the graph was described in TypeScript). An *inline agent function* receives only the *inputs* paramter as a variable length arguments.
+
+Here is an examnple (from [weather chat](https://github.com/receptron/graphai/blob/main/samples/sample_weather.ts)):
+
+```typescript
+    messagesWithUserInput: {
+      // Appends the user's input to the messages.
+      agent: (messages: Array<any>, content: string) => [...messages, { role: "user", content }],
+      inputs: ["messages", "userInput"],
+      if: "checkInput",
+    },
+```
 
 ## Node
 
-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)). 
+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, and returns the result (output). 
+
+A *static node* is a placeholder of a value (just like a variable in programming languages), which is initially specified by its *value* property, and can be updated by an external program (before the execution of the graph), or updated using the *update* property at the end of each iteration of a [loop](#loop) operation. 
 
 ### Computed Node
 
-A *computed node* have following properties.
+A *computed node* has following properties.
 
-- '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.
-- '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.
+- *agent*: An **required** property, which specifies the id of the *agent function*, or an *inline agent function* (NOTE: this is not possible in JSON or YAML).
+- *params*: An optional agent-specific property to control the behavior of the associated agent function. The top level property may reference a *data source*.
+- *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.
+- *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
 
-A *static* node have following properties.
+A *static* node has 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. See the [loop](#loop) for details.
+- *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* for a [loop](#loop) operation. After each iteration, the value of this node will be updated with the data from the specified *data source*.
 
 ## Flow Control
 
-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).
+Since the data-flow graph must be asyclic by design, we added a few mechanisms to control data flows, [nesting](#nesting), [loop](#loop), [mapping](#mapping) and [conditional flow](#conditional-flow).
 
 ### Nested Graph
 
@@ -152,23 +182,23 @@ 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"
+    agent: "identifierAgent"
     inputs: ["source"] // == "sourceNode.query"
   database:
-    agentId: "nestedAgent"
+    agent: "nestedAgent"
     inputs: ["question", "projectId"]
     graph:
       nodes:
         schema: // retrieves the database schema for the apecified projectId
-          agentId: "schemaAgent"
+          agent: "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"
+          agent: "llama3Agent"
           inputs: ["prompt"]
           isResult: true
   response: // Deliver the answer
-    agentid: "deliveryAgent"      
+    agent: "deliveryAgent"      
     inputs: [database.query.$last.content]
 ```
 
@@ -181,7 +211,7 @@ flowchart LR
  question --> projectId(projectId)
  question --> database
  projectId --> database
- database[[database]] -- query --> response(responce)
+ database[[database]] -- query --> response(response)
 ```
 
 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.
@@ -198,9 +228,12 @@ This mechanism does not only allows devleoper to reuse code, but also makes it p
 
 ### 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.
+The loop is an optional property of a graph, which has two optional properties. 
 
-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). 
+- *count*: Specifies the number of times the graph needs to be executed.
+- *while*: Specifies the *data source* to check after the each iteration. It continues if the data from that *data source* is *true*. 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 sends 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.
 
@@ -216,16 +249,16 @@ nodes:
     update: reducer
     isResult: true
   retriever:
-    agentId: shift
+    agent: shift
     inputs: [people]
   query:
-    agentId: slashgpt
+    agent: slashgpt
     params:
       manifest:
         prompt: Describe about the person in less than 100 words
     inputs: [retriever.item]
   reducer:
-    agentId: push
+    agent: push
     inputs: [result, query.content]
 ```
 
@@ -258,12 +291,12 @@ nodes:
   people:
     value: [Steve Jobs, Elon Musk, Nikola Tesla]
   retriever:
-    agentId: "mapAgent"
+    agent: "mapAgent"
     inputs: ["people"]
     graph:
       nodes:
         query:
-          agentId: slashgpt
+          agent: slashgpt
           params:
             manifest:
               prompt: Describe about the person in less than 100 words
@@ -283,7 +316,34 @@ flowchart LR
 ```
 ### Conditional Flow
 
-To be filled.
+When a node has *if* property (which specifies the data source), the data flows to this node only if the value from the data source has some value. 
+
+A sample code, [weather chat](https://github.com/receptron/graphai/blob/main/samples/sample_weather.ts) uses the following *if* property to execute a block of graph, if the LLM asks to use a tool (i.e., function call).
+
+```typescript
+    tool_calls: {
+      // This node is activated if the LLM requests a tool call.
+      agent: "nestedAgent",
+      inputs: ["groq.choices.$0.message.tool_calls", "messagesWithFirstRes"],
+      if: "groq.choices.$0.message.tool_calls",
+      graph: {
+        // This graph is nested only for the readability.
+```
+
+Even though it is not required, we strongly recommand to use it with a nested graph for the readability. 
+
+The *anyInput* property (boolean) allows the developer to "merge" multiple data flow paths into one. When the value of this property is true, the agent function associated with this node will be executed when the data from one of data sources became available.
+
+The [weather chat](https://github.com/receptron/graphai/blob/main/samples/sample_weather.ts) sample application uses this property to continue the chat iteration either a tool was requested by LLM or not.
+
+```typescript
+    reducer: {
+      // Receives messages from either case.
+      agent: "copyAgent",
+      anyInput: true,
+      inputs: ["no_tool_calls", "tool_calls.messagesWithSecondRes"],
+    },
+```
 
 ## Concurrency
 

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

@@ -1,5 +1,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,10 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.copyAgent = exports.propertyFilterAgent = exports.dataSumTemplateAgent = exports.dataObjectMergeTemplateAgent = exports.totalAgent = void 0;
+exports.copyAgent = exports.propertyFilterAgent = exports.dataSumTemplateAgent = 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");
-Object.defineProperty(exports, "dataObjectMergeTemplateAgent", { enumerable: true, get: function () { return data_object_merge_template_agent_1.dataObjectMergeTemplateAgent; } });
 var data_sum_template_agent_1 = require("../../experimental_agents/data_agents/data_sum_template_agent");
 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");

package/lib/experimental_agents/graph_agents/map_agent.js

@@ -37,7 +37,7 @@ const mapAgent = async ({ params, inputs, agents, log, taskManager, graphData })
     });
     const results = await Promise.all(runs);
     const nodeIds = Object.keys(results[0]);
-    (0, utils_1.assert)(nodeIds.length > 0, "mapAgent: no return values (missing isResult)");
+    // assert(nodeIds.length > 0, "mapAgent: no return values (missing isResult)");
     const compositeResult = nodeIds.reduce((tmp, nodeId) => {
         tmp[nodeId] = results.map((result) => {
             return result[nodeId];

package/lib/experimental_agents/graph_agents/nested_agent.js

@@ -38,22 +38,13 @@ const nestedAgent = async ({ params, inputs, agents, log, taskManager, graphData
         }
     });
     const graphAI = new graphai_1.GraphAI(nestedGraphData, agents || {}, { taskManager });
-    try {
-        // Inject inputs to specified source nodes
-        injectionTo.forEach((injectToNodeId, index) => {
-            graphAI.injectValue(injectToNodeId, inputs[index]);
-        });
-        const results = await graphAI.run(false);
-        log?.push(...graphAI.transactionLogs());
-        return results;
-    }
-    catch (error) {
-        log?.push(...graphAI.transactionLogs());
-        if (error instanceof Error) {
-            console.log("Error:", error.message);
-        }
-        throw error;
-    }
+    // Inject inputs to specified source nodes
+    injectionTo.forEach((injectToNodeId, index) => {
+        graphAI.injectValue(injectToNodeId, inputs[index]);
+    });
+    const results = await graphAI.run(false);
+    log?.push(...graphAI.transactionLogs());
+    return results;
 };
 exports.nestedAgent = nestedAgent;
 const nestedAgentInfo = {

package/lib/experimental_agents/index.d.ts

@@ -1,12 +1,6 @@
-export * from "./string_agents";
+export * from "./vanilla";
+export { dataObjectMergeTemplateAgent } from "../experimental_agents/data_agents/data_object_merge_template_agent";
 export * from "./sleeper_agents";
-export * from "./data_agents";
-export * from "./array_agents";
-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

@@ -14,15 +14,12 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./string_agents"), exports);
+exports.dataObjectMergeTemplateAgent = void 0;
+__exportStar(require("./vanilla"), exports);
+// Agents that use npm modules will be added here.
+var data_object_merge_template_agent_1 = require("../experimental_agents/data_agents/data_object_merge_template_agent");
+Object.defineProperty(exports, "dataObjectMergeTemplateAgent", { enumerable: true, get: function () { return data_object_merge_template_agent_1.dataObjectMergeTemplateAgent; } });
 __exportStar(require("./sleeper_agents"), exports);
-__exportStar(require("./data_agents"), exports);
-__exportStar(require("./array_agents"), exports);
-__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.d.ts

@@ -1,21 +1,36 @@
 import { AgentFunction } from "../../graphai";
-export declare const gloqAgent: AgentFunction<{
+export declare const groqAgent: AgentFunction<{
     model: string;
     query?: string;
     system?: string;
-}, Record<string, any> | string, string>;
-declare const gloqAgentInfo: {
+    verbose?: boolean;
+    tools?: Record<string, any>;
+    temperature?: number;
+    max_tokens?: number;
+    tool_choice?: string | Record<string, any>;
+}, Record<string, any> | string, string | Array<Record<string, any>>>;
+declare const groqAgentInfo: {
     name: string;
     agent: AgentFunction<{
         model: string;
         query?: string | undefined;
         system?: string | undefined;
-    }, string | Record<string, any>, string>;
+        verbose?: boolean | undefined;
+        tools?: Record<string, any> | undefined;
+        temperature?: number | undefined;
+        max_tokens?: number | undefined;
+        tool_choice?: string | Record<string, any> | undefined;
+    }, string | Record<string, any>, string | Record<string, any>[]>;
     mock: AgentFunction<{
         model: string;
         query?: string | undefined;
         system?: string | undefined;
-    }, string | Record<string, any>, string>;
+        verbose?: boolean | undefined;
+        tools?: Record<string, any> | undefined;
+        temperature?: number | undefined;
+        max_tokens?: number | undefined;
+        tool_choice?: string | Record<string, any> | undefined;
+    }, string | Record<string, any>, string | Record<string, any>[]>;
     samples: never[];
     description: string;
     category: string[];
@@ -23,4 +38,4 @@ declare const gloqAgentInfo: {
     repository: string;
     license: string;
 };
-export default gloqAgentInfo;
+export default groqAgentInfo;

package/lib/experimental_agents/llm_agents/groq_agent.js

@@ -1,29 +1,63 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.gloqAgent = void 0;
+exports.groqAgent = void 0;
 const groq_sdk_1 = require("groq-sdk");
 const utils_1 = require("../../utils/utils");
 const groq = process.env.GROQ_API_KEY ? new groq_sdk_1.Groq({ apiKey: process.env.GROQ_API_KEY }) : undefined;
-const gloqAgent = async ({ params, inputs }) => {
+//
+// This agent takes two optional inputs, and following parameters.
+// inputs:
+// - [0]: query string (typically from the user), optional
+// - [1]: array of messages from previous conversation, optional
+//
+// params:
+// - model: LLM model (Llama3-8b-8192, Llama3-70b-8192, Mixtral-8x7b-32768), required.
+// - query: Additional query string from the app to prepend the query from the user, optional.
+// - system: System prompt (ignored if inputs[1] is specified), optional
+// - tools: Function definitions, optional
+// - tool_choice: Tool choice parameter, optional (default = "auto")
+// - temperature: Controls randomness of responses, optional (default = 0.7)
+// - max_tokens: The maximum number of tokens that the model can process in a single response, optional.
+// - verbose: dumps the message array to the debug console, before sending it the LLM.
+//
+// https://console.groq.com/docs/quickstart
+//
+const groqAgent = async ({ params, inputs }) => {
     (0, utils_1.assert)(groq !== undefined, "The GROQ_API_KEY environment variable is missing.");
-    const query = params?.query ? [params.query] : [];
-    const content = query.concat(inputs).join("\n");
-    const messages = params?.system ? [{ role: "system", content: params.system }] : [];
-    messages.push({
-        role: "user",
-        content,
-    });
-    const result = await groq.chat.completions.create({
+    const { verbose, query, system, tools, tool_choice, max_tokens, temperature } = params;
+    const [input_query, previous_messages] = inputs;
+    // Notice that we ignore params.system if previous_message exists.
+    const messages = previous_messages && Array.isArray(previous_messages) ? previous_messages : system ? [{ role: "system", content: system }] : [];
+    const content = (query ? [query] : []).concat(input_query ? [input_query] : []).join("\n");
+    if (content) {
+        messages.push({
+            role: "user",
+            content,
+        });
+    }
+    if (verbose) {
+        console.log(messages);
+    }
+    const options = {
         messages,
         model: params.model,
-    });
+        temperature: temperature ?? 0.7,
+    };
+    if (max_tokens) {
+        options.max_tokens = max_tokens;
+    }
+    if (tools) {
+        options.tools = tools;
+        options.tool_choice = tool_choice ?? "auto";
+    }
+    const result = await groq.chat.completions.create(options);
     return result;
 };
-exports.gloqAgent = gloqAgent;
-const gloqAgentInfo = {
-    name: "gloqAgent",
-    agent: exports.gloqAgent,
-    mock: exports.gloqAgent,
+exports.groqAgent = groqAgent;
+const groqAgentInfo = {
+    name: "groqAgent",
+    agent: exports.groqAgent,
+    mock: exports.groqAgent,
     samples: [],
     description: "Groq Agent",
     category: ["llm"],
@@ -31,4 +65,4 @@ const gloqAgentInfo = {
     repository: "https://github.com/receptron/graphai",
     license: "MIT",
 };
-exports.default = gloqAgentInfo;
+exports.default = groqAgentInfo;

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

@@ -1,3 +1,3 @@
-import gloqAgent from "../../experimental_agents/llm_agents/groq_agent";
+import groqAgent from "../../experimental_agents/llm_agents/groq_agent";
 import slashGPTAgent from "../../experimental_agents/llm_agents/slashgpt_agent";
-export { gloqAgent, slashGPTAgent };
+export { groqAgent, slashGPTAgent };

package/lib/experimental_agents/llm_agents/packages.js

@@ -3,8 +3,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.slashGPTAgent = exports.gloqAgent = void 0;
+exports.slashGPTAgent = exports.groqAgent = void 0;
 const groq_agent_1 = __importDefault(require("../../experimental_agents/llm_agents/groq_agent"));
-exports.gloqAgent = groq_agent_1.default;
+exports.groqAgent = groq_agent_1.default;
 const slashgpt_agent_1 = __importDefault(require("../../experimental_agents/llm_agents/slashgpt_agent"));
 exports.slashGPTAgent = slashgpt_agent_1.default;

package/lib/experimental_agents/packages.d.ts

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

package/lib/experimental_agents/packages.js

@@ -26,6 +26,7 @@ __exportStar(require("./matrix_agents/packages"), exports);
 __exportStar(require("./test_agents/packages"), exports);
 __exportStar(require("./graph_agents/packages"), exports);
 __exportStar(require("./llm_agents/packages"), exports);
+__exportStar(require("./service_agents/packages"), exports);
 const embedding_agent_1 = __importDefault(require("./embedding_agent"));
 exports.stringEmbeddingsAgent = embedding_agent_1.default;
 const token_agent_1 = __importDefault(require("./token_agent"));

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

@@ -0,0 +1,62 @@
+import { AgentFunction } from "../../graphai";
+export declare const fetchAgent: AgentFunction<{
+    debug?: boolean;
+    type?: string;
+    returnErrorResult?: boolean;
+}, any, any>;
+declare const fetchAgentInfo: {
+    name: string;
+    agent: AgentFunction<{
+        debug?: boolean | undefined;
+        type?: string | undefined;
+        returnErrorResult?: boolean | undefined;
+    }, any, any>;
+    mock: AgentFunction<{
+        debug?: boolean | undefined;
+        type?: string | undefined;
+        returnErrorResult?: boolean | undefined;
+    }, any, any>;
+    samples: ({
+        inputs: (string | {
+            foo: string;
+            "x-myHeader"?: undefined;
+        } | {
+            "x-myHeader": string;
+            foo?: undefined;
+        })[];
+        params: {
+            debug: boolean;
+        };
+        result: {
+            method: string;
+            url: string;
+            headers: {
+                "x-myHeader": string;
+                "Content-Type"?: undefined;
+            };
+            body: undefined;
+        };
+    } | {
+        inputs: (string | {
+            foo: string;
+        } | undefined)[];
+        params: {
+            debug: boolean;
+        };
+        result: {
+            method: string;
+            url: string;
+            headers: {
+                "Content-Type": string;
+                "x-myHeader"?: undefined;
+            };
+            body: string;
+        };
+    })[];
+    description: string;
+    category: string[];
+    author: string;
+    repository: string;
+    license: string;
+};
+export default fetchAgentInfo;

package/lib/experimental_agents/service_agents/fetch_agent.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchAgent = void 0;
+const xml2js_1 = require("xml2js");
+const fetchAgent = async ({ inputs, params }) => {
+    const [baseUrl, queryParams, baseHeaders, body] = inputs;
+    const url = new URL(baseUrl);
+    const headers = baseHeaders ? { ...baseHeaders } : {};
+    if (queryParams) {
+        const params = new URLSearchParams(queryParams);
+        url.search = params.toString();
+    }
+    if (body) {
+        headers["Content-Type"] = "application/json";
+    }
+    const fetchOptions = {
+        method: body ? "POST" : "GET",
+        headers: new Headers(headers),
+        body: body ? JSON.stringify(body) : undefined,
+    };
+    if (params?.debug) {
+        return {
+            url: url.toString(),
+            method: fetchOptions.method,
+            headers,
+            body: fetchOptions.body,
+        };
+    }
+    const response = await fetch(url.toString(), fetchOptions);
+    if (!response.ok) {
+        const status = response.status;
+        const error = await response.text();
+        if (params?.returnErrorResult) {
+            return { status, error };
+        }
+        throw new Error(`HTTP error! Status: ${status} ${error} ${url.toString()}`);
+    }
+    const result = await (async () => {
+        const type = params?.type ?? "json";
+        if (type === "json") {
+            return await response.json();
+        }
+        else if (type === "xml") {
+            const xmlData = await response.text();
+            return await (0, xml2js_1.parseStringPromise)(xmlData, { explicitArray: false, mergeAttrs: true });
+        }
+        else if (type === "text") {
+            return response.text();
+        }
+        throw new Error(`Unknown Type! ${type}`);
+    })();
+    return result;
+};
+exports.fetchAgent = fetchAgent;
+const fetchAgentInfo = {
+    name: "fetchAgent",
+    agent: exports.fetchAgent,
+    mock: exports.fetchAgent,
+    samples: [
+        {
+            inputs: ["https://www.google.com", { foo: "bar" }, { "x-myHeader": "secret" }],
+            params: {
+                debug: true,
+            },
+            result: {
+                method: "GET",
+                url: "https://www.google.com/?foo=bar",
+                headers: {
+                    "x-myHeader": "secret",
+                },
+                body: undefined,
+            },
+        },
+        {
+            inputs: ["https://www.google.com", undefined, undefined, { foo: "bar" }],
+            params: {
+                debug: true,
+            },
+            result: {
+                method: "POST",
+                url: "https://www.google.com/",
+                headers: {
+                    "Content-Type": "application/json",
+                },
+                body: "{\"foo\":\"bar\"}",
+            },
+        },
+    ],
+    description: "Retrieves JSON data from the specified URL",
+    category: ["data"],
+    author: "Receptron",
+    repository: "https://github.com/receptron/graphai",
+    license: "MIT",
+};
+exports.default = fetchAgentInfo;

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

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

package/lib/experimental_agents/service_agents/index.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.rssAgent = exports.wikipediaAgent = void 0;
+exports.fetchAgent = 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; } });
+var fetch_agent_1 = require("../../experimental_agents/service_agents/fetch_agent");
+Object.defineProperty(exports, "fetchAgent", { enumerable: true, get: function () { return fetch_agent_1.fetchAgent; } });

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

@@ -0,0 +1,2 @@
+import fetchAgent from "../../experimental_agents/service_agents/fetch_agent";
+export { fetchAgent };

package/lib/experimental_agents/service_agents/packages.js

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchAgent = void 0;
+const fetch_agent_1 = __importDefault(require("../../experimental_agents/service_agents/fetch_agent"));
+exports.fetchAgent = fetch_agent_1.default;

package/lib/experimental_agents/test_agents/echo_agent.js

@@ -1,7 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.echoAgent = void 0;
-const echoAgent = async ({ params }) => {
+const echoAgent = async ({ params, filterParams }) => {
+    if (params.filterParams) {
+        return filterParams;
+    }
     return params;
 };
 exports.echoAgent = echoAgent;

package/lib/experimental_agents/vanilla.d.ts

@@ -0,0 +1,8 @@
+export * from "./string_agents";
+export * from "./array_agents";
+export * from "./matrix_agents";
+export * from "./test_agents";
+export * from "./graph_agents";
+export * from "./function_agent";
+export * from "./embedding_agent";
+export * from "./data_agents";

package/lib/experimental_agents/vanilla.js

@@ -0,0 +1,26 @@
+"use strict";
+// This file adds agents that runs in pure JavaScript without any external npm modules.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Please refrain from adding agents that require npm. Those should be added to the index.ts.
+__exportStar(require("./string_agents"), exports);
+__exportStar(require("./array_agents"), exports);
+__exportStar(require("./matrix_agents"), exports);
+__exportStar(require("./test_agents"), exports);
+__exportStar(require("./graph_agents"), exports);
+__exportStar(require("./function_agent"), exports);
+__exportStar(require("./embedding_agent"), exports);
+__exportStar(require("./data_agents"), exports);

package/lib/graphai.js

@@ -52,15 +52,13 @@ class GraphAI {
             const node = this.nodes[nodeId];
             if (node?.isStaticNode) {
                 const value = node?.value;
-                const update = node?.update;
                 if (value) {
                     this.injectValue(nodeId, value, nodeId);
                 }
+                const update = node?.update;
                 if (update && previousResults) {
                     const result = this.getValueFromResults(update, previousResults);
-                    if (result) {
-                        this.injectValue(nodeId, result, update);
-                    }
+                    this.injectValue(nodeId, result, update);
                 }
             }
         });

package/lib/node.d.ts

@@ -16,6 +16,7 @@ export declare class ComputedNode extends Node {
     readonly graphId: string;
     readonly isResult: boolean;
     readonly params: NodeDataParams;
+    private readonly dynamicParams;
     readonly nestedGraph?: GraphData;
     readonly retryLimit: number;
     retryCount: number;
@@ -28,6 +29,7 @@ export declare class ComputedNode extends Node {
     readonly anyInput: boolean;
     dataSources: Array<DataSource>;
     pendings: Set<string>;
+    private ifSource?;
     readonly isStaticNode = false;
     readonly isComputedNode = true;
     constructor(graphId: string, nodeId: string, data: ComputedNodeData, graph: GraphAI);

package/lib/node.js

@@ -44,8 +44,9 @@ class ComputedNode extends Node {
         }
         else {
             (0, utils_2.assert)(typeof data.agent === "function", "agent must be either string or function");
+            const agent = data.agent;
             this.agentFunction = async ({ inputs }) => {
-                return data.agent(...inputs);
+                return agent(...inputs);
             };
         }
         this.retryLimit = data.retry ?? graph.retryLimit ?? 0;
@@ -55,6 +56,23 @@ class ComputedNode extends Node {
         this.anyInput = data.anyInput ?? false;
         this.dataSources = (data.inputs ?? []).map((input) => (0, utils_2.parseNodeName)(input));
         this.pendings = new Set(this.dataSources.filter((source) => source.nodeId).map((source) => source.nodeId));
+        if (data.if) {
+            this.ifSource = (0, utils_2.parseNodeName)(data.if);
+            (0, utils_2.assert)(!!this.ifSource.nodeId, `Invalid data source ${data.if}`);
+            this.pendings.add(this.ifSource.nodeId);
+        }
+        const regex = /^\$\{([^{}]+)\}$/;
+        this.dynamicParams = Object.keys(this.params).reduce((tmp, key) => {
+            const value = this.params[key];
+            const match = typeof value === "string" ? value.match(regex) : null;
+            if (match) {
+                const dataSource = (0, utils_2.parseNodeName)(match[1]);
+                tmp[key] = dataSource;
+                (0, utils_2.assert)(!!dataSource.nodeId, `Invalid data source ${key}:${value}`);
+                this.pendings.add(dataSource.nodeId);
+            }
+            return tmp;
+        }, {});
         this.log.initForComputedNode(this);
     }
     getAgentId() {
@@ -70,6 +88,15 @@ class ComputedNode extends Node {
                 return result === undefined ? count : count + 1;
             }, 0);
             if (!this.anyInput || counter > 0) {
+                if (this.ifSource) {
+                    const [condition] = this.graph.resultsOf([this.ifSource]);
+                    if (!condition) {
+                        this.state = type_1.NodeState.Skipped;
+                        this.log.onSkipped(this, this.graph);
+                        return false;
+                    }
+                    return true;
+                }
                 return true;
             }
         }
@@ -175,14 +202,20 @@ class ComputedNode extends Node {
         try {
             const callback = this.agentFunction ?? this.graph.getCallback(this.agentId);
             const localLog = [];
+            const params = Object.keys(this.dynamicParams).reduce((tmp, key) => {
+                const [result] = this.graph.resultsOf([this.dynamicParams[key]]);
+                tmp[key] = result;
+                return tmp;
+            }, { ...this.params });
             const context = {
-                params: this.params,
+                params: params,
                 inputs: previousResults,
                 debugInfo: {
                     nodeId: this.nodeId,
                     retry: this.retryCount,
                     verbose: this.graph.verbose,
                 },
+                filterParams: {},
                 log: localLog,
             };
             // NOTE: We use the existence of graph object in the agent-specific params to determine
@@ -225,8 +258,9 @@ class ComputedNode extends Node {
     // the retry if specified.
     errorProcess(error, transactionId) {
         if (error instanceof Error && error.message !== utils_1.strIntentionalError) {
-            console.error(this.agentId + ": error");
-            console.error(error);
+            console.error(`<-- ${this.nodeId}, ${this.agentId}`);
+            console.log(error);
+            console.log("-->");
         }
         if (!this.isCurrentTransaction(transactionId)) {
             console.log(`-- ${this.nodeId}: transactionId mismatch(error)`);

package/lib/transaction_log.d.ts

@@ -25,4 +25,5 @@ export declare class TransactionLog {
     beforeExecute(node: ComputedNode, graph: GraphAI, transactionId: number, inputs: ResultData[]): void;
     beforeAddTask(node: ComputedNode, graph: GraphAI): void;
     onError(node: ComputedNode, graph: GraphAI, errorMessage: string): void;
+    onSkipped(node: ComputedNode, graph: GraphAI): void;
 }

package/lib/transaction_log.js

@@ -57,5 +57,10 @@ class TransactionLog {
         graph.setLoopLog(this);
         graph.updateLog(this);
     }
+    onSkipped(node, graph) {
+        this.state = node.state;
+        graph.setLoopLog(this);
+        graph.updateLog(this);
+    }
 }
 exports.TransactionLog = TransactionLog;

package/lib/type.d.ts

@@ -7,9 +7,10 @@ export declare enum NodeState {
     Failed = "failed",
     TimedOut = "timed-out",
     Completed = "completed",
-    Injected = "injected"
+    Injected = "injected",
+    Skipped = "skipped"
 }
-export type DefaultResultData = Record<string, any> | string | number | Array<DefaultResultData>;
+export type DefaultResultData = Record<string, any> | string | number | boolean | Array<DefaultResultData>;
 export type DefaultInputData = Record<string, any>;
 export type ResultData<ResultType = DefaultResultData> = ResultType | undefined;
 export type ResultDataDictonary<ResultType = DefaultResultData> = Record<string, ResultData<ResultType>>;
@@ -25,13 +26,15 @@ export type StaticNodeData = {
     update?: string;
     isResult?: boolean;
 };
+export type AgentNamelessFunction = (...param: any[]) => unknown;
 export type ComputedNodeData = {
-    agent: string | any;
+    agent: string | AgentNamelessFunction;
     inputs?: Array<any>;
     anyInput?: boolean;
     params?: NodeDataParams;
     retry?: number;
     timeout?: number;
+    if?: string;
     graph?: GraphData;
     isResult?: boolean;
     priority?: number;
@@ -59,8 +62,9 @@ export type AgentFunctionContext<ParamsType = DefaultParamsType, InputDataType =
     };
     graphData?: GraphData | string;
     agents?: AgentFunctionDictonary;
-    log?: TransactionLog[];
     taskManager?: TaskManager;
+    filterParams: Record<string, any>;
+    log?: TransactionLog[];
 };
 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>>;

package/lib/type.js

@@ -10,4 +10,5 @@ var NodeState;
     NodeState["TimedOut"] = "timed-out";
     NodeState["Completed"] = "completed";
     NodeState["Injected"] = "injected";
+    NodeState["Skipped"] = "skipped";
 })(NodeState || (exports.NodeState = NodeState = {}));

package/lib/utils/test_utils.d.ts

@@ -1,4 +1,4 @@
-import { AgentFunctionInfo } from "../type";
+import { AgentFunctionInfo, AgentFunctionContext, AgentFunction, AgentFilterInfo, ResultData } from "../type";
 export declare const defaultTestContext: {
     debugInfo: {
         nodeId: string;
@@ -6,7 +6,9 @@ export declare const defaultTestContext: {
         verbose: boolean;
     };
     params: {};
+    filterParams: {};
     agents: {};
     log: never[];
 };
 export declare const agentTestRunner: (agentInfo: AgentFunctionInfo) => Promise<void>;
+export declare const agentFilterRunnerBuilder: (__agentFilters: AgentFilterInfo[]) => (context: AgentFunctionContext, agent: AgentFunction) => Promise<ResultData>;

package/lib/utils/test_utils.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.agentTestRunner = exports.defaultTestContext = void 0;
+exports.agentFilterRunnerBuilder = exports.agentTestRunner = exports.defaultTestContext = void 0;
 const node_assert_1 = __importDefault(require("node:assert"));
 const node_test_1 = __importDefault(require("node:test"));
 exports.defaultTestContext = {
@@ -13,6 +13,7 @@ exports.defaultTestContext = {
         verbose: true,
     },
     params: {},
+    filterParams: {},
     agents: {},
     log: [],
 };
@@ -37,3 +38,20 @@ const agentTestRunner = async (agentInfo) => {
     }
 };
 exports.agentTestRunner = agentTestRunner;
+// for agent and agent filter.
+const agentFilterRunnerBuilder = (__agentFilters) => {
+    const agentFilters = __agentFilters;
+    const agentFilterRunner = (context, agent) => {
+        let index = 0;
+        const next = (context) => {
+            const agentFilter = agentFilters[index++];
+            if (agentFilter) {
+                return agentFilter.agent(context, next);
+            }
+            return agent(context);
+        };
+        return next(context);
+    };
+    return agentFilterRunner;
+};
+exports.agentFilterRunnerBuilder = agentFilterRunnerBuilder;

package/lib/validators/common.js

@@ -2,5 +2,5 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.staticNodeAttributeKeys = exports.computedNodeAttributeKeys = exports.graphDataAttributeKeys = void 0;
 exports.graphDataAttributeKeys = ["nodes", "concurrency", "agentId", "loop", "verbose", "version"];
-exports.computedNodeAttributeKeys = ["inputs", "anyInput", "params", "retry", "timeout", "agent", "graph", "isResult", "priority"];
+exports.computedNodeAttributeKeys = ["inputs", "anyInput", "params", "retry", "timeout", "agent", "graph", "isResult", "priority", "if"];
 exports.staticNodeAttributeKeys = ["value", "update", "isResult"];

package/lib/vanilla_agents.d.ts

@@ -0,0 +1 @@
+export * from "./experimental_agents/vanilla";

package/lib/vanilla_agents.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "graphai",
-  "version": "0.2.7",
+  "version": "0.2.8",
   "description": "Asynchronous data flow execution engine for agentic AI apps.",
   "main": "lib/index.js",
   "files": [

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

@@ -1,13 +0,0 @@
-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

@@ -1,29 +0,0 @@
-"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;