graphai 0.5.12 → 0.5.14

package/lib/graphai.d.ts

@@ -16,6 +16,7 @@ export declare class GraphAI {
     readonly taskManager: TaskManager;
     readonly agentFilters: AgentFilterInfo[];
     readonly retryLimit?: number;
+    private readonly propFunctions;
     nodes: GraphNodes;
     onLogCallback: (__log: TransactionLog, __isUpdate: boolean) => void;
     verbose: boolean;

package/lib/graphai.js

@@ -2,10 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GraphAI = exports.graphDataLatestVersion = exports.defaultConcurrency = void 0;
 const node_1 = require("./node");
+const result_1 = require("./utils/result");
+const prop_function_1 = require("./utils/prop_function");
 const utils_1 = require("./utils/utils");
+const data_source_1 = require("./utils/data_source");
 const validator_1 = require("./validator");
 const task_manager_1 = require("./task_manager");
-const result_1 = require("./result");
 exports.defaultConcurrency = 8;
 exports.graphDataLatestVersion = 0.5;
 class GraphAI {
@@ -42,7 +44,7 @@ class GraphAI {
         return nodes;
     }
     getValueFromResults(source, results) {
-        return (0, utils_1.getDataFromSource)(source.nodeId ? results[source.nodeId] : undefined, source);
+        return (0, data_source_1.getDataFromSource)(source.nodeId ? results[source.nodeId] : undefined, source, this.propFunctions);
     }
     // for static
     initializeStaticNodes(enableConsoleLog = false) {
@@ -101,6 +103,7 @@ class GraphAI {
         this.graphId = URL.createObjectURL(new Blob()).slice(-36);
         this.data = data;
         this.agentFunctionInfoDictionary = agentFunctionInfoDictionary;
+        this.propFunctions = prop_function_1.propFunctions;
         this.taskManager = options.taskManager ?? new task_manager_1.TaskManager(data.concurrency ?? exports.defaultConcurrency);
         this.agentFilters = options.agentFilters ?? [];
         this.bypassAgentIds = options.bypassAgentIds ?? [];
@@ -275,14 +278,14 @@ class GraphAI {
         }
     }
     resultsOf(inputs, anyInput = false) {
-        const results = (0, result_1.resultsOf)(inputs ?? [], this.nodes);
+        const results = (0, result_1.resultsOf)(inputs ?? [], this.nodes, this.propFunctions);
         if (anyInput) {
             return (0, result_1.cleanResult)(results);
         }
         return results;
     }
     resultOf(source) {
-        return (0, result_1.resultOf)(source, this.nodes);
+        return (0, result_1.resultOf)(source, this.nodes, this.propFunctions);
     }
 }
 exports.GraphAI = GraphAI;

package/lib/node.js

@@ -218,6 +218,7 @@ class ComputedNode extends Node {
             if (this.nestedGraph) {
                 this.graph.taskManager.prepareForNesting();
                 context.taskManager = this.graph.taskManager;
+                context.onLogCallback = this.graph.onLogCallback;
                 if ("nodes" in this.nestedGraph) {
                     context.graphData = this.nestedGraph;
                 }

package/lib/type.d.ts

@@ -83,6 +83,7 @@ export type AgentFunctionContext<ParamsType = DefaultParamsType, InputDataType =
     graphData?: GraphData;
     agents?: AgentFunctionInfoDictionary;
     taskManager?: TaskManager;
+    onLogCallback?: (log: TransactionLog, isUpdate: boolean) => void;
     filterParams: AgentFilterParams;
     agentFilters?: AgentFilterInfo[];
     log?: TransactionLog[];
@@ -123,3 +124,4 @@ export type AgentFunctionInfo = {
     npms?: string[];
 };
 export type AgentFunctionInfoDictionary = Record<string, AgentFunctionInfo>;
+export type PropFunction = (result: ResultData, propId: string) => ResultData;

package/lib/utils/data_source.d.ts

@@ -0,0 +1,2 @@
+import { ResultData, DataSource, PropFunction } from "../type";
+export declare const getDataFromSource: (result: ResultData | undefined, source: DataSource, propFunctions: PropFunction[]) => ResultData | undefined;

package/lib/utils/data_source.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDataFromSource = void 0;
+const utils_1 = require("./utils");
+const prop_function_1 = require("./prop_function");
+const getNestedData = (result, propId, propFunctions) => {
+    const match = propId.match(prop_function_1.propFunctionRegex);
+    if (match) {
+        for (const propFunction of propFunctions) {
+            const ret = propFunction(result, propId);
+            if (!(0, utils_1.isNull)(ret)) {
+                return ret;
+            }
+        }
+    }
+    // for array.
+    if (Array.isArray(result)) {
+        // $0, $1. array value.
+        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];
+        }
+    }
+    else if ((0, utils_1.isObject)(result)) {
+        if (propId in result) {
+            return result[propId];
+        }
+    }
+    return undefined;
+};
+const innerGetDataFromSource = (result, propIds, propFunctions) => {
+    if (!(0, utils_1.isNull)(result) && propIds && propIds.length > 0) {
+        const propId = propIds[0];
+        const ret = getNestedData(result, propId, propFunctions);
+        if (ret === undefined) {
+            console.error(`prop: ${propIds.join(".")} is not hit`);
+        }
+        if (propIds.length > 1) {
+            return innerGetDataFromSource(ret, propIds.slice(1), propFunctions);
+        }
+        return ret;
+    }
+    return result;
+};
+const getDataFromSource = (result, source, propFunctions) => {
+    if (!source.nodeId) {
+        return source.value;
+    }
+    return innerGetDataFromSource(result, source.propIds, propFunctions);
+};
+exports.getDataFromSource = getDataFromSource;

package/lib/utils/prop_function.d.ts

@@ -0,0 +1,4 @@
+import { PropFunction } from "../type";
+export declare const propFunctionRegex: RegExp;
+export declare const propFunctions: PropFunction[];
+export declare const propFunction: PropFunction;

package/lib/utils/prop_function.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.propFunction = exports.propFunctions = exports.propFunctionRegex = void 0;
+const utils_1 = require("./utils");
+exports.propFunctionRegex = /^[a-zA-Z]+\([^)]*\)$/;
+const propArrayFunction = (result, propId) => {
+    if (Array.isArray(result)) {
+        if (propId === "length()") {
+            return result.length;
+        }
+        if (propId === "flat()") {
+            return result.flat();
+        }
+        if (propId === "toJSON()") {
+            return JSON.stringify(result);
+        }
+        if (propId === "isEmpty()") {
+            return result.length === 0;
+        }
+        // array join
+        const matchJoin = propId.match(/^join\(([,-]?)\)$/);
+        if (matchJoin && Array.isArray(matchJoin)) {
+            return result.join(matchJoin[1] ?? "");
+        }
+    }
+    return undefined;
+};
+const propObjectFunction = (result, propId) => {
+    if ((0, utils_1.isObject)(result)) {
+        if (propId === "keys()") {
+            return Object.keys(result);
+        }
+        if (propId === "values()") {
+            return Object.values(result);
+        }
+        if (propId === "toJSON()") {
+            return JSON.stringify(result);
+        }
+    }
+    return undefined;
+};
+const propStringFunction = (result, propId) => {
+    if (typeof result === "string") {
+        if (propId === "codeBlock()") {
+            const match = ("\n" + result).match(/\n```[a-zA-z]*([\s\S]*?)\n```/);
+            if (match) {
+                return match[1];
+            }
+        }
+        if (propId === "jsonParse()") {
+            return JSON.parse(result);
+        }
+        if (propId === "toNumber()") {
+            const ret = Number(result);
+            if (!isNaN(ret)) {
+                return ret;
+            }
+        }
+    }
+    return undefined;
+};
+const propNumberFunction = (result, propId) => {
+    if (result !== undefined && Number.isFinite(result)) {
+        if (propId === "toString()") {
+            return String(result);
+        }
+        const regex = /^add\((-?\d+)\)$/;
+        const match = propId.match(regex);
+        if (match) {
+            return Number(result) + Number(match[1]);
+        }
+    }
+    return undefined;
+};
+const propBooleanFunction = (result, propId) => {
+    if (typeof result === "boolean") {
+        if (propId === "not()") {
+            return !result;
+        }
+    }
+    return undefined;
+};
+exports.propFunctions = [propArrayFunction, propObjectFunction, propStringFunction, propNumberFunction, propBooleanFunction];
+const propFunction = (result, propId) => {
+    if (Array.isArray(result)) {
+        // flat, join
+        return propArrayFunction(result, propId);
+    }
+    else if ((0, utils_1.isObject)(result)) {
+        return propObjectFunction(result, propId);
+    }
+    else if (typeof result === "string") {
+        return propStringFunction(result, propId);
+    }
+    else if (result !== undefined && Number.isFinite(result)) {
+        return propNumberFunction(result, propId);
+    }
+    else if (typeof result === "boolean") {
+        return propBooleanFunction(result, propId);
+    }
+    return undefined;
+};
+exports.propFunction = propFunction;

package/lib/{result.d.ts → utils/result.d.ts}

@@ -1,6 +1,6 @@
-import { DataSource, ResultData } from "./type";
-import { GraphNodes } from "./node";
-export declare const resultsOf: (inputs: Record<string, any> | Array<string>, nodes: GraphNodes) => Record<string, ResultData>;
-export declare const resultOf: (source: DataSource, nodes: GraphNodes) => ResultData;
+import { DataSource, ResultData, PropFunction } from "../type";
+import { GraphNodes } from "../node";
+export declare const resultsOf: (inputs: Record<string, any> | Array<string>, nodes: GraphNodes, propFunctions: PropFunction[]) => Record<string, ResultData>;
+export declare const resultOf: (source: DataSource, nodes: GraphNodes, propFunctions: PropFunction[]) => ResultData;
 export declare const cleanResultInner: (results: ResultData) => ResultData | null;
 export declare const cleanResult: (results: Record<string, ResultData | undefined>) => Record<string, ResultData>;

package/lib/{result.js → utils/result.js}

@@ -1,43 +1,44 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.cleanResult = exports.cleanResultInner = exports.resultOf = exports.resultsOf = void 0;
-const utils_1 = require("./utils/utils");
-const resultsOfInner = (input, nodes) => {
+const utils_1 = require("../utils/utils");
+const data_source_1 = require("../utils/data_source");
+const resultsOfInner = (input, nodes, propFunctions) => {
     if (Array.isArray(input)) {
-        return input.map((inp) => resultsOfInner(inp, nodes));
+        return input.map((inp) => resultsOfInner(inp, nodes, propFunctions));
     }
     if ((0, utils_1.isNamedInputs)(input)) {
-        return (0, exports.resultsOf)(input, nodes);
+        return (0, exports.resultsOf)(input, nodes, propFunctions);
     }
     if (typeof input === "string") {
         const templateMatch = [...input.matchAll(/\${(:[^}]+)}/g)].map((m) => m[1]);
         if (templateMatch.length > 0) {
-            const results = resultsOfInner(templateMatch, nodes);
+            const results = resultsOfInner(templateMatch, nodes, propFunctions);
             return Array.from(templateMatch.keys()).reduce((tmp, key) => {
                 return tmp.replaceAll("${" + templateMatch[key] + "}", results[key]);
             }, input);
         }
     }
-    return (0, exports.resultOf)((0, utils_1.parseNodeName)(input), nodes);
+    return (0, exports.resultOf)((0, utils_1.parseNodeName)(input), nodes, propFunctions);
 };
-const resultsOf = (inputs, nodes) => {
+const resultsOf = (inputs, nodes, propFunctions) => {
     // for inputs. TODO remove if array input is not supported
     if (Array.isArray(inputs)) {
         return inputs.reduce((tmp, key) => {
-            tmp[key] = resultsOfInner(key, nodes);
+            tmp[key] = resultsOfInner(key, nodes, propFunctions);
             return tmp;
         }, {});
     }
     return Object.keys(inputs).reduce((tmp, key) => {
         const input = inputs[key];
-        tmp[key] = (0, utils_1.isNamedInputs)(input) ? (0, exports.resultsOf)(input, nodes) : resultsOfInner(input, nodes);
+        tmp[key] = (0, utils_1.isNamedInputs)(input) ? (0, exports.resultsOf)(input, nodes, propFunctions) : resultsOfInner(input, nodes, propFunctions);
         return tmp;
     }, {});
 };
 exports.resultsOf = resultsOf;
-const resultOf = (source, nodes) => {
+const resultOf = (source, nodes, propFunctions) => {
     const { result } = source.nodeId ? nodes[source.nodeId] : { result: undefined };
-    return (0, utils_1.getDataFromSource)(result, source);
+    return (0, data_source_1.getDataFromSource)(result, source, propFunctions);
 };
 exports.resultOf = resultOf;
 // clean up object for anyInput

package/lib/utils/utils.d.ts

@@ -1,10 +1,9 @@
-import { DataSource, ResultData, AgentFunction, DefaultInputData } from "../type";
+import { DataSource, AgentFunction, DefaultInputData } from "../type";
 export declare const sleep: (milliseconds: number) => Promise<unknown>;
 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) => x is object;
 export declare const isNull: (data: unknown) => data is null | undefined;
-export declare const getDataFromSource: (result: ResultData | undefined, source: DataSource) => ResultData | undefined;
 export declare const strIntentionalError = "Intentional Error for Debugging";
 export declare const defaultAgentInfo: {
     name: string;

package/lib/utils/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isNamedInputs = exports.defaultTestContext = exports.isLogicallyTrue = exports.debugResultKey = exports.agentInfoWrapper = exports.defaultAgentInfo = exports.strIntentionalError = exports.getDataFromSource = exports.isNull = exports.isObject = exports.parseNodeName = exports.sleep = void 0;
+exports.isNamedInputs = exports.defaultTestContext = exports.isLogicallyTrue = exports.debugResultKey = exports.agentInfoWrapper = exports.defaultAgentInfo = exports.strIntentionalError = exports.isNull = exports.isObject = exports.parseNodeName = exports.sleep = void 0;
 exports.assert = assert;
 const sleep = async (milliseconds) => {
     return await new Promise((resolve) => setTimeout(resolve, milliseconds));
@@ -38,88 +38,6 @@ const isNull = (data) => {
     return data === null || data === undefined;
 };
 exports.isNull = isNull;
-const getNestedData = (result, propId) => {
-    // for array.
-    if (Array.isArray(result)) {
-        // $0, $1. array value.
-        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];
-        }
-        if (propId === "length()") {
-            return result.length;
-        }
-        if (propId === "flat()") {
-            return result.flat();
-        }
-        if (propId === "toJSON()") {
-            return JSON.stringify(result);
-        }
-        // array join
-        const matchJoin = propId.match(/^join\(([,-]?)\)$/);
-        if (matchJoin && Array.isArray(matchJoin)) {
-            return result.join(matchJoin[1] ?? "");
-        }
-        // flat, join
-    }
-    else if ((0, exports.isObject)(result)) {
-        if (propId === "keys()") {
-            return Object.keys(result);
-        }
-        if (propId === "values()") {
-            return Object.values(result);
-        }
-        if (propId === "toJSON()") {
-            return JSON.stringify(result);
-        }
-        if (propId in result) {
-            return result[propId];
-        }
-    }
-    else if (typeof result === "string") {
-        if (propId === "jsonParse()") {
-            return JSON.parse(result);
-        }
-        if (propId === "toNumber()") {
-            const ret = Number(result);
-            if (!isNaN(ret)) {
-                return ret;
-            }
-        }
-    }
-    else if (Number.isFinite(result)) {
-        if (propId === "toString()") {
-            return String(result);
-        }
-    }
-    return undefined;
-};
-const innerGetDataFromSource = (result, propIds) => {
-    if (result && propIds && propIds.length > 0) {
-        const propId = propIds[0];
-        const ret = getNestedData(result, propId);
-        if (ret === undefined) {
-            console.error(`prop: ${propIds.join(".")} is not hit`);
-        }
-        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";
 exports.defaultAgentInfo = {
     name: "defaultAgentInfo",

package/package.json

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