@eko-ai/eko 1.0.12 → 1.0.14

package/dist/web.esm.js

@@ -30,6 +30,7 @@ function clickable_elements_to_string(element_tree, includeAttributes) {
             'type',
             'name',
             'role',
+            'class',
             // 'href',
             'tabindex',
             'aria-label',
@@ -9173,9 +9174,11 @@ class ExportFile {
      * @returns > { success: true }
      */
     async execute(context, params) {
+        var _a, _b, _c;
         if (typeof params !== 'object' || params === null || !('content' in params)) {
             throw new Error('Invalid parameters. Expected an object with a "content" property.');
         }
+        await ((_c = (_b = (_a = context.callback) === null || _a === undefined ? undefined : _a.hooks) === null || _b === undefined ? undefined : _b.onExportFile) === null || _c === undefined ? undefined : _c.call(_b, params));
         let type = 'text/plain';
         switch (params.fileType) {
             case 'csv':
@@ -9377,14 +9380,251 @@ class Screenshot {
     }
 }
 
+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 === undefined ? undefined : _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;
+        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 onHumanInputText = (_a = context.callback) === null || _a === undefined ? undefined : _a.hooks.onHumanInputText;
+        if (onHumanInputText) {
+            let answer;
+            try {
+                answer = await onHumanInputText(question);
+            }
+            catch (e) {
+                console.error(e);
+                return { status: "Error: Cannot get user's answer.", answer: "" };
+            }
+            console.log("answer: " + answer);
+            return { status: "OK", answer: answer };
+        }
+        else {
+            console.error("`onHumanInputText` not implemented");
+            return { status: "Error: Cannot get user's 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;
+        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 onHumanInputSingleChoice = (_a = context.callback) === null || _a === undefined ? undefined : _a.hooks.onHumanInputSingleChoice;
+        if (onHumanInputSingleChoice) {
+            let answer;
+            try {
+                answer = await onHumanInputSingleChoice(question, choices);
+            }
+            catch (e) {
+                console.error(e);
+                return { status: "Error: Cannot get user's answer.", answer: "" };
+            }
+            console.log("answer: " + answer);
+            return { status: "OK", answer: answer };
+        }
+        else {
+            console.error("`onHumanInputSingleChoice` not implemented");
+            return { status: "Error: Cannot get user's 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;
+        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 onHumanInputMultipleChoice = (_a = context.callback) === null || _a === undefined ? undefined : _a.hooks.onHumanInputMultipleChoice;
+        if (onHumanInputMultipleChoice) {
+            let answer;
+            try {
+                answer = await onHumanInputMultipleChoice(question, choices);
+            }
+            catch (e) {
+                console.error(e);
+                return { status: "`onHumanInputMultipleChoice` not implemented", answer: [] };
+            }
+            console.log("answer: " + answer);
+            return { status: "OK", answer: answer };
+        }
+        else {
+            console.error("Cannot get user's answer.");
+            return { status: "Error: Cannot get user's 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;
+        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 onHumanOperate = (_a = context.callback) === null || _a === undefined ? undefined : _a.hooks.onHumanOperate;
+        if (onHumanOperate) {
+            let userOperation;
+            try {
+                userOperation = await onHumanOperate(reason);
+            }
+            catch (e) {
+                console.error(e);
+                return { status: "`onHumanOperate` not implemented", userOperation: "" };
+            }
+            console.log("userOperation: " + userOperation);
+            return { status: "OK", userOperation: userOperation };
+        }
+        else {
+            console.error("Cannot get user's operation.");
+            return { status: "Error: Cannot get user's operation.", userOperation: "" };
+        }
+    }
+}
+
+class SummaryWorkflow {
+    constructor() {
+        this.name = 'summary_workflow';
+        this.description = 'Summarize briefly what this workflow has accomplished.';
+        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 === undefined ? undefined : (_b = _a.hooks).onSummaryWorkflow) === null || _c === undefined ? undefined : _c.call(_b, summary));
+        return { status: "OK" };
+    }
+}
+
 var tools = /*#__PURE__*/Object.freeze({
     __proto__: null,
     BrowserUse: BrowserUse,
+    CancelWorkflow: CancelWorkflow,
     ElementClick: ElementClick,
     ExportFile: ExportFile,
     ExtractContent: ExtractContent,
     FindElementPosition: FindElementPosition,
-    Screenshot: Screenshot
+    HumanInputMultipleChoice: HumanInputMultipleChoice,
+    HumanInputSingleChoice: HumanInputSingleChoice,
+    HumanInputText: HumanInputText,
+    HumanOperate: HumanOperate,
+    Screenshot: Screenshot,
+    SummaryWorkflow: SummaryWorkflow
 });
 
 function loadTools() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eko-ai/eko",
-  "version": "1.0.12",
+  "version": "1.0.14",
   "description": "Empowering language to transform human words into action.",
   "main": "dist/index.cjs.js",
   "module": "dist/index.esm.js",