graphai 0.0.12 → 0.1.1

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,7 @@
+import { AgentFunction } from "../../graphai";
+export declare const stringSplitterAgent: AgentFunction<{
+    chunkSize?: number;
+    overlap?: number;
+}, {
+    contents: Array<string>;
+}, string>;

package/lib/experimental_agents/string_agents/string_splitter_agent.js

@@ -0,0 +1,24 @@
+"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;

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

@@ -0,0 +1,4 @@
+import { AgentFunction } from "../../graphai";
+export declare const stringTemplateAgent: AgentFunction<{
+    template: string;
+}, Record<string, any> | string, string>;

package/lib/experimental_agents/{string_agent.js → string_agents/string_template_agent.js}

@@ -3,12 +3,9 @@ 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 stringTemplateAgent = async ({ params, inputs }) => {
     const content = inputs.reduce((template, input, index) => {
-        return template.replace("${" + index + "}", input[params.inputKey ?? "content"]);
+        return template.replace("${" + index + "}", input);
     }, params.template);
     return { content };
 };

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

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

package/lib/experimental_agents/test_agents/echo_fork_index_agent.js

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

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

@@ -0,0 +1,5 @@
+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";

package/lib/experimental_agents/test_agents/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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; } });

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,124 +1,41 @@
-export declare enum NodeState {
-    Waiting = "waiting",
-    Executing = "executing",
-    Failed = "failed",
-    TimedOut = "timed-out",
-    Completed = "completed",
-    Injected = "injected",
-    Dispatched = "dispatched"
-}
-type ResultData<ResultType = Record<string, any>> = ResultType | undefined;
-type ResultDataDictonary<ResultType = Record<string, any>> = Record<string, ResultData<ResultType>>;
-export type NodeDataParams<ParamsType = Record<string, any>> = ParamsType;
-type NodeData = {
-    inputs?: Array<string>;
-    params?: NodeDataParams;
-    retry?: number;
-    timeout?: number;
-    agentId?: string;
-    fork?: number;
-    source?: boolean;
-    value?: ResultData;
-    next?: string;
-    outputs?: Record<string, string>;
-};
-type LoopData = {
-    count?: number;
-    while?: string;
-};
-export type GraphData = {
-    agentId?: string;
-    nodes: Record<string, NodeData>;
-    concurrency?: number;
-    loop?: LoopData;
-    verbose?: boolean;
-};
-export type TransactionLog = {
-    nodeId: string;
-    state: NodeState;
-    startTime: number;
-    endTime?: number;
-    retryCount?: number;
-    agentId?: string;
-    params?: NodeDataParams;
-    inputs?: Array<ResultData>;
-    errorMessage?: string;
-    result?: ResultData;
-    log?: TransactionLog[];
-};
-export type AgentFunctionContext<ParamsType, PreviousResultType> = {
-    nodeId: string;
-    forkIndex?: number;
-    retry: number;
-    params: NodeDataParams<ParamsType>;
-    inputs: Array<PreviousResultType>;
-    verbose: boolean;
-    agents: CallbackDictonaryArgs;
-    log: TransactionLog[];
-};
-export type AgentFunction<ParamsType = Record<string, any>, ResultType = Record<string, any>, PreviousResultType = Record<string, any>> = (context: AgentFunctionContext<ParamsType, PreviousResultType>) => Promise<ResultData<ResultType>>;
-export type AgentFunctionDictonary = Record<string, AgentFunction<any, any, any>>;
-declare class Node {
-    nodeId: string;
-    params: NodeDataParams;
-    inputs: Array<string>;
-    inputProps: Record<string, string>;
-    pendings: Set<string>;
-    waitlist: Set<string>;
-    state: NodeState;
-    agentId?: string;
-    fork?: number;
-    forkIndex?: number;
-    result: ResultData;
-    retryLimit: number;
-    retryCount: number;
-    transactionId: undefined | number;
-    timeout?: number;
-    error?: Error;
-    source: boolean;
-    outputs?: Record<string, string>;
-    private graph;
-    constructor(nodeId: string, forkIndex: number | undefined, data: NodeData, graph: GraphAI);
-    asString(): string;
-    private retry;
-    removePending(nodeId: string): void;
-    pushQueueIfReady(): void;
-    injectValue(value: ResultData): void;
-    private setResult;
-    execute(): Promise<void>;
-}
-type GraphNodes = Record<string, Node>;
-export type CallbackDictonaryArgs = AgentFunctionDictonary;
+export { AgentFunction, AgentFunctionDictonary, GraphData } 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);
-    getCallback(agentId?: string): AgentFunction<any, any, any>;
+    constructor(data: GraphData, callbackDictonary: AgentFunctionDictonary, taskManager?: TaskManager | undefined);
+    getCallback(agentId?: string): import("./type").AgentFunction<any, any, any>;
     asString(): string;
-    results(): ResultDataDictonary<Record<string, any>>;
+    results<T = DefaultResultData>(all: boolean): ResultDataDictonary<T>;
     errors(): Record<string, Error>;
     private pushReadyNodesIntoQueue;
-    run(): Promise<ResultDataDictonary>;
-    private runNode;
-    pushQueue(node: Node): void;
-    removeRunning(node: Node): void;
+    private pushQueueIfReady;
+    pushQueueIfReadyAndRunning(node: ComputedNode): void;
+    pushQueue(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(nodeIds: Array<string>): ResultData<Record<string, any>>[];
+    injectValue(nodeId: string, value: ResultData, injectFrom?: string): void;
+    resultsOf(sources: Array<DataSource>, anyInput?: boolean): any[];
 }
-export {};