graphai 0.3.0 → 0.3.1

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/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.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,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,12 +67,12 @@ 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 ?? 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);
@@ -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;

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;
@@ -64,6 +65,7 @@ class ComputedNode extends Node {
         this.dynamicParams = Object.keys(this.params).reduce((tmp, key) => {
             const dataSource = (0, utils_2.parseNodeName)(this.params[key], graph.version < 0.3 ? 0.3 : graph.version);
             if (dataSource.nodeId) {
+                (0, utils_2.assert)(!this.anyInput, "Dynamic params are not supported with anyInput");
                 tmp[key] = dataSource;
                 this.pendings.add(dataSource.nodeId);
             }
@@ -171,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);
@@ -208,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
@@ -278,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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "graphai",
-  "version": "0.3.0",
+  "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",