graphai 0.1.1 → 0.2.0

package/lib/node.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StaticNode = exports.ComputedNode = exports.Node = void 0;
-const type_1 = require("./type");
 const utils_1 = require("./utils/utils");
+const type_1 = require("./type");
+const utils_2 = require("./utils/utils");
 const transaction_log_1 = require("./transaction_log");
 class Node {
     constructor(nodeId, graph) {
@@ -33,7 +34,6 @@ class ComputedNode extends Node {
     constructor(graphId, nodeId, data, graph) {
         super(nodeId, graph);
         this.retryCount = 0;
-        this.sources = {}; // data sources.
         this.isStaticNode = false;
         this.isComputedNode = true;
         this.graphId = graphId;
@@ -44,13 +44,8 @@ class ComputedNode extends Node {
         this.timeout = data.timeout;
         this.isResult = data.isResult ?? false;
         this.anyInput = data.anyInput ?? false;
-        this.sources = (data.inputs ?? []).reduce((tmp, input) => {
-            const source = (0, utils_1.parseNodeName)(input);
-            tmp[source.nodeId] = source;
-            return tmp;
-        }, {});
-        this.inputs = Object.keys(this.sources);
-        this.pendings = new Set(this.inputs);
+        this.dataSources = (data.inputs ?? []).map(utils_2.parseNodeName);
+        this.pendings = new Set(this.dataSources.map((source) => source.nodeId));
         this.log.initForComputedNode(this);
     }
     isReadyNode() {
@@ -58,9 +53,8 @@ class ComputedNode extends Node {
             // Count the number of data actually available.
             // We care it only when this.anyInput is true.
             // Notice that this logic enables dynamic data-flows.
-            const counter = this.inputs.reduce((count, nodeId) => {
-                const source = this.sources[nodeId];
-                const [result] = this.graph.resultsOf([source], this.anyInput);
+            const counter = this.dataSources.reduce((count, source) => {
+                const [result] = this.graph.resultsOf([source]);
                 return result === undefined ? count : count + 1;
             }, 0);
             if (!this.anyInput || counter > 0) {
@@ -86,12 +80,18 @@ class ComputedNode extends Node {
             this.graph.onExecutionComplete(this);
         }
     }
+    checkDataAvailability() {
+        (0, utils_2.assert)(this.anyInput, "checkDataAvailability should be called only for anyInput case");
+        const results = this.graph.resultsOf(this.dataSources).filter((result) => {
+            return result !== undefined;
+        });
+        return results.length > 0;
+    }
     // This method is called when the data became available on one of nodes,
     // which this node needs data from.
     removePending(nodeId) {
         if (this.anyInput) {
-            const [result] = this.graph.resultsOf([this.sources[nodeId]], this.anyInput);
-            if (result) {
+            if (this.checkDataAvailability()) {
                 this.pendings.clear();
             }
         }
@@ -116,11 +116,7 @@ class ComputedNode extends Node {
     // then it removes itself from the "running node" list of the graph.
     // Notice that setting the result of this node may make other nodes ready to run.
     async execute() {
-        const previousResults = this.graph
-            .resultsOf(this.inputs.map((input) => {
-            return this.sources[input];
-        }), this.anyInput)
-            .filter((result) => {
+        const previousResults = this.graph.resultsOf(this.dataSources).filter((result) => {
             // Remove undefined if anyInput flag is set.
             return !this.anyInput || result !== undefined;
         });
@@ -183,8 +179,10 @@ class ComputedNode extends Node {
     // the agent function. It records the error in the transaction log and handles
     // the retry if specified.
     errorProcess(error, transactionId) {
-        console.error(this.agentId + ": error");
-        console.error(error);
+        if (error instanceof Error && error.message !== utils_1.strIntentionalError) {
+            console.error(this.agentId + ": error");
+            console.error(error);
+        }
         if (!this.isCurrentTransaction(transactionId)) {
             console.log(`-- ${this.nodeId}: transactionId mismatch(error)`);
             return;

package/lib/transaction_log.js

@@ -40,7 +40,7 @@ class TransactionLog {
         this.state = node.state;
         this.retryCount = node.retryCount > 0 ? node.retryCount : undefined;
         this.startTime = transactionId;
-        this.inputs = node.inputs;
+        this.inputs = node.dataSources.map((source) => source.nodeId);
         this.inputsData = inputs.length > 0 ? inputs : undefined;
         graph.setLoopLog(this);
         graph.appendLog(this);

package/lib/type.d.ts

@@ -10,7 +10,7 @@ export declare enum NodeState {
     Injected = "injected",
     Dispatched = "dispatched"
 }
-export type DefaultResultData = Record<string, any>;
+export type DefaultResultData = Record<string, any> | string | number | Array<DefaultResultData>;
 export type DefaultInputData = Record<string, any>;
 export type ResultData<ResultType = DefaultResultData> = ResultType | undefined;
 export type ResultDataDictonary<ResultType = DefaultResultData> = Record<string, ResultData<ResultType>>;
@@ -18,7 +18,7 @@ export type DefaultParamsType = Record<string, any>;
 export type NodeDataParams<ParamsType = DefaultParamsType> = ParamsType;
 export type DataSource = {
     nodeId: string;
-    propId?: string;
+    propIds?: string[];
 };
 export type StaticNodeData = {
     value: ResultData;
@@ -54,7 +54,7 @@ export type AgentFunctionContext<ParamsType, InputDataType> = {
         nodeId: string;
         retry: number;
     };
-    graphData?: GraphData;
+    graphData?: GraphData | string;
     agents?: AgentFunctionDictonary;
     log?: TransactionLog[];
     taskManager?: TaskManager;
@@ -71,6 +71,7 @@ export type AgentFunctionInfo = {
         result: any;
     }[];
     description: string;
+    category: string[];
     author: string;
     repository: string;
     license: string;

package/lib/utils/test_agents.d.ts

@@ -0,0 +1,2 @@
+import { AgentFunctionDictonary } from "../graphai";
+export declare const defaultTestAgents: AgentFunctionDictonary;

package/lib/utils/test_agents.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultTestAgents = void 0;
+const experimental_agents_1 = require("../experimental_agents");
+exports.defaultTestAgents = {
+    bypassAgent: experimental_agents_1.bypassAgent,
+    echoAgent: experimental_agents_1.echoAgent,
+    copyMessageAgent: experimental_agents_1.copyMessageAgent,
+    mergeNodeIdAgent: experimental_agents_1.mergeNodeIdAgent,
+    sleeperAgent: experimental_agents_1.sleeperAgent,
+    sleeperAgentDebug: experimental_agents_1.sleeperAgentDebug,
+    stringTemplateAgent: experimental_agents_1.stringTemplateAgent,
+    nestedAgent: experimental_agents_1.nestedAgent,
+    mapAgent: experimental_agents_1.mapAgent,
+    totalAgent: experimental_agents_1.totalAgent,
+    countingAgent: experimental_agents_1.countingAgent,
+    copy2ArrayAgent: experimental_agents_1.copy2ArrayAgent,
+    pushAgent: experimental_agents_1.pushAgent,
+    popAgent: experimental_agents_1.popAgent,
+};

package/lib/utils/test_utils.d.ts

@@ -0,0 +1,12 @@
+import { AgentFunctionInfo } from "../type";
+export declare const defaultTestContext: {
+    debugInfo: {
+        nodeId: string;
+        retry: number;
+        verbose: boolean;
+    };
+    params: {};
+    agents: {};
+    log: never[];
+};
+export declare const agentTestRunner: (agentInfo: AgentFunctionInfo) => Promise<void>;

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(actual, result);
+        }
+    });
+};
+exports.agentTestRunner = agentTestRunner;

package/lib/utils/utils.d.ts

@@ -1,5 +1,7 @@
-import { DataSource } from "../type";
+import { DataSource, ResultData } from "../type";
 export declare const sleep: (milliseconds: number) => Promise<unknown>;
 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;
+export declare const getDataFromSource: (result: ResultData, propIds: string[] | undefined) => ResultData | undefined;
+export declare const strIntentionalError = "Intentional Error for Debugging";

package/lib/utils/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isObject = exports.assert = exports.parseNodeName = exports.sleep = void 0;
+exports.strIntentionalError = exports.getDataFromSource = exports.isObject = exports.assert = exports.parseNodeName = exports.sleep = void 0;
 const sleep = async (milliseconds) => {
     return await new Promise((resolve) => setTimeout(resolve, milliseconds));
 };
@@ -10,7 +10,7 @@ const parseNodeName = (inputNodeId) => {
     if (parts.length == 1) {
         return { nodeId: parts[0] };
     }
-    return { nodeId: parts[0], propId: parts[1] };
+    return { nodeId: parts[0], propIds: parts.slice(1) };
 };
 exports.parseNodeName = parseNodeName;
 function assert(condition, message, isWarn = false) {
@@ -26,3 +26,31 @@ const isObject = (x) => {
     return x !== null && typeof x === "object";
 };
 exports.isObject = isObject;
+const getNestedData = (result, propId) => {
+    if (Array.isArray(result)) {
+        const regex = /^\$(\d+)$/;
+        const match = propId.match(regex);
+        if (match) {
+            const index = parseInt(match[1], 10);
+            return result[index];
+        }
+        if (propId === "$last") {
+            return result[result.length - 1];
+        }
+    }
+    assert((0, exports.isObject)(result), "result is not object.");
+    return result[propId];
+};
+const getDataFromSource = (result, propIds) => {
+    if (result && propIds && propIds.length > 0) {
+        const propId = propIds[0];
+        const ret = getNestedData(result, propId);
+        if (propIds.length > 1) {
+            return (0, exports.getDataFromSource)(ret, propIds.slice(1));
+        }
+        return ret;
+    }
+    return result;
+};
+exports.getDataFromSource = getDataFromSource;
+exports.strIntentionalError = "Intentional Error for Debugging";

package/package.json

@@ -1,30 +1,31 @@
 {
   "name": "graphai",
-  "version": "0.1.1",
-  "description": "Asynchronous data flow execution engine to make it simple to build LLM apps.",
+  "version": "0.2.0",
+  "description": "Asynchronous data flow execution engine for agentic AI apps.",
   "main": "lib/index.js",
   "files": [
     "./lib"
   ],
   "scripts": {
-    "build": "tsc && tsc-alias",
+    "build": "rm -r lib/* && tsc && tsc-alias",
     "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",
+    "http_test": "node --test  -r tsconfig-paths/register --require ts-node/register ./tests/**/http_*.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",
@@ -45,10 +46,8 @@
     "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/map_agent.d.ts

@@ -1,4 +0,0 @@
-import { AgentFunction } from "../graphai";
-export declare const mapAgent: AgentFunction<{
-    injectionTo?: string;
-}, Record<string, Array<any>>, any>;

package/lib/experimental_agents/matrix_agent.d.ts

@@ -1,9 +0,0 @@
-import { AgentFunction } from "../graphai";
-export declare const dotProductAgent: AgentFunction<Record<string, any>, {
-    contents: Array<number>;
-}, Array<Array<number>>>;
-export declare const sortByValuesAgent: AgentFunction<{
-    assendant?: boolean;
-}, {
-    contents: Array<any>;
-}, Array<any>>;

package/lib/experimental_agents/nested_agent.d.ts

@@ -1,6 +0,0 @@
-import { GraphData, AgentFunction } from "../graphai";
-export declare const nestedAgent: AgentFunction<{
-    graph: GraphData;
-    resultFrom: string;
-    injectionTo?: Array<string>;
-}>;

package/lib/experimental_agents/nested_agent.js

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.nestedAgent = void 0;
-const graphai_1 = require("../graphai");
-const utils_1 = require("../utils/utils");
-const nestedAgent = async ({ params, inputs, agents, log, taskManager, graphData }) => {
-    if (taskManager) {
-        const status = taskManager.getStatus(false);
-        (0, utils_1.assert)(status.concurrency > status.running, `nestedAgent: Concurrency is too low: ${status.concurrency}`);
-    }
-    (0, utils_1.assert)(graphData !== undefined, "nestedAgent: graphData is required");
-    const graphAI = new graphai_1.GraphAI(graphData, agents || {}, taskManager);
-    try {
-        // Inject inputs to specified source nodes
-        (params.injectionTo ?? []).forEach((injectToNodeId, index) => {
-            graphAI.injectValue(injectToNodeId, inputs[index]);
-        });
-        const results = await graphAI.run(true);
-        log?.push(...graphAI.transactionLogs());
-        return results[params.resultFrom];
-    }
-    catch (error) {
-        log?.push(...graphAI.transactionLogs());
-        if (error instanceof Error) {
-            console.log("Error:", error.message);
-        }
-        throw error;
-    }
-};
-exports.nestedAgent = nestedAgent;

package/lib/experimental_agents/test_agents/echo_fork_index_agent.d.ts

@@ -1,2 +0,0 @@
-import { AgentFunction } from "../../graphai";
-export declare const echoForkIndexAgent: AgentFunction;

package/lib/experimental_agents/test_agents/echo_fork_index_agent.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.echoForkIndexAgent = void 0;
-const echoForkIndexAgent = async ({ debugInfo: { forkIndex } }) => {
-    return { forkIndex };
-};
-exports.echoForkIndexAgent = echoForkIndexAgent;

package/lib/log.d.ts

@@ -1,22 +0,0 @@
-import { ResultData, NodeDataParams, NodeState } from "./type";
-import type { GraphAI } from "./graphai";
-import type { ComputedNode, StaticNode } from "./node";
-export declare class TransactionLog {
-    nodeId: string;
-    state: NodeState;
-    startTime?: number;
-    endTime?: number;
-    retryCount?: number;
-    agentId?: string;
-    params?: NodeDataParams;
-    inputs?: Array<ResultData>;
-    errorMessage?: string;
-    result?: ResultData;
-    log?: TransactionLog[];
-    constructor(nodeId: string);
-    initForComputedNode(node: ComputedNode): void;
-    onInjected(node: StaticNode, graph: GraphAI): void;
-    onComplete(node: ComputedNode, graph: GraphAI, localLog: TransactionLog[]): void;
-    beforeExecute(node: ComputedNode, graph: GraphAI, transactionId: number, inputs: ResultData[]): void;
-    onError(node: ComputedNode, graph: GraphAI, errorMessage: string): void;
-}

package/lib/log.js

@@ -1,49 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TransactionLog = void 0;
-const type_1 = require("./type");
-class TransactionLog {
-    constructor(nodeId) {
-        this.nodeId = nodeId;
-        this.state = type_1.NodeState.Waiting;
-    }
-    initForComputedNode(node) {
-        this.agentId = node.agentId;
-        this.params = node.params;
-    }
-    onInjected(node, graph) {
-        const isUpdating = "endTime" in this;
-        this.result = node.value;
-        this.state = node.state;
-        this.endTime = Date.now();
-        if (isUpdating) {
-            graph.updateLog(this);
-        }
-        else {
-            graph.appendLog(this);
-        }
-    }
-    onComplete(node, graph, localLog) {
-        this.result = node.result;
-        this.state = node.state;
-        this.endTime = Date.now();
-        if (localLog.length > 0) {
-            this.log = localLog;
-        }
-        graph.updateLog(this);
-    }
-    beforeExecute(node, graph, transactionId, inputs) {
-        this.state = node.state;
-        this.retryCount = node.retryCount > 0 ? node.retryCount : undefined;
-        this.startTime = transactionId;
-        this.inputs = inputs.length > 0 ? inputs : undefined;
-        graph.appendLog(this);
-    }
-    onError(node, graph, errorMessage) {
-        this.state = node.state;
-        this.errorMessage = errorMessage;
-        this.endTime = Date.now();
-        graph.updateLog(this);
-    }
-}
-exports.TransactionLog = TransactionLog;

package/lib/task.d.ts

@@ -1,18 +0,0 @@
-import { ComputedNode } from "./node";
-export declare class TaskManager {
-    private concurrency;
-    private taskQueue;
-    private runningNodes;
-    constructor(concurrency: number);
-    private dequeueTaskIfPossible;
-    addTask(node: ComputedNode, callback: (node: ComputedNode) => void): void;
-    onComplete(node: ComputedNode): void;
-    prepareForNesting(): void;
-    getStatus(verbose?: boolean): {
-        runningNodes?: string[] | undefined;
-        queuedNodes?: string[] | undefined;
-        concurrency: number;
-        queue: number;
-        running: number;
-    };
-}

package/lib/task.js

@@ -1,63 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TaskManager = void 0;
-const utils_1 = require("./utils/utils");
-// TaskManage object controls the concurrency of ComputedNode execution.
-//
-// NOTE: A TaskManager instance will be shared between parent graph and its children
-// when nested agents are involved.
-class TaskManager {
-    constructor(concurrency) {
-        this.taskQueue = [];
-        this.runningNodes = new Set();
-        this.concurrency = concurrency;
-    }
-    // This internal method dequeus a task from the task queue
-    // and call the associated callback method, if the number of
-    // running task is lower than the spcified limit.
-    dequeueTaskIfPossible() {
-        if (this.runningNodes.size < this.concurrency) {
-            const task = this.taskQueue.shift();
-            if (task) {
-                this.runningNodes.add(task.node);
-                task.callback(task.node);
-            }
-        }
-    }
-    // Node will call this method to put itself in the execution queue.
-    // We call the associated callback function when it is dequeued.
-    addTask(node, callback) {
-        this.taskQueue.push({ node, callback });
-        this.dequeueTaskIfPossible();
-    }
-    // Node MUST call this method once the execution of agent function is completed
-    // either successfully or not.
-    onComplete(node) {
-        (0, utils_1.assert)(this.runningNodes.has(node), `TaskManager.onComplete node(${node.nodeId}) is not in list`);
-        this.runningNodes.delete(node);
-        this.dequeueTaskIfPossible();
-    }
-    // Node will call this method before it hands the task manager from the graph
-    // to a nested agent. We need to make it sure that there is enough room to run
-    // computed nodes inside the nested graph to avoid a deadlock.
-    prepareForNesting() {
-        if (this.runningNodes.size === this.concurrency) {
-            this.concurrency++;
-            console.warn("WARNING: increasing concurrenty to", this.concurrency);
-        }
-    }
-    getStatus(verbose = false) {
-        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),
-                }
-                : {}),
-        };
-    }
-}
-exports.TaskManager = TaskManager;