graphai 0.5.5 → 0.5.7

package/lib/graphai.d.ts

@@ -1,4 +1,4 @@
-import { AgentFunctionInfoDictionary, AgentFilterInfo, GraphData, DataSource, ResultDataDictionary, ResultData, DefaultResultData, GraphOptions } from "./type";
+import { AgentFunctionInfoDictionary, AgentFilterInfo, GraphData, DataSource, ResultDataDictionary, ResultData, DefaultResultData, GraphOptions, NestedDataSource } from "./type";
 import { TransactionLog } from "./transaction_log";
 import { ComputedNode, StaticNode } from "./node";
 import { TaskManager } from "./task_manager";
@@ -46,7 +46,8 @@ export declare class GraphAI {
     updateLog(log: TransactionLog): void;
     transactionLogs(): TransactionLog[];
     injectValue(nodeId: string, value: ResultData, injectFrom?: string): void;
-    resultsOf(sources: Record<string, DataSource | DataSource[]>): Record<string, ResultData>;
+    private nestedResultOf;
+    resultsOf(sources: NestedDataSource): Record<string, ResultData>;
     resultOf(source: DataSource): ResultData;
 }
 export {};

package/lib/graphai.js

@@ -252,18 +252,18 @@ class GraphAI {
             throw new Error(`injectValue with Invalid nodeId, ${nodeId}`);
         }
     }
+    nestedResultOf(source) {
+        if (Array.isArray(source)) {
+            return source.map((a) => {
+                return this.nestedResultOf(a);
+            });
+        }
+        return this.resultOf(source);
+    }
     resultsOf(sources) {
         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);
-            }
+            ret[key] = this.nestedResultOf(sources[key]);
         });
         return ret;
     }

package/lib/node.d.ts

@@ -1,5 +1,5 @@
 import type { GraphAI, GraphData } from "./index";
