graphai 0.2.8 → 0.3.1

package/README.md

@@ -22,30 +22,30 @@ nodes:
       query: describe the final sentence by the court for Sam Bank-Fried
   wikipedia: // Retrieve data from Wikipedia
     agent: wikipediaAgent
-    inputs: [source.name]
+    inputs: [:source.name]
   chunks: // Break the text from Wikipedia into chunks (2048 character each with 512 overlap）
     agent: stringSplitterAgent
-    inputs: [wikipedia]
+    inputs: [:wikipedia]
   chunkEmbeddings: // Get embedding vector of each chunk
     agent: stringEmbeddingsAgent
-    inputs: [chunks]
+    inputs: [:chunks]
   topicEmbedding: // Get embedding vector of the question
     agent: stringEmbeddingsAgent
-    inputs: [source.query]
+    inputs: [:source.query]
   similarities: // Calculate the cosine similarity of each chunk
     agent: dotProductAgent
-    inputs: [chunkEmbeddings, topicEmbedding]
+    inputs: [:chunkEmbeddings, :topicEmbedding]
   sortedChunks: // Sort chunks based on their similarities
     agent: sortByValuesAgent
-    inputs: [chunks, similarities]
+    inputs: [:chunks, :similarities]
   referenceText: // Concatenate chunks up to the token limit (5000)
     agent: tokenBoundStringsAgent
-    inputs: [sortedChunks]
+    inputs: [:sortedChunks]
     params:
       limit: 5000
   prompt: // Generate a prompt with that reference text
     agent: stringTemplateAgent
-    inputs: [source, referenceText]
+    inputs: [:source, :referenceText]
     params:
       template: |-
         Using the following document, ${0}
@@ -56,7 +56,7 @@ nodes:
       manifest:
         model: gpt-3.5-turbo
     isResult: true // indicating this is the final result
-    inputs: [prompt]
+    inputs: [:prompt]
 ```
 
 ```mermaid
