graphai 0.1.2 → 0.2.1

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

@@ -0,0 +1,7 @@
+import echoAgent from "../../experimental_agents/test_agents/echo_agent";
+import bypassAgent from "../../experimental_agents/test_agents/bypass_agent";
+import countingAgent from "../../experimental_agents/test_agents/counting_agent";
+import copyMessageAgent from "../../experimental_agents/test_agents/copy_message_agent";
+import copy2ArrayAgent from "../../experimental_agents/test_agents/copy2array_agent";
+import mergeNodeIdAgent from "../../experimental_agents/test_agents/merge_node_id_agent";
+export { echoAgent, bypassAgent, countingAgent, copyMessageAgent, copy2ArrayAgent, mergeNodeIdAgent };

package/lib/experimental_agents/test_agents/packages.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeNodeIdAgent = exports.copy2ArrayAgent = exports.copyMessageAgent = exports.countingAgent = exports.bypassAgent = exports.echoAgent = void 0;
+const echo_agent_1 = __importDefault(require("../../experimental_agents/test_agents/echo_agent"));
+exports.echoAgent = echo_agent_1.default;
+const bypass_agent_1 = __importDefault(require("../../experimental_agents/test_agents/bypass_agent"));
+exports.bypassAgent = bypass_agent_1.default;
+const counting_agent_1 = __importDefault(require("../../experimental_agents/test_agents/counting_agent"));
+exports.countingAgent = counting_agent_1.default;
+const copy_message_agent_1 = __importDefault(require("../../experimental_agents/test_agents/copy_message_agent"));
+exports.copyMessageAgent = copy_message_agent_1.default;
+const copy2array_agent_1 = __importDefault(require("../../experimental_agents/test_agents/copy2array_agent"));
+exports.copy2ArrayAgent = copy2array_agent_1.default;
+const merge_node_id_agent_1 = __importDefault(require("../../experimental_agents/test_agents/merge_node_id_agent"));
+exports.mergeNodeIdAgent = merge_node_id_agent_1.default;

package/lib/experimental_agents/token_agent.d.ts

@@ -4,3 +4,23 @@ export declare const tokenBoundStringsAgent: AgentFunction<{
 }, {
     content: string;
 }, Array<string>>;
+declare const tokenBoundStringsAgentInfo: {
+    name: string;
+    agent: AgentFunction<{
+        limit?: number | undefined;
+    }, {
+        content: string;
+    }, string[]>;
+    mock: AgentFunction<{
+        limit?: number | undefined;
+    }, {
+        content: string;
+    }, string[]>;
+    samples: never[];
+    description: string;
+    category: never[];
+    author: string;
+    repository: string;
+    license: string;
+};
+export default tokenBoundStringsAgentInfo;

package/lib/experimental_agents/token_agent.js

@@ -31,3 +31,15 @@ const tokenBoundStringsAgent = async ({ params, inputs }) => {
     return { content, tokenCount, endIndex };
 };
 exports.tokenBoundStringsAgent = tokenBoundStringsAgent;
+const tokenBoundStringsAgentInfo = {
+    name: "tokenBoundStringsAgent",
+    agent: exports.tokenBoundStringsAgent,
+    mock: exports.tokenBoundStringsAgent,
+    samples: [],
+    description: "token bound Agent",
+    category: [],
+    author: "Receptron team",
+    repository: "https://github.com/receptron/graphai",
+    license: "MIT",
+};
+exports.default = tokenBoundStringsAgentInfo;

package/lib/graphai.d.ts

