graphai 0.1.0 → 0.1.2

package/lib/experimental_agents/matrix_agents/sort_by_values_agent.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sortByValuesAgent = void 0;
+// This agent returned a sorted array of one array (A) based on another array (B).
+// The default sorting order is "decendant".
+//
+// Parameters:
+//  acendant: Specifies if the sorting order should be acendant. The default is "false" (decendant).
+// Inputs:
+//  inputs[0]: Array<any>; // array to be sorted
+//  inputs[1]: Array<number>; // array of numbers for sorting
+//
+const sortByValuesAgent = async ({ params, inputs }) => {
+    const direction = params?.assendant ?? false ? -1 : 1;
+    const sources = inputs[0];
+    const values = inputs[1];
+    const joined = sources.map((item, index) => {
+        return { item, value: values[index] };
+    });
+    const contents = joined
+        .sort((a, b) => {
+        return (b.value - a.value) * direction;
+    })
+        .map((a) => {
+        return a.item;
+    });
+    return { contents };
+};
+exports.sortByValuesAgent = sortByValuesAgent;

package/lib/experimental_agents/nested_agent.d.ts

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

package/lib/experimental_agents/nested_agent.js

@@ -2,19 +2,35 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.nestedAgent = void 0;
 const graphai_1 = require("../graphai");