@@ -96,10 +96,11 @@ A DFG consists of a collection of [nodes](#node), which contains a series of nes
 
 ### Data Source
 
-Connections between nodes will be established by references from one node to another, using either its "inputs" or "update" property. The values of those properties are *data sources*. A *data souce* is specified by either the nodeId (e.g., "node1"), or nodeId + propertyId (e.g., "node1.item"), index (e.g., "node1.$0", "node2.$last") or combinations (e.g., "node1.messages.$0.content").
+Connections between nodes will be established by references from one node to another, using either its "inputs", "update", "if" or "while" property. The values of those properties are *data sources*. A *data souce* is specified by either the ":" + nodeId (e.g., ":node1"), or ":" + nodeId + propertyId (e.g., ":node1.item"), index (e.g., ":node1.$0", ":node2.$last") or combinations (e.g., ":node1.messages.$0.content").
 
 ### DFG Structure
 
+- *version*: GraphAI version, *required*. The latest version is 0.3.
 - *nodes*: A list of node. Required.
 - *concurrency*: An optional property, which specifies the maximum number of concurrent operations (agent functions to be executed at the same time). The default is 8.
 - *loop*: An optional property, which specifies if the graph needs to be executed multiple times (iterations). See the [Loop section below](#loop) for details.
@@ -134,7 +135,7 @@ Here is an examnple (from [weather chat](https://github.com/receptron/graphai/bl
     messagesWithUserInput: {
       // Appends the user's input to the messages.
       agent: (messages: Array<any>, content: string) => [...messages, { role: "user", content }],
-      inputs: ["messages", "userInput"],
+      inputs: [":messages", ":userInput"],
       if: "checkInput",
     },
 ```
@@ -183,23 +184,23 @@ nodes:
     value: "Find out which materials we need to purchase this week for Joe Smith's residential house project."
   projectId: // identifies the projectId from the question
     agent: "identifierAgent"
-    inputs: ["source"] // == "sourceNode.query"
+    inputs: [":source"] // == "sourceNode.query"
   database:
     agent: "nestedAgent"
-    inputs: ["question", "projectId"]
+    inputs: [":question", ":projectId"]
     graph:
       nodes:
         schema: // retrieves the database schema for the apecified projectId
           agent: "schemaAgent"
-          inputs: ["$1"]
+          inputs: [":$1"]
         ... // issue query to the database and build an appropriate prompt with it.
         query: // send the generated prompt to the LLM
           agent: "llama3Agent"
-          inputs: ["prompt"]
+          inputs: [":prompt"]
           isResult: true
   response: // Deliver the answer
     agent: "deliveryAgent"      
-    inputs: [database.query.$last.content]
+    inputs: [:database.query.$last.content]
 ```
 
 The databaseQuery node (which is associated "nestedAgent") takes the data from "question" node abd "projectId" node, and make them available to inner nodes (nodes of the child graph) via phantom node, "$0" and "$1". After the completion of the child graph, the data from "query" node (which has "isResult" property) becomes available as a property of the output of "database" node.
@@ -239,14 +240,14 @@ The "update" property of two static nodes ("people" and "result"), updates those
 
 ```
 loop:
-  while: people
+  while: :people
 nodes:
   people:
     value: [Steve Jobs, Elon Musk, Nikola Tesla]
-    update: retriever.array
+    update: :retriever.array
   result:
     value: []
-    update: reducer
+    update: :reducer
     isResult: true
   retriever:
     agent: shift
@@ -256,10 +257,10 @@ nodes:
     params:
       manifest:
         prompt: Describe about the person in less than 100 words
-    inputs: [retriever.item]
+    inputs: [:retriever.item]
   reducer:
     agent: push
-    inputs: [result, query.content]
+    inputs: [:result, :query.content]
 ```
 
 ```mermaid
@@ -292,7 +293,7 @@ nodes:
     value: [Steve Jobs, Elon Musk, Nikola Tesla]
   retriever:
     agent: "mapAgent"
-    inputs: ["people"]
+    inputs: [":people"]
     graph:
       nodes:
         query:
@@ -300,7 +301,7 @@ nodes:
           params:
             manifest:
               prompt: Describe about the person in less than 100 words
-          inputs: ["$0"]
+          inputs: [":$0"]
 ```
 
 Here is the conceptual representation of this operation.
@@ -324,8 +325,8 @@ A sample code, [weather chat](https://github.com/receptron/graphai/blob/main/sam
     tool_calls: {
       // This node is activated if the LLM requests a tool call.
       agent: "nestedAgent",
-      inputs: ["groq.choices.$0.message.tool_calls", "messagesWithFirstRes"],
-      if: "groq.choices.$0.message.tool_calls",
+      inputs: [":groq.choices.$0.message.tool_calls", ":messagesWithFirstRes"],
+      if: ":groq.choices.$0.message.tool_calls",
       graph: {
         // This graph is nested only for the readability.
 ```
@@ -341,7 +342,7 @@ The [weather chat](https://github.com/receptron/graphai/blob/main/samples/sample
       // Receives messages from either case.
       agent: "copyAgent",
       anyInput: true,
-      inputs: ["no_tool_calls", "tool_calls.messagesWithSecondRes"],
+      inputs: [":no_tool_calls", ":tool_calls.messagesWithSecondRes"],
     },
 ```
 

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/llm_agents/groq_agent.d.ts

@@ -1,14 +1,15 @@
 import { AgentFunction } from "../../graphai";
+import { Groq } from "groq-sdk";
 export declare const groqAgent: AgentFunction<{
     model: string;
     query?: string;
     system?: string;
     verbose?: boolean;
-    tools?: Record<string, any>;
+    tools?: Record<string, Groq.Chat.CompletionCreateParams.Tool>;
     temperature?: number;
     max_tokens?: number;
-    tool_choice?: string | Record<string, any>;
-}, Record<string, any> | string, string | Array<Record<string, any>>>;
+    tool_choice?: string | Record<string, Groq.Chat.CompletionCreateParams.ToolChoice>;
+}, Groq.Chat.ChatCompletion, string | Array<Groq.Chat.CompletionCreateParams.Message>>;
 declare const groqAgentInfo: {
     name: string;
     agent: AgentFunction<{
@@ -16,21 +17,21 @@ declare const groqAgentInfo: {
         query?: string | undefined;
         system?: string | undefined;
         verbose?: boolean | undefined;
-        tools?: Record<string, any> | undefined;
+        tools?: Record<string, Groq.Chat.Completions.CompletionCreateParams.Tool> | undefined;
         temperature?: number | undefined;
         max_tokens?: number | undefined;
-        tool_choice?: string | Record<string, any> | undefined;
-    }, string | Record<string, any>, string | Record<string, any>[]>;
+        tool_choice?: string | Record<string, Groq.Chat.Completions.CompletionCreateParams.ToolChoice> | undefined;
+    }, Groq.Chat.Completions.ChatCompletion, string | Groq.Chat.Completions.CompletionCreateParams.Message[]>;
     mock: AgentFunction<{
         model: string;
         query?: string | undefined;
         system?: string | undefined;
         verbose?: boolean | undefined;
-        tools?: Record<string, any> | undefined;
+        tools?: Record<string, Groq.Chat.Completions.CompletionCreateParams.Tool> | undefined;
         temperature?: number | undefined;
         max_tokens?: number | undefined;
-        tool_choice?: string | Record<string, any> | undefined;
-    }, string | Record<string, any>, string | Record<string, any>[]>;
+        tool_choice?: string | Record<string, Groq.Chat.Completions.CompletionCreateParams.ToolChoice> | undefined;
+    }, Groq.Chat.Completions.ChatCompletion, string | Groq.Chat.Completions.CompletionCreateParams.Message[]>;
     samples: never[];
     description: string;
     category: string[];

package/lib/experimental_agents/llm_agents/groq_agent.js

@@ -28,7 +28,7 @@ const groqAgent = async ({ params, inputs }) => {
     const [input_query, previous_messages] = inputs;
     // Notice that we ignore params.system if previous_message exists.
     const messages = previous_messages && Array.isArray(previous_messages) ? previous_messages : system ? [{ role: "system", content: system }] : [];
-    const content = (query ? [query] : []).concat(input_query ? [input_query] : []).join("\n");
+    const content = (query ? [query] : []).concat(input_query && typeof input_query === "string" ? [input_query] : []).join("\n");
     if (content) {
         messages.push({
             role: "user",

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

@@ -0,0 +1,57 @@
+import { AgentFunction } from "../../graphai";
+export declare const openAIAgent: AgentFunction<{
+    model?: string;
+    query?: string;
+    system?: string;
+    verbose?: boolean;
+    temperature?: number;
+}, Record<string, any> | string, string | Array<any>>;
+export declare const openAIMockAgent: AgentFunction<{
+    model?: string;
+    query?: string;
+    system?: string;
+    verbose?: boolean;
+    temperature?: number;
+}, Record<string, any> | string, string | Array<any>>;
+declare const openaiAgentInfo: {
+    name: string;
+    agent: AgentFunction<{
+        model?: string | undefined;
+        query?: string | undefined;
+        system?: string | undefined;
+        verbose?: boolean | undefined;
+        temperature?: number | undefined;
+    }, string | Record<string, any>, string | any[]>;
+    mock: AgentFunction<{
+        model?: string | undefined;
+        query?: string | undefined;
+        system?: string | undefined;
+        verbose?: boolean | undefined;
+        temperature?: number | undefined;
+    }, string | Record<string, any>, string | any[]>;
+    samples: {
+        inputs: string[];
+        params: {};
+        result: {
+            object: string;
+            id: string;
+            choices: {
+                message: {
+                    role: string;
+                    content: string;
+                };
+                finish_reason: string;
+                index: number;
+                logprobs: null;
+            }[];
+            created: number;
+            model: string;
+        };
+    }[];
+    description: string;
+    category: string[];
+    author: string;
+    repository: string;
+    license: string;
+};
+export default openaiAgentInfo;

package/lib/experimental_agents/llm_agents/openai_agent.js

@@ -0,0 +1,86 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openAIMockAgent = exports.openAIAgent = void 0;
+const openai_1 = __importDefault(require("openai"));
+const utils_1 = require("../../utils/utils");
+const openAIAgent = async ({ filterParams, params, inputs }) => {
+    const { verbose, query, system, temperature } = params;
+    const [input_query, previous_messages] = inputs;
+    // Notice that we ignore params.system if previous_message exists.
+    const messages = previous_messages && Array.isArray(previous_messages) ? previous_messages : system ? [{ role: "system", content: system }] : [];
+    const content = (query ? [query] : []).concat(input_query ? [input_query] : []).join("\n");
+    if (content) {
+        messages.push({
+            role: "user",
+            content,
+        });
+    }
+    if (verbose) {
+        console.log(messages);
+    }
+    const openai = new openai_1.default();
+    const chatStream = await openai.beta.chat.completions.stream({
+        model: params.model || "gpt-3.5-turbo",
+        messages,
+        temperature: temperature ?? 0.7,
+        stream: true,
+    });
+    for await (const message of chatStream) {
+        const token = message.choices[0].delta.content;
+        if (filterParams && filterParams.streamTokenCallback && token) {
+            filterParams.streamTokenCallback(token);
+        }
+    }
+    const chatCompletion = await chatStream.finalChatCompletion();
+    return chatCompletion;
+};
+exports.openAIAgent = openAIAgent;
+const input_sample = "this is response result";
+const result_sample = {
+    object: "chat.completion",
+    id: "chatcmpl-9N7HxXYbwjmdbdiQE94MHoVluQhyt",
+    choices: [
+        {
+            message: {
+                role: "assistant",
+                content: input_sample,
+            },
+            finish_reason: "stop",
+            index: 0,
+            logprobs: null,
+        },
+    ],
+    created: 1715296589,
+    model: "gpt-3.5-turbo-0125",
+};
+const openAIMockAgent = async ({ filterParams }) => {
+    for await (const token of input_sample.split("")) {
+        if (filterParams && filterParams.streamTokenCallback && token) {
+            await (0, utils_1.sleep)(100);
+            filterParams.streamTokenCallback(token);
+        }
+    }
+    return result_sample;
+};
+exports.openAIMockAgent = openAIMockAgent;
+const openaiAgentInfo = {
+    name: "openAIAgent",
+    agent: exports.openAIAgent,
+    mock: exports.openAIMockAgent,
+    samples: [
+        {
+            inputs: [input_sample],
+            params: {},
+            result: result_sample,
+        },
+    ],
+    description: "Openai Agent",
+    category: ["llm"],
+    author: "Receptron team",
+    repository: "https://github.com/receptron/graphai",
+    license: "MIT",
+};
+exports.default = openaiAgentInfo;

package/lib/experimental_agents/llm_agents/slashgpt_agent.js

@@ -7,7 +7,7 @@ exports.slashGPTAgent = void 0;
 const path_1 = __importDefault(require("path"));
 const slashgpt_1 = require("slashgpt");
 const config = new slashgpt_1.ChatConfig(path_1.default.resolve(__dirname));
-const slashGPTAgent = async ({ params, inputs, debugInfo: { verbose, nodeId } }) => {
+const slashGPTAgent = async ({ params, inputs, debugInfo: { verbose, nodeId }, filterParams }) => {
     if (verbose) {
         console.log("executing", nodeId, params);
     }
@@ -15,7 +15,11 @@ const slashGPTAgent = async ({ params, inputs, debugInfo: { verbose, nodeId } })
     const query = params?.query ? [params.query] : [];
     const contents = query.concat(inputs);
     session.append_user_question(contents.join("\n"));
-    await session.call_loop(() => { });
+    await session.call_loop(() => { }, (token) => {
+        if (filterParams && filterParams.streamTokenCallback && token) {
+            filterParams.streamTokenCallback(token);
+        }
+    });
     return session.history.messages();
 };
 exports.slashGPTAgent = slashGPTAgent;

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

@@ -1,11 +1,11 @@
 import { AgentFunction } from "../../graphai";
-export declare const dotProductAgent: AgentFunction<Record<never, never>, Array<number>, Array<Array<number>>>;
+export declare const dotProductAgent: AgentFunction<Record<never, never>, Array<number>, Array<Array<number>> | Array<number>>;
 declare const dotProductAgentInfo: {
     name: string;
-    agent: AgentFunction<Record<never, never>, number[], number[][]>;
-    mock: AgentFunction<Record<never, never>, number[], number[][]>;
+    agent: AgentFunction<Record<never, never>, number[], number[] | number[][]>;
+    mock: AgentFunction<Record<never, never>, number[], number[] | number[][]>;
     samples: {
-        inputs: number[][][];
+        inputs: (number[] | number[][])[];
         params: {};
         result: number[];
     }[];

package/lib/experimental_agents/matrix_agents/dot_product_agent.js

@@ -5,14 +5,14 @@ exports.dotProductAgent = void 0;
 // typically used to calculate cosine similarity of embedding vectors.
 // Inputs:
 //  inputs[0]: Two dimentional array of numbers.
-//  inputs[1]: Two dimentional array of numbers (but the array size is 1 for the first dimention)
+//  inputs[1]: One dimentional array of numbers.
 // Outputs:
 //  { contents: Array<number> } // array of docProduct of each vector (A[]) and vector B
 const dotProductAgent = async ({ inputs }) => {
     const embeddings = inputs[0];
-    const reference = inputs[1][0];
+    const reference = inputs[1];
     if (embeddings[0].length != reference.length) {
-        throw new Error("dotProduct: Length of vectors do not match.");
+        throw new Error(`dotProduct: Length of vectors do not match. ${embeddings[0].length}, ${reference.length}`);
     }
     const contents = embeddings.map((embedding) => {
         return embedding.reduce((dotProduct, value, index) => {
@@ -34,7 +34,7 @@ const dotProductAgentInfo = {
                     [3, 4],
                     [5, 6],
                 ],
-                [[3, 2]],
+                [3, 2],
             ],
             params: {},
             result: [7, 17, 27],

package/lib/experimental_agents/test_agents/stream_mock_agent.js

@@ -2,11 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.streamMockAgent = void 0;
 const utils_1 = require("../../utils/utils");
-const streamMockAgent = async ({ params }) => {
-    const message = params.message;
+const streamMockAgent = async ({ params, filterParams }) => {
+    const message = params.message || "";
     for await (const token of message.split("")) {
-        if (params.streamCallback) {
-            params.streamCallback(token);
+        if (filterParams.streamTokenCallback) {
+            filterParams.streamTokenCallback(token);
         }
         await (0, utils_1.sleep)(params.sleep || 100);
     }
@@ -19,9 +19,9 @@ const streamMockAgentInfo = {
     agent: exports.streamMockAgent,
     mock: exports.streamMockAgent,
     samples: [],
-    description: "Sstream mock agent",
+    description: "Stream mock agent",
     category: [],
-    author: "xSatoshi Nakajima",
+    author: "Isamu Arimoto",
     repository: "https://github.com/receptron/graphai",
     license: "MIT",
 };

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

@@ -6,6 +6,7 @@ const utils_1 = require("./utils/utils");
 const validator_1 = require("./validator");
 const task_manager_1 = require("./task_manager");
 const defaultConcurrency = 8;
+const latestVersion = 0.3;
 class GraphAI {
     // This method is called when either the GraphAI obect was created,
     // or we are about to start n-th iteration (n>2).
@@ -39,8 +40,7 @@ class GraphAI {
         });
         return nodes;
     }
-    getValueFromResults(key, results) {
-        const source = (0, utils_1.parseNodeName)(key);
+    getValueFromResults(source, results) {
         return (0, utils_1.getDataFromSource)(source.nodeId ? results[source.nodeId] : undefined, source);
     }
     // for static
@@ -58,7 +58,7 @@ class GraphAI {
                 const update = node?.update;
                 if (update && previousResults) {
                     const result = this.getValueFromResults(update, previousResults);
-                    this.injectValue(nodeId, result, update);
+                    this.injectValue(nodeId, result, update.nodeId);
                 }
             }
         });
@@ -67,10 +67,13 @@ class GraphAI {
         this.logs = [];
         this.onLogCallback = (__log, __isUpdate) => { };
         this.repeatCount = 0;
-        if (!data.version) {
-            console.log("------------ no version");
+        if (!data.version && !options.taskManager) {
+            console.log("------------ missing version number");
+        }
+        this.version = data.version ?? latestVersion;
+        if (this.version < latestVersion) {
+            console.log(`------------ upgrade to ${latestVersion}!`);
         }
-        this.version = data.version ?? 0.2;
         this.retryLimit = data.retry; // optional
         this.graphId = URL.createObjectURL(new Blob()).slice(-36);
         this.data = data;
@@ -195,7 +198,8 @@ class GraphAI {
             this.initializeNodes(results);
             // Notice that we need to check the while condition *after* calling initializeNodes.
             if (loop.while) {
-                const value = this.getValueFromResults(loop.while, this.results(true));
+                const source = (0, utils_1.parseNodeName)(loop.while, this.version);
+                const value = this.getValueFromResults(source, this.results(true));
                 // NOTE: We treat an empty array as false.
                 if (Array.isArray(value) ? value.length === 0 : !value) {
                     return false; // while condition is not met

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 filterParams;
     private readonly dynamicParams;
     readonly nestedGraph?: GraphData;
     readonly retryLimit: number;
@@ -49,7 +50,7 @@ export declare class ComputedNode extends Node {
 }
 export declare class StaticNode extends Node {
     value?: ResultData;
-    readonly update?: string;
+    readonly update?: DataSource;
     readonly isResult: boolean;
     readonly isStaticNode = true;
     readonly isComputedNode = false;

package/lib/node.js

@@ -38,6 +38,7 @@ class ComputedNode extends Node {
         this.isComputedNode = true;
         this.graphId = graphId;
         this.params = data.params ?? {};
+        this.filterParams = data.filterParams ?? {};
         this.nestedGraph = data.graph;
         if (typeof data.agent === "string") {
             this.agentId = data.agent;
@@ -54,21 +55,18 @@ 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);
+            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);
         }
-        const regex = /^\$\{([^{}]+)\}$/;
         this.dynamicParams = Object.keys(this.params).reduce((tmp, key) => {
-            const value = this.params[key];
-            const match = typeof value === "string" ? value.match(regex) : null;
-            if (match) {
-                const dataSource = (0, utils_2.parseNodeName)(match[1]);
+            const dataSource = (0, utils_2.parseNodeName)(this.params[key], graph.version < 0.3 ? 0.3 : graph.version);
+            if (dataSource.nodeId) {
+                (0, utils_2.assert)(!this.anyInput, "Dynamic params are not supported with anyInput");
                 tmp[key] = dataSource;
-                (0, utils_2.assert)(!!dataSource.nodeId, `Invalid data source ${key}:${value}`);
                 this.pendings.add(dataSource.nodeId);
             }
             return tmp;
@@ -175,6 +173,9 @@ class ComputedNode extends Node {
             const agentFilter = this.graph.agentFilters[index++];
             if (agentFilter) {
                 if (this.shouldApplyAgentFilter(agentFilter)) {
+                    if (agentFilter.filterParams) {
+                        context.filterParams = { ...agentFilter.filterParams, ...context.filterParams };
+                    }
                     return agentFilter.agent(context, next);
                 }
                 return next(context);
@@ -212,10 +213,11 @@ class ComputedNode extends Node {
                 inputs: previousResults,
                 debugInfo: {
                     nodeId: this.nodeId,
+                    agentId: this.agentId,
                     retry: this.retryCount,
                     verbose: this.graph.verbose,
                 },
-                filterParams: {},
+                filterParams: this.filterParams,
                 log: localLog,
             };
             // NOTE: We use the existence of graph object in the agent-specific params to determine
@@ -282,7 +284,7 @@ class StaticNode extends Node {
         this.isStaticNode = true;
         this.isComputedNode = false;
         this.value = data.value;
-        this.update = data.update;
+        this.update = data.update ? (0, utils_2.parseNodeName)(data.update, graph.version) : undefined;
         this.isResult = data.isResult ?? false;
     }
     injectValue(value, injectFrom) {

package/lib/type.d.ts

@@ -27,11 +27,13 @@ export type StaticNodeData = {
     isResult?: boolean;
 };
 export type AgentNamelessFunction = (...param: any[]) => unknown;
+export type AgentFilterParams = Record<string, any>;
 export type ComputedNodeData = {
     agent: string | AgentNamelessFunction;
     inputs?: Array<any>;
     anyInput?: boolean;
     params?: NodeDataParams;
+    filterParams?: AgentFilterParams;
     retry?: number;
     timeout?: number;
     if?: string;
@@ -59,11 +61,12 @@ export type AgentFunctionContext<ParamsType = DefaultParamsType, InputDataType =
         verbose: boolean;
         nodeId: string;
         retry: number;
+        agentId?: string;
     };
     graphData?: GraphData | string;
     agents?: AgentFunctionDictonary;
     taskManager?: TaskManager;
-    filterParams: Record<string, any>;
+    filterParams: AgentFilterParams;
     log?: TransactionLog[];
 };
 export type AgentFunction<ParamsType = DefaultParamsType, ResultType = DefaultResultData, InputDataType = DefaultInputData> = (context: AgentFunctionContext<ParamsType, InputDataType>) => Promise<ResultData<ResultType>>;
@@ -73,6 +76,7 @@ export type AgentFilterInfo = {
     agent: AgentFilterFunction;
     agentIds?: string[];
     nodeIds?: string[];
+    filterParams?: AgentFilterParams;
 };
 export type AgentFunctionDictonary = Record<string, AgentFunction<any, any, any>>;
 export type AgentFunctionInfo = {

package/lib/utils/test_agents.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.defaultTestAgents = void 0;
 const experimental_agents_1 = require("../experimental_agents");
+const openai_agent_1 = require("../experimental_agents/llm_agents/openai_agent");
 exports.defaultTestAgents = {
     bypassAgent: experimental_agents_1.bypassAgent,
     echoAgent: experimental_agents_1.echoAgent,
@@ -19,4 +20,5 @@ exports.defaultTestAgents = {
     popAgent: experimental_agents_1.popAgent,
     shiftAgent: experimental_agents_1.shiftAgent,
     streamMockAgent: experimental_agents_1.streamMockAgent,
+    openAIMockAgent: openai_agent_1.openAIMockAgent,
 };

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/agent_validator.js

@@ -4,7 +4,7 @@ exports.agentValidator = void 0;
 const agentValidator = (graphAgentIds, agentIds) => {
     graphAgentIds.forEach((agentId) => {
         if (!agentIds.has(agentId)) {
-            throw new Error("Invalid AgentId : " + agentId + " is not in callbackDictonary.");
+            throw new Error("Invalid Agent : " + agentId + " is not in callbackDictonary.");
         }
     });
     return true;

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", "if"];
+exports.computedNodeAttributeKeys = ["inputs", "anyInput", "params", "retry", "timeout", "agent", "graph", "isResult", "priority", "if", "filterParams"];
 exports.staticNodeAttributeKeys = ["value", "update", "isResult"];

package/lib/validators/nodeValidator.js

@@ -3,10 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.nodeValidator = void 0;
 const nodeValidator = (nodeData) => {
     if (nodeData.agent && nodeData.value) {
-        throw new Error("Cannot set both agentId and value");
+        throw new Error("Cannot set both agent and value");
     }
     if (!("agent" in nodeData) && !("value" in nodeData)) {
-        throw new Error("Either agentId or value is required");
+        throw new Error("Either agent or value is required");
     }
     return true;
 };

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "graphai",
-  "version": "0.2.8",
+  "version": "0.3.1",
   "description": "Asynchronous data flow execution engine for agentic AI apps.",
   "main": "lib/index.js",
   "files": [
@@ -28,12 +28,14 @@
   "homepage": "https://github.com/receptron/graphai#readme",
   "devDependencies": {
     "@inquirer/prompts": "^5.0.0",
+    "@types/cors": "^2.8.17",
     "@types/express": "^4.17.21",
     "@types/node": "^20.8.7",
     "@types/xml2js": "^0.4.14",
     "@typescript-eslint/eslint-plugin": "^6.8.0",
     "@typescript-eslint/parser": "^6.8.0",
     "arxiv-api-ts": "^1.0.3",
+    "cors": "^2.8.5",
     "deepmerge": "^4.3.1",
     "dotenv": "^16.4.5",
     "eslint": "^7.32.0 || ^8.2.0",
@@ -42,7 +44,7 @@
     "groq-sdk": "^0.3.3",
     "openai": "^4.12.4",
     "prettier": "^3.0.3",
-    "slashgpt": "^0.0.8",
+    "slashgpt": "^0.0.9",
     "tiktoken": "^1.0.14",
     "ts-node": "^10.9.1",
     "tsc-alias": "^1.8.8",