graphai 2.0.14 → 2.0.16

package/lib/graphai.d.ts

@@ -32,7 +32,7 @@ export declare class GraphAI {
     private setStaticNodeResults;
     private updateStaticNodes;
     constructor(graphData: GraphData, agentFunctionInfoDictionary: AgentFunctionInfoDictionary, options?: GraphOptions);
-    getAgentFunctionInfo(agentId?: string): import("./type").AgentFunctionInfo | {
+    getAgentFunctionInfo(agentId?: string, nodeId?: string): import("./type").AgentFunctionInfo | {
         agent: () => Promise<null>;
         hasGraphData: boolean;
         inputs: null;

package/lib/graphai.js

@@ -12,6 +12,28 @@ const GraphAILogger_1 = require("./utils/GraphAILogger");
 exports.defaultConcurrency = 8;
 exports.graphDataLatestVersion = 0.5;
 class GraphAI {
+    version;
+    graphId;
+    graphData;
+    staticNodeInitData = {};
+    loop;
+    forceLoop;
+    logs = [];
+    mapIndex;
+    bypassAgentIds;
+    config = {};
+    agentFunctionInfoDictionary;
+    taskManager;
+    agentFilters;
+    retryLimit;
+    propFunctions;
+    graphLoader;
+    nodes;
+    onLogCallback = (__log, __isUpdate) => { };
+    callbacks = [];
+    verbose; // REVIEW: Do we need this?
+    onComplete;
+    repeatCount = 0;
     // This method is called when either the GraphAI obect was created,
     // or we are about to start n-th iteration (n>2).
     createNodes(graphData) {
@@ -90,12 +112,6 @@ class GraphAI {
         forceLoop: false,
         mapIndex: undefined,
     }) {
-        this.staticNodeInitData = {};
-        this.logs = [];
-        this.config = {};
-        this.onLogCallback = (__log, __isUpdate) => { };
-        this.callbacks = [];
-        this.repeatCount = 0;
         if (!graphData.version && !options.taskManager) {
             GraphAILogger_1.GraphAILogger.warn("------------ missing version number");
         }
@@ -130,7 +146,7 @@ class GraphAI {
         };
         this.nodes = this.createNodes(this.graphData);
     }
-    getAgentFunctionInfo(agentId) {
+    getAgentFunctionInfo(agentId, nodeId) {
         if (agentId && this.agentFunctionInfoDictionary[agentId]) {
             return this.agentFunctionInfoDictionary[agentId];
         }
@@ -145,6 +161,9 @@ class GraphAI {
             };
         }
         // We are not supposed to hit this error because the validator will catch it.
+        if (nodeId) {
+            throw new Error(`No agent: ${agentId} in ${nodeId} node`);
+        }
         throw new Error("No agent: " + agentId);
     }
     asString() {

package/lib/node.js

@@ -9,10 +9,14 @@ const transaction_log_1 = require("./transaction_log");
 const result_1 = require("./utils/result");
 const GraphAILogger_1 = require("./utils/GraphAILogger");
 class Node {
+    nodeId;
+    waitlist = new Set(); // List of nodes which need data from this node.
+    state = type_1.NodeState.Waiting;
+    result = undefined;
+    graph;
+    log;
+    console; // console output option (before and/or after)
     constructor(nodeId, graph) {
-        this.waitlist = new Set(); // List of nodes which need data from this node.
-        this.state = type_1.NodeState.Waiting;
-        this.result = undefined;
         this.nodeId = nodeId;
         this.graph = graph;
         this.log = new transaction_log_1.TransactionLog(nodeId, this.graph.mapIndex);
@@ -51,13 +55,35 @@ class Node {
 }
 exports.Node = Node;
 class ComputedNode extends Node {
+    graphId;
+    isResult;
+    params; // Agent-specific parameters
+    filterParams;
+    nestedGraph;
+    retryLimit;
+    retryCount = 0;
+    repeatUntil;
+    agentId;
+    agentFunction;
+    timeout; // msec
+    priority;
+    error;
+    transactionId; // To reject callbacks from timed-out transactions
+    passThrough;
+    anyInput; // any input makes this node ready
+    dataSources = []; // no longer needed. This is for transaction log.
+    inputs;
+    output;
+    pendings; // List of nodes this node is waiting data from.
+    ifSource; // conditional execution
+    unlessSource; // conditional execution
+    defaultValue;
+    isSkip = false;
+    debugInfo;
+    isStaticNode = false;
+    isComputedNode = true;
     constructor(graphId, nodeId, data, graph) {
         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;
         this.params = data.params ?? {};
         this.console = data.console ?? {};
@@ -254,7 +280,7 @@ class ComputedNode extends Node {
         if (typeof agentId === "function") {
             this.agentFunction = agentId;
         }
-        const hasNestedGraph = Boolean(this.nestedGraph) || Boolean(agentId && this.graph.getAgentFunctionInfo(agentId).hasGraphData);
+        const hasNestedGraph = Boolean(this.nestedGraph) || Boolean(typeof agentId === "string" && this.graph.getAgentFunctionInfo(agentId, this.nodeId).hasGraphData);
         const config = this.getConfig(hasNestedGraph, agentId);
         const transactionId = Date.now();
         this.prepareExecute(transactionId, previousResults, agentId);
@@ -264,7 +290,7 @@ class ComputedNode extends Node {
             }, this.timeout);
         }
         try {
-            const agentFunction = this.agentFunction ?? this.graph.getAgentFunctionInfo(agentId).agent;
+            const agentFunction = this.agentFunction ?? this.graph.getAgentFunctionInfo(agentId, this.nodeId).agent;
             const localLog = [];
             const context = this.getContext(previousResults, localLog, agentId, config);
             // NOTE: We use the existence of graph object in the agent-specific params to determine
@@ -373,9 +399,9 @@ class ComputedNode extends Node {
             //params: this.graph.resultsOf(this.params),
             params,
             namedInputs: previousResults,
-            inputSchema: this.agentFunction ? undefined : this.graph.getAgentFunctionInfo(agentId)?.inputs,
+            inputSchema: this.agentFunction ? undefined : this.graph.getAgentFunctionInfo(agentId, this.nodeId)?.inputs,
             debugInfo: this.debugInfo,
-            cacheType: this.agentFunction ? undefined : this.graph.getAgentFunctionInfo(agentId)?.cacheType,
+            cacheType: this.agentFunction ? undefined : this.graph.getAgentFunctionInfo(agentId, this.nodeId)?.cacheType,
             filterParams: this.filterParams,
             config,
             log: localLog,
@@ -419,10 +445,13 @@ class ComputedNode extends Node {
 }
 exports.ComputedNode = ComputedNode;
 class StaticNode extends Node {
+    value;
+    update;
+    isResult;
+    isStaticNode = true;
+    isComputedNode = false;
     constructor(nodeId, data, graph) {
         super(nodeId, graph);
-        this.isStaticNode = true;
-        this.isComputedNode = false;
         this.value = data.value;
         this.update = data.update ? (0, utils_2.parseNodeName)(data.update) : undefined;
         this.isResult = data.isResult ?? false;

package/lib/task_manager.js

@@ -7,9 +7,10 @@ const utils_1 = require("./utils/utils");
 // NOTE: A TaskManager instance will be shared between parent graph and its children
 // when nested agents are involved.
 class TaskManager {
+    concurrency;
+    taskQueue = [];
+    runningNodes = new Set();
     constructor(concurrency) {
-        this.taskQueue = [];
-        this.runningNodes = new Set();
         this.concurrency = concurrency;
     }
     // This internal method dequeus a task from the task queue

package/lib/transaction_log.js

@@ -5,6 +5,24 @@ const type_1 = require("./type");
 const utils_1 = require("./utils/utils");
 const nodeUtils_1 = require("./utils/nodeUtils");
 class TransactionLog {
+    nodeId;
+    state;
+    startTime;
+    endTime;
+    retryCount;
+    agentId;
+    params;
+    inputs;
+    inputsData;
+    namedInputs;
+    injectFrom;
+    errorMessage;
+    result;
+    resultKeys;
+    mapIndex;
+    isLoop;
+    repeatCount;
+    log;
     constructor(nodeId, mapIndex) {
         this.nodeId = nodeId;
         this.state = type_1.NodeState.Waiting;

package/lib/type.d.ts

@@ -164,4 +164,6 @@ export type AgentFunctionInfo = {
 export type AgentFunctionInfoDictionary = Record<string, AgentFunctionInfo>;
 export type PropFunction = (result: ResultData, propId: string) => ResultData;
 export type CallbackFunction = (log: TransactionLog, isUpdate: boolean) => void;
+export type LogLevel = "debug" | "info" | "log" | "warn" | "error";
+export type LoggerFunction = (level: LogLevel, ...args: any[]) => void;
 export {};

package/lib/utils/GraphAILogger.d.ts

@@ -1,5 +1,4 @@
-type LogLevel = "debug" | "info" | "log" | "warn" | "error";
-type LoggerFunction = (level: LogLevel, ...args: any[]) => void;
+import { type LogLevel, type LoggerFunction } from "../type";
 declare function setLevelEnabled(level: LogLevel, enabled: boolean): void;
 declare function setLogger(logger: LoggerFunction): void;
 declare function debug(...args: any[]): void;

package/lib/utils/data_source.js

@@ -39,7 +39,7 @@ const innerGetDataFromSource = (result, propIds, propFunctions) => {
         const propId = propIds[0];
         const ret = getNestedData(result, propId, propFunctions);
         if (ret === undefined) {
-            GraphAILogger_1.GraphAILogger.info(`prop: ${propIds.join(".")} is not hit`);
+            GraphAILogger_1.GraphAILogger.debug(`prop: ${propIds.join(".")} is not hit`);
         }
         if (propIds.length > 1) {
             return innerGetDataFromSource(ret, propIds.slice(1), propFunctions);

package/lib/utils/utils.d.ts

@@ -2,7 +2,7 @@ import { DataSource, AgentFunction, AgentFunctionInfo, NodeData, StaticNodeData,
 import type { GraphNodes } from "../node";
 export declare const sleep: (milliseconds: number) => Promise<unknown>;
 export declare const parseNodeName: (inputNodeId: any, isSelfNode?: boolean, nodes?: GraphNodes) => DataSource;
-export declare function assert(condition: boolean, message: string, isWarn?: boolean): asserts condition;
+export declare function assert(condition: boolean, message: string, isWarn?: boolean, cause?: unknown): asserts condition;
 export declare const isObject: <Values = unknown>(x: unknown) => x is Record<string, Values>;
 export declare const isNull: (data: unknown) => data is null | undefined;
 export declare const strIntentionalError = "Intentional Error for Debugging";

package/lib/utils/utils.js

@@ -37,9 +37,12 @@ const parseNodeName = (inputNodeId, isSelfNode = false, nodes) => {
     return { value: inputNodeId }; // non-string literal
 };
 exports.parseNodeName = parseNodeName;
-function assert(condition, message, isWarn = false) {
+function assert(condition, message, isWarn = false, cause) {
     if (!condition) {
         if (!isWarn) {
+            if (cause) {
+                throw new Error(message, { cause });
+            }
             throw new Error(message);
         }
         GraphAILogger_1.GraphAILogger.warn("warn: " + message);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "graphai",
-  "version": "2.0.14",
+  "version": "2.0.16",
   "description": "Asynchronous data flow execution engine for agentic AI apps.",
   "main": "lib/index.js",
   "files": [
@@ -27,8 +27,8 @@
   },
   "homepage": "https://github.com/receptron/graphai#readme",
   "devDependencies": {
-    "typedoc": "^0.28.10",
-    "typedoc-plugin-markdown": "^4.8.1"
+    "typedoc": "^0.28.13",
+    "typedoc-plugin-markdown": "^4.9.0"
   },
   "types": "./lib/index.d.ts",
   "directories": {