graphai 0.1.0 → 0.1.1

package/lib/type.d.ts

@@ -1,5 +1,8 @@
+import type { TransactionLog } from "./transaction_log";
+import type { TaskManager } from "./task_manager";
 export declare enum NodeState {
     Waiting = "waiting",
+    Queued = "queued",
     Executing = "executing",
     Failed = "failed",
     TimedOut = "timed-out",
@@ -7,58 +10,68 @@ export declare enum NodeState {
     Injected = "injected",
     Dispatched = "dispatched"
 }
-export type ResultData<ResultType = Record<string, any>> = ResultType | undefined;
-export type ResultDataDictonary<ResultType = Record<string, any>> = Record<string, ResultData<ResultType>>;
-export type NodeDataParams<ParamsType = Record<string, any>> = ParamsType;
+export type DefaultResultData = Record<string, any>;
+export type DefaultInputData = Record<string, any>;
+export type ResultData<ResultType = DefaultResultData> = ResultType | undefined;
+export type ResultDataDictonary<ResultType = DefaultResultData> = Record<string, ResultData<ResultType>>;
+export type DefaultParamsType = Record<string, any>;
+export type NodeDataParams<ParamsType = DefaultParamsType> = ParamsType;
 export type DataSource = {
     nodeId: string;
     propId?: string;
 };
-export type NodeData = {
+export type StaticNodeData = {
+    value: ResultData;
+    update?: string;
+    isResult?: boolean;
+};
+export type ComputedNodeData = {
+    agentId: string;
     inputs?: Array<string>;
     anyInput?: boolean;
     params?: NodeDataParams;
     retry?: number;
     timeout?: number;
-    agentId?: string;
-    fork?: number;
-    value?: ResultData;
-    update?: string;
+    graph?: GraphData;
+    isResult?: boolean;
 };
+export type NodeData = StaticNodeData | ComputedNodeData;
 export type LoopData = {
     count?: number;
     while?: string;
 };
 export type GraphData = {
-    agentId?: string;
     nodes: Record<string, NodeData>;
     concurrency?: number;
     loop?: LoopData;
     verbose?: boolean;
 };
-export type TransactionLog = {
-    nodeId: string;
-    state: NodeState;
-    startTime: number;
-    endTime?: number;
-    retryCount?: number;
-    agentId?: string;
-    params?: NodeDataParams;
-    inputs?: Array<ResultData>;
-    errorMessage?: string;
-    result?: ResultData;
-    log?: TransactionLog[];
-};
-export type AgentFunctionContext<ParamsType, PreviousResultType> = {
-    nodeId: string;
-    forkIndex?: number;
-    retry: number;
+export type AgentFunctionContext<ParamsType, InputDataType> = {
     params: NodeDataParams<ParamsType>;
-    inputs: Array<PreviousResultType>;
-    verbose: boolean;
-    agents: CallbackDictonaryArgs;
-    log: TransactionLog[];
+    inputs: Array<InputDataType>;
+    debugInfo: {
+        verbose: boolean;
+        nodeId: string;
+        retry: number;
+    };
+    graphData?: GraphData;
+    agents?: AgentFunctionDictonary;
+    log?: TransactionLog[];
+    taskManager?: TaskManager;
 };
-export type AgentFunction<ParamsType = Record<string, any>, ResultType = Record<string, any>, PreviousResultType = Record<string, any>> = (context: AgentFunctionContext<ParamsType, PreviousResultType>) => Promise<ResultData<ResultType>>;
+export type AgentFunction<ParamsType = DefaultParamsType, ResultType = DefaultResultData, InputDataType = DefaultInputData> = (context: AgentFunctionContext<ParamsType, InputDataType>) => Promise<ResultData<ResultType>>;
 export type AgentFunctionDictonary = Record<string, AgentFunction<any, any, any>>;
-export type CallbackDictonaryArgs = AgentFunctionDictonary;
+export type AgentFunctionInfo = {
+    name: string;
+    agent: AgentFunction<any, any, any>;
+    mock: AgentFunction<any, any, any>;
+    samples: {
+        inputs: any;
+        params: DefaultParamsType;
+        result: any;
+    }[];
+    description: string;
+    author: string;
+    repository: string;
+    license: string;
+};

package/lib/type.js

@@ -4,6 +4,7 @@ exports.NodeState = void 0;
 var NodeState;
 (function (NodeState) {
     NodeState["Waiting"] = "waiting";
+    NodeState["Queued"] = "queued";
     NodeState["Executing"] = "executing";
     NodeState["Failed"] = "failed";
     NodeState["TimedOut"] = "timed-out";

package/lib/utils/utils.d.ts

@@ -1,3 +1,5 @@
 import { DataSource } from "../type";
 export declare const sleep: (milliseconds: number) => Promise<unknown>;
-export declare const parseNodeName: (name: string) => DataSource;
+export declare const parseNodeName: (inputNodeId: string) => DataSource;
+export declare function assert(condition: boolean, message: string, isWarn?: boolean): asserts condition;
+export declare const isObject: (x: unknown) => boolean;

package/lib/utils/utils.js

@@ -1,17 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseNodeName = exports.sleep = void 0;
+exports.isObject = exports.assert = exports.parseNodeName = exports.sleep = void 0;
 const sleep = async (milliseconds) => {
     return await new Promise((resolve) => setTimeout(resolve, milliseconds));
 };
 exports.sleep = sleep;
-const parseNodeName = (name) => {
-    const parts = name.split(".");
+const parseNodeName = (inputNodeId) => {
+    const parts = inputNodeId.split(".");
     if (parts.length == 1) {
         return { nodeId: parts[0] };
     }
-    else {
-        return { nodeId: parts[0], propId: parts[1] };
-    }
+    return { nodeId: parts[0], propId: parts[1] };
 };
 exports.parseNodeName = parseNodeName;
+function assert(condition, message, isWarn = false) {
+    if (!condition) {
+        if (!isWarn) {
+            throw new Error(message);
+        }
+        console.warn("warn: " + message);
+    }
+}
+exports.assert = assert;
+const isObject = (x) => {
+    return x !== null && typeof x === "object";
+};
+exports.isObject = isObject;

package/lib/validator.d.ts

@@ -0,0 +1,2 @@
+import { GraphData } from "./type";
+export declare const validateGraphData: (data: GraphData, agentIds: string[]) => boolean;

package/lib/validator.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateGraphData = void 0;
+const graph_data_validator_1 = require("./validators/graph_data_validator");
+const nodeValidator_1 = require("./validators/nodeValidator");
+const static_node_validator_1 = require("./validators/static_node_validator");
+const computed_node_validator_1 = require("./validators/computed_node_validator");
+const relation_validator_1 = require("./validators/relation_validator");
+const agent_validator_1 = require("./validators/agent_validator");
+const validateGraphData = (data, agentIds) => {
+    (0, graph_data_validator_1.graphNodesValidator)(data);
+    (0, graph_data_validator_1.graphDataValidator)(data);
+    const computedNodeIds = [];
+    const staticNodeIds = [];
+    const graphAgentIds = new Set();
+    Object.keys(data.nodes).forEach((nodeId) => {
+        const node = data.nodes[nodeId];
+        const isStaticNode = "value" in node;
+        (0, nodeValidator_1.nodeValidator)(node);
+        const agentId = isStaticNode ? "" : node.agentId;
+        isStaticNode && (0, static_node_validator_1.staticNodeValidator)(node) && staticNodeIds.push(nodeId);
+        !isStaticNode && (0, computed_node_validator_1.computedNodeValidator)(node) && computedNodeIds.push(nodeId) && graphAgentIds.add(agentId);
+    });
+    (0, agent_validator_1.agentValidator)(graphAgentIds, new Set(agentIds));
+    (0, relation_validator_1.relationValidator)(data, staticNodeIds, computedNodeIds);
+    return true;
+};
+exports.validateGraphData = validateGraphData;

package/lib/validators/agent_validator.d.ts

@@ -0,0 +1 @@
+export declare const agentValidator: (graphAgentIds: Set<string>, agentIds: Set<string>) => boolean;

package/lib/validators/agent_validator.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.agentValidator = void 0;
+const agentValidator = (graphAgentIds, agentIds) => {
+    graphAgentIds.forEach((agentId) => {
+        if (!agentIds.has(agentId)) {
+            throw new Error("Invalid AgentId : " + agentId + " is not in callbackDictonary.");
+        }
+    });
+    return true;
+};
+exports.agentValidator = agentValidator;

package/lib/validators/common.d.ts

@@ -0,0 +1,3 @@
+export declare const graphDataAttributeKeys: string[];
+export declare const computedNodeAttributeKeys: string[];
+export declare const staticNodeAttributeKeys: string[];

package/lib/validators/common.js

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

package/lib/validators/computed_node_validator.d.ts

@@ -0,0 +1,2 @@
+import { ComputedNodeData } from "../type";
+export declare const computedNodeValidator: (nodeData: ComputedNodeData) => boolean;

package/lib/validators/computed_node_validator.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computedNodeValidator = void 0;
+const common_1 = require("../validators/common");
+const computedNodeValidator = (nodeData) => {
+    Object.keys(nodeData).forEach((key) => {
+        if (!common_1.computedNodeAttributeKeys.includes(key)) {
+            throw new Error("Computed node does not allow " + key);
+        }
+    });
+    return true;
+};
+exports.computedNodeValidator = computedNodeValidator;

package/lib/validators/graph_data_validator.d.ts

@@ -0,0 +1,3 @@
+import { GraphData } from "../type";
+export declare const graphNodesValidator: (data: GraphData) => void;
+export declare const graphDataValidator: (data: GraphData) => void;

package/lib/validators/graph_data_validator.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.graphDataValidator = exports.graphNodesValidator = void 0;
+const common_1 = require("../validators/common");
+const graphNodesValidator = (data) => {
+    if (data.nodes === undefined) {
+        throw new Error("Invalid Graph Data: no nodes");
+    }
+    if (typeof data.nodes !== "object") {
+        throw new Error("Invalid Graph Data: invalid nodes");
+    }
+    if (Array.isArray(data.nodes)) {
+        throw new Error("Invalid Graph Data: nodes must be object");
+    }
+    if (Object.keys(data.nodes).length === 0) {
+        throw new Error("Invalid Graph Data: nodes is empty");
+    }
+    Object.keys(data).forEach((key) => {
+        if (!common_1.graphDataAttributeKeys.includes(key)) {
+            throw new Error("Graph Data does not allow " + key);
+        }
+    });
+};
+exports.graphNodesValidator = graphNodesValidator;
+const graphDataValidator = (data) => {
+    if (data.loop) {
+        if (data.loop.count === undefined && data.loop.while === undefined) {
+            throw new Error("Loop: Either count or while is required in loop");
+        }
+        if (data.loop.count !== undefined && data.loop.while !== undefined) {
+            throw new Error("Loop: Both count and while cannot be set");
+        }
+    }
+    if (data.concurrency !== undefined) {
+        if (!Number.isInteger(data.concurrency)) {
+            throw new Error("Concurrency must be an integer");
+        }
+        if (data.concurrency < 1) {
+            throw new Error("Concurrency must be a positive integer");
+        }
+    }
+};
+exports.graphDataValidator = graphDataValidator;

package/lib/validators/nodeValidator.d.ts

@@ -0,0 +1,2 @@
+import { NodeData } from "../type";
+export declare const nodeValidator: (nodeData: NodeData) => boolean;

package/lib/validators/nodeValidator.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nodeValidator = void 0;
+const nodeValidator = (nodeData) => {
+    if (nodeData.agentId && nodeData.value) {
+        throw new Error("Cannot set both agentId and value");
+    }
+    if (!("agentId" in nodeData) && !("value" in nodeData)) {
+        throw new Error("Either agentId or value is required");
+    }
+    return true;
+};
+exports.nodeValidator = nodeValidator;

package/lib/validators/relation_validator.d.ts

@@ -0,0 +1,2 @@
+import { GraphData } from "../type";
+export declare const relationValidator: (data: GraphData, staticNodeIds: string[], computedNodeIds: string[]) => void;

package/lib/validators/relation_validator.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.relationValidator = void 0;
+const utils_1 = require("../utils/utils");
+const relationValidator = (data, staticNodeIds, computedNodeIds) => {
+    const nodeIds = new Set(Object.keys(data.nodes));
+    const pendings = {};
+    const waitlist = {};
+    // validate input relation and set pendings and wait list
+    computedNodeIds.forEach((computedNodeId) => {
+        const nodeData = data.nodes[computedNodeId];
+        pendings[computedNodeId] = new Set();
+        if (nodeData.inputs) {
+            nodeData.inputs.forEach((inputNodeId) => {
+                const input = (0, utils_1.parseNodeName)(inputNodeId).nodeId;
+                if (!nodeIds.has(input)) {
+                    throw new Error(`Inputs not match: NodeId ${computedNodeId}, Inputs: ${input}`);
+                }
+                waitlist[input] === undefined && (waitlist[input] = new Set());
+                pendings[computedNodeId].add(input);
+                waitlist[input].add(computedNodeId);
+            });
+        }
+    });
+    // TODO. validate update
+    staticNodeIds.forEach((staticNodeId) => {
+        const nodeData = data.nodes[staticNodeId];
+        const update = nodeData.update;
+        if (update) {
+            const updateNodeId = (0, utils_1.parseNodeName)(update).nodeId;
+            if (!nodeIds.has(updateNodeId)) {
+                throw new Error(`Update not match: NodeId ${staticNodeId}, update: ${update}`);
+            }
+        }
+    });
+    const cycle = (possibles) => {
+        possibles.forEach((possobleNodeId) => {
+            (waitlist[possobleNodeId] || []).forEach((waitingNodeId) => {
+                pendings[waitingNodeId].delete(possobleNodeId);
+            });
+        });
+        const running = [];
+        Object.keys(pendings).forEach((pendingNodeId) => {
+            if (pendings[pendingNodeId].size === 0) {
+                running.push(pendingNodeId);
+                delete pendings[pendingNodeId];
+            }
+        });
+        return running;
+    };
+    let runningQueue = cycle(staticNodeIds);
+    if (runningQueue.length === 0) {
+        throw new Error("No Initial Runnning Node");
+    }
+    do {
+        runningQueue = cycle(runningQueue);
+    } while (runningQueue.length > 0);
+    if (Object.keys(pendings).length > 0) {
+        throw new Error("Some nodes are not executed: " + Object.keys(pendings).join(", "));
+    }
+};
+exports.relationValidator = relationValidator;

package/lib/validators/static_node_validator.d.ts

@@ -0,0 +1,2 @@
+import { StaticNodeData } from "../type";
+export declare const staticNodeValidator: (nodeData: StaticNodeData) => boolean;

package/lib/validators/static_node_validator.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.staticNodeValidator = void 0;
+const common_1 = require("../validators/common");
+const staticNodeValidator = (nodeData) => {
+    Object.keys(nodeData).forEach((key) => {
+        if (!common_1.staticNodeAttributeKeys.includes(key)) {
+            throw new Error("Static node does not allow " + key);
+        }
+    });
+    return true;
+};
+exports.staticNodeValidator = staticNodeValidator;

package/package.json

@@ -1,11 +1,8 @@
 {
   "name": "graphai",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Asynchronous data flow execution engine to make it simple to build LLM apps.",
   "main": "lib/index.js",
-  "bin": {
-    "graphai": "lib/graphai_cli.js"
-  },
   "files": [
     "./lib"
   ],
@@ -14,7 +11,7 @@
     "eslint": "eslint --fix --ext .ts ./src ./tests ./samples",
     "format": "prettier --write '{src,tests,samples}/**/*.ts' .eslintrc.js",
     "test": "node --test  -r tsconfig-paths/register --require ts-node/register ./tests/**/test_*.ts",
-    "cli": "npx ts-node  -r tsconfig-paths/register ./src/graphai_cli.ts",
+    "b": "yarn run format && yarn run eslint && yarn run build",
     "samples": "npx ts-node  -r tsconfig-paths/register samples/sample_runner.ts",
     "sample": "npx ts-node  -r tsconfig-paths/register"
   },
@@ -43,6 +40,7 @@
     "openai": "^4.12.4",
     "prettier": "^3.0.3",
     "slashgpt": "^0.0.8",
+    "tiktoken": "^1.0.14",
     "ts-node": "^10.9.1",
     "tsc-alias": "^1.8.8",
     "tsconfig-paths": "^4.2.0",

package/lib/experimental_agents/array_agents.d.ts

@@ -1,4 +0,0 @@
-import { AgentFunction } from "../graphai";
-export declare const pushAgent: AgentFunction<Record<string, any>, Record<string, any>, Record<string, any>>;
-export declare const popAgent: AgentFunction<Record<string, any>, Record<string, any>, Record<string, any>>;
-export declare const shiftAgent: AgentFunction<Record<string, any>, Record<string, any>, Record<string, any>>;

package/lib/experimental_agents/data_agent.d.ts

@@ -1,3 +0,0 @@
-import { AgentFunction } from "../graphai";
-export declare const dataObjectMergeTemplateAgent: AgentFunction;
-export declare const dataSumTemplateAgent: AgentFunction<Record<string, any>, number, number>;

package/lib/experimental_agents/data_agent.js

@@ -1,25 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.dataSumTemplateAgent = exports.dataObjectMergeTemplateAgent = void 0;
-const deepmerge_1 = __importDefault(require("deepmerge"));
-const dataObjectMergeTemplateAgent = async ({ nodeId, params, inputs, verbose }) => {
-    if (verbose) {
-        console.log("executing", nodeId, params);
-    }
-    return inputs.reduce((tmp, input) => {
-        return (0, deepmerge_1.default)(tmp, input);
-    }, {});
-};
-exports.dataObjectMergeTemplateAgent = dataObjectMergeTemplateAgent;
-const dataSumTemplateAgent = async ({ nodeId, params, inputs, verbose }) => {
-    if (verbose) {
-        console.log("executing", nodeId, params);
-    }
-    return inputs.reduce((tmp, input) => {
-        return tmp + input;
-    }, 0);
-};
-exports.dataSumTemplateAgent = dataSumTemplateAgent;

package/lib/experimental_agents/sleeper_agent.d.ts

@@ -1,10 +0,0 @@
-import { AgentFunction } from "../graphai";
-export declare const sleeperAgent: AgentFunction<{
-    duration: number;
-    value?: Record<string, any>;
-}>;
-export declare const sleeperAgentDebug: AgentFunction<{
-    duration: number;
-    value?: Record<string, any>;
-    fail?: boolean;
-}>;

package/lib/experimental_agents/string_agent.d.ts

@@ -1,7 +0,0 @@
-import { AgentFunction } from "../graphai";
-export declare const stringTemplateAgent: AgentFunction<{
-    template: string;
-    inputKey?: string;
-}, {
-    content: string;
-}>;

package/lib/graphai_cli.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};

package/lib/graphai_cli.js

@@ -1,37 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const graphai_1 = require("./graphai");
-const experimental_agents_1 = require("./experimental_agents");
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-const yaml_1 = __importDefault(require("yaml"));
-const testAgent = async () => {
-    return {};
-};
-const main = async () => {
-    const file = process.argv[2];
-    if (file === undefined) {
-        console.log("no file");
-        return;
-    }
-    const file_path = path_1.default.resolve(process.cwd() + "/" + file);
-    if (!fs_1.default.existsSync(file_path)) {
-        console.log("no file");
-        return;
-    }
-    try {
-        const graph_data_file = fs_1.default.readFileSync(file_path, "utf8");
-        const graph_data = yaml_1.default.parse(graph_data_file);
-        const graph = new graphai_1.GraphAI(graph_data, { testAgent, slashGPTAgent: experimental_agents_1.slashGPTAgent, stringTemplateAgent: experimental_agents_1.stringTemplateAgent });
-        const results = await graph.run();
-        console.log(results);
-    }
-    catch (e) {
-        console.log("error", e);
-    }
-};
-main();

package/lib/utils.d.ts

@@ -1,7 +0,0 @@
-export declare const parseNodeName: (name: string) => {
-    sourceNodeId: string;
-    propId?: undefined;
-} | {
-    sourceNodeId: string;
-    propId: string;
-};

package/lib/utils.js

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseNodeName = void 0;
-const parseNodeName = (name) => {
-    const parts = name.split(".");
-    if (parts.length == 1) {
-        return { sourceNodeId: parts[0] };
-    }
-    else {
-        return { sourceNodeId: parts[0], propId: parts[1] };
-    }
-};
-exports.parseNodeName = parseNodeName;