graphai 0.5.2 → 0.5.4

package/lib/graphai.d.ts

@@ -3,6 +3,8 @@ import { TransactionLog } from "./transaction_log";
 import { ComputedNode, StaticNode } from "./node";
 import { TaskManager } from "./task_manager";
 type GraphNodes = Record<string, ComputedNode | StaticNode>;
+export declare const defaultConcurrency = 8;
+export declare const graphDataLatestVersion = 0.5;
 export declare class GraphAI {
     readonly version: number;
     private readonly graphId;
@@ -10,6 +12,7 @@ export declare class GraphAI {
     private readonly loop?;
     private readonly logs;
     private readonly bypassAgentIds;
+    readonly config?: Record<string, unknown>;
     readonly agentFunctionInfoDictionary: AgentFunctionInfoDictionary;
     readonly taskManager: TaskManager;
     readonly agentFilters: AgentFilterInfo[];
@@ -43,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

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GraphAI = void 0;
+exports.GraphAI = exports.graphDataLatestVersion = exports.defaultConcurrency = void 0;
 const node_1 = require("./node");
 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;
+exports.defaultConcurrency = 8;
+exports.graphDataLatestVersion = 0.5;
 class GraphAI {
     // This method is called when either the GraphAI obect was created,
     // or we are about to start n-th iteration (n>2).
@@ -67,24 +67,27 @@ class GraphAI {
         taskManager: undefined,
         agentFilters: [],
         bypassAgentIds: [],
+        config: {},
     }) {
         this.logs = [];
+        this.config = {};
         this.onLogCallback = (__log, __isUpdate) => { };
         this.repeatCount = 0;
         if (!data.version && !options.taskManager) {
             console.warn("------------ missing version number");
         }
-        this.version = data.version ?? latestVersion;
-        if (this.version < latestVersion) {
-            console.warn(`------------ upgrade to ${latestVersion}!`);
+        this.version = data.version ?? exports.graphDataLatestVersion;
+        if (this.version < exports.graphDataLatestVersion) {
+            console.warn(`------------ upgrade to ${exports.graphDataLatestVersion}!`);
         }
         this.retryLimit = data.retry; // optional
         this.graphId = URL.createObjectURL(new Blob()).slice(-36);
         this.data = data;
         this.agentFunctionInfoDictionary = agentFunctionInfoDictionary;
-        this.taskManager = options.taskManager ?? new task_manager_1.TaskManager(data.concurrency ?? defaultConcurrency);
+        this.taskManager = options.taskManager ?? new task_manager_1.TaskManager(data.concurrency ?? exports.defaultConcurrency);
         this.agentFilters = options.agentFilters ?? [];
         this.bypassAgentIds = options.bypassAgentIds ?? [];
+        this.config = options.config;
         this.loop = data.loop;
         this.verbose = data.verbose === true;
         this.onComplete = () => {
@@ -250,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/index.d.ts

@@ -1,4 +1,4 @@
-export { GraphAI } from "./graphai";
+export { GraphAI, defaultConcurrency, graphDataLatestVersion } from "./graphai";
 export { AgentFunction, AgentFunctionInfo, AgentFunctionInfoDictionary, AgentFunctionInfoSample, AgentFunctionContext, GraphData, ResultDataDictionary, ResultData, NodeState, AgentFilterFunction, AgentFilterInfo, NodeData, StaticNodeData, ComputedNodeData, DefaultResultData, DefaultInputData, } from "./type";
 export type { TransactionLog } from "./transaction_log";
 export { defaultAgentInfo, agentInfoWrapper, defaultTestContext, strIntentionalError, assert, sleep } from "./utils/utils";

package/lib/index.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValidationError = exports.sleep = exports.assert = exports.strIntentionalError = exports.defaultTestContext = exports.agentInfoWrapper = exports.defaultAgentInfo = exports.NodeState = exports.GraphAI = void 0;
+exports.ValidationError = exports.sleep = exports.assert = exports.strIntentionalError = exports.defaultTestContext = exports.agentInfoWrapper = exports.defaultAgentInfo = exports.NodeState = exports.graphDataLatestVersion = exports.defaultConcurrency = exports.GraphAI = void 0;
 var graphai_1 = require("./graphai");
 Object.defineProperty(exports, "GraphAI", { enumerable: true, get: function () { return graphai_1.GraphAI; } });
+Object.defineProperty(exports, "defaultConcurrency", { enumerable: true, get: function () { return graphai_1.defaultConcurrency; } });
+Object.defineProperty(exports, "graphDataLatestVersion", { enumerable: true, get: function () { return graphai_1.graphDataLatestVersion; } });
 var type_1 = require("./type");
 Object.defineProperty(exports, "NodeState", { enumerable: true, get: function () { return type_1.NodeState; } });
 var utils_1 = require("./utils/utils");

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,33 +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) {
@@ -279,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;
@@ -338,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/type.d.ts

@@ -61,6 +61,7 @@ export type GraphOptions = {
     agentFilters?: AgentFilterInfo[] | undefined;
     taskManager?: TaskManager | undefined;
     bypassAgentIds?: string[] | undefined;
+    config?: Record<string, unknown>;
 };
 export type AgentFunctionContext<ParamsType = DefaultParamsType, InputDataType = DefaultInputData, NamedInputDataType = DefaultInputData> = {
     params: NodeDataParams<ParamsType>;
@@ -80,6 +81,7 @@ export type AgentFunctionContext<ParamsType = DefaultParamsType, InputDataType =
     filterParams: AgentFilterParams;
     agentFilters?: AgentFilterInfo[];
     log?: TransactionLog[];
+    config?: Record<string, unknown>;
 };
 export type AgentFunction<ParamsType = DefaultParamsType, ResultType = DefaultResultData, InputDataType = DefaultInputData, NamedInputDataType = DefaultInputData> = (context: AgentFunctionContext<ParamsType, InputDataType, NamedInputDataType>) => Promise<ResultData<ResultType>>;
 export type AgentFilterFunction<ParamsType = DefaultParamsType, ResultType = DefaultResultData, InputDataType = DefaultInputData, NamedInputDataType = DefaultInputData> = (context: AgentFunctionContext<ParamsType, InputDataType, NamedInputDataType>, agent: AgentFunction) => Promise<ResultData<ResultType>>;
@@ -102,6 +104,8 @@ export type AgentFunctionInfo = {
     mock: AgentFunction<any, any, any, any>;
     inputs?: any;
     output?: any;
+    outputFormat?: any;
+    params?: any;
     samples: AgentFunctionInfoSample[];
     description: string;
     category: string[];

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/lib/utils/utils.d.ts

@@ -2,7 +2,7 @@ import { DataSource, ResultData, AgentFunction } from "../type";
 export declare const sleep: (milliseconds: number) => Promise<unknown>;
 export declare const parseNodeName: (inputNodeId: any, version: number) => DataSource;
 export declare function assert(condition: boolean, message: string, isWarn?: boolean): asserts condition;
-export declare const isObject: (x: unknown) => boolean;
+export declare const isObject: (x: unknown) => x is object;
 export declare const getDataFromSource: (result: ResultData | undefined, source: DataSource) => ResultData | undefined;
 export declare const strIntentionalError = "Intentional Error for Debugging";
 export declare const defaultAgentInfo: {

package/lib/utils/utils.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.defaultTestContext = exports.isLogicallyTrue = exports.debugResultKey = exports.agentInfoWrapper = exports.defaultAgentInfo = exports.strIntentionalError = exports.getDataFromSource = exports.isObject = exports.assert = exports.parseNodeName = exports.sleep = void 0;
+exports.defaultTestContext = exports.isLogicallyTrue = exports.debugResultKey = exports.agentInfoWrapper = exports.defaultAgentInfo = exports.strIntentionalError = exports.getDataFromSource = exports.isObject = exports.parseNodeName = exports.sleep = void 0;
+exports.assert = assert;
 const sleep = async (milliseconds) => {
     return await new Promise((resolve) => setTimeout(resolve, milliseconds));
 };
@@ -47,7 +48,6 @@ function assert(condition, message, isWarn = false) {
         console.warn("warn: " + message);
     }
 }
-exports.assert = assert;
 const isObject = (x) => {
     return x !== null && typeof x === "object";
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "graphai",
-  "version": "0.5.2",
+  "version": "0.5.4",
   "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.25.13"
+    "typedoc": "^0.26.3"
   },
   "types": "./lib/index.d.ts",
   "directories": {