graphai 0.6.3 → 0.6.5

package/lib/graphai.js

@@ -16,15 +16,13 @@ class GraphAI {
     createNodes(data) {
         const nodes = Object.keys(data.nodes).reduce((_nodes, nodeId) => {
             const nodeData = data.nodes[nodeId];
-            if ("value" in nodeData) {
-                _nodes[nodeId] = new node_1.StaticNode(nodeId, nodeData, this);
-            }
-            else if ("agent" in nodeData) {
+            if ("agent" in nodeData) {
                 _nodes[nodeId] = new node_1.ComputedNode(this.graphId, nodeId, nodeData, this);
             }
             else {
-                throw new Error("Unknown node type (neither value nor agent): " + nodeId);
+                _nodes[nodeId] = new node_1.StaticNode(nodeId, nodeData, this);
             }
+            // throw new Error("Unknown node type (neither value nor agent): " + nodeId);
             return _nodes;
         }, {});
         // Generate the waitlist for each node.
@@ -193,6 +191,11 @@ class GraphAI {
     }
     // Public API
     async run(all = false) {
+        if (Object.values(this.nodes)
+            .filter((node) => node.isStaticNode)
+            .some((node) => node.result === undefined && node.update === undefined)) {
+            throw new Error("Static node must have value. Set value or injectValue or set update");
+        }
         if (this.isRunning()) {
             throw new Error("This GraphUI instance is already running");
         }

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, ConsoleElement } from "./type";
 import { TransactionLog } from "./transaction_log";
 export declare class Node {
     readonly nodeId: string;
@@ -8,7 +8,7 @@ export declare class Node {
     result: ResultData | undefined;
     protected graph: GraphAI;
     protected log: TransactionLog;
-    protected console: Record<string, string | boolean>;
+    protected console: ConsoleElement;
     constructor(nodeId: string, graph: GraphAI);
     asString(): string;
     protected onSetResult(): void;
@@ -19,7 +19,6 @@ export declare class ComputedNode extends Node {
     readonly isResult: boolean;
     readonly params: NodeDataParams;
     private readonly filterParams;
-    private readonly dynamicParams;
     readonly nestedGraph?: GraphData | DataSource;
     readonly retryLimit: number;
     retryCount: number;
@@ -33,9 +32,12 @@ export declare class ComputedNode extends Node {
     readonly anyInput: boolean;
     dataSources: DataSource[];
     private inputs?;
+    private output?;
     pendings: Set<string>;
     private ifSource?;
     private unlessSource?;
+    private defaultValue?;
+    private isSkip;
     readonly isStaticNode = false;
     readonly isComputedNode = true;
     constructor(graphId: string, nodeId: string, data: ComputedNodeData, graph: GraphAI);
@@ -51,9 +53,9 @@ export declare class ComputedNode extends Node {
     private shouldApplyAgentFilter;
     private agentFilterHandler;
     execute(): Promise<void>;
+    private afterExecute;
     private prepareExecute;
     private errorProcess;
-    private getParams;
     private getContext;
     private getResult;
     private getDebugInfo;

package/lib/node.js

@@ -6,6 +6,7 @@ const nodeUtils_1 = require("./utils/nodeUtils");
 const type_1 = require("./type");
 const utils_2 = require("./utils/utils");
 const transaction_log_1 = require("./transaction_log");
+const result_1 = require("./utils/result");
 class Node {
     constructor(nodeId, graph) {
         this.waitlist = new Set(); // List of nodes which need data from this node.
@@ -31,7 +32,7 @@ class Node {
         });
     }
     afterConsoleLog(result) {
-        if (this.console.after === true) {
+        if (this.console === true || this.console.after === true) {
             console.log(typeof result === "string" ? result : JSON.stringify(result, null, 2));
         }
         else if (this.console.after) {
@@ -45,6 +46,7 @@ class ComputedNode extends Node {
         super(nodeId, graph);
         this.retryCount = 0;
         this.dataSources = []; // no longer needed. This is for transaction log.
+        this.isSkip = false;
         this.isStaticNode = false;
         this.isComputedNode = true;
         this.graphId = graphId;
@@ -58,7 +60,8 @@ class ComputedNode extends Node {
         this.priority = data.priority ?? 0;
         this.anyInput = data.anyInput ?? false;
         this.inputs = data.inputs;
-        this.dataSources = data.inputs ? (0, nodeUtils_1.inputs2dataSources)(data.inputs).flat(10) : [];
+        this.output = data.output;
+        this.dataSources = [...(data.inputs ? (0, nodeUtils_1.inputs2dataSources)(data.inputs).flat(10) : []), ...(data.params ? (0, nodeUtils_1.inputs2dataSources)(data.params).flat(10) : [])];
         if (data.inputs && Array.isArray(data.inputs)) {
             throw new Error(`array inputs have been deprecated. nodeId: ${nodeId}: see https://github.com/receptron/graphai/blob/main/docs/NamedInputs.md`);
         }
@@ -83,15 +86,10 @@ class ComputedNode extends Node {
         if (data.unless) {
             this.unlessSource = this.addPendingNode(data.unless);
         }
-        this.dynamicParams = Object.keys(this.params).reduce((tmp, key) => {
-            const dataSource = (0, utils_2.parseNodeName)(this.params[key]);
-            if (dataSource.nodeId) {
-                (0, utils_2.assert)(!this.anyInput, "Dynamic params are not supported with anyInput");
-                tmp[key] = dataSource;
-                this.pendings.add(dataSource.nodeId);
-            }
-            return tmp;
-        }, {});
+        if (data.defaultValue) {
+            this.defaultValue = data.defaultValue;
+        }
+        this.isSkip = false;
         this.log.initForComputedNode(this, graph);
     }
     getAgentId() {
@@ -107,8 +105,9 @@ class ComputedNode extends Node {
         if (this.state !== type_1.NodeState.Waiting || this.pendings.size !== 0) {
             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.isSkip = !!((this.ifSource && !(0, utils_2.isLogicallyTrue)(this.graph.resultOf(this.ifSource))) ||
+            (this.unlessSource && (0, utils_2.isLogicallyTrue)(this.graph.resultOf(this.unlessSource))));
+        if (this.isSkip && this.defaultValue === undefined) {
             this.state = type_1.NodeState.Skipped;
             this.log.onSkipped(this, this.graph);
             return false;
@@ -202,6 +201,10 @@ 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() {
+        if (this.isSkip) {
+            this.afterExecute(this.defaultValue, []);
+            return;
+        }
         const previousResults = this.graph.resultsOf(this.inputs, this.anyInput);
         const transactionId = Date.now();
         this.prepareExecute(transactionId, Object.values(previousResults));
@@ -218,16 +221,7 @@ class ComputedNode extends Node {
             // if this is a nested agent or not.
             if (this.nestedGraph) {
                 this.graph.taskManager.prepareForNesting();
-                // context.taskManager = this.graph.taskManager;
                 context.onLogCallback = this.graph.onLogCallback;
-                /*
-                if ("nodes" in this.nestedGraph) {
-                  context.graphData = this.nestedGraph;
-                } else {
-                  context.graphData = this.graph.resultOf(this.nestedGraph) as GraphData; // HACK: compiler work-around
-                  }
-                */
-                // context.agents = this.graph.agentFunctionInfoDictionary;
                 context.forNestedGraph = {
                     graphData: "nodes" in this.nestedGraph ? this.nestedGraph : this.graph.resultOf(this.nestedGraph), // HACK: compiler work-around
                     agents: this.graph.agentFunctionInfoDictionary,
@@ -253,16 +247,23 @@ class ComputedNode extends Node {
                 console.log(`-- transactionId mismatch with ${this.nodeId} (probably timeout)`);
                 return;
             }
-            this.state = type_1.NodeState.Completed;
-            this.result = this.getResult(result);
-            this.log.onComplete(this, this.graph, localLog);
-            this.onSetResult();
-            this.graph.onExecutionComplete(this);
+            // after process
+            this.afterExecute(result, localLog);
         }
         catch (error) {
             this.errorProcess(error, transactionId, previousResults);
         }
     }
+    afterExecute(result, localLog) {
+        this.state = type_1.NodeState.Completed;
+        this.result = this.getResult(result);
+        if (this.output) {
+            this.result = (0, result_1.resultsOf)(this.output, { self: this }, this.graph.propFunctions, true);
+        }
+        this.log.onComplete(this, this.graph, localLog);
+        this.onSetResult();
+        this.graph.onExecutionComplete(this);
+    }
     // This private method (called only by execute()) prepares the ComputedNode object
     // for execution, and create a new transaction to record it.
     prepareExecute(transactionId, inputs) {
@@ -292,24 +293,9 @@ class ComputedNode extends Node {
             this.retry(type_1.NodeState.Failed, Error("Unknown"));
         }
     }
-    getParams() {
-        return Object.keys(this.dynamicParams).reduce((tmp, key) => {
-            const result = this.graph.resultOf(this.dynamicParams[key]);
-            tmp[key] = result;
-            return tmp;
-        }, { ...this.params });
-    }
-    /*
-    private getInputs(previousResults: Record<string, ResultData | undefined>) {
-      if (Array.isArray(this.inputs)) {
-        return (this.inputs ?? []).map((key) => previousResults[String(key)]).filter((a) => !this.anyInput || a);
-      }
-      return [];
-    }
-    */
     getContext(previousResults, localLog) {
         const context = {
-            params: this.getParams(),
+            params: this.graph.resultsOf(this.params),
             namedInputs: previousResults,
             inputSchema: this.agentFunction ? undefined : this.graph.getAgentFunctionInfo(this.agentId)?.inputs,
             debugInfo: this.getDebugInfo(),
@@ -343,7 +329,7 @@ class ComputedNode extends Node {
         };
     }
     beforeConsoleLog(context) {
-        if (this.console.before === true) {
+        if (this.console === true || this.console.before === true) {
             console.log(JSON.stringify(context.namedInputs, null, 2));
         }
         else if (this.console.before) {

package/lib/type.d.ts

@@ -23,11 +23,16 @@ export type DataSource = {
     value?: any;
     propIds?: string[];
 };
+type ConsoleAttribute = true | string | Record<string, any>;
+export type ConsoleElement = true | {
+    before?: ConsoleAttribute;
+    after?: ConsoleAttribute;
+};
 export type StaticNodeData = {
-    value: ResultData;
+    value?: ResultData;
     update?: string;
     isResult?: boolean;
-    console?: Record<string, string | boolean>;
+    console?: ConsoleElement;
 };
 export type AgentAnonymousFunction = (...params: any[]) => unknown;
 export type AgentFilterParams = Record<string, any>;
@@ -37,7 +42,8 @@ export type GraphDataLoaderOption = {
 };
 export type ComputedNodeData = {
     agent: string | AgentAnonymousFunction;
-    inputs?: Array<any> | Record<string, any>;
+    inputs?: Record<string, any>;
+    output?: Record<string, any>;
     anyInput?: boolean;
     params?: NodeDataParams;
     filterParams?: AgentFilterParams;
@@ -45,12 +51,13 @@ export type ComputedNodeData = {
     timeout?: number;
     if?: string;
     unless?: string;
+    defaultValue?: ResultData;
     graph?: GraphData | string;
     graphLoader?: GraphDataLoaderOption;
     isResult?: boolean;
     priority?: number;
     passThrough?: PassThrough;
-    console?: Record<string, string | boolean>;
+    console?: ConsoleElement;
 };
 export type NodeData = StaticNodeData | ComputedNodeData;
 export type LoopData = {
@@ -137,3 +144,4 @@ export type AgentFunctionInfo = {
 };
 export type AgentFunctionInfoDictionary = Record<string, AgentFunctionInfo>;
 export type PropFunction = (result: ResultData, propId: string) => ResultData;
+export {};

package/lib/utils/prop_function.js

@@ -18,7 +18,7 @@ const propArrayFunction = (result, propId) => {
             return result.length === 0;
         }
         // array join
-        const matchJoin = propId.match(/^join\(([,-]?)\)$/);
+        const matchJoin = propId.match(/^join\(([,-\s]?)\)$/);
         if (matchJoin && Array.isArray(matchJoin)) {
             return result.join(matchJoin[1] ?? "");
         }

package/lib/utils/result.d.ts

@@ -1,6 +1,6 @@
 import { DataSource, ResultData, PropFunction } from "../type";
 import { GraphNodes } from "../node";
-export declare const resultsOf: (inputs: Record<string, any> | Array<string>, nodes: GraphNodes, propFunctions: PropFunction[]) => Record<string, ResultData>;
+export declare const resultsOf: (inputs: Record<string, any>, nodes: GraphNodes, propFunctions: PropFunction[], isSelfNode?: boolean) => Record<string, ResultData>;
 export declare const resultOf: (source: DataSource, nodes: GraphNodes, propFunctions: PropFunction[]) => ResultData;
 export declare const cleanResultInner: (results: ResultData) => ResultData | null;
 export declare const cleanResult: (results: Record<string, ResultData | undefined>) => Record<string, ResultData>;

package/lib/utils/result.js

@@ -3,35 +3,28 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.cleanResult = exports.cleanResultInner = exports.resultOf = exports.resultsOf = void 0;
 const utils_1 = require("../utils/utils");
 const data_source_1 = require("../utils/data_source");
-const resultsOfInner = (input, nodes, propFunctions) => {
+const resultsOfInner = (input, nodes, propFunctions, isSelfNode = false) => {
     if (Array.isArray(input)) {
-        return input.map((inp) => resultsOfInner(inp, nodes, propFunctions));
+        return input.map((inp) => resultsOfInner(inp, nodes, propFunctions, isSelfNode));
     }
     if ((0, utils_1.isNamedInputs)(input)) {
-        return (0, exports.resultsOf)(input, nodes, propFunctions);
+        return (0, exports.resultsOf)(input, nodes, propFunctions, isSelfNode);
     }
     if (typeof input === "string") {
         const templateMatch = [...input.matchAll(/\${(:[^}]+)}/g)].map((m) => m[1]);
         if (templateMatch.length > 0) {
-            const results = resultsOfInner(templateMatch, nodes, propFunctions);
+            const results = resultsOfInner(templateMatch, nodes, propFunctions, isSelfNode);
             return Array.from(templateMatch.keys()).reduce((tmp, key) => {
                 return tmp.replaceAll("${" + templateMatch[key] + "}", results[key]);
             }, input);
         }
     }
-    return (0, exports.resultOf)((0, utils_1.parseNodeName)(input), nodes, propFunctions);
+    return (0, exports.resultOf)((0, utils_1.parseNodeName)(input, isSelfNode), nodes, propFunctions);
 };
-const resultsOf = (inputs, nodes, propFunctions) => {
-    // for inputs. TODO remove if array input is not supported
-    if (Array.isArray(inputs)) {
-        return inputs.reduce((tmp, key) => {
-            tmp[key] = resultsOfInner(key, nodes, propFunctions);
-            return tmp;
-        }, {});
-    }
+const resultsOf = (inputs, nodes, propFunctions, isSelfNode = false) => {
     return Object.keys(inputs).reduce((tmp, key) => {
         const input = inputs[key];
-        tmp[key] = (0, utils_1.isNamedInputs)(input) ? (0, exports.resultsOf)(input, nodes, propFunctions) : resultsOfInner(input, nodes, propFunctions);
+        tmp[key] = (0, utils_1.isNamedInputs)(input) ? (0, exports.resultsOf)(input, nodes, propFunctions, isSelfNode) : resultsOfInner(input, nodes, propFunctions, isSelfNode);
         return tmp;
     }, {});
 };

package/lib/utils/utils.d.ts

@@ -1,6 +1,6 @@
 import { DataSource, AgentFunction, DefaultInputData } from "../type";
 export declare const sleep: (milliseconds: number) => Promise<unknown>;
-export declare const parseNodeName: (inputNodeId: any) => DataSource;
+export declare const parseNodeName: (inputNodeId: any, isSelfNode?: boolean) => DataSource;
 export declare function assert(condition: boolean, message: string, isWarn?: boolean): asserts condition;
 export declare const isObject: (x: unknown) => x is object;
 export declare const isNull: (data: unknown) => data is null | undefined;

package/lib/utils/utils.js

@@ -6,7 +6,14 @@ const sleep = async (milliseconds) => {
     return await new Promise((resolve) => setTimeout(resolve, milliseconds));
 };
 exports.sleep = sleep;
-const parseNodeName = (inputNodeId) => {
+const parseNodeName = (inputNodeId, isSelfNode = false) => {
+    if (isSelfNode) {
+        if (typeof inputNodeId === "string" && inputNodeId[0] === ".") {
+            const parts = inputNodeId.split(".");
+            return { nodeId: "self", propIds: parts.slice(1) };
+        }
+        return { value: inputNodeId };
+    }
     if (typeof inputNodeId === "string") {
         const regex = /^:(.*)$/;
         const match = inputNodeId.match(regex);

package/lib/validator.js

@@ -15,7 +15,7 @@ const validateGraphData = (data, agentIds) => {
     const graphAgentIds = new Set();
     Object.keys(data.nodes).forEach((nodeId) => {
         const node = data.nodes[nodeId];
-        const isStaticNode = "value" in node;
+        const isStaticNode = !("agent" in node);
         (0, nodeValidator_1.nodeValidator)(node);
         const agentId = isStaticNode ? "" : node.agent;
         isStaticNode && (0, static_node_validator_1.staticNodeValidator)(node) && staticNodeIds.push(nodeId);

package/lib/validators/common.js

@@ -4,6 +4,7 @@ exports.ValidationError = exports.staticNodeAttributeKeys = exports.computedNode
 exports.graphDataAttributeKeys = ["nodes", "concurrency", "agentId", "loop", "verbose", "version"];
 exports.computedNodeAttributeKeys = [
     "inputs",
+    "output",
     "anyInput",
     "params",
     "retry",
@@ -15,6 +16,7 @@ exports.computedNodeAttributeKeys = [
     "priority",
     "if",
     "unless",
+    "defaultValue",
     "filterParams",
     "console",
     "passThrough",

package/lib/validators/nodeValidator.js

@@ -6,9 +6,9 @@ const nodeValidator = (nodeData) => {
     if (nodeData.agent && nodeData.value) {
         throw new common_1.ValidationError("Cannot set both agent and value");
     }
-    if (!("agent" in nodeData) && !("value" in nodeData)) {
-        throw new common_1.ValidationError("Either agent or value is required");
-    }
+    // if (!("agent" in nodeData) && !("value" in nodeData)) {
+    //   throw new ValidationError("Either agent or value is required");
+    // }
     return true;
 };
 exports.nodeValidator = nodeValidator;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "graphai",
-  "version": "0.6.3",
+  "version": "0.6.5",
   "description": "Asynchronous data flow execution engine for agentic AI apps.",
   "main": "lib/bundle.cjs.js",
   "module": "lib/bundle.esm.js",