@eko-ai/eko 2.0.2 → 2.0.3

package/dist/index.esm.js

@@ -1,7 +1,8 @@
 const config = {
     name: "Fellou",
     platform: "mac",
-    maxReactNum: 100
+    maxReactNum: 100,
+    maxTokens: 16000
 };
 
 var LogLevel;
@@ -8556,6 +8557,15 @@ function mergeAgents(agents1, agents2) {
     }
     return tools;
 }
+function sub(str, maxLength, appendPoint = true) {
+    if (!str) {
+        return "";
+    }
+    if (str.length > maxLength) {
+        return str.substring(0, maxLength) + (appendPoint ? "..." : "");
+    }
+    return str;
+}
 function fixXmlTag(code) {
     function fixDoubleChar(code) {
         const stack = [];
@@ -12728,7 +12738,7 @@ class RetryLanguageModel {
     constructor(llms, names, stream_first_timeout) {
         this.llms = llms;
         this.names = names || [];
-        this.stream_first_timeout = stream_first_timeout || 20000;
+        this.stream_first_timeout = stream_first_timeout || 30000;
         if (this.names.indexOf("default") == -1) {
             this.names.push("default");
         }
@@ -12742,7 +12752,7 @@ class RetryLanguageModel {
                 toolChoice: request.toolChoice,
             },
             prompt: request.messages,
-            maxTokens: request.maxTokens,
+            maxTokens: request.maxTokens || config.maxTokens,
             temperature: request.temperature,
             topP: request.topP,
             topK: request.topK,
@@ -12765,6 +12775,9 @@ class RetryLanguageModel {
                 return result;
             }
             catch (e) {
+                if (e?.name === "AbortError") {
+                    throw e;
+                }
                 if (Log.isEnableInfo()) {
                     Log.info(`LLM nonstream request, name: ${name} => `, {
                         tools: options.mode?.tools,
@@ -12785,7 +12798,7 @@ class RetryLanguageModel {
                 toolChoice: request.toolChoice,
             },
             prompt: request.messages,
-            maxTokens: request.maxTokens,
+            maxTokens: request.maxTokens || config.maxTokens,
             temperature: request.temperature,
             topP: request.topP,
             topK: request.topK,
@@ -12801,12 +12814,19 @@ class RetryLanguageModel {
                 continue;
             }
             try {
-                const result = await call_timeout(async () => await llm.doStream(options), this.stream_first_timeout);
+                const controller = new AbortController();
+                const signal = options.abortSignal
+                    ? AbortSignal.any([options.abortSignal, controller.signal])
+                    : controller.signal;
+                const result = await call_timeout(async () => await llm.doStream({ ...options, abortSignal: signal }), this.stream_first_timeout, (e) => {
+                    controller.abort();
+                });
                 const stream = result.stream;
                 const reader = stream.getReader();
                 const { done, value } = await call_timeout(async () => await reader.read(), this.stream_first_timeout, (e) => {
                     reader.cancel();
                     reader.releaseLock();
+                    controller.abort();
                 });
                 if (done) {
                     Log.warn(`LLM stream done, name: ${name} => `, { done, value });
@@ -12826,6 +12846,9 @@ class RetryLanguageModel {
                 return result;
             }
             catch (e) {
+                if (e?.name === "AbortError") {
+                    throw e;
+                }
                 if (Log.isEnableInfo()) {
                     Log.info(`LLM stream request, name: ${name} => `, {
                         tools: options.mode?.tools,
@@ -15624,6 +15647,7 @@ const TOOL_NAME$3 = "human_interact";
 class HumanInteractTool {
     constructor() {
         this.name = TOOL_NAME$3;
+        this.noPlan = true;
         this.description = `AI interacts with humans:
 confirm: Ask the user to confirm whether to execute an operation, especially when performing dangerous actions such as deleting system files.
 input: Prompt the user to enter text; for example, when a task is ambiguous, the AI can choose to ask the user for details, and the user can respond by inputting.
@@ -15637,93 +15661,57 @@ request_help: Request assistance from the user; for instance, when an operation
                     description: "The type of interaction with users.",
                     enum: ["confirm", "input", "select", "request_help"],
                 },
-                confirm: {
-                    type: "object",
-                    properties: {
-                        prompt: {
-                            type: "string",
-                            description: "Display prompts to users",
-                        },
-                    },
-                    required: ["prompt"],
+                prompt: {
+                    type: "string",
+                    description: "Display prompts to users",
                 },
-                input: {
-                    type: "object",
-                    properties: {
-                        prompt: {
-                            type: "string",
-                            description: "Display prompts to users",
-                        },
+                selectOptions: {
+                    type: "array",
+                    description: "Options provided to users, this parameter is required when interactType is select.",
+                    items: {
+                        type: "string",
                     },
-                    required: ["prompt"],
                 },
-                select: {
-                    type: "object",
-                    properties: {
-                        prompt: {
-                            type: "string",
-                            description: "Display prompts to users",
-                        },
-                        options: {
-                            type: "array",
-                            description: "Options provided to the user",
-                            items: {
-                                type: "string",
-                            },
-                        },
-                        multiple: {
-                            type: "boolean",
-                        },
-                    },
-                    required: ["prompt", "options"],
+                selectMultiple: {
+                    type: "boolean",
+                    description: "isMultiple, used when interactType is select",
                 },
-                request_help: {
-                    type: "object",
-                    properties: {
-                        helpType: {
-                            type: "string",
-                            description: "Display prompts to users",
-                            enum: ["request_login", "request_assistance"],
-                        },
-                        prompt: {
-                            type: "string",
-                            description: "Display prompts to users",
-                        },
-                    },
-                    required: ["helpType", "prompt"],
+                helpType: {
+                    type: "string",
+                    description: "Help type, required when interactType is request_help.",
+                    enum: ["request_login", "request_assistance"],
                 },
             },
-            required: ["interactType"],
+            required: ["interactType", "prompt"],
         };
     }
     async execute(args, agentContext) {
         let interactType = args.interactType;
-        let interact = args[interactType];
         let callback = agentContext.context.config.callback;
         let resultText = "";
         if (callback) {
             switch (interactType) {
                 case "confirm":
                     if (callback.onHumanConfirm) {
-                        let result = await callback.onHumanConfirm(agentContext, interact.prompt);
+                        let result = await callback.onHumanConfirm(agentContext, args.prompt);
                         resultText = `confirm result: ${result ? "Yes" : "No"}`;
                     }
                     break;
                 case "input":
                     if (callback.onHumanInput) {
-                        let result = await callback.onHumanInput(agentContext, interact.prompt);
+                        let result = await callback.onHumanInput(agentContext, args.prompt);
                         resultText = `input result: ${result}`;
                     }
                     break;
                 case "select":
                     if (callback.onHumanSelect) {
-                        let result = await callback.onHumanSelect(agentContext, interact.prompt, interact.options, interact.multiple);
+                        let result = await callback.onHumanSelect(agentContext, args.prompt, (args.selectOptions || []), (args.selectMultiple || false));
                         resultText = `select result: ${JSON.stringify(result)}`;
                     }
                     break;
                 case "request_help":
                     if (callback.onHumanHelp) {
-                        let result = await callback.onHumanHelp(agentContext, interact.helpType, interact.prompt);
+                        let result = await callback.onHumanHelp(agentContext, (args.helpType || "request_assistance"), args.prompt);
                         resultText = `request_help result: ${result ? "Solved" : "Unresolved"}`;
                     }
                     break;
@@ -15897,7 +15885,7 @@ class WatchTriggerTool {
         };
     }
     async execute(args, agentContext) {
-        // TODO 监听 dom 或 文件 改变，执行节点
+        // TODO Listen for changes to the DOM or file, and execute nodes
         return null;
     }
 }
@@ -15936,11 +15924,15 @@ UTC datetime: {datetime}
 </root>
 `;
 const HUMAN_PROMPT = `
-During the task execution process, you can use the \`${TOOL_NAME$3}\` tool to interact with humans. Please do not abuse this tool to harass humans. Please call it in the following situations:
+* HUMAN INTERACT
+During the task execution process, you can use the \`${TOOL_NAME$3}\` tool to interact with humans, please call it in the following situations:
 - When performing dangerous operations such as deleting files, confirmation from humans is required
 - When encountering obstacles while accessing websites, such as requiring user login, you need to request human assistance
+- When requesting login, please only call the function when a login dialog box is clearly displayed.
+- Try not to use the \`${TOOL_NAME$3}\` tool
 `;
 const VARIABLE_PROMPT = `
+* VARIABLE STORAGE
 If you need to read and write the input/output variables in the node, require the use of the \`${TOOL_NAME$1}\` tool.
 `;
 const FOR_EACH_NODE = `
@@ -15965,14 +15957,18 @@ const WATCH_NODE = `
 const WATCH_PROMPT = `
 \`watch\`: monitor changes in webpage DOM or file content, when executing to the watch node, require the use of the \`${TOOL_NAME}\` tool.
 `;
-function getAgentSystemPrompt(agent, agentNode, context, systemPrompt) {
-    let prompt = "";
+function getAgentSystemPrompt(agent, agentNode, context, tools, extSysPrompt) {
+    let prompt = extSysPrompt || "";
     let nodePrompt = "";
     let agentNodeXml = agentNode.xml;
-    let hasForEach = agentNodeXml.indexOf("</forEach>") > -1;
     let hasWatch = agentNodeXml.indexOf("</watch>") > -1;
-    let hasVariable = agentNodeXml.indexOf(" input=") > -1 || agentNodeXml.indexOf(" output=") > -1;
-    let hasHumanTool = agent.Tools.filter((tool) => tool.name == TOOL_NAME$3).length > 0;
+    let hasForEach = agentNodeXml.indexOf("</forEach>") > -1;
+    let hasHumanTool = (tools || agent.Tools).filter((tool) => tool.name == TOOL_NAME$3)
+        .length > 0;
+    let hasVariable = agentNodeXml.indexOf("input=") > -1 ||
+        agentNodeXml.indexOf("output=") > -1 ||
+        (tools || agent.Tools).filter((tool) => tool.name == TOOL_NAME$1)
+            .length > 0;
     if (hasHumanTool) {
         prompt += HUMAN_PROMPT;
     }
@@ -15987,8 +15983,17 @@ function getAgentSystemPrompt(agent, agentNode, context, systemPrompt) {
         prompt += WATCH_PROMPT;
         nodePrompt += WATCH_NODE;
     }
-    return (systemPrompt || AGENT_SYSTEM_TEMPLATE)
-        .replace("{name}", config.name)
+    if (context.chain.agents.length > 1) {
+        prompt += "\n Main task: " + context.chain.taskPrompt;
+        prompt += "\n# Pre-task execution results";
+        for (let i = 0; i < context.chain.agents.length; i++) {
+            let agentChain = context.chain.agents[i];
+            if (agentChain.agentResult) {
+                prompt += `\n## ${agentChain.agent.task || agentChain.agent.name}\n${sub(agentChain.agentResult, 500)}`;
+            }
+        }
+    }
+    return AGENT_SYSTEM_TEMPLATE.replace("{name}", config.name)
         .replace("{agent}", agent.Name)
         .replace("{description}", agent.Description)
         .replace("{datetime}", new Date().toISOString())
@@ -15996,8 +16001,9 @@ function getAgentSystemPrompt(agent, agentNode, context, systemPrompt) {
         .replace("{nodePrompt}", nodePrompt)
         .trim();
 }
-function getAgentUserPrompt(agent, agentNode, context) {
-    let hasTaskNodeStatusTool = agent.Tools.filter((tool) => tool.name == TOOL_NAME$2).length > 0;
+function getAgentUserPrompt(agent, agentNode, context, tools) {
+    let hasTaskNodeStatusTool = (tools || agent.Tools).filter((tool) => tool.name == TOOL_NAME$2)
+        .length > 0;
     return buildAgentRootXml(agentNode.xml, context.chain.taskPrompt, (nodeId, node) => {
         if (hasTaskNodeStatusTool) {
             node.setAttribute("status", "todo");
@@ -16030,9 +16036,10 @@ class Agent {
         let loopNum = 0;
         let context = agentContext.context;
         let agentNode = agentContext.agentChain.agent;
-        let messages = this.initMessages(agentContext);
+        const tools = [...this.tools, ...this.system_auto_tools(agentNode)];
+        let messages = await this.initMessages(agentContext, tools);
         let rlm = new RetryLanguageModel(context.config.llms, this.llms);
-        let agentTools = [...this.tools, ...this.system_auto_tools(agentNode)];
+        let agentTools = tools;
         while (loopNum < maxReactNum) {
             context.checkAborted();
             if (mcpClient) {
@@ -16040,7 +16047,7 @@ class Agent {
                 if (controlMcp.mcpTools) {
                     let mcpTools = await this.listTools(agentNode, context, mcpClient, controlMcp.mcpParams);
                     let usedTools = this.extractUsedTool(messages, agentTools);
-                    let _agentTools = mergeTools(this.tools, usedTools);
+                    let _agentTools = mergeTools(tools, usedTools);
                     agentTools = mergeTools(_agentTools, mcpTools);
                 }
             }
@@ -16052,7 +16059,7 @@ class Agent {
             }
             loopNum++;
         }
-        return null;
+        return "Unfinished";
     }
     async handleResult(agentContext, messages, agentTools, results) {
         let text = null;
@@ -16132,8 +16139,8 @@ class Agent {
     system_auto_tools(agentNode) {
         let tools = [];
         let agentNodeXml = agentNode.xml;
-        let hasVariable = agentNodeXml.indexOf(" input=") > -1 ||
-            agentNodeXml.indexOf(" output=") > -1;
+        let hasVariable = agentNodeXml.indexOf("input=") > -1 ||
+            agentNodeXml.indexOf("output=") > -1;
         if (hasVariable) {
             tools.push(new VariableStorageTool());
         }
@@ -16162,24 +16169,27 @@ class Agent {
         }
         return _results;
     }
-    initMessages(agentContext) {
+    async initMessages(agentContext, tools) {
         let messages = [
             {
                 role: "system",
-                content: getAgentSystemPrompt(this, agentContext.agentChain.agent, agentContext.context),
+                content: getAgentSystemPrompt(this, agentContext.agentChain.agent, agentContext.context, tools, await this.extSysPrompt(agentContext)),
             },
             {
                 role: "user",
                 content: [
                     {
                         type: "text",
-                        text: getAgentUserPrompt(this, agentContext.agentChain.agent, agentContext.context),
+                        text: getAgentUserPrompt(this, agentContext.agentChain.agent, agentContext.context, tools),
                     },
                 ],
             },
         ];
         return messages;
     }
+    async extSysPrompt(agentContext) {
+        return "";
+    }
     async listTools(agentNode, context, mcpClient, mcpParams) {
         let list = await mcpClient.listTools({
             taskId: context.taskId,
@@ -16215,7 +16225,7 @@ class Agent {
                         nodeId: agentContext.agentChain.agent.id,
                         environment: config.platform,
                         agent_name: agentContext.agent.Name,
-                    }
+                    },
                 });
             },
         };
@@ -16243,7 +16253,7 @@ class Agent {
             let message = messages[i];
             if (message.role == "tool") {
                 for (let j = 0; j < message.content.length; j++) {
-                    let toolName = message.content[i].toolName;
+                    let toolName = message.content[j].toolName;
                     if (toolNames.indexOf(toolName) > -1) {
                         continue;
                     }
@@ -16287,12 +16297,17 @@ class Agent {
         else if (!isError && text.length == 0) {
             text = "Successful";
         }
-        let result = { result: text };
+        let contentText = {
+            type: "text",
+            text: text,
+        };
+        let result = text;
         if (text &&
             ((text.startsWith("{") && text.endsWith("}")) ||
                 (text.startsWith("[") && text.endsWith("]")))) {
             try {
                 result = JSON.parse(text);
+                contentText = null;
             }
             catch (e) { }
         }
@@ -16301,6 +16316,7 @@ class Agent {
             toolCallId: toolUse.toolCallId,
             toolName: toolUse.toolName,
             result: result,
+            content: contentText ? [contentText] : undefined,
             isError: isError,
         };
     }
@@ -16575,7 +16591,7 @@ Your task is to understand the user's requirements, dynamically plan the user's
 2. Analyze the Agents that need to be used based on the user's requirements.
 3. Generate the Agent calling plan based on the analysis results.
 4. About agent name, please do not arbitrarily fabricate non-existent agent names.
-5. You only need to provide the steps to complete the user's task, steps are simple and straightforward, no need for too many specific details.
+5. You only need to provide the steps to complete the user's task, key steps only, no need to be too detailed.
 6. Please strictly follow the output format and example output.
 7. The output language should follow the language corresponding to the user's task.
 
@@ -16726,15 +16742,22 @@ const PLAN_USER_TEMPLATE = `
 User Platform: {platform}
 Task Description: {taskPrompt}
 `;
+const PLAN_USER_TASK_WEBSITE_TEMPLATE = `
+User Platform: {platform}
+Task Website: {task_website}
+Task Description: {taskPrompt}
+`;
 function getPlanSystemPrompt(agents) {
     let agents_prompt = agents
         .map((agent) => {
         return (`<agent name="${agent.Name}">\n` +
             `Description: ${agent.PlanDescription || agent.Description}\nTools:\n` +
-            agent.Tools.map((tool) => `- ${tool.name}: ${tool.description || ""}`).join("\n") +
+            agent.Tools.filter((tool) => !tool.noPlan)
+                .map((tool) => `- ${tool.name}: ${tool.planDescription || tool.description || ""}`)
+                .join("\n") +
             `\n</agent>`);
     })
-        .join("\n");
+        .join("\n\n");
     let example_prompt = "";
     let hasChatAgent = agents.filter((a) => a.Name == AGENT_NAME$4).length > 0;
     const example_list = hasChatAgent
@@ -16749,10 +16772,18 @@ function getPlanSystemPrompt(agents) {
         .replace("{example_prompt}", example_prompt)
         .trim();
 }
-function getPlanUserPrompt(taskPrompt) {
-    return PLAN_USER_TEMPLATE.replace("{taskPrompt}", taskPrompt)
-        .replace("{platform}", config.platform)
-        .trim();
+function getPlanUserPrompt(taskPrompt, task_website) {
+    if (task_website) {
+        return PLAN_USER_TASK_WEBSITE_TEMPLATE.replace("{taskPrompt}", taskPrompt)
+            .replace("{platform}", config.platform)
+            .replace("{task_website}", task_website)
+            .trim();
+    }
+    else {
+        return PLAN_USER_TEMPLATE.replace("{taskPrompt}", taskPrompt)
+            .replace("{platform}", config.platform)
+            .trim();
+    }
 }
 
 class Planner {
@@ -16781,7 +16812,7 @@ class Planner {
                 {
                     role: "user",
                     content: [{ type: "text", text: taskPrompt }],
-                }
+                },
             ];
         }
         else {
@@ -16789,12 +16820,17 @@ class Planner {
                 { role: "system", content: getPlanSystemPrompt(this.context.agents) },
                 {
                     role: "user",
-                    content: [{ type: "text", text: getPlanUserPrompt(taskPrompt) }],
+                    content: [
+                        {
+                            type: "text",
+                            text: getPlanUserPrompt(taskPrompt, this.context.variables.get("task_website")),
+                        },
+                    ],
                 },
             ];
         }
         let request = {
-            maxTokens: 1024,
+            maxTokens: 4096,
             temperature: 0.7,
             messages: messages,
             abortSignal: this.context.controller.signal,
@@ -16898,30 +16934,33 @@ class Eko {
             throw new Error("The task does not exist");
         }
         try {
-            return this.doRunWorkflow(context);
+            return await this.doRunWorkflow(context);
         }
         catch (e) {
             return {
+                taskId,
                 success: false,
                 stopReason: e?.name == "AbortError" ? "abort" : "error",
                 result: e,
             };
         }
-        finally {
-            this.deleteTask(taskId);
-        }
     }
     async run(taskPrompt, taskId = uuidv4(), contextParams) {
         await this.generate(taskPrompt, taskId, contextParams);
         return await this.execute(taskId);
     }
     async initContext(workflow, contextParams) {
-        const agents = [...(this.config.agents || [])];
+        const agents = this.config.agents || [];
         let chain = new Chain(workflow.taskPrompt || workflow.name);
         let context = new Context(workflow.taskId, this.config, agents, chain);
+        if (this.config.a2aClient) {
+            let a2aList = await this.config.a2aClient.listAgents(workflow.taskPrompt || workflow.name);
+            context.agents = mergeAgents(context.agents, a2aList);
+        }
         if (contextParams) {
             Object.keys(contextParams).forEach((key) => context.variables.set(key, contextParams[key]));
         }
+        context.workflow = workflow;
         this.taskMap.set(workflow.taskId, context);
         return context;
     }
@@ -16935,7 +16974,7 @@ class Eko {
             map[item.Name] = item;
             return map;
         }, {});
-        let lastResult;
+        let results = [];
         for (let i = 0; i < workflow.agents.length; i++) {
             context.checkAborted();
             let agentNode = workflow.agents[i];
@@ -16946,18 +16985,21 @@ class Eko {
             let agentChain = new AgentChain(agentNode);
             context.chain.push(agentChain);
             agent.result = await agent.run(context, agentChain);
-            lastResult = agent.result;
+            results.push(agent.result);
         }
-        // TODO 超过2个Agent时需要summary输出结果。
         return {
             success: true,
             stopReason: "done",
-            result: lastResult,
+            result: results[results.length - 1],
+            taskId: context.taskId,
         };
     }
     getTask(taskId) {
         return this.taskMap.get(taskId);
     }
+    getAllTaskId() {
+        return [...this.taskMap.keys()];
+    }
     deleteTask(taskId) {
         return this.taskMap.delete(taskId);
     }
@@ -17202,18 +17244,17 @@ function parseChunk(chunk) {
 
 const AGENT_NAME$3 = "File";
 class BaseFileAgent extends Agent {
-    constructor(work_path, llms, ext_tools, mcpClient) {
+    constructor(work_path, llms, ext_tools, mcpClient, planDescription) {
         const _tools_ = [];
-        const prompt = work_path
-            ? `Your default working path is: ${work_path}`
-            : "";
+        const prompt = work_path ? `Your default working path is: ${work_path}` : "";
         super({
             name: AGENT_NAME$3,
             description: `You are a file agent, handling file-related tasks such as creating, finding, reading, modifying files, etc.${prompt}`,
             tools: _tools_,
             llms: llms,
             mcpClient: mcpClient,
-            planDescription: "File operation agent, handling file-related tasks such as creating, finding, reading, modifying files, etc.",
+            planDescription: planDescription ||
+                "File operation agent, handling file-related tasks such as creating, finding, reading, modifying files, etc, only text file writing is supported.",
         });
         let init_tools = this.buildInitTools();
         if (ext_tools && ext_tools.length > 0) {
@@ -17259,7 +17300,7 @@ class BaseFileAgent extends Agent {
             },
             {
                 name: "file_write",
-                description: "Overwrite or append content to a file. Use for creating new files, appending content, or modifying existing files.",
+                description: "Overwrite or append content to a file. Use for creating new files, appending content, or modifying existing files, only supports txt/md/csv or other text formats.",
                 parameters: {
                     type: "object",
                     properties: {
@@ -17335,7 +17376,7 @@ class BaseFileAgent extends Agent {
 
 const AGENT_NAME$2 = "Shell";
 class BaseShellAgent extends Agent {
-    constructor(llms, ext_tools, mcpClient) {
+    constructor(llms, ext_tools, mcpClient, planDescription) {
         const _tools_ = [];
         super({
             name: AGENT_NAME$2,
@@ -17343,7 +17384,7 @@ class BaseShellAgent extends Agent {
             tools: _tools_,
             llms: llms,
             mcpClient: mcpClient,
-            planDescription: "Shell command agent, use to execute shell commands.",
+            planDescription: planDescription || "Shell command agent, use to execute shell commands.",
         });
         let init_tools = this.buildInitTools();
         if (ext_tools && ext_tools.length > 0) {
@@ -17417,34 +17458,55 @@ class BaseTimerAgent extends Agent {
 
 const AGENT_NAME$1 = "Computer";
 class BaseComputerAgent extends Agent {
-    constructor(llms, ext_tools, mcpClient) {
+    constructor(llms, ext_tools, mcpClient, keyboardKeys) {
         const _tools_ = [];
         super({
             name: AGENT_NAME$1,
-            description: "You are a computer operation agent, who interacts with the computer using mouse and keyboard, completing specified tasks step by step based on the given tasks and screenshots. After each of your operations, you will receive the latest computer screenshot to evaluate the task execution status.",
+            description: `You are a computer operation agent, who interacts with the computer using mouse and keyboard, completing specified tasks step by step based on the given tasks and screenshots. After each of your operations, you will receive the latest computer screenshot to evaluate the task execution status.
+This is a computer GUI interface, observe the execution through screenshots, and specify action sequences to complete designated tasks.
+* COMPUTER OPERATIONS:
+  - You can operate the application using shortcuts.
+  - If stuck, try alternative approaches`,
             tools: _tools_,
             llms: llms,
             mcpClient: mcpClient,
-            planDescription: "Computer operation agent, interact with the computer using the mouse and keyboard."
+            planDescription: "Computer operation agent, interact with the computer using the mouse and keyboard, operation application."
         });
-        this.keyboardKeys = [
-            'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
-            'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
-            '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
-            'enter', 'esc', 'backspace', 'tab', 'space', 'delete',
-            'ctrl', 'alt', 'shift', 'win',
-            'up', 'down', 'left', 'right',
-            'f1', 'f2', 'f3', 'f4', 'f5', 'f6', 'f7', 'f8', 'f9', 'f10', 'f11', 'f12',
-            'ctrl+c', 'ctrl+v', 'ctrl+x', 'ctrl+z', 'ctrl+a', 'ctrl+s',
-            'alt+tab', 'alt+f4', 'ctrl+alt+delete'
-        ];
-        let init_tools = this.buildInitTools();
+        if (!keyboardKeys) {
+            if (config.platform == "windows") {
+                keyboardKeys = [
+                    'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
+                    'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
+                    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+                    'enter', 'esc', 'backspace', 'tab', 'space', 'delete',
+                    'ctrl', 'alt', 'shift', 'win',
+                    'up', 'down', 'left', 'right',
+                    'f1', 'f2', 'f3', 'f4', 'f5', 'f6', 'f7', 'f8', 'f9', 'f10', 'f11', 'f12',
+                    'ctrl+c', 'ctrl+v', 'ctrl+x', 'ctrl+z', 'ctrl+a', 'ctrl+s',
+                    'alt+tab', 'alt+f4', 'ctrl+alt+delete'
+                ];
+            }
+            else {
+                keyboardKeys = [
+                    'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
+                    'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
+                    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+                    'enter', 'esc', 'backspace', 'tab', 'space', 'delete',
+                    'command', 'option', 'shift', 'control',
+                    'up', 'down', 'left', 'right',
+                    'f1', 'f2', 'f3', 'f4', 'f5', 'f6', 'f7', 'f8', 'f9', 'f10', 'f11', 'f12',
+                    'command+c', 'command+v', 'command+x', 'command+z', 'command+a', 'command+s',
+                    'command+tab', 'command+q', 'command+escape'
+                ];
+            }
+        }
+        let init_tools = this.buildInitTools(keyboardKeys);
         if (ext_tools && ext_tools.length > 0) {
             init_tools = mergeTools(init_tools, ext_tools);
         }
         init_tools.forEach((tool) => _tools_.push(tool));
     }
-    buildInitTools() {
+    buildInitTools(keyboardKeys) {
         return [
             {
                 name: "typing",
@@ -17525,15 +17587,22 @@ class BaseComputerAgent extends Agent {
                     properties: {
                         amount: {
                             type: "number",
-                            description: "Scroll amount (positive for up, negative for down)",
-                            minimum: -10,
+                            description: "Scroll amount (up / down)",
+                            minimum: 1,
                             maximum: 10,
                         },
+                        direction: {
+                            type: "string",
+                            enum: ["up", "down"],
+                        },
                     },
-                    required: ["amount"],
+                    required: ["amount", "direction"],
                 },
                 execute: async (args, agentContext) => {
-                    return await this.callInnerTool(() => this.scroll(agentContext, args.amount));
+                    return await this.callInnerTool(async () => {
+                        let amount = args.amount;
+                        await this.scroll(agentContext, args.direction == "up" ? -amount : amount);
+                    });
                 },
             },
             {
@@ -17545,7 +17614,7 @@ class BaseComputerAgent extends Agent {
                         key: {
                             type: "string",
                             description: "Key to press",
-                            enum: this.keyboardKeys,
+                            enum: keyboardKeys,
                         },
                     },
                     required: ["key"],
@@ -17563,7 +17632,7 @@ class BaseComputerAgent extends Agent {
                         keys: {
                             type: "string",
                             description: "Key combination to press",
-                            enum: this.keyboardKeys,
+                            enum: keyboardKeys,
                         },
                     },
                     required: ["keys"],
@@ -17603,20 +17672,23 @@ class BaseComputerAgent extends Agent {
             },
             {
                 name: "wait",
+                noPlan: true,
                 description: "Wait for specified duration",
                 parameters: {
                     type: "object",
                     properties: {
                         duration: {
                             type: "number",
-                            description: "Duration in seconds",
-                            default: 0.5,
+                            description: "Duration in millisecond",
+                            default: 500,
+                            minimum: 200,
+                            maximum: 2000,
                         },
                     },
                     required: ["duration"],
                 },
                 execute: async (args, agentContext) => {
-                    return await this.callInnerTool(() => sleep((args.duration || 0.5) * 1000));
+                    return await this.callInnerTool(() => sleep((args.duration || 200)));
                 },
             },
         ];
@@ -17625,7 +17697,7 @@ class BaseComputerAgent extends Agent {
         let lastMessage = messages[messages.length - 1];
         if (lastMessage.role == "tool" &&
             lastMessage.content.filter((t) => t.type == "tool-result").length > 0) {
-            await sleep(200);
+            await sleep(300);
             let result = await this.screenshot(agentContext);
             let image = toImage(result.imageBase64);
             messages.push({
@@ -17660,12 +17732,15 @@ class BaseComputerAgent extends Agent {
 
 class BaseBrowserAgent extends Agent {
     async go_back(agentContext) {
-        await this.execute_script(agentContext, () => {
-            return window.navigation.back();
-        }, []);
-        await sleep(200);
+        try {
+            await this.execute_script(agentContext, () => {
+                window.navigation.back();
+            }, []);
+            await sleep(100);
+        }
+        catch (e) { }
     }
-    async extract_content(agentContext) {
+    async extract_content(agentContext, variable_name) {
         let content = await this.execute_script(agentContext, () => {
             return window.document.body.innerText
                 .replaceAll(/\n+/g, "\n")
@@ -17673,19 +17748,37 @@ class BaseBrowserAgent extends Agent {
                 .trim();
         }, []);
         let pageInfo = await this.get_current_page(agentContext);
-        return `title: ${pageInfo.title}\npage_url: ${pageInfo.url}\npage_content: \n${content}`;
+        let result = `title: ${pageInfo.title}\npage_url: ${pageInfo.url}\npage_content: \n${content}`;
+        if (variable_name) {
+            agentContext.context.variables.set(variable_name, result);
+        }
+        return result;
     }
     async controlMcpTools(agentContext, messages, loopNum) {
-        let url = (await this.get_current_page(agentContext)).url;
-        let lastUrl = agentContext.variables.get("lastUrl");
-        agentContext.variables.set("lastUrl", url);
-        return {
-            mcpTools: loopNum == 0 || url != lastUrl,
-            mcpParams: {
-                environment: "browser",
-                browser_url: url,
-            },
-        };
+        if (loopNum > 0) {
+            let url = null;
+            try {
+                url = (await this.get_current_page(agentContext)).url;
+            }
+            catch (e) { }
+            let lastUrl = agentContext.variables.get("lastUrl");
+            agentContext.variables.set("lastUrl", url);
+            return {
+                mcpTools: loopNum == 0 || url != lastUrl,
+                mcpParams: {
+                    environment: "browser",
+                    browser_url: url,
+                },
+            };
+        }
+        else {
+            return {
+                mcpTools: true,
+                mcpParams: {
+                    environment: "browser",
+                },
+            };
+        }
     }
     toolExecuter(mcpClient, name) {
         return {
@@ -17699,7 +17792,7 @@ class BaseBrowserAgent extends Agent {
                         environment: "browser",
                         agent_name: agentContext.agent.Name,
                         browser_url: agentContext.variables.get("lastUrl"),
-                    }
+                    },
                 });
                 if (result.extInfo &&
                     result.extInfo["javascript"] &&
@@ -17739,6 +17832,42 @@ class BaseBrowserAgent extends Agent {
             };
         }, []);
     }
+    lastToolResult(messages) {
+        let lastMessage = messages[messages.length - 1];
+        if (lastMessage.role != "tool") {
+            return null;
+        }
+        let toolResult = lastMessage.content.filter((t) => t.type == "tool-result")[0];
+        if (!toolResult) {
+            return null;
+        }
+        let result = toolResult.result;
+        let isError = toolResult.isError;
+        for (let i = messages.length - 2; i > 0; i--) {
+            if (messages[i].role !== "assistant" ||
+                typeof messages[i].content == "string") {
+                continue;
+            }
+            for (let j = 0; j < messages[i].content.length; j++) {
+                let content = messages[i].content[j];
+                if (typeof content !== "string" && content.type !== "tool-call") {
+                    continue;
+                }
+                let toolUse = content;
+                if (toolResult.toolCallId != toolUse.toolCallId) {
+                    continue;
+                }
+                return {
+                    id: toolResult.toolCallId,
+                    toolName: toolUse.toolName,
+                    args: toolUse.args,
+                    result,
+                    isError,
+                };
+            }
+        }
+        return null;
+    }
     async execute_mcp_script(agentContext, script) {
         return;
     }
@@ -17765,7 +17894,7 @@ function run_build_dom_tree() {
         return window.clickable_elements[highlightIndex];
     }
     function remove_highlight() {
-        let highlight = document.getElementById('playwright-highlight-container');
+        let highlight = document.getElementById('eko-highlight-container');
         if (highlight) {
             highlight.remove();
         }
@@ -17825,6 +17954,10 @@ function run_build_dom_tree() {
                         for (let i = 0; i < includeAttributes.length; i++) {
                             let key = includeAttributes[i];
                             let value = node.attributes[key];
+                            if (key == "class" && value && value.length > 30) {
+                                let classList = value.split(" ").slice(0, 3);
+                                value = classList.join(" ");
+                            }
                             if (key && value) {
                                 attributes_str += ` ${key}="${value}"`;
                             }
@@ -17903,10 +18036,10 @@ function run_build_dom_tree() {
         let highlightIndex = 0; // Reset highlight index
         function highlightElement(element, index, parentIframe = null) {
             // Create or get highlight container
-            let container = document.getElementById('playwright-highlight-container');
+            let container = document.getElementById('eko-highlight-container');
             if (!container) {
                 container = document.createElement('div');
-                container.id = 'playwright-highlight-container';
+                container.id = 'eko-highlight-container';
                 container.style.position = 'fixed';
                 container.style.pointerEvents = 'none';
                 container.style.top = '0';
@@ -17959,7 +18092,7 @@ function run_build_dom_tree() {
             overlay.style.height = `${rect.height}px`;
             // Create label
             const label = document.createElement('div');
-            label.className = 'playwright-highlight-label';
+            label.className = 'eko-highlight-label';
             label.style.position = 'absolute';
             label.style.background = baseColor;
             label.style.color = 'white';
@@ -17993,7 +18126,7 @@ function run_build_dom_tree() {
             container.appendChild(overlay);
             container.appendChild(label);
             // Store reference for cleanup
-            element.setAttribute('browser-user-highlight-id', `playwright-highlight-${index}`);
+            element.setAttribute('eko-user-highlight-id', `eko-highlight-${index}`);
             return index + 1;
         }
         // Helper function to generate XPath as a tree
@@ -18338,15 +18471,17 @@ class BaseBrowserLabelsAgent extends BaseBrowserAgent {
   - Screenshot help verify element positions and relationships. Labels may sometimes overlap, so extracted elements are used to verify the correct elements.
   - In addition to screenshot, simplified information about interactive elements is returned, with element indexes corresponding to those in the screenshot.
   - This tool can ONLY screenshot the VISIBLE content. If a complete content is required, use 'extract_content' instead.
+  - If the webpage content hasn't loaded, please use the \`wait\` tool to allow time for the content to load.
 * ELEMENT INTERACTION:
    - Only use indexes that exist in the provided element list
    - Each element has a unique index number (e.g., "[33]:<button>")
    - Elements marked with "[]:" are non-interactive (for context only)
-* NAVIGATION & ERROR HANDLING:
+* ERROR HANDLING:
    - If no suitable elements exist, use other functions to complete the task
-   - If stuck, try alternative approaches
+   - If stuck, try alternative approaches, don't refuse tasks
    - Handle popups/cookies by accepting or closing them
-   - Use scroll to find elements you are looking for`;
+   - Use scroll to find elements you are looking for
+   - When extracting content, prioritize using extract_content, only scroll when you need to load more content`;
         const _tools_ = [];
         super({
             name: AGENT_NAME,
@@ -18364,6 +18499,9 @@ class BaseBrowserLabelsAgent extends BaseBrowserAgent {
     }
     async input_text(agentContext, index, text, enter) {
         await this.execute_script(agentContext, typing, [{ index, text, enter }]);
+        if (enter) {
+            await sleep(200);
+        }
     }
     async click_element(agentContext, index, num_clicks, button) {
         await this.execute_script(agentContext, do_click, [
@@ -18380,18 +18518,32 @@ class BaseBrowserLabelsAgent extends BaseBrowserAgent {
     }
     async scroll_mouse_wheel(agentContext, amount) {
         await this.execute_script(agentContext, (amount) => {
-            window.scrollBy(0, amount * 50);
+            let viewportHeight = window.innerHeight ||
+                document.documentElement.clientHeight ||
+                document.body.clientHeight;
+            let y = Math.max(20, Math.min(viewportHeight / 10, 200));
+            window.scrollBy(0, y * amount);
         }, [amount]);
         await sleep(200);
     }
     async hover_to_element(agentContext, index) {
         await this.execute_script(agentContext, hover_to, [{ index }]);
     }
+    async get_select_options(agentContext, index) {
+        return await this.execute_script(agentContext, get_select_options, [
+            { index },
+        ]);
+    }
+    async select_option(agentContext, index, option) {
+        return await this.execute_script(agentContext, select_option, [
+            { index, option },
+        ]);
+    }
     async screenshot_and_html(agentContext) {
         try {
             let element_result = null;
             for (let i = 0; i < 5; i++) {
-                await sleep(300);
+                await sleep(200);
                 await this.execute_script(agentContext, run_build_dom_tree, []);
                 element_result = (await this.execute_script(agentContext, () => {
                     return window.get_clickable_elements(true);
@@ -18400,7 +18552,9 @@ class BaseBrowserLabelsAgent extends BaseBrowserAgent {
                     break;
                 }
             }
+            await sleep(50);
             let screenshot = await this.screenshot(agentContext);
+            // agentContext.variables.set("selector_map", element_result.selector_map);
             let pseudoHtml = element_result.element_str;
             return {
                 imageBase64: screenshot.imageBase64,
@@ -18538,15 +18692,22 @@ class BaseBrowserLabelsAgent extends BaseBrowserAgent {
                     properties: {
                         amount: {
                             type: "number",
-                            description: "Scroll amount (positive for up, negative for down)",
-                            minimum: -10,
+                            description: "Scroll amount (up / down)",
+                            minimum: 1,
                             maximum: 10,
                         },
+                        direction: {
+                            type: "string",
+                            enum: ["up", "down"],
+                        },
                     },
-                    required: ["amount"],
+                    required: ["amount", "direction"],
                 },
                 execute: async (args, agentContext) => {
-                    return await this.callInnerTool(() => this.scroll_mouse_wheel(agentContext, args.amount));
+                    return await this.callInnerTool(async () => {
+                        let amount = args.amount;
+                        await this.scroll_mouse_wheel(agentContext, args.direction == "up" ? -amount : amount);
+                    });
                 },
             },
             {
@@ -18568,7 +18729,7 @@ class BaseBrowserLabelsAgent extends BaseBrowserAgent {
             },
             {
                 name: "extract_content",
-                description: "Extract the text content of the current webpage.",
+                description: "Extract the text content of the current webpage, obtain webpage data through this tool.",
                 parameters: {
                     type: "object",
                     properties: {},
@@ -18577,31 +18738,102 @@ class BaseBrowserLabelsAgent extends BaseBrowserAgent {
                     return await this.callInnerTool(() => this.extract_content(agentContext));
                 },
             },
+            {
+                name: "get_select_options",
+                description: "Get all options from a native dropdown element",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        index: {
+                            type: "number",
+                            description: "The index of the element to select",
+                        },
+                    },
+                    required: ["index"],
+                },
+                execute: async (args, agentContext) => {
+                    return await this.callInnerTool(() => this.get_select_options(agentContext, args.index));
+                },
+            },
+            {
+                name: "select_option",
+                description: "Select the native dropdown option",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        index: {
+                            type: "number",
+                            description: "The index of the element to select",
+                        },
+                        option: {
+                            type: "string",
+                            description: "Text option",
+                        },
+                    },
+                    required: ["index", "option"],
+                },
+                execute: async (args, agentContext) => {
+                    return await this.callInnerTool(() => this.select_option(agentContext, args.index, args.option));
+                },
+            },
+            {
+                name: "get_all_tabs",
+                description: "Get all tabs of the current browser",
+                parameters: {
+                    type: "object",
+                    properties: {},
+                },
+                execute: async (args, agentContext) => {
+                    return await this.callInnerTool(() => this.get_all_tabs(agentContext));
+                },
+            },
+            {
+                name: "switch_tab",
+                description: "Switch to the specified tab page",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        tabId: {
+                            type: "number",
+                            description: "Tab ID, obtained through get_all_tabs",
+                        },
+                    },
+                    required: ["tabId"],
+                },
+                execute: async (args, agentContext) => {
+                    return await this.callInnerTool(() => this.switch_tab(agentContext, args.tabId));
+                },
+            },
             {
                 name: "wait",
+                noPlan: true,
                 description: "Wait for specified duration",
                 parameters: {
                     type: "object",
                     properties: {
                         duration: {
                             type: "number",
-                            description: "Duration in seconds",
-                            default: 0.5,
+                            description: "Duration in millisecond",
+                            default: 500,
+                            minimum: 200,
+                            maximum: 2000,
                         },
                     },
                     required: ["duration"],
                 },
                 execute: async (args, agentContext) => {
-                    return await this.callInnerTool(() => sleep((args.duration || 0.5) * 1000));
+                    return await this.callInnerTool(() => sleep((args.duration || 200)));
                 },
             },
         ];
     }
     async handleMessages(agentContext, messages) {
-        let lastMessage = messages[messages.length - 1];
-        if (lastMessage.role == "tool" &&
-            lastMessage.content.filter((t) => t.type == "tool-result").length > 0) {
-            await sleep(200);
+        let lastTool = this.lastToolResult(messages);
+        if (lastTool &&
+            lastTool.toolName !== "extract_content" &&
+            lastTool.toolName !== "get_all_tabs" &&
+            lastTool.toolName !== "variable_storage") {
+            await sleep(300);
             let result = await this.screenshot_and_html(agentContext);
             let image = toImage(result.imageBase64);
             messages.push({
@@ -18658,6 +18890,10 @@ function typing(params) {
     }
     else {
         input.value = text;
+        if (input.__proto__) {
+            let value_setter = Object.getOwnPropertyDescriptor(input.__proto__, "value")?.set;
+            value_setter && value_setter.call(input, text);
+        }
     }
     input.dispatchEvent(new Event("input", { bubbles: true }));
     if (enter) {
@@ -18717,6 +18953,45 @@ function hover_to(params) {
     element.dispatchEvent(event);
     return true;
 }
+function get_select_options(params) {
+    let element = window.get_highlight_element(params.index);
+    if (!element || element.tagName.toUpperCase() !== "SELECT") {
+        return "Error: Not a select element";
+    }
+    return {
+        options: Array.from(element.options).map((opt) => ({
+            index: opt.index,
+            text: opt.text.trim(),
+            value: opt.value,
+        })),
+        name: element.name,
+    };
+}
+function select_option(params) {
+    let element = window.get_highlight_element(params.index);
+    if (!element || element.tagName.toUpperCase() !== "SELECT") {
+        return "Error: Not a select element";
+    }
+    let text = params.option.trim();
+    let option = Array.from(element.options).find((opt) => opt.text.trim() === text);
+    if (!option) {
+        option = Array.from(element.options).find((opt) => opt.value.trim() === text);
+    }
+    if (!option) {
+        return {
+            success: false,
+            error: "Select Option not found",
+            availableOptions: Array.from(element.options).map((o) => o.text.trim()),
+        };
+    }
+    element.value = option.value;
+    element.dispatchEvent(new Event("change"));
+    return {
+        success: true,
+        selectedValue: option.value,
+        selectedText: option.text.trim(),
+    };
+}
 
 class BaseBrowserScreenAgent extends BaseBrowserAgent {
     constructor(llms, ext_tools, mcpClient) {
@@ -18738,7 +19013,7 @@ class BaseBrowserScreenAgent extends BaseBrowserAgent {
             tools: _tools_,
             llms: llms,
             mcpClient: mcpClient,
-            planDescription: "Browser operation agent, interact with the browser using the mouse and keyboard."
+            planDescription: "Browser operation agent, interact with the browser using the mouse and keyboard.",
         });
         let init_tools = this.buildInitTools();
         if (ext_tools && ext_tools.length > 0) {
@@ -18866,20 +19141,27 @@ class BaseBrowserScreenAgent extends BaseBrowserAgent {
                     properties: {
                         amount: {
                             type: "number",
-                            description: "Scroll amount (positive for up, negative for down)",
-                            minimum: -10,
+                            description: "Scroll amount (up / down)",
+                            minimum: 1,
                             maximum: 10,
                         },
+                        direction: {
+                            type: "string",
+                            enum: ["up", "down"],
+                        },
                     },
-                    required: ["amount"],
+                    required: ["amount", "direction"],
                 },
                 execute: async (args, agentContext) => {
-                    return await this.callInnerTool(() => this.scroll(agentContext, args.amount));
+                    return await this.callInnerTool(async () => {
+                        let amount = args.amount;
+                        await this.scroll(agentContext, args.direction == "up" ? -amount : amount);
+                    });
                 },
             },
             {
                 name: "extract_content",
-                description: "Extract the text content of the current webpage.",
+                description: "Extract the text content of the current webpage, obtain webpage data through this tool.",
                 parameters: {
                     type: "object",
                     properties: {},
@@ -18935,31 +19217,64 @@ class BaseBrowserScreenAgent extends BaseBrowserAgent {
                     return await this.callInnerTool(() => this.drag_and_drop(agentContext, args.x1, args.y1, args.x2, args.y2));
                 },
             },
+            {
+                name: "get_all_tabs",
+                description: "Get all tabs of the current browser",
+                parameters: {
+                    type: "object",
+                    properties: {},
+                },
+                execute: async (args, agentContext) => {
+                    return await this.callInnerTool(() => this.get_all_tabs(agentContext));
+                },
+            },
+            {
+                name: "switch_tab",
+                description: "Switch to the specified tab page",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        tabId: {
+                            type: "number",
+                            description: "Tab ID, obtained through get_all_tabs",
+                        },
+                    },
+                    required: ["tabId"],
+                },
+                execute: async (args, agentContext) => {
+                    return await this.callInnerTool(() => this.switch_tab(agentContext, args.tabId));
+                },
+            },
             {
                 name: "wait",
+                noPlan: true,
                 description: "Wait for specified duration",
                 parameters: {
                     type: "object",
                     properties: {
                         duration: {
                             type: "number",
-                            description: "Duration in seconds",
-                            default: 0.5,
+                            description: "Duration in millisecond",
+                            default: 500,
+                            minimum: 200,
+                            maximum: 2000,
                         },
                     },
                     required: ["duration"],
                 },
                 execute: async (args, agentContext) => {
-                    return await this.callInnerTool(() => sleep((args.duration || 0.5) * 1000));
+                    return await this.callInnerTool(() => sleep((args.duration || 200)));
                 },
             },
         ];
     }
     async handleMessages(agentContext, messages) {
-        let lastMessage = messages[messages.length - 1];
-        if (lastMessage.role == "tool" &&
-            lastMessage.content.filter((t) => t.type == "tool-result").length > 0) {
-            await sleep(200);
+        let lastTool = this.lastToolResult(messages);
+        if (lastTool &&
+            lastTool.toolName !== "extract_content" &&
+            lastTool.toolName !== "get_all_tabs" &&
+            lastTool.toolName !== "variable_storage") {
+            await sleep(300);
             let result = await this.screenshot(agentContext);
             let image = toImage(result.imageBase64);
             messages.push({