-import { NodeDataParams, ResultData, DataSource, ComputedNodeData, StaticNodeData, NodeState } from "./type";
+import { NodeDataParams, ResultData, DataSource, ComputedNodeData, StaticNodeData, NodeState, NestedDataSource } from "./type";
 import { TransactionLog } from "./transaction_log";
 export declare class Node {
     readonly nodeId: string;
@@ -27,8 +27,9 @@ export declare class ComputedNode extends Node {
     readonly priority: number;
     error?: Error;
     transactionId: undefined | number;
+    private readonly passThrough?;
     readonly anyInput: boolean;
-    dataSources: Record<string, DataSource | DataSource[]>;
+    dataSources: NestedDataSource;
     private inputs?;
     inputNames?: Array<string>;
     pendings: Set<string>;
@@ -55,6 +56,8 @@ export declare class ComputedNode extends Node {
     private getNamedInput;
     private getInputs;
     private getDebugInfo;
+    private beforeConsoleLog;
+    private afterConsoleLog;
 }
 export declare class StaticNode extends Node {
     value?: ResultData;

package/lib/node.js

@@ -42,6 +42,7 @@ class ComputedNode extends Node {
         this.params = data.params ?? {};
         this.console = data.console ?? {};
         this.filterParams = data.filterParams ?? {};
+        this.passThrough = data.passThrough;
         this.retryLimit = data.retry ?? graph.retryLimit ?? 0;
         this.timeout = data.timeout;
         this.isResult = data.isResult ?? false;
@@ -57,32 +58,17 @@ class ComputedNode extends Node {
                 this.dataSources = (0, nodeUtils_1.namedInputs2dataSources)(data.inputs, graph.version);
             }
         }
-        this.pendings = new Set(Object.values(this.dataSources)
-            .flat()
-            .filter((source) => source.nodeId)
-            .map((source) => source.nodeId));
+        this.pendings = new Set((0, nodeUtils_1.flatDataSourceNodeIds)(Object.values(this.dataSources)));
+        (0, utils_2.assert)(["function", "string"].includes(typeof data.agent), "agent must be either string or function");
         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;
-            if (this.inputNames) {
-                this.agentFunction = async ({ namedInputs }) => {
-                    return agent(namedInputs);
-                };
-            }
-            else {
-                this.agentFunction = async ({ inputs }) => {
-                    return agent(...inputs);
-                };
-            }
-        }
-        if (typeof data.graph === "string") {
-            this.nestedGraph = this.addPengindNode(data.graph);
+            this.agentFunction = this.inputNames ? async ({ namedInputs }) => agent(namedInputs) : async ({ inputs }) => agent(...inputs);
         }
-        else if (data.graph) {
-            this.nestedGraph = data.graph;
+        if (data.graph) {
+            this.nestedGraph = typeof data.graph === "string" ? this.addPengindNode(data.graph) : data.graph;
         }
         if (data.if) {
             this.ifSource = this.addPengindNode(data.if);
@@ -114,12 +100,6 @@ class ComputedNode extends Node {
         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;
-        }
         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;
@@ -145,10 +125,7 @@ class ComputedNode extends Node {
             this.graph.onExecutionComplete(this);
         }
     }
-    checkDataAvailability(checkAnyInput = true) {
-        if (checkAnyInput) {
-            (0, utils_2.assert)(this.anyInput, "checkDataAvailability should be called only for anyInput case");
-        }
+    checkDataAvailability() {
         return Object.values(this.graph.resultsOf(this.dataSources))
             .flat()
             .some((result) => result !== undefined);
@@ -254,18 +231,13 @@ class ComputedNode extends Node {
                     context.graphData = this.nestedGraph;
                 }
                 else {
-                    const graphData = this.graph.resultOf(this.nestedGraph);
-                    context.graphData = graphData; // HACK: compiler work-around
+                    context.graphData = this.graph.resultOf(this.nestedGraph); // HACK: compiler work-around
                 }
                 context.agents = this.graph.agentFunctionInfoDictionary;
             }
-            if (this.console.before) {
-                console.log(this.console.before === true ? JSON.stringify(this.inputNames ? context.namedInputs : context.inputs, null, 2) : this.console.before);
-            }
+            this.beforeConsoleLog(context);
             const result = await this.agentFilterHandler(context, agentFunction);
-            if (this.console.after) {
-                console.log(this.console.after === true ? (typeof result === "string" ? result : JSON.stringify(result, null, 2)) : this.console.after);
-            }
+            this.afterConsoleLog(result);
             if (this.nestedGraph) {
                 this.graph.taskManager.restoreAfterNesting();
             }
@@ -276,7 +248,17 @@ class ComputedNode extends Node {
                 return;
             }
             this.state = type_1.NodeState.Completed;
-            this.result = result;
+            this.result = (() => {
+                if (result && this.passThrough) {
+                    if ((0, utils_2.isObject)(result) && !Array.isArray(result)) {
+                        return { ...result, ...this.passThrough };
+                    }
+                    else if (Array.isArray(result)) {
+                        return result.map((r) => ((0, utils_2.isObject)(r) && !Array.isArray(r) ? { ...r, ...this.passThrough } : r));
+                    }
+                }
+                return result;
+            })();
             this.log.onComplete(this, this.graph, localLog);
             this.onSetResult();
             this.graph.onExecutionComplete(this);
@@ -337,8 +319,25 @@ class ComputedNode extends Node {
             retry: this.retryCount,
             verbose: this.graph.verbose,
             version: this.graph.version,
+            isResult: this.isResult,
         };
     }
+    beforeConsoleLog(context) {
+        if (this.console.before === true) {
+            console.log(JSON.stringify(this.inputNames ? context.namedInputs : context.inputs, null, 2));
+        }
+        else if (this.console.before) {
+            console.log(this.console.before);
+        }
+    }
+    afterConsoleLog(result) {
+        if (this.console.after === true) {
+            console.log(typeof result === "string" ? result : JSON.stringify(result, null, 2));
+        }
+        else if (this.console.after) {
+            console.log(this.console.after);
+        }
+    }
 }
 exports.ComputedNode = ComputedNode;
 class StaticNode extends Node {

package/lib/transaction_log.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TransactionLog = void 0;
 const type_1 = require("./type");
 const utils_1 = require("./utils/utils");
+const nodeUtils_1 = require("./utils/nodeUtils");
 class TransactionLog {
     constructor(nodeId) {
         this.nodeId = nodeId;
@@ -43,10 +44,7 @@ class TransactionLog {
         this.state = node.state;
         this.retryCount = node.retryCount > 0 ? node.retryCount : undefined;
         this.startTime = transactionId;
-        this.inputs = Object.values(node.dataSources)
-            .flat()
-            .filter((source) => source.nodeId)
-            .map((source) => source.nodeId);
+        this.inputs = (0, nodeUtils_1.flatDataSourceNodeIds)(Object.values(node.dataSources));
         this.inputsData = inputs.length > 0 ? inputs : undefined;
         graph.setLoopLog(this);
         graph.appendLog(this);

package/lib/type.d.ts

@@ -17,11 +17,15 @@ export type ResultData<ResultType = DefaultResultData> = ResultType | undefined;
 export type ResultDataDictionary<ResultType = DefaultResultData> = Record<string, ResultData<ResultType>>;
 export type DefaultParamsType = Record<string, any>;
 export type NodeDataParams<ParamsType = DefaultParamsType> = ParamsType;
+export type PassThrough = Record<string, any>;
 export type DataSource = {
     nodeId?: string;
     value?: any;
     propIds?: string[];
 };
+export type DataSources = DataSource | DataSource[] | DataSources[];
+export type NestedDataSource = Record<string, DataSources>;
+export type ResultDataSet = ResultData | ResultData[] | ResultDataSet[];
 export type StaticNodeData = {
     value: ResultData;
     update?: string;
@@ -42,6 +46,7 @@ export type ComputedNodeData = {
     graph?: GraphData | string;
     isResult?: boolean;
     priority?: number;
+    passThrough?: PassThrough;
     console?: Record<string, string | boolean>;
 };
 export type NodeData = StaticNodeData | ComputedNodeData;
@@ -74,6 +79,7 @@ export type AgentFunctionContext<ParamsType = DefaultParamsType, InputDataType =
         retry: number;
         agentId?: string;
         version?: number;
+        isResult?: boolean;
     };
     graphData?: GraphData;
     agents?: AgentFunctionInfoDictionary;

package/lib/utils/nodeUtils.d.ts

@@ -1,3 +1,5 @@
-import { DataSource } from "../type";
+import { DataSource, DataSources, NestedDataSource } 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[]>;
+export declare const namedInputs2dataSources: (inputs: Record<string, any>, graphVersion: number) => NestedDataSource;
+export declare const flatDataSourceNodeIds: (sources: DataSource[] | DataSources[]) => string[];
+export declare const flatDataSource: (sources: DataSource[] | DataSources[]) => DataSource[];

package/lib/utils/nodeUtils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.namedInputs2dataSources = exports.inputs2dataSources = void 0;
+exports.flatDataSource = exports.flatDataSourceNodeIds = exports.namedInputs2dataSources = exports.inputs2dataSources = void 0;
 const utils_1 = require("./utils");
 const inputs2dataSources = (inputs, graphVersion) => {
     return inputs.reduce((tmp, input) => {
@@ -9,16 +9,41 @@ const inputs2dataSources = (inputs, graphVersion) => {
     }, {});
 };
 exports.inputs2dataSources = inputs2dataSources;
+const nestedParseNodeName = (input, graphVersion) => {
+    if (Array.isArray(input)) {
+        return input.map((inp) => nestedParseNodeName(inp, graphVersion));
+    }
+    return (0, utils_1.parseNodeName)(input, graphVersion);
+};
 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);
-        }
+        tmp[key] = nestedParseNodeName(input, graphVersion);
         return tmp;
     }, {});
 };
 exports.namedInputs2dataSources = namedInputs2dataSources;
+const flatDataSourceNodeIds = (sources) => {
+    return (0, exports.flatDataSource)(sources)
+        .filter((source) => source.nodeId)
+        .map((source) => source.nodeId);
+};
+exports.flatDataSourceNodeIds = flatDataSourceNodeIds;
+const flatDataSource = (sources) => {
+    return sources
+        .map((source) => {
+        if (Array.isArray(source)) {
+            return source
+                .map((s) => {
+                if (Array.isArray(s)) {
+                    return (0, exports.flatDataSource)(s);
+                }
+                return s;
+            })
+                .flat();
+        }
+        return source;
+    })
+        .flat();
+};
+exports.flatDataSource = flatDataSource;

package/lib/utils/utils.d.ts

@@ -18,7 +18,7 @@ export declare const defaultAgentInfo: {
     repository: string;
     license: string;
 };
-export declare const agentInfoWrapper: (agent: AgentFunction<any, any, any>) => {
+export declare const agentInfoWrapper: (agent: AgentFunction<any, any, any, any>) => {
     name: string;
     samples: {
         inputs: never[];
@@ -30,8 +30,8 @@ export declare const agentInfoWrapper: (agent: AgentFunction<any, any, any>) =>
     author: string;
     repository: string;
     license: string;
-    agent: AgentFunction<any, any, any>;
-    mock: AgentFunction<any, any, any>;
+    agent: AgentFunction<any, any, any, any>;
+    mock: AgentFunction<any, any, any, any>;
 };
 export declare const debugResultKey: (agentId: string, result: any) => string[];
 export declare const isLogicallyTrue: (value: any) => boolean;

package/lib/validators/common.js

@@ -16,6 +16,7 @@ exports.computedNodeAttributeKeys = [
     "unless",
     "filterParams",
     "console",
+    "passThrough",
 ];
 exports.staticNodeAttributeKeys = ["value", "update", "isResult"];
 class ValidationError extends Error {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "graphai",
-  "version": "0.5.5",
+  "version": "0.5.7",
   "description": "Asynchronous data flow execution engine for agentic AI apps.",
   "main": "lib/index.js",
   "files": [
@@ -26,7 +26,7 @@
   },
   "homepage": "https://github.com/receptron/graphai#readme",
   "devDependencies": {
-    "typedoc": "^0.26.3"
+    "typedoc": "^0.26.5"
   },
   "types": "./lib/index.d.ts",
   "directories": {