graphai 0.3.1 → 0.3.2

package/README.md

@@ -317,9 +317,12 @@ flowchart LR
 ```
 ### Conditional Flow
 
-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. 
+GraphAI provides mechanisms to control the flow of data based on certain conditions. This is achieved through the *if* and *anyInput* properties.
 
-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).
+#### If Property
+
+The *if* property allows you to specify a condition that must be met for the data to flow into a particular node. The condition is defined by a data source. If the value obtained from the specified *data source* is truthy (i.e., not null, undefined, 0, false, NaN, or an empty array/string), the node will be executed; otherwise, it will be skipped.
+For example, the following node will only be executed if the *tool_calls* property of the message from the LLM contains a value:
 
 ```typescript
     tool_calls: {
@@ -331,11 +334,13 @@ A sample code, [weather chat](https://github.com/receptron/graphai/blob/main/sam
         // 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. 
+It is recommended to use the *if* property in conjunction with nested graphs for better code readability and organization.
+
+#### AnyInput Property
 
-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 *anyInput* property (boolean) allows you to merge multiple data flow paths into a single node. When set to *true*, the agent function associated with the node will be executed as soon as data becomes available from any of the specified input data sources.
 
-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.
+This property is particularly useful when you want to continue the flow regardless of which path the data comes from. In the weather chat sample application, it is used to continue the chat iteration whether a tool was requested by the LLM or not:
 
 ```typescript
     reducer: {
@@ -346,17 +351,31 @@ The [weather chat](https://github.com/receptron/graphai/blob/main/samples/sample
     },
 ```
 
+In this example, the "reducer" node will execute as soon as data is available from either the "no_tool_calls" or "tool_calls.messagesWithSecondRes" data source.
+
+By combining the *if* and *anyInput* properties, you can create complex conditional flows that control the execution of nodes based on the availability and values of data from various sources. This flexibility allows you to build sophisticated data-driven applications with GraphAI.
+
 ## 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.
+GraphAI supports concurrent execution of tasks, allowing you to leverage parallelism and improve performance. The level of concurrency can be controlled through the *concurrency* property at the top level of the graph definition.
+
+```typescript
+  concurrency: 16 # Maximum number of concurrent tasks
+```
+
+If the *concurrency* property is not specified, the default value of 8 is used.
+
+### Concurrency and Nested Graphs
 
 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. 
+### Task Prioritization
+
+By default, tasks are executed in a first-in, first-out (FIFO) order with a neutral priority (0). However, you can assign custom priorities to nodes using the *priority* property. Tasks associated with nodes that have a higher priority value will be executed before those with lower priorities.
 
-It is possible to change this priority by specifying Node's optional property "priority". The task with higher priority will be executed first. 
+Negative priority values are allowed, enabling you to fine-tune the execution order based on your application's requirements.
 
 ## GraphAI class
 

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

@@ -5,6 +5,46 @@ declare const dataObjectMergeTemplateAgentInfo: {
     agent: AgentFunction;
     mock: AgentFunction;
     samples: ({
+        inputs: ({
+            content1: string;
+            content2?: undefined;
+        } | {
+            content2: string;
+            content1?: undefined;
+        })[];
+        params: {};
+        result: {
+            content1: string;
+            content2: string;
+            content?: undefined;
+            a?: undefined;
+            b?: undefined;
+        };
+    } | {
+        inputs: {
+            content1: string;
+        }[];
+        params: {};
+        result: {
+            content1: string;
+            content2?: undefined;
+            content?: undefined;
+            a?: undefined;
+            b?: undefined;
+        };
+    } | {
+        inputs: {
+            content: string;
+        }[];
+        params: {};
+        result: {
+            content: string;
+            content1?: undefined;
+            content2?: undefined;
+            a?: undefined;
+            b?: undefined;
+        };
+    } | {
         inputs: ({
             a: number;
             b: number;
@@ -72,6 +112,9 @@ declare const dataObjectMergeTemplateAgentInfo: {
                     };
                 };
             };
+            content1?: undefined;
+            content2?: undefined;
+            content?: undefined;
         };
     })[];
     description: string;

package/lib/experimental_agents/data_agents/data_object_merge_template_agent.js

@@ -24,6 +24,28 @@ const dataObjectMergeTemplateAgentInfo = {
     agent: exports.dataObjectMergeTemplateAgent,
     mock: exports.dataObjectMergeTemplateAgent,
     samples: [
+        {
+            inputs: [{ content1: "hello" }, { content2: "test" }],
+            params: {},
+            result: {
+                content1: "hello",
+                content2: "test",
+            },
+        },
+        {
+            inputs: [{ content1: "hello" }],
+            params: {},
+            result: {
+                content1: "hello",
+            },
+        },
+        {
+            inputs: [{ content: "hello1" }, { content: "hello2" }],
+            params: {},
+            result: {
+                content: "hello2",
+            },
+        },
         {
             inputs: sampleInputs,
             params: sampleParams,

package/lib/experimental_agents/data_agents/data_sum_template_agent.js

@@ -21,6 +21,21 @@ const dataSumTemplateAgentInfo = {
             params: sampleParams,
             result: sampleResult,
         },
+        {
+            inputs: [1],
+            params: {},
+            result: 1,
+        },
+        {
+            inputs: [1, 2],
+            params: {},
+            result: 3,
+        },
+        {
+            inputs: [1, 2, 3],
+            params: {},
+            result: 6,
+        },
     ],
     description: "Returns the sum of input values",
     category: ["data"],

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

@@ -2,55 +2,156 @@ import { AgentFunction } from "../../graphai";
 export declare const propertyFilterAgent: AgentFunction<{
     include?: Array<string>;
     exclude?: Array<string>;
+    alter?: Record<string, Record<string, string>>;
+    inject?: Record<string, Record<string, any>>;
 }>;
 declare const propertyFilterAgentInfo: {
     name: string;
     agent: AgentFunction<{
         include?: string[] | undefined;
         exclude?: string[] | undefined;
+        alter?: Record<string, Record<string, string>> | undefined;
+        inject?: Record<string, Record<string, any>> | undefined;
     }>;
     mock: AgentFunction<{
         include?: string[] | undefined;
         exclude?: string[] | undefined;
+        alter?: Record<string, Record<string, string>> | undefined;
+        inject?: Record<string, Record<string, any>> | undefined;
     }>;
     samples: ({
-        inputs: {
+        inputs: (string | {
             color: string;
             model: string;
             type: string;
             maker: string;
             range: number;
-        }[];
+        })[];
         params: {
             include: string[];
             exclude?: undefined;
+            alter?: undefined;
+            inject?: undefined;
         };
         result: {
             color: string;
             model: string;
-            type?: undefined;
-            maker?: undefined;
-            range?: undefined;
         };
     } | {
-        inputs: {
+        inputs: (string | {
             color: string;
             model: string;
             type: string;
             maker: string;
             range: number;
+        }[])[];
+        params: {
+            include: string[];
+            exclude?: undefined;
+            alter?: undefined;
+            inject?: undefined;
+        };
+        result: {
+            color: string;
+            model: string;
         }[];
+    } | {
+        inputs: (string | {
+            color: string;
+            model: string;
+            type: string;
+            maker: string;
+            range: number;
+        }[])[];
         params: {
             exclude: string[];
             include?: undefined;
+            alter?: undefined;
+            inject?: undefined;
         };
         result: {
             type: string;
             maker: string;
             range: number;
-            color?: undefined;
-            model?: undefined;
+        }[];
+    } | {
+        inputs: (string | {
+            color: string;
+            model: string;
+            type: string;
+            maker: string;
+            range: number;
+        }[])[];
+        params: {
+            alter: {
+                color: {
+                    red: string;
+                    blue: string;
+                };
+            };
+            include?: undefined;
+            exclude?: undefined;
+            inject?: undefined;
         };
+        result: {
+            color: string;
+            model: string;
+            type: string;
+            maker: string;
+            range: number;
+        }[];
+    } | {
+        inputs: (string | {
+            color: string;
+            model: string;
+            type: string;
+            maker: string;
+            range: number;
+        }[])[];
+        params: {
+            inject: {
+                maker: {
+                    from: number;
+                    index?: undefined;
+                };
+            };
+            include?: undefined;
+            exclude?: undefined;
+            alter?: undefined;
+        };
+        result: {
+            color: string;
+            model: string;
+            type: string;
+            maker: string;
+            range: number;
+        }[];
+    } | {
+        inputs: (string | {
+            color: string;
+            model: string;
+            type: string;
+            maker: string;
+            range: number;
+        }[])[];
+        params: {
+            inject: {
+                maker: {
+                    index: number;
+                    from: number;
+                };
+            };
+            include?: undefined;
+            exclude?: undefined;
+            alter?: undefined;
+        };
+        result: {
+            color: string;
+            model: string;
+            type: string;
+            maker: string;
+            range: number;
+        }[];
     })[];
     description: string;
     category: string[];

package/lib/experimental_agents/data_agents/property_filter_agent.js

@@ -1,40 +1,91 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.propertyFilterAgent = void 0;
-const applyFilter = (input, include, exclude) => {
+const applyFilter = (input, index, inputs, include, exclude, alter, inject) => {
     const propIds = include ? include : Object.keys(input);
     const excludeSet = new Set(exclude ?? []);
     return propIds.reduce((tmp, propId) => {
         if (!excludeSet.has(propId)) {
-            tmp[propId] = input[propId];
+            const injection = inject && inject[propId];
+            const mapping = alter && alter[propId];
+            if (injection && (injection.index === undefined || injection.index === index)) {
+                tmp[propId] = inputs[injection.from];
+            }
+            else if (mapping && mapping[input[propId]]) {
+                tmp[propId] = mapping[input[propId]];
+            }
+            else {
+                tmp[propId] = input[propId];
+            }
         }
         return tmp;
     }, {});
 };
 const propertyFilterAgent = async ({ inputs, params }) => {
     const [input] = inputs;
-    const { include, exclude } = params;
+    const { include, exclude, alter, inject } = params;
     if (Array.isArray(input)) {
-        return input.map((item) => applyFilter(item, include, exclude));
+        return input.map((item, index) => applyFilter(item, index, inputs, include, exclude, alter, inject));
     }
-    return applyFilter(input, include, exclude);
+    return applyFilter(input, 0, inputs, include, exclude, alter);
 };
 exports.propertyFilterAgent = propertyFilterAgent;
-const inputs = [{ color: "red", model: "Model 3", type: "EV", maker: "Tesla", range: 300 }];
+const testInputs = [
+    [
+        { color: "red", model: "Model 3", type: "EV", maker: "Tesla", range: 300 },
+        { color: "blue", model: "Model Y", type: "EV", maker: "Tesla", range: 400 },
+    ],
+    "Tesla Motors",
+];
 const propertyFilterAgentInfo = {
     name: "propertyFilterAgent",
     agent: exports.propertyFilterAgent,
     mock: exports.propertyFilterAgent,
     samples: [
         {
-            inputs,
+            inputs: [testInputs[0][0]],
             params: { include: ["color", "model"] },
             result: { color: "red", model: "Model 3" },
         },
         {
-            inputs,
+            inputs: testInputs,
+            params: { include: ["color", "model"] },
+            result: [
+                { color: "red", model: "Model 3" },
+                { color: "blue", model: "Model Y" },
+            ],
+        },
+        {
+            inputs: testInputs,
             params: { exclude: ["color", "model"] },
-            result: { type: "EV", maker: "Tesla", range: 300 },
+            result: [
+                { type: "EV", maker: "Tesla", range: 300 },
+                { type: "EV", maker: "Tesla", range: 400 },
+            ],
+        },
+        {
+            inputs: testInputs,
+            params: { alter: { color: { red: "blue", blue: "red" } } },
+            result: [
+                { color: "blue", model: "Model 3", type: "EV", maker: "Tesla", range: 300 },
+                { color: "red", model: "Model Y", type: "EV", maker: "Tesla", range: 400 },
+            ],
+        },
+        {
+            inputs: testInputs,
+            params: { inject: { maker: { from: 1 } } },
+            result: [
+                { color: "red", model: "Model 3", type: "EV", maker: "Tesla Motors", range: 300 },
+                { color: "blue", model: "Model Y", type: "EV", maker: "Tesla Motors", range: 400 },
+            ],
+        },
+        {
+            inputs: testInputs,
+            params: { inject: { maker: { index: 0, from: 1 } } },
+            result: [
+                { color: "red", model: "Model 3", type: "EV", maker: "Tesla Motors", range: 300 },
+                { color: "blue", model: "Model Y", type: "EV", maker: "Tesla", range: 400 },
+            ],
         },
     ],
     description: "Filter properties based on property name either with 'include' or 'exclude'",

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

@@ -37,6 +37,19 @@ declare const totalAgentInfo: {
             c: number;
             d: number;
         };
+    } | {
+        inputs: ({
+            a: number;
+            b?: undefined;
+        } | {
+            a: number;
+            b: number;
+        })[];
+        params: {};
+        result: {
+            a: number;
+            b: number;
+        };
     })[];
     description: string;
     category: string[];

package/lib/experimental_agents/data_agents/total_agent.js

@@ -42,6 +42,35 @@ const totalAgentInfo = {
             params: sample2Params,
             result: sample2Result,
         },
+        {
+            inputs: [{ a: 1 }],
+            params: {},
+            result: { a: 1 },
+        },
+        {
+            inputs: [{ a: 1 }, { a: 2 }],
+            params: {},
+            result: { a: 3 },
+        },
+        {
+            inputs: [{ a: 1 }, { a: 2 }, { a: 3 }],
+            params: {},
+            result: { a: 6 },
+        },
+        {
+            inputs: [
+                { a: 1, b: 1 },
+                { a: 2, b: 2 },
+                { a: 3, b: 0 },
+            ],
+            params: {},
+            result: { a: 6, b: 3 },
+        },
+        {
+            inputs: [{ a: 1 }, { a: 2, b: 2 }, { a: 3, b: 0 }],
+            params: {},
+            result: { a: 6, b: 2 },
+        },
     ],
     description: "Returns the sum of input values",
     category: ["data"],

package/lib/experimental_agents/graph_agents/map_agent.js

@@ -4,7 +4,7 @@ exports.mapAgent = void 0;
 const graphai_1 = require("../../graphai");
 const utils_1 = require("../../utils/utils");
 const nested_agent_1 = require("./nested_agent");
-const mapAgent = async ({ params, inputs, agents, log, taskManager, graphData }) => {
+const mapAgent = async ({ params, inputs, agents, log, taskManager, graphData, agentFilters }) => {
     if (taskManager) {
         const status = taskManager.getStatus();
         (0, utils_1.assert)(status.concurrency > status.running, `mapAgent: Concurrency is too low: ${status.concurrency}`);
@@ -25,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, agentFilters: agentFilters || [] });
         // 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

@@ -21,27 +21,24 @@ const getNestedGraphData = (graphData, inputs) => {
     return graphData;
 };
 exports.getNestedGraphData = getNestedGraphData;
-const nestedAgent = async ({ params, inputs, agents, log, taskManager, graphData }) => {
+const nestedAgent = async ({ params, inputs, agents, log, taskManager, graphData, agentFilters }) => {
     if (taskManager) {
         const status = taskManager.getStatus(false);
         (0, utils_1.assert)(status.concurrency > status.running, `nestedAgent: Concurrency is too low: ${status.concurrency}`);
     }
     const nestedGraphData = (0, exports.getNestedGraphData)(graphData, inputs);
-    const injectionTo = params.injectionTo ??
-        inputs.map((__input, index) => {
-            return `$${index}`;
-        });
-    injectionTo.forEach((nodeId) => {
+    const injectionTo = params.injectionTo ?? inputs.map((__input, index) => `$${index}`);
+    injectionTo.forEach((nodeId, index) => {
         if (nestedGraphData.nodes[nodeId] === undefined) {
             // If the input node does not exist, automatically create a static node
-            nestedGraphData.nodes[nodeId] = { value: {} };
+            nestedGraphData.nodes[nodeId] = { value: inputs[index] };
+        }
+        else {
+            // Otherwise, inject the proper data here (instead of calling injectTo method later)
+            nestedGraphData.nodes[nodeId]["value"] = inputs[index];
         }
     });
-    const graphAI = new graphai_1.GraphAI(nestedGraphData, agents || {}, { taskManager });
-    // Inject inputs to specified source nodes
-    injectionTo.forEach((injectToNodeId, index) => {
-        graphAI.injectValue(injectToNodeId, inputs[index]);
-    });
+    const graphAI = new graphai_1.GraphAI(nestedGraphData, agents || {}, { taskManager, agentFilters });
     const results = await graphAI.run(false);
     log?.push(...graphAI.transactionLogs());
     return results;

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

@@ -0,0 +1,42 @@
+import { AgentFunction } from "../../graphai";
+import { Groq } from "groq-sdk";
+export declare const groqStreamAgent: AgentFunction<{
+    model: string;
+    query?: string;
+    system?: string;
+    verbose?: boolean;
+    tools?: Groq.Chat.CompletionCreateParams.Tool[];
+    temperature?: number;
+    max_tokens?: number;
+    tool_choice?: Groq.Chat.CompletionCreateParams.ToolChoice;
+}, any, string | Array<Groq.Chat.CompletionCreateParams.Message>>;
+declare const groqStreamAgentInfo: {
+    name: string;
+    agent: AgentFunction<{
+        model: string;
+        query?: string | undefined;
+        system?: string | undefined;
+        verbose?: boolean | undefined;
+        tools?: Groq.Chat.Completions.CompletionCreateParams.Tool[] | undefined;
+        temperature?: number | undefined;
+        max_tokens?: number | undefined;
+        tool_choice?: Groq.Chat.Completions.CompletionCreateParams.ToolChoice | undefined;
+    }, any, string | Groq.Chat.Completions.CompletionCreateParams.Message[]>;
+    mock: AgentFunction<{
+        model: string;
+        query?: string | undefined;
+        system?: string | undefined;
+        verbose?: boolean | undefined;
+        tools?: Groq.Chat.Completions.CompletionCreateParams.Tool[] | undefined;
+        temperature?: number | undefined;
+        max_tokens?: number | undefined;
+        tool_choice?: Groq.Chat.Completions.CompletionCreateParams.ToolChoice | undefined;
+    }, any, string | Groq.Chat.Completions.CompletionCreateParams.Message[]>;
+    samples: never[];
+    description: string;
+    category: string[];
+    author: string;
+    repository: string;
+    license: string;
+};
+export default groqStreamAgentInfo;

package/lib/experimental_agents/llm_agents/groq_stream_agent.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.groqStreamAgent = 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;
+//
+// 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 groqStreamAgent = async ({ params, inputs, filterParams }) => {
+    (0, utils_1.assert)(groq !== undefined, "The GROQ_API_KEY environment variable is missing.");
+    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 && typeof input_query === "string" ? [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,
+        stream: true,
+    };
+    if (max_tokens) {
+        options.max_tokens = max_tokens;
+    }
+    if (tools) {
+        options.tools = tools;
+        options.tool_choice = tool_choice ?? "auto";
+    }
+    const stream = await groq.chat.completions.create(options);
+    let lastMessage = null;
+    const contents = [];
+    for await (const message of stream) {
+        const token = message.choices[0].delta.content;
+        if (token) {
+            if (filterParams && filterParams.streamTokenCallback) {
+                filterParams.streamTokenCallback(token);
+            }
+            contents.push(token);
+        }
+        lastMessage = message;
+    }
+    if (lastMessage) {
+        lastMessage.choices[0]["message"] = [{ role: "assistant", content: contents.join("") }];
+    }
+    return lastMessage;
+};
+exports.groqStreamAgent = groqStreamAgent;
+const groqStreamAgentInfo = {
+    name: "groqStreamAgent",
+    agent: exports.groqStreamAgent,
+    mock: exports.groqStreamAgent,
+    samples: [],
+    description: "Groq Stream Agent",
+    category: ["llm"],
+    author: "Receptron team",
+    repository: "https://github.com/receptron/graphai",
+    license: "MIT",
+};
+exports.default = groqStreamAgentInfo;

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

@@ -1,2 +1,4 @@
+export * from "./openai_agent";
 export * from "./slashgpt_agent";
 export * from "./groq_agent";
+export * from "./groq_stream_agent";

package/lib/experimental_agents/llm_agents/index.js

@@ -14,5 +14,7 @@ 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("./openai_agent"), exports);
 __exportStar(require("./slashgpt_agent"), exports);
 __exportStar(require("./groq_agent"), exports);
+__exportStar(require("./groq_stream_agent"), exports);

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

@@ -48,6 +48,7 @@ declare const openaiAgentInfo: {
             model: string;
         };
     }[];
+    skipTest: boolean;
     description: string;
     category: string[];
     author: string;

package/lib/experimental_agents/llm_agents/openai_agent.js

@@ -77,6 +77,7 @@ const openaiAgentInfo = {
             result: result_sample,
         },
     ],
+    skipTest: true,
     description: "Openai Agent",
     category: ["llm"],
     author: "Receptron team",

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

@@ -1,3 +1,5 @@
 import groqAgent from "../../experimental_agents/llm_agents/groq_agent";
+import groqStreamAgent from "../../experimental_agents/llm_agents/groq_stream_agent";
 import slashGPTAgent from "../../experimental_agents/llm_agents/slashgpt_agent";
-export { groqAgent, slashGPTAgent };
+import openAIAgent from "../../experimental_agents/llm_agents/openai_agent";
+export { groqAgent, groqStreamAgent, slashGPTAgent, openAIAgent };

package/lib/experimental_agents/llm_agents/packages.js

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

package/lib/experimental_agents/matrix_agents/dot_product_agent.js

@@ -39,6 +39,17 @@ const dotProductAgentInfo = {
             params: {},
             result: [7, 17, 27],
         },
+        {
+            inputs: [
+                [
+                    [1, 2],
+                    [2, 3],
+                ],
+                [1, 2],
+            ],
+            params: {},
+            result: [5, 8],
+        },
     ],
     description: "dotProduct Agent",
     category: [],

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

@@ -10,7 +10,19 @@ declare const sortByValuesAgentInfo: {
     mock: AgentFunction<{
         assendant?: boolean | undefined;
     }, any[], any[]>;
-    samples: never[];
+    samples: ({
+        inputs: (string[] | number[])[];
+        params: {
+            assendant?: undefined;
+        };
+        result: string[];
+    } | {
+        inputs: (string[] | number[])[];
+        params: {
+            assendant: boolean;
+        };
+        result: string[];
+    })[];
     description: string;
     category: never[];
     author: string;

package/lib/experimental_agents/matrix_agents/sort_by_values_agent.js

@@ -31,7 +31,26 @@ const sortByValuesAgentInfo = {
     name: "sortByValuesAgent",
     agent: exports.sortByValuesAgent,
     mock: exports.sortByValuesAgent,
-    samples: [],
+    samples: [
+        {
+            inputs: [
+                ["banana", "orange", "lemon", "apple"],
+                [2, 5, 6, 4],
+            ],
+            params: {},
+            result: ["lemon", "orange", "apple", "banana"],
+        },
+        {
+            inputs: [
+                ["banana", "orange", "lemon", "apple"],
+                [2, 5, 6, 4],
+            ],
+            params: {
+                assendant: true,
+            },
+            result: ["banana", "apple", "orange", "lemon"],
+        },
+    ],
     description: "sortByValues Agent",
     category: [],
     author: "Receptron team",

package/lib/experimental_agents/service_agents/fetch_agent.js

@@ -82,7 +82,7 @@ const fetchAgentInfo = {
                 headers: {
                     "Content-Type": "application/json",
                 },
-                body: "{\"foo\":\"bar\"}",
+                body: JSON.stringify({ foo: "bar" }),
             },
         },
     ],

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

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

package/lib/experimental_agents/service_agents/packages.js

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

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

@@ -15,6 +15,7 @@ declare const wikipediaAgentInfo: {
     }, Record<string, any> | undefined, string>;
     description: string;
     category: string[];
+    samples: never[];
     author: string;
     repository: string;
     license: string;

package/lib/experimental_agents/service_agents/wikipedia.js

@@ -31,6 +31,7 @@ const wikipediaAgentInfo = {
     mock: exports.wikipediaAgent,
     description: "Retrieves data from wikipedia",
     category: ["data"],
+    samples: [],
     author: "Receptron",
     repository: "https://github.com/receptron/graphai",
     license: "MIT",

package/lib/experimental_agents/token_agent.d.ts

@@ -16,7 +16,17 @@ declare const tokenBoundStringsAgentInfo: {
     }, {
         content: string;
     }, string[]>;
-    samples: never[];
+    samples: {
+        inputs: string[][];
+        params: {
+            limit: number;
+        };
+        result: {
+            content: string;
+            tokenCount: number;
+            endIndex: number;
+        };
+    }[];
     description: string;
     category: never[];
     author: string;

package/lib/experimental_agents/token_agent.js

@@ -35,7 +35,36 @@ const tokenBoundStringsAgentInfo = {
     name: "tokenBoundStringsAgent",
     agent: exports.tokenBoundStringsAgent,
     mock: exports.tokenBoundStringsAgent,
-    samples: [],
+    samples: [
+        {
+            inputs: [
+                [
+                    "Here's to the crazy ones. The misfits. The rebels. The troublemakers.",
+                    "The round pegs in the square holes. The ones who see things differently.",
+                    "They're not fond of rules. And they have no respect for the status quo.",
+                    "You can quote them, disagree with them, glorify or vilify them.",
+                    "About the only thing you can't do is ignore them.",
+                    "Because they change things.",
+                    "They push the human race forward.",
+                    "And while some may see them as the crazy ones, we see genius.",
+                    "Because the people who are crazy enough to think they can change the world, are the ones who do.",
+                ],
+            ],
+            params: {
+                limit: 80,
+            },
+            result: {
+                content: "Here's to the crazy ones. The misfits. The rebels. The troublemakers.\n" +
+                    "The round pegs in the square holes. The ones who see things differently.\n" +
+                    "They're not fond of rules. And they have no respect for the status quo.\n" +
+                    "You can quote them, disagree with them, glorify or vilify them.\n" +
+                    "About the only thing you can't do is ignore them.\n" +
+                    "Because they change things.",
+                tokenCount: 79,
+                endIndex: 6,
+            },
+        },
+    ],
     description: "token bound Agent",
     category: [],
     author: "Receptron team",

package/lib/graphai.d.ts

@@ -10,7 +10,7 @@ export declare class GraphAI {
     private readonly data;
     private readonly loop?;
     private readonly logs;
-    readonly callbackDictonary: AgentFunctionDictonary;
+    readonly agentFunctionDictionary: AgentFunctionDictonary;
     readonly taskManager: TaskManager;
     readonly agentFilters: AgentFilterInfo[];
     readonly retryLimit?: number;
@@ -22,11 +22,11 @@ export declare class GraphAI {
     private createNodes;
     private getValueFromResults;
     private initializeNodes;
-    constructor(data: GraphData, callbackDictonary: AgentFunctionDictonary, options?: {
+    constructor(data: GraphData, agentFunctionDictionary: AgentFunctionDictonary, options?: {
         agentFilters?: AgentFilterInfo[] | undefined;
         taskManager?: TaskManager | undefined;
     });
-    getCallback(agentId?: string): import("./type").AgentFunction<any, any, any>;
+    getAgentFunction(agentId?: string): import("./type").AgentFunction<any, any, any>;
     asString(): string;
     results<T = DefaultResultData>(all: boolean): ResultDataDictonary<T>;
     errors(): Record<string, Error>;

package/lib/graphai.js

@@ -63,7 +63,7 @@ class GraphAI {
             }
         });
     }
-    constructor(data, callbackDictonary, options = { taskManager: undefined, agentFilters: [] }) {
+    constructor(data, agentFunctionDictionary, options = { taskManager: undefined, agentFilters: [] }) {
         this.logs = [];
         this.onLogCallback = (__log, __isUpdate) => { };
         this.repeatCount = 0;
@@ -77,7 +77,7 @@ class GraphAI {
         this.retryLimit = data.retry; // optional
         this.graphId = URL.createObjectURL(new Blob()).slice(-36);
         this.data = data;
-        this.callbackDictonary = callbackDictonary;
+        this.agentFunctionDictionary = agentFunctionDictionary;
         this.taskManager = options.taskManager ?? new task_manager_1.TaskManager(data.concurrency ?? defaultConcurrency);
         this.agentFilters = options.agentFilters ?? [];
         this.loop = data.loop;
@@ -85,13 +85,13 @@ class GraphAI {
         this.onComplete = () => {
             console.error("-- SOMETHING IS WRONG: onComplete is called without run()");
         };
-        (0, validator_1.validateGraphData)(data, Object.keys(callbackDictonary));
+        (0, validator_1.validateGraphData)(data, Object.keys(agentFunctionDictionary));
         this.nodes = this.createNodes(data);
         this.initializeNodes();
     }
-    getCallback(agentId) {
-        if (agentId && this.callbackDictonary[agentId]) {
-            return this.callbackDictonary[agentId];
+    getAgentFunction(agentId) {
+        if (agentId && this.agentFunctionDictionary[agentId]) {
+            return this.agentFunctionDictionary[agentId];
         }
         throw new Error("No agent: " + agentId);
     }

package/lib/node.js

@@ -71,7 +71,7 @@ class ComputedNode extends Node {
             }
             return tmp;
         }, {});
-        this.log.initForComputedNode(this);
+        this.log.initForComputedNode(this, graph);
     }
     getAgentId() {
         return this.agentId ?? "__custom__function"; // only for display purpose in the log.
@@ -167,20 +167,20 @@ class ComputedNode extends Node {
         }
         return !agentFilter.agentIds && !agentFilter.nodeIds;
     }
-    agentFilterHandler(context, agent) {
+    agentFilterHandler(context, agentFunction) {
         let index = 0;
-        const next = (context) => {
+        const next = (innerContext) => {
             const agentFilter = this.graph.agentFilters[index++];
             if (agentFilter) {
                 if (this.shouldApplyAgentFilter(agentFilter)) {
                     if (agentFilter.filterParams) {
-                        context.filterParams = { ...agentFilter.filterParams, ...context.filterParams };
+                        innerContext.filterParams = { ...agentFilter.filterParams, ...innerContext.filterParams };
                     }
-                    return agentFilter.agent(context, next);
+                    return agentFilter.agent(innerContext, next);
                 }
-                return next(context);
+                return next(innerContext);
             }
-            return agent(context);
+            return agentFunction(innerContext);
         };
         return next(context);
     }
@@ -201,7 +201,7 @@ class ComputedNode extends Node {
             }, this.timeout);
         }
         try {
-            const callback = this.agentFunction ?? this.graph.getCallback(this.agentId);
+            const agentFunction = this.agentFunction ?? this.graph.getAgentFunction(this.agentId);
             const localLog = [];
             const params = Object.keys(this.dynamicParams).reduce((tmp, key) => {
                 const [result] = this.graph.resultsOf([this.dynamicParams[key]]);
@@ -218,6 +218,7 @@ class ComputedNode extends Node {
                     verbose: this.graph.verbose,
                 },
                 filterParams: this.filterParams,
+                agentFilters: this.graph.agentFilters,
                 log: localLog,
             };
             // NOTE: We use the existence of graph object in the agent-specific params to determine
@@ -226,9 +227,9 @@ class ComputedNode extends Node {
                 this.graph.taskManager.prepareForNesting();
                 context.taskManager = this.graph.taskManager;
                 context.graphData = this.nestedGraph;
-                context.agents = this.graph.callbackDictonary;
+                context.agents = this.graph.agentFunctionDictionary;
             }
-            const result = await this.agentFilterHandler(context, callback);
+            const result = await this.agentFilterHandler(context, agentFunction);
             if (this.nestedGraph) {
                 this.graph.taskManager.restoreAfterNesting();
             }

package/lib/task_manager.js

@@ -58,12 +58,9 @@ class TaskManager {
         this.concurrency--;
     }
     getStatus(verbose = false) {
-        const nodes = verbose
-            ? {
-                runningNodes: Array.from(this.runningNodes).map((node) => node.nodeId),
-                queuedNodes: this.taskQueue.map((task) => task.node.nodeId),
-            }
-            : {};
+        const runningNodes = Array.from(this.runningNodes).map((node) => node.nodeId);
+        const queuedNodes = this.taskQueue.map((task) => task.node.nodeId);
+        const nodes = verbose ? { runningNodes, queuedNodes } : {};
         return {
             concurrency: this.concurrency,
             queue: this.taskQueue.length,

package/lib/transaction_log.d.ts

@@ -19,7 +19,7 @@ export declare class TransactionLog {
     repeatCount?: number;
     log?: TransactionLog[];
     constructor(nodeId: string);
-    initForComputedNode(node: ComputedNode): void;
+    initForComputedNode(node: ComputedNode, graph: GraphAI): void;
     onInjected(node: StaticNode, graph: GraphAI, injectFrom?: string): void;
     onComplete(node: ComputedNode, graph: GraphAI, localLog: TransactionLog[]): void;
     beforeExecute(node: ComputedNode, graph: GraphAI, transactionId: number, inputs: ResultData[]): void;

package/lib/transaction_log.js

@@ -7,9 +7,10 @@ class TransactionLog {
         this.nodeId = nodeId;
         this.state = type_1.NodeState.Waiting;
     }
-    initForComputedNode(node) {
+    initForComputedNode(node, graph) {
         this.agentId = node.getAgentId();
         this.params = node.params;
+        graph.appendLog(this);
     }
     onInjected(node, graph, injectFrom) {
         const isUpdating = "endTime" in this;

package/lib/type.d.ts

@@ -67,6 +67,7 @@ export type AgentFunctionContext<ParamsType = DefaultParamsType, InputDataType =
     agents?: AgentFunctionDictonary;
     taskManager?: TaskManager;
     filterParams: AgentFilterParams;
+    agentFilters?: AgentFilterInfo[];
     log?: TransactionLog[];
 };
 export type AgentFunction<ParamsType = DefaultParamsType, ResultType = DefaultResultData, InputDataType = DefaultInputData> = (context: AgentFunctionContext<ParamsType, InputDataType>) => Promise<ResultData<ResultType>>;
@@ -88,6 +89,7 @@ export type AgentFunctionInfo = {
         params: DefaultParamsType;
         result: any;
     }[];
+    skipTest?: boolean;
     description: string;
     category: string[];
     author: string;

package/lib/utils/test_utils.js

@@ -19,8 +19,8 @@ exports.defaultTestContext = {
 };
 // for agent
 const agentTestRunner = async (agentInfo) => {
-    const { agent, samples } = agentInfo;
-    if (samples.length === 0) {
+    const { agent, samples, skipTest } = agentInfo;
+    if (samples.length === 0 || skipTest) {
         console.log(`test ${agentInfo.name}: No test`);
     }
     else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "graphai",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "description": "Asynchronous data flow execution engine for agentic AI apps.",
   "main": "lib/index.js",
   "files": [
@@ -8,8 +8,8 @@
   ],
   "scripts": {
     "build": "rm -r lib/* && tsc && tsc-alias",
-    "eslint": "eslint --fix --ext .ts ./src ./tests ./samples",
-    "format": "prettier --write '{src,tests,samples}/**/*.ts' .eslintrc.js",
+    "eslint": "eslint",
+    "format": "prettier --write '{src,tests,samples}/**/*.ts'",
     "test": "node --test  -r tsconfig-paths/register --require ts-node/register ./tests/**/test_*.ts",
     "http_test": "node --test  -r tsconfig-paths/register --require ts-node/register ./tests/**/http_*.ts",
     "b": "yarn run format && yarn run eslint && yarn run build",
@@ -30,26 +30,25 @@
     "@inquirer/prompts": "^5.0.0",
     "@types/cors": "^2.8.17",
     "@types/express": "^4.17.21",
-    "@types/node": "^20.8.7",
+    "@types/node": "^20.12.11",
     "@types/xml2js": "^0.4.14",
-    "@typescript-eslint/eslint-plugin": "^6.8.0",
-    "@typescript-eslint/parser": "^6.8.0",
     "arxiv-api-ts": "^1.0.3",
     "cors": "^2.8.5",
     "deepmerge": "^4.3.1",
     "dotenv": "^16.4.5",
-    "eslint": "^7.32.0 || ^8.2.0",
-    "eslint-plugin-import": "^2.25.2",
+    "eslint": "^9.2.0",
     "express": "^4.19.2",
+    "globals": "^15.2.0",
     "groq-sdk": "^0.3.3",
     "openai": "^4.12.4",
-    "prettier": "^3.0.3",
+    "prettier": "^3.2.5",
     "slashgpt": "^0.0.9",
     "tiktoken": "^1.0.14",
-    "ts-node": "^10.9.1",
+    "ts-node": "^10.9.2",
     "tsc-alias": "^1.8.8",
     "tsconfig-paths": "^4.2.0",
-    "typescript": "^5.2.2",
+    "typescript": "^5.4.5",
+    "typescript-eslint": "^7.8.0",
     "wikipedia": "^2.1.2",
     "xml2js": "^0.6.2",
     "yaml": "^2.4.1"