graphai 0.6.8 → 0.6.10

package/lib/bundle.esm.js

@@ -445,7 +445,7 @@ class Node {
         }
         else if (this.console.after) {
             if (isObject(this.console.after)) {
-                console.log(JSON.stringify(resultsOf(this.console.after, { self: this }, this.graph.propFunctions, true), null, 2));
+                console.log(JSON.stringify(resultsOf(this.console.after, { self: { result } }, this.graph.propFunctions, true), null, 2));
             }
             else {
                 console.log(this.console.after);
@@ -470,14 +470,6 @@ class ComputedNode extends Node {
         this.timeout = data.timeout;
         this.isResult = data.isResult ?? false;
         this.priority = data.priority ?? 0;
-        this.anyInput = data.anyInput ?? false;
-        this.inputs = data.inputs;
-        this.output = data.output;
-        this.dataSources = [...(data.inputs ? inputs2dataSources(data.inputs).flat(10) : []), ...(data.params ? 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`);
-        }
-        this.pendings = new Set(dataSourceNodeIds(this.dataSources));
         assert(["function", "string"].includes(typeof data.agent), "agent must be either string or function");
         if (typeof data.agent === "string") {
             this.agentId = data.agent;
@@ -486,6 +478,18 @@ class ComputedNode extends Node {
             const agent = data.agent;
             this.agentFunction = async ({ namedInputs, params }) => agent(namedInputs, params);
         }
+        this.anyInput = data.anyInput ?? false;
+        this.inputs = data.inputs;
+        this.output = data.output;
+        this.dataSources = [
+            ...(data.inputs ? inputs2dataSources(data.inputs).flat(10) : []),
+            ...(data.params ? inputs2dataSources(data.params).flat(10) : []),
+            ...(this.agentId ? [parseNodeName(this.agentId)] : []),
+        ];
+        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`);
+        }
+        this.pendings = new Set(dataSourceNodeIds(this.dataSources));
         if (data.graph) {
             this.nestedGraph = typeof data.graph === "string" ? this.addPendingNode(data.graph) : data.graph;
         }
@@ -578,9 +582,9 @@ class ComputedNode extends Node {
         }
     }
     // Check if we need to apply this filter to this node or not.
-    shouldApplyAgentFilter(agentFilter) {
+    shouldApplyAgentFilter(agentFilter, agentId) {
         if (agentFilter.agentIds && Array.isArray(agentFilter.agentIds) && agentFilter.agentIds.length > 0) {
-            if (this.agentId && agentFilter.agentIds.includes(this.agentId)) {
+            if (agentId && agentFilter.agentIds.includes(agentId)) {
                 return true;
             }
         }
@@ -591,12 +595,12 @@ class ComputedNode extends Node {
         }
         return !agentFilter.agentIds && !agentFilter.nodeIds;
     }
-    agentFilterHandler(context, agentFunction) {
+    agentFilterHandler(context, agentFunction, agentId) {
         let index = 0;
         const next = (innerContext) => {
             const agentFilter = this.graph.agentFilters[index++];
             if (agentFilter) {
-                if (this.shouldApplyAgentFilter(agentFilter)) {
+                if (this.shouldApplyAgentFilter(agentFilter, agentId)) {
                     if (agentFilter.filterParams) {
                         innerContext.filterParams = { ...agentFilter.filterParams, ...innerContext.filterParams };
                     }
@@ -618,6 +622,7 @@ class ComputedNode extends Node {
             return;
         }
         const previousResults = this.graph.resultsOf(this.inputs, this.anyInput);
+        const agentId = this.agentId ? this.graph.resultOf(parseNodeName(this.agentId)) : this.agentId;
         const transactionId = Date.now();
         this.prepareExecute(transactionId, Object.values(previousResults));
         if (this.timeout && this.timeout > 0) {
@@ -626,9 +631,9 @@ class ComputedNode extends Node {
             }, this.timeout);
         }
         try {
-            const agentFunction = this.agentFunction ?? this.graph.getAgentFunctionInfo(this.agentId).agent;
+            const agentFunction = this.agentFunction ?? this.graph.getAgentFunctionInfo(agentId).agent;
             const localLog = [];
-            const context = this.getContext(previousResults, localLog);
+            const context = this.getContext(previousResults, localLog, agentId);
             // 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) {
@@ -647,7 +652,7 @@ class ComputedNode extends Node {
                 };
             }
             this.beforeConsoleLog(context);
-            const result = await this.agentFilterHandler(context, agentFunction);
+            const result = await this.agentFilterHandler(context, agentFunction, agentId);
             this.afterConsoleLog(result);
             if (this.nestedGraph) {
                 this.graph.taskManager.restoreAfterNesting();
@@ -704,13 +709,13 @@ class ComputedNode extends Node {
             this.retry(NodeState.Failed, Error("Unknown"));
         }
     }
-    getContext(previousResults, localLog) {
+    getContext(previousResults, localLog, agentId) {
         const context = {
             params: this.graph.resultsOf(this.params),
             namedInputs: previousResults,
-            inputSchema: this.agentFunction ? undefined : this.graph.getAgentFunctionInfo(this.agentId)?.inputs,
-            debugInfo: this.getDebugInfo(),
-            cacheType: this.agentFunction ? undefined : this.graph.getAgentFunctionInfo(this.agentId)?.cacheType,
+            inputSchema: this.agentFunction ? undefined : this.graph.getAgentFunctionInfo(agentId)?.inputs,
+            debugInfo: this.getDebugInfo(agentId),
+            cacheType: this.agentFunction ? undefined : this.graph.getAgentFunctionInfo(agentId)?.cacheType,
             filterParams: this.filterParams,
             agentFilters: this.graph.agentFilters,
             config: this.graph.config,
@@ -729,10 +734,10 @@ class ComputedNode extends Node {
         }
         return result;
     }
-    getDebugInfo() {
+    getDebugInfo(agentId) {
         return {
             nodeId: this.nodeId,
-            agentId: this.agentId,
+            agentId,
             retry: this.retryCount,
             verbose: this.graph.verbose,
             version: this.graph.version,
@@ -867,13 +872,13 @@ const computedNodeValidator = (nodeData) => {
     return true;
 };
 
-const relationValidator = (data, staticNodeIds, computedNodeIds) => {
-    const nodeIds = new Set(Object.keys(data.nodes));
+const relationValidator = (graphData, staticNodeIds, computedNodeIds) => {
+    const nodeIds = new Set(Object.keys(graphData.nodes));
     const pendings = {};
     const waitlist = {};
     // validate input relation and set pendings and wait list
     computedNodeIds.forEach((computedNodeId) => {
-        const nodeData = data.nodes[computedNodeId];
+        const nodeData = graphData.nodes[computedNodeId];
         pendings[computedNodeId] = new Set();
         const dataSourceValidator = (sourceType, sourceNodeIds) => {
             sourceNodeIds.forEach((sourceNodeId) => {
@@ -892,6 +897,10 @@ const relationValidator = (data, staticNodeIds, computedNodeIds) => {
                 const sourceNodeIds = dataSourceNodeIds(inputs2dataSources(nodeData.inputs));
                 dataSourceValidator("Inputs", sourceNodeIds);
             }
+            if (nodeData.params) {
+                const sourceNodeIds = dataSourceNodeIds(inputs2dataSources(nodeData.params));
+                dataSourceValidator("Params", sourceNodeIds);
+            }
             if (nodeData.if) {
                 const sourceNodeIds = dataSourceNodeIds(inputs2dataSources({ if: nodeData.if }));
                 dataSourceValidator("If", sourceNodeIds);
@@ -904,11 +913,15 @@ const relationValidator = (data, staticNodeIds, computedNodeIds) => {
                 const sourceNodeIds = dataSourceNodeIds(inputs2dataSources({ graph: nodeData.graph }));
                 dataSourceValidator("Graph", sourceNodeIds);
             }
+            if (typeof nodeData.agent === "string" && nodeData.agent[0] === ":") {
+                const sourceNodeIds = dataSourceNodeIds(inputs2dataSources({ agent: nodeData.agent }));
+                dataSourceValidator("Agent", sourceNodeIds);
+            }
         }
     });
     // TODO. validate update
     staticNodeIds.forEach((staticNodeId) => {
-        const nodeData = data.nodes[staticNodeId];
+        const nodeData = graphData.nodes[staticNodeId];
         if ("value" in nodeData && nodeData.update) {
             const update = nodeData.update;
             const updateNodeId = parseNodeName(update).nodeId;
@@ -949,7 +962,8 @@ const relationValidator = (data, staticNodeIds, computedNodeIds) => {
 
 const agentValidator = (graphAgentIds, agentIds) => {
     graphAgentIds.forEach((agentId) => {
-        if (!agentIds.has(agentId)) {
+        // agentId or dynamic agentId
+        if (!agentIds.has(agentId) && agentId[0] !== ":") {
             throw new ValidationError("Invalid Agent : " + agentId + " is not in AgentFunctionInfoDictionary.");
         }
     });
@@ -974,6 +988,16 @@ const validateGraphData = (data, agentIds) => {
     relationValidator(data, staticNodeIds, computedNodeIds);
     return true;
 };
+const validateAgent = (agentFunctionInfoDictionary) => {
+    Object.keys(agentFunctionInfoDictionary).forEach((agentId) => {
+        if (agentId !== "default") {
+            const agentInfo = agentFunctionInfoDictionary[agentId];
+            if (!agentInfo || !agentInfo.agent) {
+                throw new ValidationError("No Agent: " + agentId + " is not in AgentFunctionInfoDictionary.");
+            }
+        }
+    });
+};
 
 // TaskManage object controls the concurrency of ComputedNode execution.
 //
@@ -1048,9 +1072,9 @@ const 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).
-    createNodes(data) {
-        const nodes = Object.keys(data.nodes).reduce((_nodes, nodeId) => {
-            const nodeData = data.nodes[nodeId];
+    createNodes(graphData) {
+        const nodes = Object.keys(graphData.nodes).reduce((_nodes, nodeId) => {
+            const nodeData = graphData.nodes[nodeId];
             if ("agent" in nodeData) {
                 _nodes[nodeId] = new ComputedNode(this.graphId, nodeId, nodeData, this);
             }
@@ -1083,7 +1107,7 @@ class GraphAI {
         // If the result property is specified, inject it.
         // If the previousResults exists (indicating we are in a loop),
         // process the update property (nodeId or nodeId.propId).
-        Object.keys(this.data.nodes).forEach((nodeId) => {
+        Object.keys(this.graphData.nodes).forEach((nodeId) => {
             const node = this.nodes[nodeId];
             if (node?.isStaticNode) {
                 const value = node?.value;
@@ -1100,7 +1124,7 @@ class GraphAI {
         // If the result property is specified, inject it.
         // If the previousResults exists (indicating we are in a loop),
         // process the update property (nodeId or nodeId.propId).
-        Object.keys(this.data.nodes).forEach((nodeId) => {
+        Object.keys(this.graphData.nodes).forEach((nodeId) => {
             const node = this.nodes[nodeId];
             if (node?.isStaticNode) {
                 const update = node?.update;
@@ -1114,7 +1138,7 @@ class GraphAI {
             }
         });
     }
-    constructor(data, agentFunctionInfoDictionary, options = {
+    constructor(graphData, agentFunctionInfoDictionary, options = {
         taskManager: undefined,
         agentFilters: [],
         bypassAgentIds: [],
@@ -1125,30 +1149,31 @@ class GraphAI {
         this.config = {};
         this.onLogCallback = (__log, __isUpdate) => { };
         this.repeatCount = 0;
-        if (!data.version && !options.taskManager) {
+        if (!graphData.version && !options.taskManager) {
             console.warn("------------ missing version number");
         }
-        this.version = data.version ?? graphDataLatestVersion;
+        this.version = graphData.version ?? graphDataLatestVersion;
         if (this.version < graphDataLatestVersion) {
             console.warn(`------------ upgrade to ${graphDataLatestVersion}!`);
         }
-        this.retryLimit = data.retry; // optional
+        this.retryLimit = graphData.retry; // optional
         this.graphId = URL.createObjectURL(new Blob()).slice(-36);
-        this.data = data;
+        this.graphData = graphData;
         this.agentFunctionInfoDictionary = agentFunctionInfoDictionary;
         this.propFunctions = propFunctions;
-        this.taskManager = options.taskManager ?? new TaskManager(data.concurrency ?? defaultConcurrency);
+        this.taskManager = options.taskManager ?? new TaskManager(graphData.concurrency ?? defaultConcurrency);
         this.agentFilters = options.agentFilters ?? [];
         this.bypassAgentIds = options.bypassAgentIds ?? [];
         this.config = options.config;
         this.graphLoader = options.graphLoader;
-        this.loop = data.loop;
-        this.verbose = data.verbose === true;
+        this.loop = graphData.loop;
+        this.verbose = graphData.verbose === true;
         this.onComplete = () => {
             throw new Error("SOMETHING IS WRONG: onComplete is called without run()");
         };
-        validateGraphData(data, [...Object.keys(agentFunctionInfoDictionary), ...this.bypassAgentIds]);
-        this.nodes = this.createNodes(data);
+        validateGraphData(graphData, [...Object.keys(agentFunctionInfoDictionary), ...this.bypassAgentIds]);
+        validateAgent(agentFunctionInfoDictionary);
+        this.nodes = this.createNodes(graphData);
         this.initializeStaticNodes(true);
     }
     getAgentFunctionInfo(agentId) {
@@ -1295,7 +1320,7 @@ class GraphAI {
         if (this.isRunning()) {
             throw new Error("This GraphAI instance is running");
         }
-        this.nodes = this.createNodes(this.data);
+        this.nodes = this.createNodes(this.graphData);
         this.initializeStaticNodes();
     }
     setPreviousResults(previousResults) {
@@ -1338,5 +1363,5 @@ class GraphAI {
     }
 }
 
-export { GraphAI, NodeState, ValidationError, agentInfoWrapper, assert, defaultAgentInfo, defaultConcurrency, defaultTestContext, graphDataLatestVersion, inputs2dataSources, isObject, parseNodeName, sleep, strIntentionalError };
+export { GraphAI, NodeState, ValidationError, agentInfoWrapper, assert, debugResultKey, defaultAgentInfo, defaultConcurrency, defaultTestContext, graphDataLatestVersion, inputs2dataSources, isObject, parseNodeName, sleep, strIntentionalError };
 //# sourceMappingURL=bundle.esm.js.map