graphai 0.3.0 → 0.3.2

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

@@ -0,0 +1,58 @@
+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;
+        };
+    }[];
+    skipTest: boolean;
+    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,87 @@
+"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,
+        },
+    ],
+    skipTest: true,
+    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/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/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,11 +34,22 @@ const dotProductAgentInfo = {
                     [3, 4],
                     [5, 6],
                 ],
-                [[3, 2]],
+                [3, 2],
             ],
             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/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/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

@@ -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, this.version);
+    getValueFromResults(source, results) {
         return (0, utils_1.getDataFromSource)(source.nodeId ? results[source.nodeId] : undefined, source);
     }
     // for static
@@ -58,26 +58,26 @@ 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);
                 }
             }
         });
     }
-    constructor(data, callbackDictonary, options = { taskManager: undefined, agentFilters: [] }) {
+    constructor(data, agentFunctionDictionary, options = { taskManager: undefined, agentFilters: [] }) {
         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 ?? 0.2;
-        if (this.version < 0.3) {
-            console.log("------------ upgrade to 0.3!");
+        this.version = data.version ?? latestVersion;
+        if (this.version < latestVersion) {
+            console.log(`------------ upgrade to ${latestVersion}!`);
         }
         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);
     }
@@ -198,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;