graphai 0.2.7 → 0.3.0

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

@@ -5,7 +5,7 @@ import { ComputedNode, StaticNode } from "./node";
 import { TaskManager } from "./task_manager";
 type GraphNodes = Record<string, ComputedNode | StaticNode>;
 export declare class GraphAI {
-    private readonly version;
+    readonly version: number;
     private readonly graphId;
     private readonly data;
     private readonly loop?;

package/lib/graphai.js

@@ -40,7 +40,7 @@ class GraphAI {
         return nodes;
     }
     getValueFromResults(key, results) {
-        const source = (0, utils_1.parseNodeName)(key);
+        const source = (0, utils_1.parseNodeName)(key, this.version);
         return (0, utils_1.getDataFromSource)(source.nodeId ? results[source.nodeId] : undefined, source);
     }
     // for static
@@ -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);
                 }
             }
         });
@@ -73,6 +71,9 @@ class GraphAI {
             console.log("------------ no version");
         }
         this.version = data.version ?? 0.2;
+        if (this.version < 0.3) {
+            console.log("------------ upgrade to 0.3!");
+        }
         this.retryLimit = data.retry; // optional
         this.graphId = URL.createObjectURL(new Blob()).slice(-36);
         this.data = data;

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;
@@ -53,8 +54,21 @@ class ComputedNode extends Node {
         this.isResult = data.isResult ?? false;
         this.priority = data.priority ?? 0;
         this.anyInput = data.anyInput ?? false;
-        this.dataSources = (data.inputs ?? []).map((input) => (0, utils_2.parseNodeName)(input));
+        this.dataSources = (data.inputs ?? []).map((input) => (0, utils_2.parseNodeName)(input, graph.version));
         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, graph.version);
+            (0, utils_2.assert)(!!this.ifSource.nodeId, `Invalid data source ${data.if}`);
+            this.pendings.add(this.ifSource.nodeId);
+        }
+        this.dynamicParams = Object.keys(this.params).reduce((tmp, key) => {
+            const dataSource = (0, utils_2.parseNodeName)(this.params[key], graph.version < 0.3 ? 0.3 : graph.version);
+            if (dataSource.nodeId) {
+                tmp[key] = dataSource;
+                this.pendings.add(dataSource.nodeId);
+            }
+            return tmp;
+        }, {});
         this.log.initForComputedNode(this);
     }
     getAgentId() {
@@ -70,6 +84,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 +198,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 +254,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/utils/utils.d.ts

@@ -1,6 +1,6 @@
 import { DataSource, ResultData } from "../type";
 export declare const sleep: (milliseconds: number) => Promise<unknown>;
-export declare const parseNodeName: (inputNodeId: any) => DataSource;
+export declare const parseNodeName: (inputNodeId: any, version: number) => DataSource;
 export declare function assert(condition: boolean, message: string, isWarn?: boolean): asserts condition;
 export declare const isObject: (x: unknown) => boolean;
 export declare const getDataFromSource: (result: ResultData | undefined, source: DataSource) => ResultData | undefined;

package/lib/utils/utils.js

@@ -5,7 +5,7 @@ const sleep = async (milliseconds) => {
     return await new Promise((resolve) => setTimeout(resolve, milliseconds));
 };
 exports.sleep = sleep;
-const parseNodeName = (inputNodeId) => {
+const parseNodeName_02 = (inputNodeId) => {
     if (typeof inputNodeId === "string") {
         const regex = /^"(.*)"$/;
         const match = inputNodeId.match(regex);
@@ -20,6 +20,24 @@ const parseNodeName = (inputNodeId) => {
     }
     return { value: inputNodeId }; // non-string literal
 };
+const parseNodeName = (inputNodeId, version) => {
+    if (version === 0.2) {
+        return parseNodeName_02(inputNodeId);
+    }
+    if (typeof inputNodeId === "string") {
+        const regex = /^:(.*)$/;
+        const match = inputNodeId.match(regex);
+        if (!match) {
+            return { value: inputNodeId }; // string literal
+        }
+        const parts = match[1].split(".");
+        if (parts.length == 1) {
+            return { nodeId: parts[0] };
+        }
+        return { nodeId: parts[0], propIds: parts.slice(1) };
+    }
+    return { value: inputNodeId }; // non-string literal
+};
 exports.parseNodeName = parseNodeName;
 function assert(condition, message, isWarn = false) {
     if (!condition) {

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/validators/relation_validator.js

@@ -12,7 +12,7 @@ const relationValidator = (data, staticNodeIds, computedNodeIds) => {
         pendings[computedNodeId] = new Set();
         if ("inputs" in nodeData && nodeData && nodeData.inputs) {
             nodeData.inputs.forEach((inputNodeId) => {
-                const sourceNodeId = (0, utils_1.parseNodeName)(inputNodeId).nodeId;
+                const sourceNodeId = (0, utils_1.parseNodeName)(inputNodeId, data.version ?? 0.02).nodeId;
                 if (sourceNodeId) {
                     if (!nodeIds.has(sourceNodeId)) {
                         throw new Error(`Inputs not match: NodeId ${computedNodeId}, Inputs: ${sourceNodeId}`);
@@ -29,7 +29,7 @@ const relationValidator = (data, staticNodeIds, computedNodeIds) => {
         const nodeData = data.nodes[staticNodeId];
         if ("value" in nodeData && nodeData.update) {
             const update = nodeData.update;
-            const updateNodeId = (0, utils_1.parseNodeName)(update).nodeId;
+            const updateNodeId = (0, utils_1.parseNodeName)(update, data.version ?? 0.02).nodeId;
             if (!updateNodeId) {
                 throw new Error("Update it a literal");
             }

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.3.0",
   "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;