@eko-ai/eko 3.0.0 → 3.0.1-alpha.2

package/dist/index.esm.js

@@ -10,6 +10,8 @@ const config$1 = {
     fileTextMaxLength: 20000,
     maxDialogueImgFileNum: 1,
     toolResultMultimodal: true,
+    expertMode: false,
+    expertModeTodoLoopNum: 10,
 };
 
 var LogLevel;
@@ -30811,10 +30813,10 @@ ${agents.join("\n")}
     workflow.xml = xml;
 }
 
-const TOOL_NAME$8 = "task_snapshot";
+const TOOL_NAME$a = "task_snapshot";
 class TaskSnapshotTool {
     constructor() {
-        this.name = TOOL_NAME$8;
+        this.name = TOOL_NAME$a;
         this.description = `Task snapshot archive, recording key information of the current task, updating task node status, facilitating subsequent continuation of operation.`;
         this.parameters = {
             type: "object",
@@ -30907,7 +30909,7 @@ async function compressAgentMessages(agentContext, rlm, messages, tools) {
         return;
     }
     try {
-        doCompressAgentMessages(agentContext, rlm, messages, tools);
+        await doCompressAgentMessages(agentContext, rlm, messages, tools);
     }
     catch (e) {
         Log.error("Error compressing agent messages:", e);
@@ -30915,9 +30917,9 @@ async function compressAgentMessages(agentContext, rlm, messages, tools) {
 }
 async function doCompressAgentMessages(agentContext, rlm, messages, tools) {
     // extract used tool
-    let usedTools = extractUsedTool(messages, tools);
-    let snapshotTool = new TaskSnapshotTool();
-    let newTools = mergeTools(usedTools, [
+    const usedTools = extractUsedTool(messages, tools);
+    const snapshotTool = new TaskSnapshotTool();
+    const newTools = mergeTools(usedTools, [
         {
             type: "function",
             name: snapshotTool.name,
@@ -30945,16 +30947,16 @@ async function doCompressAgentMessages(agentContext, rlm, messages, tools) {
         ],
     });
     // compress snapshot
-    let result = await callAgentLLM(agentContext, rlm, newMessages, newTools, true, {
+    const result = await callAgentLLM(agentContext, rlm, newMessages, newTools, true, {
         type: "tool",
         toolName: snapshotTool.name,
     });
-    let toolCall = result.filter((s) => s.type == "tool-call")[0];
-    let args = typeof toolCall.input == "string"
+    const toolCall = result.filter((s) => s.type == "tool-call")[0];
+    const args = typeof toolCall.input == "string"
         ? JSON.parse(toolCall.input || "{}")
         : toolCall.input || {};
-    let toolResult = await snapshotTool.execute(args, agentContext);
-    let callback = agentContext.context.config.callback;
+    const toolResult = await snapshotTool.execute(args, agentContext);
+    const callback = agentContext.context.config.callback;
     if (callback) {
         await callback.onMessage({
             taskId: agentContext.context.taskId,
@@ -33187,10 +33189,10 @@ function convertUserContent(content) {
     });
 }
 
-const TOOL_NAME$7 = "taskPlanner";
+const TOOL_NAME$9 = "taskPlanner";
 class TaskPlannerTool {
     constructor(ekoDialogue, params) {
-        this.name = TOOL_NAME$7;
+        this.name = TOOL_NAME$9;
         const agents = ekoDialogue.getConfig().agents || [];
         const agentNames = agents.map((agent) => agent.Name).join(", ");
         this.description = `Used for task planning, this tool is only responsible for generating task plans, not executing them, the following agents are available: ${agentNames}...`;
@@ -33256,17 +33258,17 @@ class TaskPlannerTool {
     }
 }
 
-const TOOL_NAME$6 = "executeTask";
+const TOOL_NAME$8 = "executeTask";
 class ExecuteTaskTool {
     constructor(ekoDialogue) {
-        this.name = TOOL_NAME$6;
-        this.description = `Responsible for executing the task plan generated by the ${TOOL_NAME$7}. Use this tool if you need to execute planned tasks.`;
+        this.name = TOOL_NAME$8;
+        this.description = `Responsible for executing the task plan generated by the ${TOOL_NAME$9}. Use this tool if you need to execute planned tasks.`;
         this.parameters = {
             type: "object",
             properties: {
                 taskId: {
                     type: "string",
-                    description: `Task ID, generated by the \`${TOOL_NAME$7}\` tool.`,
+                    description: `Task ID, generated by the \`${TOOL_NAME$9}\` tool.`,
                 },
             },
             required: ["taskId"],
@@ -33331,10 +33333,10 @@ class ExecuteTaskTool {
     }
 }
 
-const TOOL_NAME$5 = "taskVariableStorage";
+const TOOL_NAME$7 = "taskVariableStorage";
 class TaskVariableStorageTool {
     constructor(ekoDialogue) {
-        this.name = TOOL_NAME$5;
+        this.name = TOOL_NAME$7;
         this.description = `Used for storing, reading, and retrieving variable data, and maintaining input/output variables in task nodes.`;
         this.parameters = {
             type: "object",
@@ -33413,9 +33415,9 @@ You are {name}, a helpful AI assistant.
 
 # Tool Usage Instructions
 For non-chat related tasks issued by users, the following tools need to be called to complete them:
-- ${TOOL_NAME$7}: This tool is used to plan tasks and generate task execution plans. For action tasks, this tool needs to be called for planning, then handed over to the \`${TOOL_NAME$6}\` tool for execution.
-- ${TOOL_NAME$6}: This tool is used to execute tasks planned by the \`${TOOL_NAME$7}\` tool.
-- ${TOOL_NAME$5}: This tool is used to read output variables from task nodes and write input variables to task nodes, mainly used to retrieve variable results after task execution is completed.
+- ${TOOL_NAME$9}: This tool is used to plan tasks and generate task execution plans. For action tasks, this tool needs to be called for planning, then handed over to the \`${TOOL_NAME$8}\` tool for execution.
+- ${TOOL_NAME$8}: This tool is used to execute tasks planned by the \`${TOOL_NAME$9}\` tool.
+- ${TOOL_NAME$7}: This tool is used to read output variables from task nodes and write input variables to task nodes, mainly used to retrieve variable results after task execution is completed.
 {prompt}
 
 The output language should match the user's conversation language.
@@ -33444,7 +33446,7 @@ class EkoDialogue {
         const messages = this.memory.getMessages();
         const lastMessage = messages[messages.length - 1];
         if (lastMessage.role !== "tool" ||
-            !lastMessage.content.some((part) => part.toolName === TOOL_NAME$7)) {
+            !lastMessage.content.some((part) => part.toolName === TOOL_NAME$9)) {
             throw new Error("No task planner tool call found");
         }
         const userMessages = messages.filter((message) => message.role === "user");
@@ -33475,7 +33477,7 @@ class EkoDialogue {
                 return finalResult;
             }
             if (this.config.segmentedExecution &&
-                results.some((r) => r.type == "tool-call" && r.toolName == TOOL_NAME$7)) {
+                results.some((r) => r.type == "tool-call" && r.toolName == TOOL_NAME$9)) {
                 return "segmentedExecution";
             }
         }
@@ -33673,11 +33675,23 @@ class SimpleSseMcpClient {
                 version: "1.0.0",
             },
         });
-        this.request("notifications/initialized", {});
+        // this.request("notifications/initialized", {});
     }
     ping() {
         this.request("ping", {});
     }
+    async listTools(param, signal) {
+        const message = await this.request("tools/list", {
+            ...param,
+        }, signal);
+        return message.result.tools || [];
+    }
+    async callTool(param, signal) {
+        const message = await this.request("tools/call", {
+            ...param,
+        }, signal);
+        return message.result;
+    }
     async request(method, params, signal) {
         const id = uuidv4();
         try {
@@ -33710,36 +33724,35 @@ class SimpleSseMcpClient {
             });
             const body = await response.text();
             if (body == "Accepted") {
-                return await callback;
+                const message = await callback;
+                if (message.error) {
+                    Log.error(`MCP ${method} error: ` + message.error);
+                    throw new Error(`MCP ${method} error: ` +
+                        (typeof message.error === "string"
+                            ? message.error
+                            : message.error.message));
+                }
+                if (message.result?.isError == true) {
+                    if (message.result.content) {
+                        throw new Error(`MCP ${method} error: ` +
+                            (typeof message.result.content === "string"
+                                ? message.result.content
+                                : message.result.content[0].text));
+                    }
+                    else {
+                        throw new Error(`MCP ${method} error: ` + JSON.stringify(message.result));
+                    }
+                }
+                return message;
             }
             else {
-                throw new Error("SseClient Response Exception: " + body);
+                throw new Error(`MCP ${method} error:` + body);
             }
         }
         finally {
             this.requestMap.delete(id);
         }
     }
-    async listTools(param, signal) {
-        const message = await this.request("tools/list", {
-            ...param,
-        }, signal);
-        if (message.error) {
-            Log.error("McpClient listTools error: ", param, message);
-            throw new Error("listTools Exception");
-        }
-        return message.result.tools || [];
-    }
-    async callTool(param, signal) {
-        const message = await this.request("tools/call", {
-            ...param,
-        }, signal);
-        if (message.error) {
-            Log.error("McpClient callTool error: ", param, message);
-            throw new Error("callTool Exception");
-        }
-        return message.result;
-    }
     isConnected() {
         if (this.sseHandler && this.sseHandler.readyState == 1) {
             return true;
@@ -33865,20 +33878,12 @@ class SimpleHttpMcpClient {
         const message = await this.request("tools/list", {
             ...param,
         }, signal);
-        if (message.error) {
-            Log.error("McpClient listTools error: ", param, message);
-            throw new Error("listTools Exception");
-        }
         return message.result.tools || [];
     }
     async callTool(param, signal) {
         const message = await this.request("tools/call", {
             ...param,
         }, signal);
-        if (message.error) {
-            Log.error("McpClient callTool error: ", param, message);
-            throw new Error("callTool Exception");
-        }
         return message.result;
     }
     isConnected() {
@@ -33906,7 +33911,7 @@ class SimpleHttpMcpClient {
                 headers: {
                     "Cache-Control": "no-cache",
                     "Content-Type": "application/json",
-                    "Accept": "application/json, text/event-stream",
+                    Accept: "application/json, text/event-stream",
                     "MCP-Protocol-Version": this.protocolVersion,
                     ...extHeaders,
                     ...this.headers,
@@ -33958,11 +33963,13 @@ class SimpleHttpMcpClient {
                         str = chunks[chunks.length - 1];
                     }
                 }
+                this.handleError(method, message);
                 return message;
             }
             else {
                 // JSON
                 const message = await response.json();
+                this.handleError(method, message);
                 return message;
             }
         }
@@ -33973,6 +33980,29 @@ class SimpleHttpMcpClient {
             throw e;
         }
     }
+    handleError(method, message) {
+        if (!message) {
+            throw new Error(`MCP ${method} error: no response`);
+        }
+        if (message?.error) {
+            Log.error(`MCP ${method} error: ` + message.error);
+            throw new Error(`MCP ${method} error: ` +
+                (typeof message.error === "string"
+                    ? message.error
+                    : message.error.message));
+        }
+        if (message.result?.isError == true) {
+            if (message.result.content) {
+                throw new Error(`MCP ${method} error: ` +
+                    (typeof message.result.content === "string"
+                        ? message.result.content
+                        : message.result.content[0].text));
+            }
+            else {
+                throw new Error(`MCP ${method} error: ` + JSON.stringify(message.result));
+            }
+        }
+    }
     parseChunk(chunk) {
         const lines = chunk.split("\n");
         const chunk_obj = {};
@@ -34014,10 +34044,10 @@ class ToolWrapper {
     }
 }
 
-const TOOL_NAME$4 = "foreach_task";
+const TOOL_NAME$6 = "foreach_task";
 class ForeachTaskTool {
     constructor() {
-        this.name = TOOL_NAME$4;
+        this.name = TOOL_NAME$6;
         this.description = `When executing the \`forEach\` node, please use the current tool for counting to ensure tasks are executed sequentially, the tool needs to be called with each loop iteration.`;
         this.parameters = {
             type: "object",
@@ -34073,10 +34103,10 @@ class ForeachTaskTool {
     }
 }
 
-const TOOL_NAME$3 = "human_interact";
+const TOOL_NAME$5 = "human_interact";
 class HumanInteractTool {
     constructor() {
-        this.name = TOOL_NAME$3;
+        this.name = TOOL_NAME$5;
         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, users will choose Yes or No.
@@ -34212,10 +34242,10 @@ request_help: Request assistance from the user; for instance, when an operation
     }
 }
 
-const TOOL_NAME$2 = "task_node_status";
+const TOOL_NAME$4 = "task_node_status";
 class TaskNodeStatusTool {
     constructor() {
-        this.name = TOOL_NAME$2;
+        this.name = TOOL_NAME$4;
         this.description = `After completing each step of the task, you need to call this tool to update the status of the task node, and think about the tasks to be processed and the next action plan.`;
         this.parameters = {
             type: "object",
@@ -34267,11 +34297,11 @@ class TaskNodeStatusTool {
     }
 }
 
-const TOOL_NAME$1 = "variable_storage";
+const TOOL_NAME$3 = "variable_storage";
 class VariableStorageTool {
     constructor() {
-        this.name = TOOL_NAME$1;
-        this.description = `Used for storing, reading, and retrieving variable data, and maintaining input/output variables in task nodes.`;
+        this.name = TOOL_NAME$3;
+        this.description = `Used for storing, reading, and retrieving variable data, and maintaining input/output variables in task nodes. When the same variable is stored repeatedly, it will overwrite the previous value.`;
         this.parameters = {
             type: "object",
             properties: {
@@ -34343,7 +34373,7 @@ class VariableStorageTool {
     }
 }
 
-const TOOL_NAME = "watch_trigger";
+const TOOL_NAME$2 = "watch_trigger";
 const watch_system_prompt = `You are a tool for detecting element changes. Given a task description, compare two images to determine whether the changes described in the task have occurred.
 If the changes have occurred, return an json with \`changed\` set to true and \`changeInfo\` containing a description of the changes. If no changes have occurred, return an object with \`changed\` set to false.
 
@@ -34362,7 +34392,7 @@ Output:
 }`;
 class WatchTriggerTool {
     constructor() {
-        this.name = TOOL_NAME;
+        this.name = TOOL_NAME$2;
         this.description = `When executing the \`watch\` node, please use it to monitor DOM element changes, it will block the listener until the element changes or times out.`;
         this.parameters = {
             type: "object",
@@ -34563,6 +34593,111 @@ class McpTool {
     }
 }
 
+const TOOL_NAME$1 = "task_result_check";
+class TaskResultCheckTool {
+    constructor() {
+        this.name = TOOL_NAME$1;
+        this.description = `Check the current task execution process and results, evaluate the overall completion status of the current task, and whether the output variables in the nodes are stored.`;
+        this.parameters = {
+            type: "object",
+            properties: {
+                thought: {
+                    type: "string",
+                    description: "Please conduct thoughtful analysis of the overall execution process and results of the current task, analyzing whether the task has been completed.",
+                },
+                completionStatus: {
+                    type: "string",
+                    description: "The completion status of the current task is only considered complete when the entire current task is finished; partial completion or task failure is considered incomplete",
+                    enum: ["completed", "incomplete"],
+                },
+                todoList: {
+                    type: "string",
+                    description: "Pending task list for incomplete tasks, when tasks are not fully completed, please describe which tasks remain to be completed",
+                },
+            },
+            required: ["thought", "completionStatus"],
+        };
+    }
+    async execute(args, agentContext) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: "success",
+                },
+            ],
+        };
+    }
+}
+async function doTaskResultCheck(agentContext, rlm, messages, tools) {
+    try {
+        // extract used tool
+        const usedTools = extractUsedTool(messages, tools);
+        const taskResultCheck = new TaskResultCheckTool();
+        const newTools = mergeTools(usedTools, [
+            {
+                type: "function",
+                name: taskResultCheck.name,
+                description: taskResultCheck.description,
+                inputSchema: taskResultCheck.parameters,
+            },
+        ]);
+        // handle messages
+        const newMessages = [...messages];
+        newMessages.push({
+            role: "user",
+            content: [
+                {
+                    type: "text",
+                    text: `Task:\n${agentContext.agentChain.agent.xml}\n\nPlease check the completion status of the current task.`,
+                },
+            ],
+        });
+        const result = await callAgentLLM(agentContext, rlm, newMessages, newTools, true, {
+            type: "tool",
+            toolName: taskResultCheck.name,
+        });
+        const toolCall = result.filter((s) => s.type == "tool-call")[0];
+        const args = typeof toolCall.input == "string"
+            ? JSON.parse(toolCall.input || "{}")
+            : toolCall.input || {};
+        const toolResult = await taskResultCheck.execute(args, agentContext);
+        const callback = agentContext.context.config.callback;
+        if (callback) {
+            await callback.onMessage({
+                taskId: agentContext.context.taskId,
+                agentName: agentContext.agent.Name,
+                nodeId: agentContext.agentChain.agent.id,
+                type: "tool_result",
+                toolId: toolCall.toolCallId,
+                toolName: toolCall.toolName,
+                params: args,
+                toolResult: toolResult,
+            }, agentContext);
+        }
+        if (args.completionStatus == "incomplete") {
+            messages.push({
+                role: "user",
+                content: [
+                    {
+                        type: "text",
+                        text: `It seems that your task has not been fully completed. Please continue with the remaining steps:\n${args.todoList || ""}`,
+                    },
+                ],
+            });
+        }
+        return {
+            completionStatus: args.completionStatus,
+        };
+    }
+    catch (e) {
+        Log.error("TaskResultCheckTool error", e);
+        return {
+            completionStatus: "completed",
+        };
+    }
+}
+
 const AGENT_SYSTEM_TEMPLATE = `
 You are {name}, an autonomous AI agent for {agent} agent.
 
@@ -34587,14 +34722,14 @@ The output language should follow the language corresponding to the user's task.
 `;
 const HUMAN_PROMPT = `
 * 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:
+During the task execution process, you can use the \`${TOOL_NAME$5}\` 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, captcha verification, QR code scanning, or human verification, you need to request manual assistance.
-- Please do not use the \`${TOOL_NAME$3}\` tool frequently.
+- Please do not use the \`${TOOL_NAME$5}\` tool frequently.
 `;
 const VARIABLE_PROMPT = `
 * VARIABLE STORAGE
-When a step node has input/output variable attributes, use the \`${TOOL_NAME$1}\` tool to read from and write to these variables, these variables enable context sharing and coordination between multiple agents.
+When a step node has input/output variable attributes, use the \`${TOOL_NAME$3}\` tool to read from and write to these variables, these variables enable context sharing and coordination between multiple agents.
 `;
 const FOR_EACH_NODE = `
     <!-- duplicate task node, items support list and variable -->
@@ -34603,7 +34738,7 @@ const FOR_EACH_NODE = `
     </forEach>`;
 const FOR_EACH_PROMPT = `
 * forEach node
-repetitive tasks, when executing to the forEach node, require the use of the \`${TOOL_NAME$4}\` tool.
+repetitive tasks, when executing to the forEach node, require the use of the \`${TOOL_NAME$6}\` tool.
 `;
 const WATCH_NODE = `
     <!-- monitor task node, the loop attribute specifies whether to listen in a loop or listen once -->
@@ -34616,7 +34751,7 @@ const WATCH_NODE = `
     </watch>`;
 const WATCH_PROMPT = `
 * watch node
-monitor changes in webpage DOM elements, when executing to the watch node, require the use of the \`${TOOL_NAME}\` tool.
+monitor changes in webpage DOM elements, when executing to the watch node, require the use of the \`${TOOL_NAME$2}\` tool.
 `;
 function getAgentSystemPrompt(agent, agentNode, context, tools, extSysPrompt) {
     let prompt = "";
@@ -34625,10 +34760,10 @@ function getAgentSystemPrompt(agent, agentNode, context, tools, extSysPrompt) {
     let agentNodeXml = agentNode.xml;
     let hasWatchNode = agentNodeXml.indexOf("</watch>") > -1;
     let hasForEachNode = agentNodeXml.indexOf("</forEach>") > -1;
-    let hasHumanTool = tools.filter((tool) => tool.name == TOOL_NAME$3).length > 0;
+    let hasHumanTool = tools.filter((tool) => tool.name == TOOL_NAME$5).length > 0;
     let hasVariable = agentNodeXml.indexOf("input=") > -1 ||
         agentNodeXml.indexOf("output=") > -1 ||
-        tools.filter((tool) => tool.name == TOOL_NAME$1).length > 0;
+        tools.filter((tool) => tool.name == TOOL_NAME$3).length > 0;
     if (hasHumanTool) {
         prompt += HUMAN_PROMPT;
     }
@@ -34636,13 +34771,13 @@ function getAgentSystemPrompt(agent, agentNode, context, tools, extSysPrompt) {
         prompt += VARIABLE_PROMPT;
     }
     if (hasForEachNode) {
-        if (tools.filter((tool) => tool.name == TOOL_NAME$4).length > 0) {
+        if (tools.filter((tool) => tool.name == TOOL_NAME$6).length > 0) {
             prompt += FOR_EACH_PROMPT;
         }
         nodePrompt += FOR_EACH_NODE;
     }
     if (hasWatchNode) {
-        if (tools.filter((tool) => tool.name == TOOL_NAME).length > 0) {
+        if (tools.filter((tool) => tool.name == TOOL_NAME$2).length > 0) {
             prompt += WATCH_PROMPT;
         }
         nodePrompt += WATCH_NODE;
@@ -34670,7 +34805,7 @@ function getAgentSystemPrompt(agent, agentNode, context, tools, extSysPrompt) {
         .trim();
 }
 function getAgentUserPrompt(agent, agentNode, context, tools) {
-    let hasTaskNodeStatusTool = (tools || agent.Tools).filter((tool) => tool.name == TOOL_NAME$2)
+    const hasTaskNodeStatusTool = (tools || agent.Tools).filter((tool) => tool.name == TOOL_NAME$4)
         .length > 0;
     return buildAgentRootXml(agentNode.xml, context.chain.taskPrompt, (nodeId, node) => {
         if (hasTaskNodeStatusTool) {
@@ -34679,6 +34814,129 @@ function getAgentUserPrompt(agent, agentNode, context, tools) {
     });
 }
 
+const TOOL_NAME = "todo_list_manager";
+class TodoListManagerTool {
+    constructor() {
+        this.name = TOOL_NAME;
+        this.description =
+            "Current task to-do list management, used for managing the to-do list of current tasks. During task execution, the to-do list needs to be updated according to the task execution status: completed, pending. It also detects whether tasks are being executed in repetitive loops during the execution process.";
+        this.parameters = {
+            type: "object",
+            properties: {
+                completedList: {
+                    type: "array",
+                    description: "Current completed task list items. Please update the completed list items based on the current task completion status.",
+                    items: {
+                        type: "string",
+                    },
+                },
+                todoList: {
+                    type: "array",
+                    description: "Current pending task list items. Please update the pending list items based on the current task pending status.",
+                    items: {
+                        type: "string",
+                    },
+                },
+                loopDetection: {
+                    type: "string",
+                    description: "Check if the current step is being repeatedly executed by comparing with previous steps.",
+                    enum: ["loop", "no_loop"],
+                },
+            },
+            required: ["completedList", "todoList", "loopDetection"],
+        };
+    }
+    async execute(args, agentContext) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: "success",
+                },
+            ],
+        };
+    }
+}
+async function doTodoListManager(agentContext, rlm, messages, tools) {
+    try {
+        // extract used tool
+        const usedTools = extractUsedTool(messages, tools);
+        const todoListManager = new TodoListManagerTool();
+        const newTools = mergeTools(usedTools, [
+            {
+                type: "function",
+                name: todoListManager.name,
+                description: todoListManager.description,
+                inputSchema: todoListManager.parameters,
+            },
+        ]);
+        // handle messages
+        const newMessages = [...messages];
+        newMessages.push({
+            role: "user",
+            content: [
+                {
+                    type: "text",
+                    text: `Task:\n${agentContext.agentChain.agent.xml}\n\nPlease check the completion status of the current task.`,
+                },
+            ],
+        });
+        const result = await callAgentLLM(agentContext, rlm, newMessages, newTools, true, {
+            type: "tool",
+            toolName: todoListManager.name,
+        });
+        const toolCall = result.filter((s) => s.type == "tool-call")[0];
+        const args = typeof toolCall.input == "string"
+            ? JSON.parse(toolCall.input || "{}")
+            : toolCall.input || {};
+        const toolResult = await todoListManager.execute(args, agentContext);
+        const callback = agentContext.context.config.callback;
+        if (callback) {
+            await callback.onMessage({
+                taskId: agentContext.context.taskId,
+                agentName: agentContext.agent.Name,
+                nodeId: agentContext.agentChain.agent.id,
+                type: "tool_result",
+                toolId: toolCall.toolCallId,
+                toolName: toolCall.toolName,
+                params: args,
+                toolResult: toolResult,
+            }, agentContext);
+        }
+        let userPrompt = "# Task Execution Status\n";
+        if (args.completedList && args.completedList.length > 0) {
+            userPrompt += "## Completed task list\n";
+            for (let i = 0; i < args.completedList.length; i++) {
+                userPrompt += `- ${args.completedList[i]}\n`;
+            }
+            userPrompt += "\n";
+        }
+        if (args.todoList && args.todoList.length > 0) {
+            userPrompt += "## Pending task list\n";
+            for (let i = 0; i < args.todoList.length; i++) {
+                userPrompt += `- ${args.todoList[i]}\n`;
+            }
+            userPrompt += "\n";
+        }
+        if (args.loopDetection == "loop") {
+            userPrompt += `## Loop detection\nIt seems that your task is being executed in a loop, Please change the execution strategy and try other methods to complete the current task.\n\n`;
+        }
+        userPrompt += "Please continue executing the remaining tasks.";
+        messages.push({
+            role: "user",
+            content: [
+                {
+                    type: "text",
+                    text: userPrompt.trim(),
+                },
+            ],
+        });
+    }
+    catch (e) {
+        Log.error("TodoListManagerTool error", e);
+    }
+}
+
 class Agent {
     constructor(params) {
         this.tools = [];
@@ -34706,21 +34964,24 @@ class Agent {
     }
     async runWithContext(agentContext, mcpClient, maxReactNum = 100, historyMessages = []) {
         let loopNum = 0;
+        let checkNum = 0;
         this.agentContext = agentContext;
         const context = agentContext.context;
         const agentNode = agentContext.agentChain.agent;
         const tools = [...this.tools, ...this.system_auto_tools(agentNode)];
+        const systemPrompt = await this.buildSystemPrompt(agentContext, tools);
+        const userPrompt = await this.buildUserPrompt(agentContext, tools);
         const messages = [
             {
                 role: "system",
-                content: await this.buildSystemPrompt(agentContext, tools),
-                providerOptions: defaultMessageProviderOptions()
+                content: systemPrompt,
+                providerOptions: defaultMessageProviderOptions(),
             },
             ...historyMessages,
             {
                 role: "user",
-                content: await this.buildUserPrompt(agentContext, tools),
-                providerOptions: defaultMessageProviderOptions()
+                content: userPrompt,
+                providerOptions: defaultMessageProviderOptions(),
             },
         ];
         agentContext.messages = messages;
@@ -34738,20 +34999,32 @@ class Agent {
                 }
             }
             await this.handleMessages(agentContext, messages, tools);
-            const results = await callAgentLLM(agentContext, rlm, messages, convertTools(agentTools), false, undefined, 0, this.callback, this.requestHandler);
-            const finalResult = await this.handleCallResult(agentContext, messages, agentTools, results);
-            if (finalResult) {
-                return finalResult;
+            const llm_tools = convertTools(agentTools);
+            const results = await callAgentLLM(agentContext, rlm, messages, llm_tools, false, undefined, 0, this.callback, this.requestHandler);
+            const forceStop = agentContext.variables.get("forceStop");
+            if (forceStop) {
+                return forceStop;
             }
+            const finalResult = await this.handleCallResult(agentContext, messages, agentTools, results);
             loopNum++;
+            if (!finalResult) {
+                if (config$1.expertMode && loopNum % config$1.expertModeTodoLoopNum == 0) {
+                    await doTodoListManager(agentContext, rlm, messages, llm_tools);
+                }
+                continue;
+            }
+            if (config$1.expertMode && checkNum == 0) {
+                checkNum++;
+                const { completionStatus } = await doTaskResultCheck(agentContext, rlm, messages, llm_tools);
+                if (completionStatus == "incomplete") {
+                    continue;
+                }
+            }
+            return finalResult;
         }
         return "Unfinished";
     }
     async handleCallResult(agentContext, messages, agentTools, results) {
-        const forceStop = agentContext.variables.get("forceStop");
-        if (forceStop) {
-            return forceStop;
-        }
         let text = null;
         let context = agentContext.context;
         let user_messages = [];