graphai 0.2.3 → 0.2.5

package/lib/experimental_agents/llm_agents/groq_agent.js

@@ -3,11 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.gloqAgent = void 0;
 const groq_sdk_1 = require("groq-sdk");
 const utils_1 = require("../../utils/utils");
-const groq = process.env.GROQ_API_KEY
-    ? new groq_sdk_1.Groq({
-        apiKey: process.env.GROQ_API_KEY,
-    })
-    : undefined;
+const groq = process.env.GROQ_API_KEY ? new groq_sdk_1.Groq({ apiKey: process.env.GROQ_API_KEY }) : undefined;
 const gloqAgent = async ({ params, inputs }) => {
     (0, utils_1.assert)(groq !== undefined, "The GROQ_API_KEY environment variable is missing.");
     const query = params?.query ? [params.query] : [];

package/lib/graphai.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GraphAI = void 0;
-const type_1 = require("./type");
 const node_1 = require("./node");
 const utils_1 = require("./utils/utils");
 const validator_1 = require("./validator");
@@ -144,7 +143,7 @@ class GraphAI {
     }
     // for computed
     pushQueue(node) {
-        node.state = type_1.NodeState.Queued;
+        node.beforeAddTask();
         this.taskManager.addTask(node, this.graphId, (_node) => {
             (0, utils_1.assert)(node.nodeId === _node.nodeId, "GraphAI.pushQueue node mismatch");
             node.execute();

package/lib/node.d.ts

@@ -21,6 +21,7 @@ export declare class ComputedNode extends Node {
     retryCount: number;
     readonly agentId?: string;
     readonly timeout?: number;
+    readonly priority: number;
     error?: Error;
     transactionId: undefined | number;
     readonly anyInput: boolean;
@@ -32,6 +33,7 @@ export declare class ComputedNode extends Node {
     isReadyNode(): boolean;
     private retry;
     private checkDataAvailability;
+    beforeAddTask(): void;
     removePending(nodeId: string): void;
     private isCurrentTransaction;
     private executeTimeout;

package/lib/node.js

@@ -43,6 +43,7 @@ class ComputedNode extends Node {
         this.retryLimit = data.retry ?? graph.retryLimit ?? 0;
         this.timeout = data.timeout;
         this.isResult = data.isResult ?? false;
+        this.priority = data.priority ?? 0;
         this.anyInput = data.anyInput ?? false;
         this.dataSources = (data.inputs ?? []).map((input) => (0, utils_2.parseNodeName)(input));
         this.pendings = new Set(this.dataSources.filter((source) => source.nodeId).map((source) => source.nodeId));
@@ -87,6 +88,11 @@ class ComputedNode extends Node {
         });
         return results.length > 0;
     }
+    // This method is called right before the Graph add this node to the task manager.
+    beforeAddTask() {
+        this.state = type_1.NodeState.Queued;
+        this.log.beforeAddTask(this, this.graph);
+    }
     // This method is called when the data became available on one of nodes,
     // which this node needs data from.
     removePending(nodeId) {

package/lib/task_manager.d.ts

@@ -11,8 +11,14 @@ export declare class TaskManager {
     prepareForNesting(): void;
     restoreAfterNesting(): void;
     getStatus(verbose?: boolean): {
-        runningNodes?: string[] | undefined;
-        queuedNodes?: string[] | undefined;
+        runningNodes: string[];
+        queuedNodes: string[];
+        concurrency: number;
+        queue: number;
+        running: number;
+    } | {
+        runningNodes?: undefined;
+        queuedNodes?: undefined;
         concurrency: number;
         queue: number;
         running: number;

package/lib/task_manager.js

@@ -27,7 +27,12 @@ class TaskManager {
     // Node will call this method to put itself in the execution queue.
     // We call the associated callback function when it is dequeued.
     addTask(node, graphId, callback) {
-        this.taskQueue.push({ node, graphId, callback });
+        // Finder tasks in the queue, which has either the same or higher priority.
+        const count = this.taskQueue.filter((task) => {
+            return task.node.priority >= node.priority;
+        }).length;
+        (0, utils_1.assert)(count <= this.taskQueue.length, "TaskManager.addTask: Something is really wrong.");
+        this.taskQueue.splice(count, 0, { node, graphId, callback });
         this.dequeueTaskIfPossible();
     }
     isRunning(graphId) {
@@ -53,16 +58,17 @@ class TaskManager {
         this.concurrency--;
     }
     getStatus(verbose = false) {
+        const nodes = verbose
+            ? {
+                runningNodes: Array.from(this.runningNodes).map((node) => node.nodeId),
+                queuedNodes: this.taskQueue.map((task) => task.node.nodeId),
+            }
+            : {};
         return {
             concurrency: this.concurrency,
             queue: this.taskQueue.length,
             running: this.runningNodes.size,
-            ...(verbose
-                ? {
-                    runningNodes: Array.from(this.runningNodes).map((node) => node.nodeId),
-                    queuedNodes: this.taskQueue.map((task) => task.node.nodeId),
-                }
-                : {}),
+            ...nodes,
         };
     }
 }

package/lib/transaction_log.d.ts

@@ -23,5 +23,6 @@ export declare class TransactionLog {
     onInjected(node: StaticNode, graph: GraphAI, injectFrom?: string): void;
     onComplete(node: ComputedNode, graph: GraphAI, localLog: TransactionLog[]): void;
     beforeExecute(node: ComputedNode, graph: GraphAI, transactionId: number, inputs: ResultData[]): void;
+    beforeAddTask(node: ComputedNode, graph: GraphAI): void;
     onError(node: ComputedNode, graph: GraphAI, errorMessage: string): void;
 }

package/lib/transaction_log.js

@@ -45,6 +45,11 @@ class TransactionLog {
         graph.setLoopLog(this);
         graph.appendLog(this);
     }
+    beforeAddTask(node, graph) {
+        this.state = node.state;
+        graph.setLoopLog(this);
+        graph.appendLog(this);
+    }
     onError(node, graph, errorMessage) {
         this.state = node.state;
         this.errorMessage = errorMessage;

package/lib/type.d.ts

@@ -7,8 +7,7 @@ export declare enum NodeState {
     Failed = "failed",
     TimedOut = "timed-out",
     Completed = "completed",
-    Injected = "injected",
-    Dispatched = "dispatched"
+    Injected = "injected"
 }
 export type DefaultResultData = Record<string, any> | string | number | Array<DefaultResultData>;
 export type DefaultInputData = Record<string, any>;
@@ -35,6 +34,7 @@ export type ComputedNodeData = {
     timeout?: number;
     graph?: GraphData;
     isResult?: boolean;
+    priority?: number;
 };
 export type NodeData = StaticNodeData | ComputedNodeData;
 export type LoopData = {

package/lib/type.js

@@ -10,5 +10,4 @@ var NodeState;
     NodeState["TimedOut"] = "timed-out";
     NodeState["Completed"] = "completed";
     NodeState["Injected"] = "injected";
-    NodeState["Dispatched"] = "dispatched";
 })(NodeState || (exports.NodeState = NodeState = {}));

package/lib/validators/common.js

@@ -2,5 +2,5 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.staticNodeAttributeKeys = exports.computedNodeAttributeKeys = exports.graphDataAttributeKeys = void 0;
 exports.graphDataAttributeKeys = ["nodes", "concurrency", "agentId", "loop", "verbose", "version"];
-exports.computedNodeAttributeKeys = ["inputs", "anyInput", "params", "retry", "timeout", "agentId", "graph", "isResult"];
+exports.computedNodeAttributeKeys = ["inputs", "anyInput", "params", "retry", "timeout", "agentId", "graph", "isResult", "priority"];
 exports.staticNodeAttributeKeys = ["value", "update", "isResult"];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "graphai",
-  "version": "0.2.3",
+  "version": "0.2.5",
   "description": "Asynchronous data flow execution engine for agentic AI apps.",
   "main": "lib/index.js",
   "files": [