graphai 0.6.4 → 0.6.6

package/lib/graphai.js

@@ -22,7 +22,6 @@ class GraphAI {
             else {
                 _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.
@@ -197,7 +196,7 @@ class GraphAI {
             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");
+            throw new Error("This GraphAI instance is already running");
         }
         this.pushReadyNodesIntoQueue();
         if (!this.isRunning()) {
@@ -250,14 +249,23 @@ class GraphAI {
                     return false; // while condition is not met
                 }
             }
-            this.nodes = this.createNodes(this.data);
-            this.initializeStaticNodes();
+            this.initializeGraphAI();
             this.updateStaticNodes(previousResults, true);
             this.pushReadyNodesIntoQueue();
             return true; // Indicating that we are going to continue.
         }
         return false;
     }
+    initializeGraphAI() {
+        if (this.isRunning()) {
+            throw new Error("This GraphAI instance is running");
+        }
+        this.nodes = this.createNodes(this.data);
+        this.initializeStaticNodes();
+    }
+    setPreviousResults(previousResults) {
+        this.updateStaticNodes(previousResults);
+    }
     setLoopLog(log) {
         log.isLoop = !!this.loop;
         log.repeatCount = this.repeatCount;

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;
@@ -32,6 +32,7 @@ export declare class ComputedNode extends Node {
     readonly anyInput: boolean;
     dataSources: DataSource[];
     private inputs?;
+    private output?;
     pendings: Set<string>;
     private ifSource?;
     private unlessSource?;

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,11 +32,16 @@ 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) {
-            console.log(this.console.after);
+            if ((0, utils_2.isObject)(this.console.after)) {
+                console.log(JSON.stringify((0, result_1.resultsOf)(this.console.after, { self: this }, this.graph.propFunctions, true), null, 2));
+            }
+            else {
+                console.log(this.console.after);
+            }
         }
     }
 }
@@ -59,6 +65,7 @@ class ComputedNode extends Node {
         this.priority = data.priority ?? 0;
         this.anyInput = data.anyInput ?? false;
         this.inputs = data.inputs;
+        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`);
@@ -255,6 +262,9 @@ class ComputedNode extends Node {
     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);
@@ -324,7 +334,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;
     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;
@@ -51,7 +57,7 @@ export type ComputedNodeData = {
     isResult?: boolean;
     priority?: number;
     passThrough?: PassThrough;
-    console?: Record<string, string | boolean>;
+    console?: ConsoleElement;
 };
 export type NodeData = StaticNodeData | ComputedNodeData;
 export type LoopData = {
@@ -138,3 +144,4 @@ export type AgentFunctionInfo = {
 };
 export type AgentFunctionInfoDictionary = Record<string, AgentFunctionInfo>;
 export type PropFunction = (result: ResultData, propId: string) => ResultData;
+export {};

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/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",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "graphai",
-  "version": "0.6.4",
+  "version": "0.6.6",
   "description": "Asynchronous data flow execution engine for agentic AI apps.",
   "main": "lib/bundle.cjs.js",
   "module": "lib/bundle.esm.js",
@@ -27,7 +27,7 @@
   },
   "homepage": "https://github.com/receptron/graphai#readme",
   "devDependencies": {
-    "typedoc": "^0.27.3"
+    "typedoc": "^0.27.4"
   },
   "types": "./lib/index.d.ts",
   "directories": {