@eko-ai/eko 1.0.8 → 1.0.9

package/dist/models/action.d.ts

@@ -1,22 +1,26 @@
 import { Action, Tool, ExecutionContext } from '../types/action.types';
+import { NodeInput, NodeOutput } from '../types/workflow.types';
 import { LLMProvider, LLMParameters } from '../types/llm.types';
 export declare class ActionImpl implements Action {
     type: 'prompt';
     name: string;
     description: string;
     tools: Tool<any, any>[];
-    private llmProvider;
+    llmProvider: LLMProvider | undefined;
     private llmConfig?;
     private readonly maxRounds;
     private writeContextTool;
+    private toolResults;
+    private logger;
     constructor(type: 'prompt', // Only support prompt type
-    name: string, description: string, tools: Tool<any, any>[], llmProvider: LLMProvider, llmConfig?: LLMParameters | undefined, config?: {
+    name: string, description: string, tools: Tool<any, any>[], llmProvider: LLMProvider | undefined, llmConfig?: LLMParameters | undefined, config?: {
         maxRounds?: number;
     });
     private executeSingleRound;
     private handleHistoryImageMessages;
-    execute(input: unknown, context: ExecutionContext, outputSchema?: unknown): Promise<unknown>;
+    private countImages;
+    execute(input: NodeInput, output: NodeOutput, context: ExecutionContext, outputSchema?: unknown): Promise<unknown>;
     private formatSystemPrompt;
     private formatUserPrompt;
-    static createPromptAction(name: string, description: string, tools: Tool<any, any>[], llmProvider: LLMProvider, llmConfig?: LLMParameters): Action;
+    static createPromptAction(name: string, description: string, tools: Tool<any, any>[], llmProvider: LLMProvider | undefined, llmConfig?: LLMParameters): Action;
 }

package/dist/models/workflow.d.ts

@@ -1,4 +1,5 @@
-import { Workflow, WorkflowNode, LLMProvider, WorkflowCallback } from "../types";
+import { ExecutionLogger, LogOptions } from "@/utils/execution-logger";
+import { Workflow, WorkflowNode, NodeOutput, LLMProvider, WorkflowCallback } from "../types";
 export declare class WorkflowImpl implements Workflow {
     id: string;
     name: string;
@@ -7,8 +8,12 @@ export declare class WorkflowImpl implements Workflow {
     variables: Map<string, unknown>;
     llmProvider?: LLMProvider | undefined;
     abort?: boolean;
-    constructor(id: string, name: string, description?: string | undefined, nodes?: WorkflowNode[], variables?: Map<string, unknown>, llmProvider?: LLMProvider | undefined);
-    execute(callback?: WorkflowCallback): Promise<void>;
+    private logger?;
+    abortControllers: Map<string, AbortController>;
+    constructor(id: string, name: string, description?: string | undefined, nodes?: WorkflowNode[], variables?: Map<string, unknown>, llmProvider?: LLMProvider | undefined, loggerOptions?: LogOptions);
+    setLogger(logger: ExecutionLogger): void;
+    cancel(): Promise<void>;
+    execute(callback?: WorkflowCallback): Promise<NodeOutput[]>;
     addNode(node: WorkflowNode): void;
     removeNode(nodeId: string): void;
     getNode(nodeId: string): WorkflowNode;

package/dist/nodejs/tools/index.d.ts

@@ -1,3 +1,4 @@
+export * from '../../universal_tools';
 export { CommandExecute } from './command_execute';
 export { FileRead } from './file_read';
 export { FileWrite } from './file_write';

package/dist/nodejs.cjs.js

@@ -26,6 +26,205 @@ var require$$2$2 = require('http2');
 var require$$2$3 = require('inspector');
 var require$$0$5 = require('async_hooks');
 
+class CancelWorkflow {
+    constructor() {
+        this.name = 'cancel_workflow';
+        this.description = 'Cancel the workflow. If any tool consistently encounters exceptions, invoke this tool to cancel the workflow.';
+        this.input_schema = {
+            type: 'object',
+            properties: {
+                reason: {
+                    type: 'string',
+                    description: 'Why the workflow should be cancelled.',
+                },
+            },
+            required: ['reason'],
+        };
+    }
+    async execute(context, params) {
+        var _a;
+        if (typeof params !== 'object' || params === null || !params.reason) {
+            throw new Error('Invalid parameters. Expected an object with a "reason" property.');
+        }
+        const reason = params.reason;
+        console.log("The workflow has been cancelled because: " + reason);
+        await ((_a = context.workflow) === null || _a === void 0 ? void 0 : _a.cancel());
+        return;
+    }
+}
+
+class HumanInputText {
+    constructor() {
+        this.name = 'human_input_text';
+        this.description = 'When you are unsure about the details of your next action, call me and ask the user for details in the "question" field. The user will provide you with a text as an answer.';
+        this.input_schema = {
+            type: 'object',
+            properties: {
+                question: {
+                    type: 'string',
+                    description: 'Ask the user here.',
+                },
+            },
+            required: ['question'],
+        };
+    }
+    async execute(context, params) {
+        var _a, _b, _c;
+        if (typeof params !== 'object' || params === null || !params.question) {
+            throw new Error('Invalid parameters. Expected an object with a "question" property.');
+        }
+        const question = params.question;
+        console.log("question: " + question);
+        let answer = await ((_c = (_a = context.callback) === null || _a === void 0 ? void 0 : (_b = _a.hooks).onHumanInputText) === null || _c === void 0 ? void 0 : _c.call(_b, question));
+        if (!answer) {
+            console.error("Cannot get user's answer.");
+            return { status: "Error: Cannot get user's answer.", answer: "" };
+        }
+        else {
+            console.log("answer: " + answer);
+            return { status: "OK", answer: answer };
+        }
+    }
+}
+class HumanInputSingleChoice {
+    constructor() {
+        this.name = 'human_input_single_choice';
+        this.description = 'When you are unsure about the details of your next action, call me and ask the user for details in the "question" field with at least 2 choices. The user will provide you with ONE choice as an answer.';
+        this.input_schema = {
+            type: 'object',
+            properties: {
+                question: {
+                    type: 'string',
+                    description: 'Ask the user here.',
+                },
+                choices: {
+                    type: 'array',
+                    description: 'All of the choices.',
+                }
+            },
+            required: ['question', 'choices'],
+        };
+    }
+    async execute(context, params) {
+        var _a, _b, _c;
+        if (typeof params !== 'object' || params === null || !params.question || !params.choices) {
+            throw new Error('Invalid parameters. Expected an object with a "question" and "choices" property.');
+        }
+        const question = params.question;
+        const choices = params.choices;
+        console.log("question: " + question);
+        console.log("choices: " + choices);
+        let answer = await ((_c = (_a = context.callback) === null || _a === void 0 ? void 0 : (_b = _a.hooks).onHumanInputSingleChoice) === null || _c === void 0 ? void 0 : _c.call(_b, question, choices));
+        if (!answer) {
+            console.error("Cannot get user's answer.");
+            return { status: "Error: Cannot get user's answer.", answer: "" };
+        }
+        else {
+            console.log("answer: " + answer);
+            return { status: "OK", answer: answer };
+        }
+    }
+}
+class HumanInputMultipleChoice {
+    constructor() {
+        this.name = 'human_input_multiple_choice';
+        this.description = 'When you are unsure about the details of your next action, call me and ask the user for details in the "question" field with at least 2 choices. The user will provide you with ONE or MORE choice as an answer.';
+        this.input_schema = {
+            type: 'object',
+            properties: {
+                question: {
+                    type: 'string',
+                    description: 'Ask the user here.',
+                },
+                choices: {
+                    type: 'array',
+                    description: 'All of the choices.',
+                }
+            },
+            required: ['question', 'choices'],
+        };
+    }
+    async execute(context, params) {
+        var _a, _b, _c;
+        if (typeof params !== 'object' || params === null || !params.question || !params.choices) {
+            throw new Error('Invalid parameters. Expected an object with a "question" and "choices" property.');
+        }
+        const question = params.question;
+        const choices = params.choices;
+        console.log("question: " + question);
+        console.log("choices: " + choices);
+        let answer = await ((_c = (_a = context.callback) === null || _a === void 0 ? void 0 : (_b = _a.hooks).onHumanInputMultipleChoice) === null || _c === void 0 ? void 0 : _c.call(_b, question, choices));
+        if (!answer) {
+            console.error("Cannot get user's answer.");
+            return { status: "Error: Cannot get user's answer.", answer: [] };
+        }
+        else {
+            console.log("answer: " + answer);
+            return { status: "OK", answer: answer };
+        }
+    }
+}
+class HumanOperate {
+    constructor() {
+        this.name = 'human_operate';
+        this.description = 'When you encounter operations that require login, CAPTCHA verification, or other tasks that you cannot complete, please call this tool, transfer control to the user, and explain why.';
+        this.input_schema = {
+            type: 'object',
+            properties: {
+                reason: {
+                    type: 'string',
+                    description: 'The reason why you need to transfer control.',
+                },
+            },
+            required: ['reason'],
+        };
+    }
+    async execute(context, params) {
+        var _a, _b, _c;
+        if (typeof params !== 'object' || params === null || !params.reason) {
+            throw new Error('Invalid parameters. Expected an object with a "reason" property.');
+        }
+        const reason = params.reason;
+        console.log("reason: " + reason);
+        let userOperation = await ((_c = (_a = context.callback) === null || _a === void 0 ? void 0 : (_b = _a.hooks).onHumanOperate) === null || _c === void 0 ? void 0 : _c.call(_b, reason));
+        if (!userOperation) {
+            console.error("Cannot get user's operation.");
+            return { status: "Error: Cannot get user's operation.", userOperation: "" };
+        }
+        else {
+            console.log("userOperation: " + userOperation);
+            return { status: "OK", userOperation: userOperation };
+        }
+    }
+}
+
+class SummaryWorkflow {
+    constructor() {
+        this.name = 'summary_workflow';
+        this.description = 'Summarize what this workflow has done from start to finish using an ordered list .';
+        this.input_schema = {
+            type: 'object',
+            properties: {
+                summary: {
+                    type: 'string',
+                    description: 'Your summary in markdown format.',
+                },
+            },
+            required: ['summary'],
+        };
+    }
+    async execute(context, params) {
+        var _a, _b, _c;
+        if (typeof params !== 'object' || params === null || !params.summary) {
+            throw new Error('Invalid parameters. Expected an object with a "summary" property.');
+        }
+        const summary = params.summary;
+        console.log("summary: " + summary);
+        await ((_c = (_a = context.callback) === null || _a === void 0 ? void 0 : (_b = _a.hooks).onSummaryWorkflow) === null || _c === void 0 ? void 0 : _c.call(_b, summary));
+        return { status: "OK" };
+    }
+}
+
 const execAsync = require$$1.promisify(require$$12.exec);
 class CommandExecute {
     constructor() {
@@ -71394,7 +71593,11 @@ class BrowserUse {
                         quality: 50,
                     });
                     let base64 = screenshotBuffer.toString('base64');
-                    let image = 'data:image/jpeg;base64,' + base64;
+                    let image = {
+                        type: 'base64',
+                        media_type: 'image/jpeg',
+                        data: base64,
+                    };
                     await page.evaluate(() => {
                         return window.remove_highlight();
                     });
@@ -71622,9 +71825,15 @@ function do_input(params) {
 var tools = /*#__PURE__*/Object.freeze({
     __proto__: null,
     BrowserUse: BrowserUse,
+    CancelWorkflow: CancelWorkflow,
     CommandExecute: CommandExecute,
     FileRead: FileRead,
-    FileWrite: FileWrite
+    FileWrite: FileWrite,
+    HumanInputMultipleChoice: HumanInputMultipleChoice,
+    HumanInputSingleChoice: HumanInputSingleChoice,
+    HumanInputText: HumanInputText,
+    HumanOperate: HumanOperate,
+    SummaryWorkflow: SummaryWorkflow
 });
 
 function loadTools() {

package/dist/nodejs.esm.js

@@ -24,6 +24,205 @@ import require$$2$1 from 'http2';
 import require$$2$3 from 'inspector';
 import require$$0$5 from 'async_hooks';
 
+class CancelWorkflow {
+    constructor() {
+        this.name = 'cancel_workflow';
+        this.description = 'Cancel the workflow. If any tool consistently encounters exceptions, invoke this tool to cancel the workflow.';
+        this.input_schema = {
+            type: 'object',
+            properties: {
+                reason: {
+                    type: 'string',
+                    description: 'Why the workflow should be cancelled.',
+                },
+            },
+            required: ['reason'],
+        };
+    }
+    async execute(context, params) {
+        var _a;
+        if (typeof params !== 'object' || params === null || !params.reason) {
+            throw new Error('Invalid parameters. Expected an object with a "reason" property.');
+        }
+        const reason = params.reason;
+        console.log("The workflow has been cancelled because: " + reason);
+        await ((_a = context.workflow) === null || _a === void 0 ? void 0 : _a.cancel());
+        return;
+    }
+}
+
+class HumanInputText {
+    constructor() {
+        this.name = 'human_input_text';
+        this.description = 'When you are unsure about the details of your next action, call me and ask the user for details in the "question" field. The user will provide you with a text as an answer.';
+        this.input_schema = {
+            type: 'object',
+            properties: {
+                question: {
+                    type: 'string',
+                    description: 'Ask the user here.',
+                },
+            },
+            required: ['question'],
+        };
+    }
+    async execute(context, params) {
+        var _a, _b, _c;
+        if (typeof params !== 'object' || params === null || !params.question) {
+            throw new Error('Invalid parameters. Expected an object with a "question" property.');
+        }
+        const question = params.question;
+        console.log("question: " + question);
+        let answer = await ((_c = (_a = context.callback) === null || _a === void 0 ? void 0 : (_b = _a.hooks).onHumanInputText) === null || _c === void 0 ? void 0 : _c.call(_b, question));
+        if (!answer) {
+            console.error("Cannot get user's answer.");
+            return { status: "Error: Cannot get user's answer.", answer: "" };
+        }
+        else {
+            console.log("answer: " + answer);
+            return { status: "OK", answer: answer };
+        }
+    }
+}
+class HumanInputSingleChoice {
+    constructor() {
+        this.name = 'human_input_single_choice';
+        this.description = 'When you are unsure about the details of your next action, call me and ask the user for details in the "question" field with at least 2 choices. The user will provide you with ONE choice as an answer.';
+        this.input_schema = {
+            type: 'object',
+            properties: {
+                question: {
+                    type: 'string',
+                    description: 'Ask the user here.',
+                },
+                choices: {
+                    type: 'array',
+                    description: 'All of the choices.',
+                }
+            },
+            required: ['question', 'choices'],
+        };
+    }
+    async execute(context, params) {
+        var _a, _b, _c;
+        if (typeof params !== 'object' || params === null || !params.question || !params.choices) {
+            throw new Error('Invalid parameters. Expected an object with a "question" and "choices" property.');
+        }
+        const question = params.question;
+        const choices = params.choices;
+        console.log("question: " + question);
+        console.log("choices: " + choices);
+        let answer = await ((_c = (_a = context.callback) === null || _a === void 0 ? void 0 : (_b = _a.hooks).onHumanInputSingleChoice) === null || _c === void 0 ? void 0 : _c.call(_b, question, choices));
+        if (!answer) {
+            console.error("Cannot get user's answer.");
+            return { status: "Error: Cannot get user's answer.", answer: "" };
+        }
+        else {
+            console.log("answer: " + answer);
+            return { status: "OK", answer: answer };
+        }
+    }
+}
+class HumanInputMultipleChoice {
+    constructor() {
+        this.name = 'human_input_multiple_choice';
+        this.description = 'When you are unsure about the details of your next action, call me and ask the user for details in the "question" field with at least 2 choices. The user will provide you with ONE or MORE choice as an answer.';
+        this.input_schema = {
+            type: 'object',
+            properties: {
+                question: {
+                    type: 'string',
+                    description: 'Ask the user here.',
+                },
+                choices: {
+                    type: 'array',
+                    description: 'All of the choices.',
+                }
+            },
+            required: ['question', 'choices'],
+        };
+    }
+    async execute(context, params) {
+        var _a, _b, _c;
+        if (typeof params !== 'object' || params === null || !params.question || !params.choices) {
+            throw new Error('Invalid parameters. Expected an object with a "question" and "choices" property.');
+        }
+        const question = params.question;
+        const choices = params.choices;
+        console.log("question: " + question);
+        console.log("choices: " + choices);
+        let answer = await ((_c = (_a = context.callback) === null || _a === void 0 ? void 0 : (_b = _a.hooks).onHumanInputMultipleChoice) === null || _c === void 0 ? void 0 : _c.call(_b, question, choices));
+        if (!answer) {
+            console.error("Cannot get user's answer.");
+            return { status: "Error: Cannot get user's answer.", answer: [] };
+        }
+        else {
+            console.log("answer: " + answer);
+            return { status: "OK", answer: answer };
+        }
+    }
+}
+class HumanOperate {
+    constructor() {
+        this.name = 'human_operate';
+        this.description = 'When you encounter operations that require login, CAPTCHA verification, or other tasks that you cannot complete, please call this tool, transfer control to the user, and explain why.';
+        this.input_schema = {
+            type: 'object',
+            properties: {
+                reason: {
+                    type: 'string',
+                    description: 'The reason why you need to transfer control.',
+                },
+            },
+            required: ['reason'],
+        };
+    }
+    async execute(context, params) {
+        var _a, _b, _c;
+        if (typeof params !== 'object' || params === null || !params.reason) {
+            throw new Error('Invalid parameters. Expected an object with a "reason" property.');
+        }
+        const reason = params.reason;
+        console.log("reason: " + reason);
+        let userOperation = await ((_c = (_a = context.callback) === null || _a === void 0 ? void 0 : (_b = _a.hooks).onHumanOperate) === null || _c === void 0 ? void 0 : _c.call(_b, reason));
+        if (!userOperation) {
+            console.error("Cannot get user's operation.");
+            return { status: "Error: Cannot get user's operation.", userOperation: "" };
+        }
+        else {
+            console.log("userOperation: " + userOperation);
+            return { status: "OK", userOperation: userOperation };
+        }
+    }
+}
+
+class SummaryWorkflow {
+    constructor() {
+        this.name = 'summary_workflow';
+        this.description = 'Summarize what this workflow has done from start to finish using an ordered list .';
+        this.input_schema = {
+            type: 'object',
+            properties: {
+                summary: {
+                    type: 'string',
+                    description: 'Your summary in markdown format.',
+                },
+            },
+            required: ['summary'],
+        };
+    }
+    async execute(context, params) {
+        var _a, _b, _c;
+        if (typeof params !== 'object' || params === null || !params.summary) {
+            throw new Error('Invalid parameters. Expected an object with a "summary" property.');
+        }
+        const summary = params.summary;
+        console.log("summary: " + summary);
+        await ((_c = (_a = context.callback) === null || _a === void 0 ? void 0 : (_b = _a.hooks).onSummaryWorkflow) === null || _c === void 0 ? void 0 : _c.call(_b, summary));
+        return { status: "OK" };
+    }
+}
+
 const execAsync = promisify(exec);
 class CommandExecute {
     constructor() {
@@ -71392,7 +71591,11 @@ class BrowserUse {
                         quality: 50,
                     });
                     let base64 = screenshotBuffer.toString('base64');
-                    let image = 'data:image/jpeg;base64,' + base64;
+                    let image = {
+                        type: 'base64',
+                        media_type: 'image/jpeg',
+                        data: base64,
+                    };
                     await page.evaluate(() => {
                         return window.remove_highlight();
                     });
@@ -71620,9 +71823,15 @@ function do_input(params) {
 var tools = /*#__PURE__*/Object.freeze({
     __proto__: null,
     BrowserUse: BrowserUse,
+    CancelWorkflow: CancelWorkflow,
     CommandExecute: CommandExecute,
     FileRead: FileRead,
-    FileWrite: FileWrite
+    FileWrite: FileWrite,
+    HumanInputMultipleChoice: HumanInputMultipleChoice,
+    HumanInputSingleChoice: HumanInputSingleChoice,
+    HumanInputText: HumanInputText,
+    HumanOperate: HumanOperate,
+    SummaryWorkflow: SummaryWorkflow
 });
 
 function loadTools() {

package/dist/schemas/workflow.schema.d.ts

@@ -30,24 +30,13 @@ export declare const workflowSchema: {
                             type: string;
                         };
                     };
-                    input: {
-                        type: string;
-                        properties: {
-                            type: {
-                                type: string;
-                            };
-                            schema: {
-                                type: string;
-                            };
-                        };
-                    };
                     output: {
                         type: string;
                         properties: {
-                            type: {
+                            name: {
                                 type: string;
                             };
-                            schema: {
+                            description: {
                                 type: string;
                             };
                         };

package/dist/services/llm/claude-provider.d.ts

@@ -1,8 +1,9 @@
-import { ClientOptions } from '@anthropic-ai/sdk';
+import Anthropic, { ClientOptions } from '@anthropic-ai/sdk';
 import { LLMProvider, LLMParameters, LLMResponse, Message, LLMStreamHandler } from '../../types/llm.types';
 export declare class ClaudeProvider implements LLMProvider {
     private client;
     private defaultModel;
+    constructor(options: Anthropic, defaultModel?: string);
     constructor(options: ClientOptions, defaultModel?: string);
     constructor(apiKey: string, defaultModel?: string | null, options?: ClientOptions);
     private processResponse;

package/dist/services/llm/openai-provider.d.ts

@@ -1,8 +1,9 @@
-import { ClientOptions } from 'openai';
+import OpenAI, { ClientOptions } from 'openai';
 import { LLMProvider, LLMParameters, LLMResponse, Message, LLMStreamHandler } from '../../types/llm.types';
 export declare class OpenaiProvider implements LLMProvider {
     private client;
     private defaultModel;
+    constructor(client: OpenAI, defaultModel?: string);
     constructor(options: ClientOptions, defaultModel?: string);
     constructor(apiKey: string, defaultModel?: string | null, options?: ClientOptions);
     private buildParams;

package/dist/services/parser/workflow-parser.d.ts

@@ -14,16 +14,9 @@ export declare class WorkflowParser {
      * Validate workflow JSON structure against schema
      */
     static validate(json: unknown): ValidationResult;
-    /**
-     * Convert parsed JSON to runtime Workflow object
-     */
     private static toRuntime;
     /**
      * Convert runtime Workflow object to JSON structure
      */
     private static fromRuntime;
-    /**
-     * Helper to convert IO definitions
-     */
-    private static convertIO;
 }

package/dist/types/action.types.d.ts

@@ -1,5 +1,7 @@
+import { Workflow } from "./workflow.types";
 import { LLMProvider } from "./llm.types";
-import { WorkflowCallback } from "./workflow.types";
+import { NodeOutput, WorkflowCallback } from "./workflow.types";
+import { NodeInput } from "./workflow.types";
 export interface Tool<T, R> {
     name: string;
     description: string;
@@ -25,14 +27,17 @@ export interface Property {
 export interface ExecutionContext {
     llmProvider: LLMProvider;
     variables: Map<string, unknown>;
+    workflow?: Workflow;
     tools?: Map<string, Tool<any, any>>;
     callback?: WorkflowCallback;
+    signal?: AbortSignal;
     [key: string]: any;
 }
 export interface Action {
     type: 'prompt' | 'script' | 'hybrid';
     name: string;
     description: string;
-    execute: (input: unknown, context: ExecutionContext) => Promise<unknown>;
-    tools: Tool<any, any>[];
+    execute: (input: NodeInput, output: NodeOutput, context: ExecutionContext) => Promise<unknown>;
+    tools: Array<Tool<any, any>>;
+    llmProvider?: LLMProvider;
 }