graphai 0.5.3 → 0.5.4

package/lib/graphai.d.ts

@@ -46,6 +46,7 @@ export declare class GraphAI {
     updateLog(log: TransactionLog): void;
     transactionLogs(): TransactionLog[];
     injectValue(nodeId: string, value: ResultData, injectFrom?: string): void;
-    resultsOf(sources: Array<DataSource>): ResultData[];
+    resultsOf(sources: Record<string, DataSource | DataSource[]>): Record<string, ResultData>;
+    resultOf(source: DataSource): ResultData;
 }
 export {};

package/lib/graphai.js

@@ -253,10 +253,23 @@ class GraphAI {
         }
     }
     resultsOf(sources) {
-        return sources.map((source) => {
-            const { result } = source.nodeId ? this.nodes[source.nodeId] : { result: undefined };
-            return (0, utils_1.getDataFromSource)(result, source);
+        const ret = {};
+        Object.keys(sources).forEach((key) => {
+            const source = sources[key];
+            if (Array.isArray(source)) {
+                ret[key] = source.map((s) => {
+                    return this.resultOf(s);
+                });
+            }
+            else {
+                ret[key] = this.resultOf(source);
+            }
         });
+        return ret;
+    }
+    resultOf(source) {
+        const { result } = source.nodeId ? this.nodes[source.nodeId] : { result: undefined };
+        return (0, utils_1.getDataFromSource)(result, source);
     }
 }
 exports.GraphAI = GraphAI;

package/lib/node.d.ts

@@ -28,7 +28,8 @@ export declare class ComputedNode extends Node {
     error?: Error;
     transactionId: undefined | number;
     readonly anyInput: boolean;
-    dataSources: Array<DataSource>;
+    dataSources: Record<string, DataSource | DataSource[]>;
+    private inputs?;
     inputNames?: Array<string>;
     pendings: Set<string>;
     private ifSource?;
@@ -38,6 +39,7 @@ export declare class ComputedNode extends Node {
     readonly isComputedNode = true;
     constructor(graphId: string, nodeId: string, data: ComputedNodeData, graph: GraphAI);
     getAgentId(): string;
+    private addPengindNode;
     isReadyNode(): boolean;
     private retry;
     private checkDataAvailability;
@@ -50,6 +52,9 @@ export declare class ComputedNode extends Node {
     execute(): Promise<void>;
     private prepareExecute;
     private errorProcess;
+    private getNamedInput;
+    private getInputs;
+    private getDebugInfo;
 }
 export declare class StaticNode extends Node {
     value?: ResultData;

package/lib/node.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StaticNode = exports.ComputedNode = exports.Node = void 0;
 const utils_1 = require("./utils/utils");
+const nodeUtils_1 = require("./utils/nodeUtils");
 const type_1 = require("./type");
 const utils_2 = require("./utils/utils");
 const transaction_log_1 = require("./transaction_log");
@@ -34,6 +35,7 @@ class ComputedNode extends Node {
     constructor(graphId, nodeId, data, graph) {
         super(nodeId, graph);
         this.retryCount = 0;
+        this.dataSources = {}; // data sources.
         this.isStaticNode = false;
         this.isComputedNode = true;
         this.graphId = graphId;
@@ -45,19 +47,20 @@ class ComputedNode extends Node {
         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));
+        if (data.inputs) {
+            if (Array.isArray(data.inputs)) {
+                this.inputs = data.inputs;
+                this.dataSources = (0, nodeUtils_1.inputs2dataSources)(data.inputs, graph.version);
+            }
+            else {
+                this.inputNames = Object.keys(data.inputs);
+                this.dataSources = (0, nodeUtils_1.namedInputs2dataSources)(data.inputs, graph.version);
+            }
         }
-        this.pendings = new Set(this.dataSources.filter((source) => source.nodeId).map((source) => source.nodeId));
+        this.pendings = new Set(Object.values(this.dataSources)
+            .flat()
+            .filter((source) => source.nodeId)
+            .map((source) => source.nodeId));
         if (typeof data.agent === "string") {
             this.agentId = data.agent;
         }
@@ -76,23 +79,16 @@ class ComputedNode extends Node {
             }
         }
         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}`);
-            this.pendings.add(source.nodeId);
-            this.nestedGraph = source;
+            this.nestedGraph = this.addPengindNode(data.graph);
         }
         else if (data.graph) {
             this.nestedGraph = data.graph;
         }
         if (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);
+            this.ifSource = this.addPengindNode(data.if);
         }
         if (data.unless) {
-            this.unlessSource = (0, utils_2.parseNodeName)(data.unless, graph.version);
-            (0, utils_2.assert)(!!this.unlessSource.nodeId, `Invalid data source ${data.unless}`);
-            this.pendings.add(this.unlessSource.nodeId);
+            this.unlessSource = this.addPengindNode(data.unless);
         }
         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);
@@ -108,36 +104,29 @@ class ComputedNode extends Node {
     getAgentId() {
         return this.agentId ?? "__custom__function"; // only for display purpose in the log.
     }
+    addPengindNode(nodeId) {
+        const source = (0, utils_2.parseNodeName)(nodeId, this.graph.version);
+        (0, utils_2.assert)(!!source.nodeId, `Invalid data source ${nodeId}`);
+        this.pendings.add(source.nodeId);
+        return source;
+    }
     isReadyNode() {
-        if (this.state === type_1.NodeState.Waiting && this.pendings.size === 0) {
-            // Count the number of data actually available.
-            // We care it only when this.anyInput is true.
-            // Notice that this logic enables dynamic data-flows.
-            const counter = this.dataSources.reduce((count, source) => {
-                const [result] = this.graph.resultsOf([source]);
-                return result === undefined ? count : count + 1;
-            }, 0);
-            if (!this.anyInput || counter > 0) {
-                if (this.ifSource) {
-                    const [condition] = this.graph.resultsOf([this.ifSource]);
-                    if (!(0, utils_2.isLogicallyTrue)(condition)) {
-                        this.state = type_1.NodeState.Skipped;
-                        this.log.onSkipped(this, this.graph);
-                        return false;
-                    }
-                }
-                if (this.unlessSource) {
-                    const [condition] = this.graph.resultsOf([this.unlessSource]);
-                    if ((0, utils_2.isLogicallyTrue)(condition)) {
-                        this.state = type_1.NodeState.Skipped;
-                        this.log.onSkipped(this, this.graph);
-                        return false;
-                    }
-                }
-                return true;
-            }
+        if (this.state !== type_1.NodeState.Waiting || this.pendings.size !== 0) {
+            return false;
+        }
+        // Count the number of data actually available.
+        // We care it only when this.anyInput is true.
+        // Notice that this logic enables dynamic data-flows.
+        if (this.anyInput && !this.checkDataAvailability(false)) {
+            return false;
         }
-        return false;
+        if ((this.ifSource && !(0, utils_2.isLogicallyTrue)(this.graph.resultOf(this.ifSource))) ||
+            (this.unlessSource && (0, utils_2.isLogicallyTrue)(this.graph.resultOf(this.unlessSource)))) {
+            this.state = type_1.NodeState.Skipped;
+            this.log.onSkipped(this, this.graph);
+            return false;
+        }
+        return true;
     }
     // This private method (only called while executing execute()) performs
     // the "retry" if specified. The transaction log must be updated before
@@ -156,12 +145,13 @@ class ComputedNode extends Node {
             this.graph.onExecutionComplete(this);
         }
     }
-    checkDataAvailability() {
-        (0, utils_2.assert)(this.anyInput, "checkDataAvailability should be called only for anyInput case");
-        const results = this.graph.resultsOf(this.dataSources).filter((result) => {
-            return result !== undefined;
-        });
-        return results.length > 0;
+    checkDataAvailability(checkAnyInput = true) {
+        if (checkAnyInput) {
+            (0, utils_2.assert)(this.anyInput, "checkDataAvailability should be called only for anyInput case");
+        }
+        return Object.values(this.graph.resultsOf(this.dataSources))
+            .flat()
+            .some((result) => result !== undefined);
     }
     // This method is called right before the Graph add this node to the task manager.
     beforeAddTask() {
@@ -228,12 +218,9 @@ class ComputedNode extends Node {
     // then it removes itself from the "running node" list of the graph.
     // Notice that setting the result of this node may make other nodes ready to run.
     async execute() {
-        const previousResults = this.graph.resultsOf(this.dataSources).filter((result) => {
-            // Remove undefined if anyInput flag is set.
-            return !this.anyInput || result !== undefined;
-        });
+        const previousResults = this.graph.resultsOf(this.dataSources);
         const transactionId = Date.now();
-        this.prepareExecute(transactionId, previousResults);
+        this.prepareExecute(transactionId, Object.values(previousResults));
         if (this.timeout && this.timeout > 0) {
             setTimeout(() => {
                 this.executeTimeout(transactionId);
@@ -243,34 +230,21 @@ class ComputedNode extends Node {
             const agentFunction = this.agentFunction ?? this.graph.getAgentFunctionInfo(this.agentId).agent;
             const localLog = [];
             const params = Object.keys(this.dynamicParams).reduce((tmp, key) => {
-                const [result] = this.graph.resultsOf([this.dynamicParams[key]]);
+                const result = this.graph.resultOf(this.dynamicParams[key]);
                 tmp[key] = result;
                 return tmp;
             }, { ...this.params });
             const context = {
                 params: params,
-                inputs: previousResults,
+                inputs: this.getInputs(previousResults),
+                namedInputs: this.getNamedInput(previousResults),
                 inputSchema: this.agentFunction ? undefined : this.graph.getAgentFunctionInfo(this.agentId)?.inputs,
-                namedInputs: {},
-                debugInfo: {
-                    nodeId: this.nodeId,
-                    agentId: this.agentId,
-                    retry: this.retryCount,
-                    verbose: this.graph.verbose,
-                    version: this.graph.version,
-                },
+                debugInfo: this.getDebugInfo(),
                 filterParams: this.filterParams,
                 agentFilters: this.graph.agentFilters,
                 config: this.graph.config,
                 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) {
@@ -280,7 +254,7 @@ class ComputedNode extends Node {
                     context.graphData = this.nestedGraph;
                 }
                 else {
-                    const [graphData] = this.graph.resultsOf([this.nestedGraph]);
+                    const graphData = this.graph.resultOf(this.nestedGraph);
                     context.graphData = graphData; // HACK: compiler work-around
                 }
                 context.agents = this.graph.agentFunctionInfoDictionary;
@@ -339,6 +313,32 @@ class ComputedNode extends Node {
             this.retry(type_1.NodeState.Failed, Error("Unknown"));
         }
     }
+    getNamedInput(previousResults) {
+        if (this.inputNames) {
+            return this.inputNames.reduce((tmp, name) => {
+                if (!this.anyInput || previousResults[name]) {
+                    tmp[name] = previousResults[name];
+                }
+                return tmp;
+            }, {});
+        }
+        return {};
+    }
+    getInputs(previousResults) {
+        if (this.inputNames) {
+            return [];
+        }
+        return (this.inputs ?? []).map((key) => previousResults[String(key)]).filter(a => !this.anyInput || a);
+    }
+    getDebugInfo() {
+        return {
+            nodeId: this.nodeId,
+            agentId: this.agentId,
+            retry: this.retryCount,
+            verbose: this.graph.verbose,
+            version: this.graph.version,
+        };
+    }
 }
 exports.ComputedNode = ComputedNode;
 class StaticNode extends Node {

package/lib/transaction_log.js

@@ -43,7 +43,10 @@ class TransactionLog {
         this.state = node.state;
         this.retryCount = node.retryCount > 0 ? node.retryCount : undefined;
         this.startTime = transactionId;
-        this.inputs = node.dataSources.filter((source) => source.nodeId).map((source) => source.nodeId);
+        this.inputs = Object.values(node.dataSources)
+            .flat()
+            .filter((source) => source.nodeId)
+            .map((source) => source.nodeId);
         this.inputsData = inputs.length > 0 ? inputs : undefined;
         graph.setLoopLog(this);
         graph.appendLog(this);

package/lib/utils/nodeUtils.d.ts

@@ -0,0 +1,3 @@
+import { DataSource } from "../type";
+export declare const inputs2dataSources: (inputs: string[], graphVersion: number) => Record<string, DataSource>;
+export declare const namedInputs2dataSources: (inputs: Record<string, any>, graphVersion: number) => Record<string, DataSource | DataSource[]>;

package/lib/utils/nodeUtils.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.namedInputs2dataSources = exports.inputs2dataSources = void 0;
+const utils_1 = require("./utils");
+const inputs2dataSources = (inputs, graphVersion) => {
+    return inputs.reduce((tmp, input) => {
+        tmp[input] = (0, utils_1.parseNodeName)(input, graphVersion);
+        return tmp;
+    }, {});
+};
+exports.inputs2dataSources = inputs2dataSources;
+const namedInputs2dataSources = (inputs, graphVersion) => {
+    return Object.keys(inputs).reduce((tmp, key) => {
+        const input = inputs[key];
+        if (Array.isArray(input)) {
+            tmp[key] = input.map((inp) => (0, utils_1.parseNodeName)(inp, graphVersion));
+        }
+        else {
+            tmp[key] = (0, utils_1.parseNodeName)(input, graphVersion);
+        }
+        return tmp;
+    }, {});
+};
+exports.namedInputs2dataSources = namedInputs2dataSources;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "graphai",
-  "version": "0.5.3",
+  "version": "0.5.4",
   "description": "Asynchronous data flow execution engine for agentic AI apps.",
   "main": "lib/index.js",
   "files": [