graphai 0.4.7 → 0.5.0

package/README.md

@@ -379,10 +379,4 @@ Since the task executing the nested graph will be in "running" state while tasks
 
 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.
 
-Negative priority values are allowed, enabling you to fine-tune the execution order based on your application's requirements.
-
-## References
-
-- [Collaboration](./Collaboration.md)
-- [Sample Graphs](./samples/README.md)
-- [API Document](./APIDocument.md)
+Negative priority values are allowed, enabling you to fine-tune the execution order based on your application's requirements.

package/lib/index.d.ts

@@ -2,5 +2,5 @@ export { GraphAI } from "./graphai";
 export { AgentFunction, AgentFunctionInfo, AgentFunctionInfoDictionary, AgentFunctionContext, GraphData, ResultDataDictionary, ResultData, NodeState, AgentFilterFunction, AgentFilterInfo, NodeData, StaticNodeData, ComputedNodeData, DefaultResultData, DefaultInputData, } from "./type";
 export type { TransactionLog } from "./transaction_log";
 export { agentFilterRunnerBuilder } from "./utils/runner";
-export { defaultAgentInfo, agentInfoWrapper, defaultTestContext, strIntentionalError } from "./utils/utils";
+export { defaultAgentInfo, agentInfoWrapper, defaultTestContext, strIntentionalError, assert, sleep } from "./utils/utils";
 export { ValidationError } from "./validators/common";

package/lib/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValidationError = exports.strIntentionalError = exports.defaultTestContext = exports.agentInfoWrapper = exports.defaultAgentInfo = exports.agentFilterRunnerBuilder = exports.NodeState = exports.GraphAI = void 0;
+exports.ValidationError = exports.sleep = exports.assert = exports.strIntentionalError = exports.defaultTestContext = exports.agentInfoWrapper = exports.defaultAgentInfo = exports.agentFilterRunnerBuilder = exports.NodeState = exports.GraphAI = void 0;
 var graphai_1 = require("./graphai");
 Object.defineProperty(exports, "GraphAI", { enumerable: true, get: function () { return graphai_1.GraphAI; } });
 var type_1 = require("./type");
