graphai 0.3.0 → 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_agent_filters/stream.d.ts

@@ -0,0 +1,2 @@
+import { AgentFilterFunction, AgentFunctionContext } from "../type";
+export declare const streamAgentFilterGenerator: <T>(callback: (context: AgentFunctionContext, data: T) => void) => AgentFilterFunction;

package/lib/experimental_agent_filters/stream.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.streamAgentFilterGenerator = void 0;
+const streamAgentFilterGenerator = (callback) => {
+    const streamAgentFilter = async (context, next) => {
+        context.filterParams.streamTokenCallback = (data) => {
+            callback(context, data);
+        };
+        return next(context);
+    };
+    return streamAgentFilter;
+};
+exports.streamAgentFilterGenerator = streamAgentFilterGenerator;

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;