@@ -5,6 +5,7 @@ import { ComputedNode, StaticNode } from "./node";
 import { TaskManager } from "./task_manager";
 type GraphNodes = Record<string, ComputedNode | StaticNode>;
 export declare class GraphAI {
+    private readonly version;
     private readonly graphId;
     private readonly data;
     private readonly loop?;
@@ -37,5 +38,5 @@ export declare class GraphAI {
     updateLog(log: TransactionLog): void;
     transactionLogs(): TransactionLog[];
     injectValue(nodeId: string, value: ResultData, injectFrom?: string): void;
-    resultsOf(sources: Array<DataSource>, anyInput?: boolean): any[];
+    resultsOf(sources: Array<DataSource>): ResultData[];
 }

package/lib/graphai.js

@@ -40,8 +40,7 @@ class GraphAI {
     }
     getValueFromResults(key, results) {
         const source = (0, utils_1.parseNodeName)(key);
-        const result = results[source.nodeId];
-        return result && source.propId ? result[source.propId] : result;
+        return (0, utils_1.getDataFromSource)(source.nodeId ? results[source.nodeId] : undefined, source);
     }
     // for static
     initializeNodes(previousResults) {
@@ -69,6 +68,10 @@ class GraphAI {
         this.logs = [];
         this.onLogCallback = (__log, __isUpdate) => { };
         this.repeatCount = 0;
+        if (!data.version) {
+            console.log("------------ no version");
+        }
+        this.version = data.version ?? 0.2;
         this.graphId = URL.createObjectURL(new Blob()).slice(-36);
         this.data = data;
         this.callbackDictonary = callbackDictonary;
@@ -96,10 +99,7 @@ class GraphAI {
     // Public API
     results(all) {
         return Object.keys(this.nodes)
-            .filter((nodeId) => {
-            const node = this.nodes[nodeId];
-            return all || node.isResult;
-        })
+            .filter((nodeId) => all || this.nodes[nodeId].isResult)
             .reduce((results, nodeId) => {
             const node = this.nodes[nodeId];
             if (node.result !== undefined) {
@@ -153,6 +153,10 @@ class GraphAI {
             console.error("-- Already Running");
         }
         this.pushReadyNodesIntoQueue();
+        if (!this.isRunning()) {
+            console.warn("-- nothing to execute");
+            return {};
+        }
         return new Promise((resolve, reject) => {
             this.onComplete = () => {
                 const errors = this.errors();
@@ -227,13 +231,10 @@ class GraphAI {
             console.error("InjectionTo can only specify static nodes");
         }
     }
-    resultsOf(sources, anyInput = false) {
+    resultsOf(sources) {
         return sources.map((source) => {
-            const { result } = this.nodes[source.nodeId];
-            if (source.propId) {
-                (0, utils_1.assert)((0, utils_1.isObject)(result), `resultsOf: result is not object. nodeId ${source.nodeId}`, anyInput);
-            }
-            return result && source.propId ? result[source.propId] : result;
+            const { result } = source.nodeId ? this.nodes[source.nodeId] : { result: undefined };
+            return (0, utils_1.getDataFromSource)(result, source);
         });
     }
 }

package/lib/node.d.ts

@@ -31,6 +31,7 @@ export declare class ComputedNode extends Node {
     constructor(graphId: string, nodeId: string, data: ComputedNodeData, graph: GraphAI);
     isReadyNode(): boolean;
     private retry;
+    private checkDataAvailability;
     removePending(nodeId: string): void;
     private isCurrentTransaction;
     private executeTimeout;

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) {
@@ -43,8 +44,8 @@ class ComputedNode extends Node {
         this.timeout = data.timeout;
         this.isResult = data.isResult ?? false;
         this.anyInput = data.anyInput ?? false;
-        this.dataSources = (data.inputs ?? []).map(utils_1.parseNodeName);
-        this.pendings = new Set(this.dataSources.map((source) => source.nodeId));
+        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));
         this.log.initForComputedNode(this);
     }
     isReadyNode() {
@@ -53,7 +54,7 @@ class ComputedNode extends Node {
             // We care it only when this.anyInput is true.
             // Notice that this logic enables dynamic data-flows.
             const counter = this.dataSources.reduce((count, source) => {
-                const [result] = this.graph.resultsOf([source], this.anyInput);
+                const [result] = this.graph.resultsOf([source]);
                 return result === undefined ? count : count + 1;
             }, 0);
             if (!this.anyInput || counter > 0) {
@@ -79,14 +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 results = this.graph.resultsOf(this.dataSources, this.anyInput).filter((result) => {
-                return result !== undefined;
-            });
-            if (results.length > 0) {
+            if (this.checkDataAvailability()) {
                 this.pendings.clear();
             }
         }
@@ -111,7 +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.dataSources, 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;
         });
@@ -174,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.dataSources.map((source) => source.nodeId);
+        this.inputs = node.dataSources.filter((source) => source.nodeId).map((source) => source.nodeId);
         this.inputsData = inputs.length > 0 ? inputs : undefined;
         graph.setLoopLog(this);
         graph.appendLog(this);

package/lib/type.d.ts

@@ -10,15 +10,16 @@ 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>>;
 export type DefaultParamsType = Record<string, any>;
 export type NodeDataParams<ParamsType = DefaultParamsType> = ParamsType;
 export type DataSource = {
-    nodeId: string;
-    propId?: string;
+    nodeId?: string;
+    value?: any;
+    propIds?: string[];
 };
 export type StaticNodeData = {
     value: ResultData;
@@ -27,7 +28,7 @@ export type StaticNodeData = {
 };
 export type ComputedNodeData = {
     agentId: string;
-    inputs?: Array<string>;
+    inputs?: Array<any>;
     anyInput?: boolean;
     params?: NodeDataParams;
     retry?: number;
@@ -41,6 +42,7 @@ export type LoopData = {
     while?: string;
 };
 export type GraphData = {
+    version?: number;
     nodes: Record<string, NodeData>;
     concurrency?: number;
     loop?: LoopData;
@@ -54,7 +56,7 @@ export type AgentFunctionContext<ParamsType, InputDataType> = {
         nodeId: string;
         retry: number;
     };
-    graphData?: GraphData;
+    graphData?: GraphData | string;
     agents?: AgentFunctionDictonary;
     log?: TransactionLog[];
     taskManager?: TaskManager;
@@ -71,6 +73,7 @@ export type AgentFunctionInfo = {
         result: any;
     }[];
     description: string;
+    category: string[];
     author: string;
     repository: string;
     license: string;

package/lib/utils/test_agents.js

@@ -17,4 +17,5 @@ exports.defaultTestAgents = {
     copy2ArrayAgent: experimental_agents_1.copy2ArrayAgent,
     pushAgent: experimental_agents_1.pushAgent,
     popAgent: experimental_agents_1.popAgent,
+    shiftAgent: experimental_agents_1.shiftAgent,
 };

package/lib/utils/test_utils.js

@@ -18,17 +18,22 @@ exports.defaultTestContext = {
 };
 // 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,
+    const { agent, samples } = agentInfo;
+    if (samples.length === 0) {
+        console.log(`test ${agentInfo.name}: No test`);
+    }
+    else {
+        for await (const sampleKey of samples.keys()) {
+            (0, node_test_1.default)(`test ${agentInfo.name} ${sampleKey}`, async () => {
+                const { params, inputs, result } = samples[sampleKey];
+                const actual = await agent({
+                    ...exports.defaultTestContext,
+                    params,
+                    inputs,
+                });
+                node_assert_1.default.deepStrictEqual(actual, result);
             });
-            node_assert_1.default.deepStrictEqual(result, actual);
         }
-    });
+    }
 };
 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 const parseNodeName: (inputNodeId: any) => 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 | undefined, source: DataSource) => ResultData | undefined;
+export declare const strIntentionalError = "Intentional Error for Debugging";

package/lib/utils/utils.js

@@ -1,16 +1,24 @@
 "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));
 };
 exports.sleep = sleep;
 const parseNodeName = (inputNodeId) => {
-    const parts = inputNodeId.split(".");
-    if (parts.length == 1) {
-        return { nodeId: parts[0] };
+    if (typeof inputNodeId === "string") {
+        const regex = /^"(.*)"$/;
+        const match = inputNodeId.match(regex);
+        if (match) {
+            return { value: match[1] }; // string literal
+        }
+        const parts = inputNodeId.split(".");
+        if (parts.length == 1) {
+            return { nodeId: parts[0] };
+        }
+        return { nodeId: parts[0], propIds: parts.slice(1) };
     }
-    return { nodeId: parts[0], propId: parts[1] };
+    return { value: inputNodeId }; // non-string literal
 };
 exports.parseNodeName = parseNodeName;
 function assert(condition, message, isWarn = false) {
@@ -26,3 +34,37 @@ 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 innerGetDataFromSource = (result, propIds) => {
+    if (result && propIds && propIds.length > 0) {
+        const propId = propIds[0];
+        const ret = getNestedData(result, propId);
+        if (propIds.length > 1) {
+            return innerGetDataFromSource(ret, propIds.slice(1));
+        }
+        return ret;
+    }
+    return result;
+};
+const getDataFromSource = (result, source) => {
+    if (!source.nodeId) {
+        return source.value;
+    }
+    return innerGetDataFromSource(result, source.propIds);
+};
+exports.getDataFromSource = getDataFromSource;
+exports.strIntentionalError = "Intentional Error for Debugging";

package/lib/validators/relation_validator.js

@@ -12,13 +12,15 @@ const relationValidator = (data, staticNodeIds, computedNodeIds) => {
         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}`);
+                const sourceNodeId = (0, utils_1.parseNodeName)(inputNodeId).nodeId;
+                if (sourceNodeId) {
+                    if (!nodeIds.has(sourceNodeId)) {
+                        throw new Error(`Inputs not match: NodeId ${computedNodeId}, Inputs: ${sourceNodeId}`);
+                    }
+                    waitlist[sourceNodeId] === undefined && (waitlist[sourceNodeId] = new Set());
+                    pendings[computedNodeId].add(sourceNodeId);
+                    waitlist[sourceNodeId].add(computedNodeId);
                 }
-                waitlist[input] === undefined && (waitlist[input] = new Set());
-                pendings[computedNodeId].add(input);
-                waitlist[input].add(computedNodeId);
             });
         }
     });
@@ -28,6 +30,9 @@ const relationValidator = (data, staticNodeIds, computedNodeIds) => {
         const update = nodeData.update;
         if (update) {
             const updateNodeId = (0, utils_1.parseNodeName)(update).nodeId;
+            if (!updateNodeId) {
+                throw new Error("Update it a literal");
+            }
             if (!nodeIds.has(updateNodeId)) {
                 throw new Error(`Update not match: NodeId ${staticNodeId}, update: ${update}`);
             }

package/package.json

@@ -1,16 +1,17 @@
 {
   "name": "graphai",
-  "version": "0.1.2",
+  "version": "0.2.1",
   "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"
@@ -37,6 +38,7 @@
     "eslint": "^7.32.0 || ^8.2.0",
     "eslint-plugin-import": "^2.25.2",
     "express": "^4.19.2",
+    "groq-sdk": "^0.3.3",
     "openai": "^4.12.4",
     "prettier": "^3.0.3",
     "slashgpt": "^0.0.8",

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

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

package/lib/experimental_agents/nested_agent.js

@@ -1,40 +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 injectionTo = params.injectionTo ??
-        inputs.map((__input, index) => {
-            return `$${index}`;
-        });
-    injectionTo.forEach((nodeId) => {
-        if (graphData.nodes[nodeId] === undefined) {
-            // If the input node does not exist, automatically create a static node
-            graphData.nodes[nodeId] = { value: {} };
-        }
-    });
-    const graphAI = new graphai_1.GraphAI(graphData, agents || {}, taskManager);
-    try {
-        // Inject inputs to specified source nodes
-        injectionTo.forEach((injectToNodeId, index) => {
-            graphAI.injectValue(injectToNodeId, inputs[index]);
-        });
-        const results = await graphAI.run(false);
-        log?.push(...graphAI.transactionLogs());
-        return results;
-    }
-    catch (error) {
-        log?.push(...graphAI.transactionLogs());
-        if (error instanceof Error) {
-            console.log("Error:", error.message);
-        }
-        throw error;
-    }
-};
-exports.nestedAgent = nestedAgent;

package/lib/experimental_agents/slashgpt_agent.d.ts

@@ -1,9 +0,0 @@
-import { AgentFunction } from "../graphai";
-import { ManifestData } from "slashgpt";
-export declare const slashGPTAgent: AgentFunction<{
-    manifest: ManifestData;
-    query?: string;
-    function_result?: boolean;
-}, {
-    content: string;
-}, string>;