@@ -12,5 +12,7 @@ Object.defineProperty(exports, "defaultAgentInfo", { enumerable: true, get: func
 Object.defineProperty(exports, "agentInfoWrapper", { enumerable: true, get: function () { return utils_1.agentInfoWrapper; } });
 Object.defineProperty(exports, "defaultTestContext", { enumerable: true, get: function () { return utils_1.defaultTestContext; } });
 Object.defineProperty(exports, "strIntentionalError", { enumerable: true, get: function () { return utils_1.strIntentionalError; } });
+Object.defineProperty(exports, "assert", { enumerable: true, get: function () { return utils_1.assert; } });
+Object.defineProperty(exports, "sleep", { enumerable: true, get: function () { return utils_1.sleep; } });
 var common_1 = require("./validators/common");
 Object.defineProperty(exports, "ValidationError", { enumerable: true, get: function () { return common_1.ValidationError; } });

package/lib/node.d.ts

@@ -29,6 +29,7 @@ export declare class ComputedNode extends Node {
     transactionId: undefined | number;
     readonly anyInput: boolean;
     dataSources: Array<DataSource>;
+    inputNames?: Array<string>;
     pendings: Set<string>;
     private ifSource?;
     private unlessSource?;

package/lib/node.js

@@ -40,23 +40,41 @@ class ComputedNode extends Node {
         this.params = data.params ?? {};
         this.console = data.console ?? {};
         this.filterParams = data.filterParams ?? {};
+        this.retryLimit = data.retry ?? graph.retryLimit ?? 0;
+        this.timeout = data.timeout;
+        this.isResult = data.isResult ?? false;
+        this.priority = data.priority ?? 0;
+        this.anyInput = data.anyInput ?? false;
+        if (!data.inputs) {
+            this.dataSources = [];
+        }
+        else if (Array.isArray(data.inputs)) {
+            this.dataSources = (data.inputs ?? []).map((input) => (0, utils_2.parseNodeName)(input, graph.version));
+        }
+        else {
+            const inputs = data.inputs;
+            const keys = Object.keys(inputs);
+            this.inputNames = keys;
+            this.dataSources = keys.map((key) => (0, utils_2.parseNodeName)(inputs[key], graph.version));
+        }
+        this.pendings = new Set(this.dataSources.filter((source) => source.nodeId).map((source) => source.nodeId));
         if (typeof data.agent === "string") {
             this.agentId = data.agent;
         }
         else {
             (0, utils_2.assert)(typeof data.agent === "function", "agent must be either string or function");
             const agent = data.agent;
-            this.agentFunction = async ({ inputs }) => {
-                return agent(...inputs);
-            };
+            if (this.inputNames) {
+                this.agentFunction = async ({ namedInputs }) => {
+                    return agent(namedInputs);
+                };
+            }
+            else {
+                this.agentFunction = async ({ inputs }) => {
+                    return agent(...inputs);
+                };
+            }
         }
-        this.retryLimit = data.retry ?? graph.retryLimit ?? 0;
-        this.timeout = data.timeout;
-        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, graph.version));
-        this.pendings = new Set(this.dataSources.filter((source) => source.nodeId).map((source) => source.nodeId));
         if (typeof data.graph === "string") {
             const source = (0, utils_2.parseNodeName)(data.graph, graph.version);
             (0, utils_2.assert)(!!source.nodeId, `Invalid data source ${data.graph}`);
@@ -232,6 +250,7 @@ class ComputedNode extends Node {
             const context = {
                 params: params,
                 inputs: previousResults,
+                namedInputs: {},
                 debugInfo: {
                     nodeId: this.nodeId,
                     agentId: this.agentId,
@@ -242,6 +261,13 @@ class ComputedNode extends Node {
                 agentFilters: this.graph.agentFilters,
                 log: localLog,
             };
+            if (this.inputNames) {
+                context.namedInputs = this.inputNames.reduce((tmp, name, index) => {
+                    tmp[name] = previousResults[index];
+                    return tmp;
+                }, {});
+                context.inputs = [];
+            }
             // NOTE: We use the existence of graph object in the agent-specific params to determine
             // if this is a nested agent or not.
             if (this.nestedGraph) {

package/lib/type.d.ts

@@ -30,7 +30,7 @@ export type AgentAnonymousFunction = (...params: any[]) => unknown;
 export type AgentFilterParams = Record<string, any>;
 export type ComputedNodeData = {
     agent: string | AgentAnonymousFunction;
-    inputs?: Array<any>;
+    inputs?: Array<any> | Record<string, any>;
     anyInput?: boolean;
     params?: NodeDataParams;
     filterParams?: AgentFilterParams;
@@ -64,6 +64,7 @@ export type GraphOptions = {
 export type AgentFunctionContext<ParamsType = DefaultParamsType, InputDataType = DefaultInputData> = {
     params: NodeDataParams<ParamsType>;
     inputs: Array<InputDataType>;
+    namedInputs: Record<string, any>;
     debugInfo: {
         verbose: boolean;
         nodeId: string;
@@ -90,6 +91,8 @@ export type AgentFunctionInfo = {
     name: string;
     agent: AgentFunction<any, any, any>;
     mock: AgentFunction<any, any, any>;
+    inputs?: any;
+    output?: any;
     samples: {
         inputs: any;
         params: DefaultParamsType;

package/lib/validators/relation_validator.js

@@ -12,17 +12,34 @@ const relationValidator = (data, staticNodeIds, computedNodeIds) => {
         const nodeData = data.nodes[computedNodeId];
         pendings[computedNodeId] = new Set();
         if ("inputs" in nodeData && nodeData && nodeData.inputs) {
-            nodeData.inputs.forEach((inputNodeId) => {
-                const sourceNodeId = (0, utils_1.parseNodeName)(inputNodeId, data.version ?? 0.02).nodeId;
-                if (sourceNodeId) {
-                    if (!nodeIds.has(sourceNodeId)) {
-                        throw new common_1.ValidationError(`Inputs not match: NodeId ${computedNodeId}, Inputs: ${sourceNodeId}`);
+            if (Array.isArray(nodeData.inputs)) {
+                nodeData.inputs.forEach((inputNodeId) => {
+                    const sourceNodeId = (0, utils_1.parseNodeName)(inputNodeId, data.version ?? 0.02).nodeId;
+                    if (sourceNodeId) {
+                        if (!nodeIds.has(sourceNodeId)) {
+                            throw new common_1.ValidationError(`Inputs not match: NodeId ${computedNodeId}, Inputs: ${sourceNodeId}`);
+                        }
+                        waitlist[sourceNodeId] === undefined && (waitlist[sourceNodeId] = new Set());
+                        pendings[computedNodeId].add(sourceNodeId);
+                        waitlist[sourceNodeId].add(computedNodeId);
                     }
-                    waitlist[sourceNodeId] === undefined && (waitlist[sourceNodeId] = new Set());
-                    pendings[computedNodeId].add(sourceNodeId);
-                    waitlist[sourceNodeId].add(computedNodeId);
-                }
-            });
+                });
+            }
+            else {
+                const keys = Object.keys(nodeData.inputs);
+                keys.forEach((key) => {
+                    const inputNodeId = nodeData.inputs[key];
+                    const sourceNodeId = (0, utils_1.parseNodeName)(inputNodeId, data.version ?? 0.3).nodeId;
+                    if (sourceNodeId) {
+                        if (!nodeIds.has(sourceNodeId)) {
+                            throw new common_1.ValidationError(`Inputs not match: NodeId ${computedNodeId}, Inputs: ${sourceNodeId}`);
+                        }
+                        waitlist[sourceNodeId] === undefined && (waitlist[sourceNodeId] = new Set());
+                        pendings[computedNodeId].add(sourceNodeId);
+                        waitlist[sourceNodeId].add(computedNodeId);
+                    }
+                });
+            }
         }
     });
     // TODO. validate update

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "graphai",
-  "version": "0.4.7",
+  "version": "0.5.0",
   "description": "Asynchronous data flow execution engine for agentic AI apps.",
   "main": "lib/index.js",
   "files": [
@@ -9,8 +9,9 @@
   "scripts": {
     "build": "rm -r lib/* && tsc && tsc-alias",
     "eslint": "eslint",
+    "rollup": "npx rollup -c",
     "doc": " npx typedoc src/index.ts --out ../../docs/apiDoc",
-    "format": "prettier --write '{src,tests,samples}/**/*.ts'",
+    "format": "prettier --write '{src,tests,samples}/**/*.ts' *.mjs",
     "test": "node --test  -r tsconfig-paths/register --require ts-node/register ./tests/**/test_*.ts",
     "b": "yarn run format && yarn run eslint && yarn run build"
   },