-const nestedAgent = async ({ params, inputs, agents, log }) => {
-    const graph = new graphai_1.GraphAI(params.graph, agents);
+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
-        (params.inputNodes ?? []).forEach((nodeId, index) => {
-            graph.injectValue(nodeId, inputs[index]);
+        injectionTo.forEach((injectToNodeId, index) => {
+            graphAI.injectValue(injectToNodeId, inputs[index]);
         });
-        const results = await graph.run();
-        log.push(...graph.transactionLogs());
-        return results[params.nodeId];
+        const results = await graphAI.run(false);
+        log?.push(...graphAI.transactionLogs());
+        return results;
     }
     catch (error) {
-        log.push(...graph.transactionLogs());
+        log?.push(...graphAI.transactionLogs());
         if (error instanceof Error) {
             console.log("Error:", error.message);
         }

package/lib/experimental_agents/slashgpt_agent.d.ts

@@ -6,4 +6,4 @@ export declare const slashGPTAgent: AgentFunction<{
     function_result?: boolean;
 }, {
     content: string;
-}>;
+}, string>;

package/lib/experimental_agents/slashgpt_agent.js

@@ -7,18 +7,13 @@ exports.slashGPTAgent = void 0;
 const path_1 = __importDefault(require("path"));
 const slashgpt_1 = require("slashgpt");
 const config = new slashgpt_1.ChatConfig(path_1.default.resolve(__dirname));
-const slashGPTAgent = async ({ nodeId, params, inputs, verbose }) => {
+const slashGPTAgent = async ({ params, inputs, debugInfo: { verbose, nodeId } }) => {
     if (verbose) {
         console.log("executing", nodeId, params);
     }
     const session = new slashgpt_1.ChatSession(config, params.manifest ?? {});
     const query = params?.query ? [params.query] : [];
-    const contents = query.concat(inputs.map((input) => {
-        if (typeof input === "string") {
-            return input;
-        }
-        return input.content;
-    }));
+    const contents = query.concat(inputs);
     session.append_user_question(contents.join("\n"));
     await session.call_loop(() => { });
     const message = (() => {

package/lib/experimental_agents/sleeper_agents/index.d.ts

@@ -0,0 +1,2 @@
+export { sleeperAgent } from "../../experimental_agents/sleeper_agents/sleeper_agent";
+export { sleeperAgentDebug } from "../../experimental_agents/sleeper_agents/sleeper_agent_debug";

package/lib/experimental_agents/sleeper_agents/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sleeperAgentDebug = exports.sleeperAgent = void 0;
+var sleeper_agent_1 = require("../../experimental_agents/sleeper_agents/sleeper_agent");
+Object.defineProperty(exports, "sleeperAgent", { enumerable: true, get: function () { return sleeper_agent_1.sleeperAgent; } });
+var sleeper_agent_debug_1 = require("../../experimental_agents/sleeper_agents/sleeper_agent_debug");
+Object.defineProperty(exports, "sleeperAgentDebug", { enumerable: true, get: function () { return sleeper_agent_debug_1.sleeperAgentDebug; } });

package/lib/experimental_agents/sleeper_agents/sleeper_agent.d.ts

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

package/lib/experimental_agents/sleeper_agents/sleeper_agent.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sleeperAgent = void 0;
+const utils_1 = require("../../utils/utils");
+const deepmerge_1 = __importDefault(require("deepmerge"));
+const sleeperAgent = async (context) => {
+    const { params, inputs } = context;
+    await (0, utils_1.sleep)(params?.duration ?? 10);
+    return inputs.reduce((result, input) => {
+        return (0, deepmerge_1.default)(result, input);
+    }, params.value ?? {});
+};
+exports.sleeperAgent = sleeperAgent;

package/lib/experimental_agents/sleeper_agents/sleeper_agent_debug.d.ts

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

package/lib/experimental_agents/{sleeper_agent.js → sleeper_agents/sleeper_agent_debug.js}

@@ -3,22 +3,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sleeperAgentDebug = exports.sleeperAgent = void 0;
-const utils_1 = require("../utils/utils");
+exports.sleeperAgentDebug = void 0;
+const utils_1 = require("../../utils/utils");
 const deepmerge_1 = __importDefault(require("deepmerge"));
-const sleeperAgent = async (context) => {
-    const { params, inputs } = context;
-    await (0, utils_1.sleep)(params.duration);
-    return inputs.reduce((result, input) => {
-        return (0, deepmerge_1.default)(result, input);
-    }, params.value ?? {});
-};
-exports.sleeperAgent = sleeperAgent;
-const sleeperAgentDebug = async (context) => {
-    const { nodeId, params, inputs, retry } = context;
+const sleeperAgentDebug = async ({ params, inputs, debugInfo: { retry }, }) => {
     await (0, utils_1.sleep)(params.duration / (retry + 1));
     if (params.fail && retry < 2) {
-        console.log("failed (intentional)", nodeId, retry);
+        // console.log("failed (intentional)", nodeId, retry);
         throw new Error("Intentional Failure");
     }
     return inputs.reduce((result, input) => {

package/lib/experimental_agents/string_agents/index.d.ts

@@ -0,0 +1,2 @@
+export { stringSplitterAgent } from "../../experimental_agents/string_agents/string_splitter_agent";
+export { stringTemplateAgent } from "../../experimental_agents/string_agents/string_template_agent";

package/lib/experimental_agents/string_agents/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringTemplateAgent = exports.stringSplitterAgent = void 0;
+var string_splitter_agent_1 = require("../../experimental_agents/string_agents/string_splitter_agent");
+Object.defineProperty(exports, "stringSplitterAgent", { enumerable: true, get: function () { return string_splitter_agent_1.stringSplitterAgent; } });
+var string_template_agent_1 = require("../../experimental_agents/string_agents/string_template_agent");
+Object.defineProperty(exports, "stringTemplateAgent", { enumerable: true, get: function () { return string_template_agent_1.stringTemplateAgent; } });

package/lib/experimental_agents/string_agents/string_splitter_agent.d.ts

@@ -0,0 +1,39 @@
+import { AgentFunction } from "../../graphai";
+export declare const stringSplitterAgent: AgentFunction<{
+    chunkSize?: number;
+    overlap?: number;
+}, {
+    contents: Array<string>;
+}, string>;
+declare const stringSplitterAgentInfo: {
+    name: string;
+    agent: AgentFunction<{
+        chunkSize?: number | undefined;
+        overlap?: number | undefined;
+    }, {
+        contents: Array<string>;
+    }, string>;
+    mock: AgentFunction<{
+        chunkSize?: number | undefined;
+        overlap?: number | undefined;
+    }, {
+        contents: Array<string>;
+    }, string>;
+    samples: {
+        inputs: string[];
+        params: {
+            chunkSize: number;
+        };
+        result: {
+            contents: string[];
+            count: number;
+            chunkSize: number;
+            overlap: number;
+        };
+    }[];
+    description: string;
+    author: string;
+    repository: string;
+    license: string;
+};
+export default stringSplitterAgentInfo;

package/lib/experimental_agents/string_agents/string_splitter_agent.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringSplitterAgent = void 0;
+// This agent strip one long string into chunks using following parameters
+//
+//  chunkSize: number; // default is 2048
+//  overlap: number;   // default is 1/8th of chunkSize.
+//
+// see example
+//  tests/agents/test_string_agent.ts
+//
+const defaultChunkSize = 2048;
+const stringSplitterAgent = async ({ params, inputs }) => {
+    const source = inputs[0];
+    const chunkSize = params.chunkSize ?? defaultChunkSize;
+    const overlap = params.overlap ?? Math.floor(chunkSize / 8);
+    const count = Math.floor(source.length / (chunkSize - overlap)) + 1;
+    const contents = new Array(count).fill(undefined).map((_, i) => {
+        const startIndex = i * (chunkSize - overlap);
+        return source.substring(startIndex, startIndex + chunkSize);
+    });
+    return { contents, count, chunkSize, overlap };
+};
+exports.stringSplitterAgent = stringSplitterAgent;
+// for test and document
+const sampleInput = [
+    "Here's to the crazy ones, the misfits, the rebels, the troublemakers, the round pegs in the square holes ... the ones who see things differently -- they're not fond of rules, and they have no respect for the status quo. ... You can quote them, disagree with them, glorify or vilify them, but the only thing you can't do is ignore them because they change things. ... They push the human race forward, and while some may see them as the crazy ones, we see genius, because the people who are crazy enough to think that they can change the world, are the ones who do.",
+];
+const sampleParams = { chunkSize: 64 };
+const sampleResult = {
+    contents: [
+        "Here's to the crazy ones, the misfits, the rebels, the troublema",
+        "roublemakers, the round pegs in the square holes ... the ones wh",
+        " ones who see things differently -- they're not fond of rules, a",
+        "rules, and they have no respect for the status quo. ... You can ",
+        "You can quote them, disagree with them, glorify or vilify them, ",
+        "y them, but the only thing you can't do is ignore them because t",
+        "ecause they change things. ... They push the human race forward,",
+        "forward, and while some may see them as the crazy ones, we see g",
+        "we see genius, because the people who are crazy enough to think ",
+        "o think that they can change the world, are the ones who do.",
+        " do.",
+    ],
+    count: 11,
+    chunkSize: 64,
+    overlap: 8,
+};
+const stringSplitterAgentInfo = {
+    name: "stringSplitterAgent",
+    agent: exports.stringSplitterAgent,
+    mock: exports.stringSplitterAgent,
+    samples: [
+        {
+            inputs: sampleInput,
+            params: sampleParams,
+            result: sampleResult,
+        },
+    ],
+    description: "This agent strip one long string into chunks using following parameters",
+    author: "Satoshi Nakajima",
+    repository: "https://github.com/receptron/graphai",
+    license: "MIT",
+};
+exports.default = stringSplitterAgentInfo;

package/lib/experimental_agents/string_agents/string_template_agent.d.ts

@@ -0,0 +1,27 @@
+import { AgentFunction } from "../../graphai";
+export declare const stringTemplateAgent: AgentFunction<{
+    template: string;
+}, Record<string, any> | string, string>;
+declare const stringTemplateAgentInfo: {
+    name: string;
+    agent: AgentFunction<{
+        template: string;
+    }, string | Record<string, any>, string>;
+    mock: AgentFunction<{
+        template: string;
+    }, string | Record<string, any>, string>;
+    samples: {
+        inputs: string[];
+        params: {
+            template: string;
+        };
+        result: {
+            content: string;
+        };
+    }[];
+    description: string;
+    author: string;
+    repository: string;
+    license: string;
+};
+export default stringTemplateAgentInfo;

package/lib/experimental_agents/string_agents/string_template_agent.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringTemplateAgent = void 0;
+// see example
+//  tests/agents/test_string_agent.ts
+const stringTemplateAgent = async ({ params, inputs }) => {
+    const content = inputs.reduce((template, input, index) => {
+        return template.replace("${" + index + "}", input);
+    }, params.template);
+    return { content };
+};
+exports.stringTemplateAgent = stringTemplateAgent;
+const sampleInput = ["hello", "test"];
+const sampleParams = { template: "${0}: ${1}" };
+const sampleResult = { content: "hello: test" };
+// for test and document
+const stringTemplateAgentInfo = {
+    name: "stringTemplateAgent",
+    agent: exports.stringTemplateAgent,
+    mock: exports.stringTemplateAgent,
+    samples: [
+        {
+            inputs: sampleInput,
+            params: sampleParams,
+            result: sampleResult,
+        },
+    ],
+    description: "Template agent",
+    author: "Satoshi Nakajima",
+    repository: "https://github.com/receptron/graphai",
+    license: "MIT",
+};
+exports.default = stringTemplateAgentInfo;

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

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

package/lib/experimental_agents/test_agents/bypass_agent.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bypassAgent = void 0;
+const bypassAgent = async (context) => {
+    if (context.inputs.length === 1) {
+        return context.inputs[0];
+    }
+    return context.inputs;
+};
+exports.bypassAgent = bypassAgent;

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

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

package/lib/experimental_agents/test_agents/copy2array_agent.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.copy2ArrayAgent = void 0;
+const copy2ArrayAgent = async ({ inputs }) => {
+    return new Array(10).fill(undefined).map(() => {
+        return inputs[0];
+    });
+};
+exports.copy2ArrayAgent = copy2ArrayAgent;

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

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

package/lib/experimental_agents/test_agents/copy_message_agent.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.copyMessageAgent = void 0;
+const copyMessageAgent = async ({ params }) => {
+    return {
+        messages: new Array(params.count).fill(undefined).map(() => {
+            return params.message;
+        }),
+    };
+};
+exports.copyMessageAgent = copyMessageAgent;

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

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

package/lib/experimental_agents/test_agents/counting_agent.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.countingAgent = void 0;
+const countingAgent = async ({ params }) => {
+    return {
+        list: new Array(params.count).fill(undefined).map((_, i) => {
+            return i;
+        }),
+    };
+};
+exports.countingAgent = countingAgent;

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

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

package/lib/experimental_agents/test_agents/echo_agent.js

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

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

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

package/lib/experimental_agents/test_agents/index.js

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

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

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

package/lib/experimental_agents/test_agents/merge_node_id_agent.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeNodeIdAgent = void 0;
+const mergeNodeIdAgent = async ({ debugInfo: { nodeId }, inputs }) => {
+    // console.log("executing", nodeId);
+    return inputs.reduce((tmp, input) => {
+        return { ...tmp, ...input };
+    }, { [nodeId]: "hello" });
+};
+exports.mergeNodeIdAgent = mergeNodeIdAgent;

package/lib/experimental_agents/token_agent.d.ts

@@ -0,0 +1,6 @@
+import { AgentFunction } from "../graphai";
+export declare const tokenBoundStringsAgent: AgentFunction<{
+    limit?: number;
+}, {
+    content: string;
+}, Array<string>>;

package/lib/experimental_agents/token_agent.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tokenBoundStringsAgent = void 0;
+const tiktoken_1 = require("tiktoken");
+const defaultMaxToken = 5000;
+const encoder = (0, tiktoken_1.get_encoding)("cl100k_base");
+// This agent generate a reference string from a sorted array of strings,
+// adding one by one until the token count exceeds the specified limit.
+// Parameters:
+//  limit?: number; // specifies the maximum token count. The default is 5000.
+// Inputs:
+//  inputs[0]: Array<string>; // array of string sorted by relevance.
+// Returns:
+//  { content: string } // reference text
+const tokenBoundStringsAgent = async ({ params, inputs }) => {
+    const contents = inputs[0];
+    const limit = params?.limit ?? defaultMaxToken;
+    const addNext = (total, index) => {
+        const length = encoder.encode(contents[index] + "\n").length;
+        if (total + length < limit && index + 1 < contents.length) {
+            return addNext(total + length, index + 1);
+        }
+        return { endIndex: index + 1, tokenCount: total };
+    };
+    const { endIndex, tokenCount } = addNext(0, 0);
+    const content = contents
+        .filter((value, index) => {
+        return index < endIndex;
+    })
+        .join("\n");
+    return { content, tokenCount, endIndex };
+};
+exports.tokenBoundStringsAgent = tokenBoundStringsAgent;

package/lib/graphai.d.ts

@@ -1,36 +1,41 @@
 export { AgentFunction, AgentFunctionDictonary, GraphData } from "./type";
-import { AgentFunctionDictonary, GraphData, DataSource, TransactionLog, ResultDataDictonary, ResultData, CallbackDictonaryArgs } from "./type";
+import { AgentFunctionDictonary, GraphData, DataSource, ResultDataDictonary, ResultData, DefaultResultData } from "./type";
+import { TransactionLog } from "./transaction_log";
 import { ComputedNode, StaticNode } from "./node";
+import { TaskManager } from "./task_manager";
 type GraphNodes = Record<string, ComputedNode | StaticNode>;
 export declare class GraphAI {
-    private data;
+    private readonly graphId;
+    private readonly data;
+    private readonly loop?;
+    private readonly logs;
+    readonly callbackDictonary: AgentFunctionDictonary;
+    readonly taskManager: TaskManager;
     nodes: GraphNodes;
-    agentId?: string;
-    callbackDictonary: AgentFunctionDictonary;
-    isRunning: boolean;
-    private runningNodes;
-    private nodeQueue;
+    onLogCallback: (__log: TransactionLog, __isUpdate: boolean) => void;
+    verbose: boolean;
     private onComplete;
-    private concurrency;
-    private loop?;
     private repeatCount;
-    verbose: boolean;
-    private logs;
     private createNodes;
     private getValueFromResults;
     private initializeNodes;
-    constructor(data: GraphData, callbackDictonary: CallbackDictonaryArgs);
+    constructor(data: GraphData, callbackDictonary: AgentFunctionDictonary, taskManager?: TaskManager | undefined);
     getCallback(agentId?: string): import("./type").AgentFunction<any, any, any>;
     asString(): string;
-    results(): ResultDataDictonary;
+    results<T = DefaultResultData>(all: boolean): ResultDataDictonary<T>;
     errors(): Record<string, Error>;
     private pushReadyNodesIntoQueue;
-    run(): Promise<ResultDataDictonary>;
-    private runNode;
+    private pushQueueIfReady;
+    pushQueueIfReadyAndRunning(node: ComputedNode): void;
     pushQueue(node: ComputedNode): void;
-    removeRunning(node: ComputedNode): void;
+    run<T = DefaultResultData>(all?: boolean): Promise<ResultDataDictonary<T>>;
+    isRunning(): boolean;
+    onExecutionComplete(node: ComputedNode): void;
+    private processLoopIfNecessary;
+    setLoopLog(log: TransactionLog): void;
     appendLog(log: TransactionLog): void;
+    updateLog(log: TransactionLog): void;
     transactionLogs(): TransactionLog[];
-    injectValue(nodeId: string, value: ResultData): void;
-    resultsOf(sources: Array<DataSource>): any[];
+    injectValue(nodeId: string, value: ResultData, injectFrom?: string): void;
+    resultsOf(sources: Array<DataSource>, anyInput?: boolean): any[];
 }