graphai 0.1.0 → 0.1.2

package/lib/utils/test_utils.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.agentTestRunner = exports.defaultTestContext = void 0;
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_test_1 = __importDefault(require("node:test"));
+exports.defaultTestContext = {
+    debugInfo: {
+        nodeId: "test",
+        retry: 0,
+        verbose: true,
+    },
+    params: {},
+    agents: {},
+    log: [],
+};
+// for agent
+const agentTestRunner = async (agentInfo) => {
+    (0, node_test_1.default)(`test ${agentInfo.name}`, async () => {
+        const { agent, samples } = agentInfo;
+        for await (const sample of samples) {
+            const { params, inputs, result } = sample;
+            const actual = await agent({
+                ...exports.defaultTestContext,
+                params,
+                inputs,
+            });
+            node_assert_1.default.deepStrictEqual(result, actual);
+        }
+    });
+};
+exports.agentTestRunner = agentTestRunner;

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",
-  "description": "Asynchronous data flow execution engine to make it simple to build LLM apps.",
+  "version": "0.1.2",
+  "description": "Asynchronous data flow execution engine for agentic AI apps.",
   "main": "lib/index.js",
-  "bin": {
-    "graphai": "lib/graphai_cli.js"
-  },
   "files": [
     "./lib"
   ],
@@ -14,20 +11,20 @@
     "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"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/snakajima/graphai"
+    "url": "git+https://github.com/receptron/graphai"
   },
-  "author": "Satoshi Nakajima",
+  "author": "Satoshi Nakajima, Isamu Arimoto",
   "license": "MIT",
   "bugs": {
-    "url": "https://github.com/snakajima/graphai/issues"
+    "url": "https://github.com/receptron/graphai/issues"
   },
-  "homepage": "https://github.com/snakajima/graphai#readme",
+  "homepage": "https://github.com/receptron/graphai#readme",
   "devDependencies": {
     "@inquirer/prompts": "^5.0.0",
     "@types/express": "^4.17.21",
@@ -43,14 +40,13 @@
     "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",
     "typescript": "^5.2.2",
-    "wikipedia": "^2.1.2"
-  },
-  "dependencies": {
-    "yaml": "^2.3.3"
+    "wikipedia": "^2.1.2",
+    "yaml": "^2.4.1"
   },
   "types": "./lib/index.d.ts",
   "directories": {

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/experimental_agents/string_agent.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.stringTemplateAgent = void 0;
-// see example
-//  tests/agents/test_string_agent.ts
-const stringTemplateAgent = async ({ nodeId, params, inputs, verbose }) => {
-    if (verbose) {
-        console.log("executing", nodeId, params);
-    }
-    const content = inputs.reduce((template, input, index) => {
-        return template.replace("${" + index + "}", input[params.inputKey ?? "content"]);
-    }, params.template);
-    return { content };
-};
-exports.stringTemplateAgent = stringTemplateAgent;

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/log.d.ts

@@ -1,6 +0,0 @@
-import { ResultData, TransactionLog, NodeDataParams } from "./type";
-export declare const injectValueLog: (nodeId: string, value: ResultData) => TransactionLog;
-export declare const executeLog: (nodeId: string, retryCount: number, transactionId: number, agentId: string | undefined, params: NodeDataParams, results: ResultData[]) => TransactionLog;
-export declare const timeoutLog: (log: TransactionLog) => void;
-export declare const callbackLog: (log: TransactionLog, result: ResultData, localLog: TransactionLog[]) => void;
-export declare const errorLog: (log: TransactionLog, errorMessage: string) => void;

package/lib/log.js

@@ -1,48 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.errorLog = exports.callbackLog = exports.timeoutLog = exports.executeLog = exports.injectValueLog = void 0;
-const type_1 = require("./type");
-const injectValueLog = (nodeId, value) => {
-    const log = {
-        nodeId,
-        state: type_1.NodeState.Injected,
-        startTime: Date.now(),
-        endTime: Date.now(),
-        result: value,
-    };
-    return log;
-};
-exports.injectValueLog = injectValueLog;
-const executeLog = (nodeId, retryCount, transactionId, agentId, params, results) => {
-    const log = {
-        nodeId,
-        retryCount: retryCount > 0 ? retryCount : undefined,
-        state: type_1.NodeState.Executing,
-        startTime: transactionId,
-        agentId,
-        params,
-        inputs: results.length > 0 ? results : undefined,
-    };
-    return log;
-};
-exports.executeLog = executeLog;
-const timeoutLog = (log) => {
-    log.errorMessage = "Timeout";
-    log.state = type_1.NodeState.TimedOut;
-    log.endTime = Date.now();
-};
-exports.timeoutLog = timeoutLog;
-const callbackLog = (log, result, localLog) => {
-    log.endTime = Date.now();
-    log.result = result;
-    if (localLog.length > 0) {
-        log.log = localLog;
-    }
-};
-exports.callbackLog = callbackLog;
-const errorLog = (log, errorMessage) => {
-    log.state = type_1.NodeState.Failed;
-    log.endTime = Date.now();
-    log.errorMessage = errorMessage;
-};
-exports.errorLog = errorLog;

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;