@eko-ai/eko 2.1.7 → 2.1.8-alpha.2

package/dist/index.cjs.js

@@ -363,8 +363,10 @@ function fixXmlTag(code) {
         const top = stack.pop();
         if (top.startsWith("<")) {
             let arr = top.match(/<(\w+)/);
-            const tagName = arr[1];
-            missingParts.push(`</${tagName}>`);
+            if (arr) {
+                const tagName = arr[1];
+                missingParts.push(`</${tagName}>`);
+            }
         }
         else {
             missingParts.push(top);
@@ -376,8 +378,9 @@ function fixXmlTag(code) {
 
 class Context {
     constructor(taskId, config, agents, chain) {
-        this.paused = false;
         this.conversation = [];
+        this.pauseStatus = 0;
+        this.currentStepControllers = new Set();
         this.taskId = taskId;
         this.config = config;
         this.agents = agents;
@@ -385,15 +388,20 @@ class Context {
         this.variables = new Map();
         this.controller = new AbortController();
     }
-    async checkAborted() {
-        // this.controller.signal.throwIfAborted();
+    async checkAborted(noCheckPause) {
         if (this.controller.signal.aborted) {
             const error = new Error("Operation was interrupted");
             error.name = "AbortError";
             throw error;
         }
-        while (this.paused) {
+        while (this.pauseStatus > 0 && !noCheckPause) {
             await sleep(500);
+            if (this.pauseStatus == 2) {
+                this.currentStepControllers.forEach((c) => {
+                    c.abort("Pause");
+                });
+                this.currentStepControllers.clear();
+            }
             if (this.controller.signal.aborted) {
                 const error = new Error("Operation was interrupted");
                 error.name = "AbortError";
@@ -410,9 +418,21 @@ class Context {
         if (!agent) {
             return null;
         }
-        const agentContext = agent["agentContext"];
+        const agentContext = agent.AgentContext;
         return [agent, agentNode.agent, agentContext];
     }
+    get pause() {
+        return this.pauseStatus > 0;
+    }
+    setPause(pause, abortCurrentStep) {
+        this.pauseStatus = pause ? (abortCurrentStep ? 2 : 1) : 0;
+        if (this.pauseStatus == 2) {
+            this.currentStepControllers.forEach((c) => {
+                c.abort("Pause");
+            });
+            this.currentStepControllers.clear();
+        }
+    }
 }
 class AgentContext {
     constructor(context, agent, agentChain) {
@@ -14137,10 +14157,11 @@ createOpenRouter({
 });
 
 class RetryLanguageModel {
-    constructor(llms, names, stream_first_timeout) {
+    constructor(llms, names, stream_first_timeout, stream_token_timeout) {
         this.llms = llms;
         this.names = names || [];
         this.stream_first_timeout = stream_first_timeout || 30000;
+        this.stream_token_timeout = stream_token_timeout || 180000;
         if (this.names.indexOf("default") == -1) {
             this.names.push("default");
         }
@@ -14165,41 +14186,49 @@ class RetryLanguageModel {
         const maxTokens = options.maxTokens;
         const providerMetadata = options.providerMetadata;
         const names = [...this.names, ...this.names];
+        let lastError;
         for (let i = 0; i < names.length; i++) {
             const name = names[i];
+            const llmConfig = this.llms[name];
             const llm = await this.getLLM(name);
             if (!llm) {
                 continue;
             }
             if (!maxTokens) {
-                options.maxTokens =
-                    this.llms[name].config?.maxTokens || config.maxTokens;
+                options.maxTokens = llmConfig.config?.maxTokens || config.maxTokens;
             }
             if (!providerMetadata) {
                 options.providerMetadata = {};
-                options.providerMetadata[llm.provider] = this.llms[name].options || {};
+                options.providerMetadata[llm.provider] = llmConfig.options || {};
+            }
+            let _options = options;
+            if (llmConfig.handler) {
+                _options = await llmConfig.handler(_options);
             }
             try {
-                let result = await llm.doGenerate(options);
+                let result = (await llm.doGenerate(_options));
                 if (Log.isEnableDebug()) {
                     Log.debug(`LLM nonstream body, name: ${name} => `, result.request?.body);
                 }
+                result.llm = name;
+                result.llmConfig = llmConfig;
                 return result;
             }
             catch (e) {
                 if (e?.name === "AbortError") {
                     throw e;
                 }
+                lastError = e;
                 if (Log.isEnableInfo()) {
                     Log.info(`LLM nonstream request, name: ${name} => `, {
-                        tools: options.mode?.tools,
-                        messages: options.prompt,
+                        tools: _options.mode?.tools,
+                        messages: _options.prompt,
                     });
                 }
                 Log.error(`LLM error, name: ${name} => `, e);
             }
         }
-        return Promise.reject(new Error("No LLM available"));
+        return Promise.reject(lastError ? lastError : new Error("No LLM available"));
     }
     async callStream(request) {
         return await this.doStream({
@@ -14221,28 +14250,33 @@ class RetryLanguageModel {
         const maxTokens = options.maxTokens;
         const providerMetadata = options.providerMetadata;
         const names = [...this.names, ...this.names];
+        let lastError;
         for (let i = 0; i < names.length; i++) {
             const name = names[i];
+            const llmConfig = this.llms[name];
             const llm = await this.getLLM(name);
             if (!llm) {
                 continue;
             }
             if (!maxTokens) {
-                options.maxTokens =
-                    this.llms[name].config?.maxTokens || config.maxTokens;
+                options.maxTokens = llmConfig.config?.maxTokens || config.maxTokens;
             }
             if (!providerMetadata) {
                 options.providerMetadata = {};
-                options.providerMetadata[llm.provider] = this.llms[name].options || {};
+                options.providerMetadata[llm.provider] = llmConfig.options || {};
+            }
+            let _options = options;
+            if (llmConfig.handler) {
+                _options = await llmConfig.handler(_options);
             }
             try {
                 const controller = new AbortController();
-                const signal = options.abortSignal
-                    ? AbortSignal.any([options.abortSignal, controller.signal])
+                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) => {
+                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) => {
@@ -14264,23 +14298,26 @@ class RetryLanguageModel {
                     reader.releaseLock();
                     continue;
                 }
-                result.stream = this.streamWrapper([chunk], reader);
+                result.llm = name;
+                result.llmConfig = llmConfig;
+                result.stream = this.streamWrapper([chunk], reader, controller);
                 return result;
             }
             catch (e) {
                 if (e?.name === "AbortError") {
                     throw e;
                 }
+                lastError = e;
                 if (Log.isEnableInfo()) {
                     Log.info(`LLM stream request, name: ${name} => `, {
-                        tools: options.mode?.tools,
-                        messages: options.prompt,
+                        tools: _options.mode?.tools,
+                        messages: _options.prompt,
                     });
                 }
                 Log.error(`LLM error, name: ${name} => `, e);
             }
         }
-        return Promise.reject(new Error("No LLM available"));
+        return Promise.reject(lastError ? lastError : new Error("No LLM available"));
     }
     async getLLM(name) {
         const llm = this.llms[name];
@@ -14355,7 +14392,8 @@ class RetryLanguageModel {
             return llm.provider.languageModel(llm.model);
         }
     }
-    streamWrapper(parts, reader) {
+    streamWrapper(parts, reader, abortController) {
+        let timer = null;
         return new ReadableStream({
             start: (controller) => {
                 if (parts != null && parts.length > 0) {
@@ -14365,7 +14403,11 @@ class RetryLanguageModel {
                 }
             },
             pull: async (controller) => {
+                timer = setTimeout(() => {
+                    abortController.abort("Streaming request timeout");
+                }, this.stream_token_timeout);
                 const { done, value } = await reader.read();
+                clearTimeout(timer);
                 if (done) {
                     controller.close();
                     reader.releaseLock();
@@ -14374,10 +14416,17 @@ class RetryLanguageModel {
                 controller.enqueue(value);
             },
             cancel: (reason) => {
+                timer && clearTimeout(timer);
                 reader.cancel(reason);
             },
         });
     }
+    get Llms() {
+        return this.llms;
+    }
+    get Names() {
+        return this.names;
+    }
 }
 
 var domParser = {};
@@ -16825,11 +16874,21 @@ function requireDomParser () {
 
 var domParserExports = requireDomParser();
 
-function parseWorkflow(taskId, xml, done) {
+function parseWorkflow(taskId, xml, done, thinking) {
+    let _workflow = null;
     try {
+        if (thinking) {
+            _workflow = {
+                taskId: taskId,
+                name: "",
+                thought: thinking,
+                agents: [],
+                xml: xml,
+            };
+        }
         let sIdx = xml.indexOf("<root>");
         if (sIdx == -1) {
-            return null;
+            return _workflow;
         }
         xml = xml.substring(sIdx);
         let eIdx = xml.indexOf("</root>");
@@ -16843,13 +16902,14 @@ function parseWorkflow(taskId, xml, done) {
         const doc = parser.parseFromString(xml, "text/xml");
         let root = doc.documentElement;
         if (root.tagName !== "root") {
-            return null;
+            return _workflow;
         }
-        let agents = [];
+        const agents = [];
+        const thought = root.getElementsByTagName("thought")[0]?.textContent || "";
         const workflow = {
             taskId: taskId,
             name: root.getElementsByTagName("name")[0]?.textContent || "",
-            thought: root.getElementsByTagName("thought")[0]?.textContent || "",
+            thought: thinking ? thinking + "\n" + thought : thought,
             agents: agents,
             xml: xml,
         };
@@ -16882,7 +16942,7 @@ function parseWorkflow(taskId, xml, done) {
             throw e;
         }
         else {
-            return null;
+            return _workflow;
         }
     }
 }
@@ -16960,7 +17020,7 @@ function buildAgentRootXml(agentXml, mainTaskPrompt, nodeCallback) {
         .replace("<task>", "<currentTask>")
         .replace("</task>", "</currentTask>");
     const xmlPrompt = `<root>${prefix}<mainTask>${mainTaskPrompt}</mainTask>${agentInnerHTML}</root>`;
-    return xmlPrompt.replace(/      /g, "  ").replace('    </root>', '</root>');
+    return xmlPrompt.replace(/      /g, "  ").replace("    </root>", "</root>");
 }
 function extractAgentXmlNode(agentXml, nodeId) {
     const parser = new domParserExports.DOMParser();
@@ -16992,6 +17052,92 @@ function getInnerXML(node) {
     }
     return result;
 }
+function buildSimpleAgentWorkflow({ taskId, name, agentName, task, taskNodes, }) {
+    if (!taskNodes || taskNodes.length == 0) {
+        taskNodes = [task];
+    }
+    const workflow = {
+        taskId: taskId,
+        name: name,
+        thought: "",
+        agents: [
+            {
+                id: taskId + "-00",
+                name: agentName,
+                task: task,
+                nodes: taskNodes.map((node) => {
+                    return {
+                        type: "normal",
+                        text: node,
+                    };
+                }),
+                xml: "",
+            },
+        ],
+        xml: "",
+    };
+    workflow.taskPrompt = task;
+    resetWorkflowXml(workflow);
+    return workflow;
+}
+function resetWorkflowXml(workflow) {
+    const agents = [];
+    for (let i = 0; i < workflow.agents.length; i++) {
+        const agent = workflow.agents[i];
+        const nodes = agent.nodes
+            .map((node) => {
+            if (node.type == "forEach") {
+                const forEachNodes = [];
+                for (let j = 0; j < node.nodes.length; j++) {
+                    const _node = node.nodes[j];
+                    const input = _node.input ? ` input="${_node.input}"` : "";
+                    const output = _node.output ? ` output="${_node.output}"` : "";
+                    forEachNodes.push(`          <node${input}${output}>${_node.text}</node>`);
+                }
+                return `        <forEach items="${node.items || ""}">
+${forEachNodes.join("\n")}
+        </forEach>`;
+            }
+            else if (node.type == "watch") {
+                const watchNodes = [];
+                for (let j = 0; j < node.triggerNodes.length; j++) {
+                    const _node = node.triggerNodes[j];
+                    const input = _node.input ? ` input="${_node.input}"` : "";
+                    const output = _node.output ? ` output="${_node.output}"` : "";
+                    watchNodes.push(`            <node${input}${output}>${_node.text}</node>`);
+                }
+                return `        <watch event="${node.event || "dom"}" loop="${node.loop ? "true" : "false"}">
+          <description>${node.description}</description>
+          <trigger>
+${watchNodes.join("\n")}
+          </trigger>
+        </watch>`;
+            }
+            else {
+                const input = node.input ? ` input="${node.input}"` : "";
+                const output = node.output ? ` output="${node.output}"` : "";
+                return `        <node${input}${output}>${node.text}</node>`;
+            }
+        })
+            .join("\n");
+        const agentXml = `    <agent name="${agent.name}">
+      <task>${agent.task}</task>
+      <nodes>
+${nodes}
+      </nodes>
+    </agent>`;
+        agent.xml = agentXml;
+        agents.push(agentXml);
+    }
+    const xml = `<root>
+  <name>${workflow.name}</name>
+  <thought>${workflow.thought}</thought>
+  <agents>
+${agents.join("\n")}
+  </agents>
+</root>`;
+    workflow.xml = xml;
+}
 
 const TOOL_NAME$5 = "task_snapshot";
 class TaskSnapshotTool {
@@ -17041,158 +17187,424 @@ class TaskSnapshotTool {
     }
 }
 
-function extractUsedTool(messages, agentTools) {
-    let tools = [];
-    let toolNames = [];
-    for (let i = 0; i < messages.length; i++) {
-        let message = messages[i];
-        if (message.role == "tool") {
-            for (let j = 0; j < message.content.length; j++) {
-                let toolName = message.content[j].toolName;
-                if (toolNames.indexOf(toolName) > -1) {
-                    continue;
-                }
-                toolNames.push(toolName);
-                let tool = agentTools.filter((tool) => tool.name === toolName)[0];
-                if (tool) {
-                    tools.push(tool);
-                }
-            }
-        }
-    }
-    return tools;
-}
-function removeDuplicateToolUse(results) {
-    if (results.length <= 1 ||
-        results.filter((r) => r.type == "tool-call").length <= 1) {
-        return results;
-    }
-    let _results = [];
-    let tool_uniques = [];
-    for (let i = 0; i < results.length; i++) {
-        if (results[i].type === "tool-call") {
-            let tool = results[i];
-            let key = tool.toolName + tool.args;
-            if (tool_uniques.indexOf(key) == -1) {
-                _results.push(results[i]);
-                tool_uniques.push(key);
-            }
-        }
-        else {
-            _results.push(results[i]);
-        }
+async function callAgentLLM(agentContext, rlm, messages, tools, noCompress, toolChoice, retry, callback) {
+    await agentContext.context.checkAborted();
+    if (messages.length >= config.compressThreshold && !noCompress) {
+        await compressAgentMessages(agentContext, rlm, messages, tools);
     }
-    return _results;
-}
-async function compressAgentMessages(agentContext, rlm, messages, tools) {
-    if (messages.length < 10) {
-        return;
+    if (!toolChoice) {
+        // Append user dialogue
+        appendUserConversation(agentContext, messages);
     }
-    // extract used tool
-    let usedTools = extractUsedTool(messages, tools);
-    let snapshotTool = new TaskSnapshotTool();
-    let newTools = mergeTools(usedTools, [
-        {
-            type: "function",
-            name: snapshotTool.name,
-            description: snapshotTool.description,
-            parameters: snapshotTool.parameters,
-        },
+    let context = agentContext.context;
+    let agentChain = agentContext.agentChain;
+    let agentNode = agentChain.agent;
+    let streamCallback = callback ||
+        context.config.callback || {
+        onMessage: async () => { },
+    };
+    const stepController = new AbortController();
+    const signal = AbortSignal.any([
+        context.controller.signal,
+        stepController.signal,
     ]);
-    // handle messages
-    let lastToolIndex = messages.length - 1;
-    let newMessages = messages;
-    for (let r = newMessages.length - 1; r > 3; r--) {
-        if (newMessages[r].role == "tool") {
-            newMessages = newMessages.slice(0, r + 1);
-            lastToolIndex = r;
-            break;
-        }
-    }
-    newMessages.push({
-        role: "user",
-        content: [
-            {
-                type: "text",
-                text: "Please create a snapshot backup of the current task, keeping only key important information and node completion status.",
-            },
-        ],
-    });
-    // compress snapshot
-    let result = await callLLM(agentContext, rlm, newMessages, newTools, true, {
-        type: "tool",
-        toolName: snapshotTool.name,
-    });
-    let toolCall = result.filter((s) => s.type == "tool-call")[0];
-    let args = typeof toolCall.args == "string"
-        ? JSON.parse(toolCall.args || "{}")
-        : toolCall.args || {};
-    let toolResult = await snapshotTool.execute(args, agentContext);
-    let 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 request = {
+        tools: tools,
+        toolChoice,
+        messages: messages,
+        abortSignal: signal,
+    };
+    agentChain.agentRequest = request;
+    let result;
+    try {
+        context.currentStepControllers.add(stepController);
+        result = await rlm.callStream(request);
     }
-    // handle original messages
-    let firstToolIndex = 3;
-    for (let i = 0; i < messages.length; i++) {
-        if (messages[0].role == "tool") {
-            firstToolIndex = i;
-            break;
+    catch (e) {
+        context.currentStepControllers.delete(stepController);
+        await context.checkAborted();
+        if (!noCompress &&
+            messages.length > 10 &&
+            ((e + "").indexOf("tokens") > -1 || (e + "").indexOf("too long") > -1)) {
+            await compressAgentMessages(agentContext, rlm, messages, tools);
+        }
+        if (!retry) {
+            await sleep(200);
+            return callAgentLLM(agentContext, rlm, messages, tools, noCompress, toolChoice, true, streamCallback);
         }
+        throw e;
     }
-    // system, user, assistant, tool(first), [...], <user>, assistant, tool(last), ...
-    messages.splice(firstToolIndex + 1, lastToolIndex - firstToolIndex - 2, {
-        role: "user",
-        content: toolResult.content.filter((s) => s.type == "text"),
-    });
-}
-function handleLargeContextMessages(messages) {
-    let imageNum = 0;
-    let fileNum = 0;
-    let maxNum = config.maxDialogueImgFileNum;
-    let longTextTools = {};
-    for (let i = messages.length - 1; i >= 0; i--) {
-        let message = messages[i];
-        if (message.role == "user") {
-            for (let j = 0; j < message.content.length; j++) {
-                let content = message.content[j];
-                if (content.type == "image") {
-                    if (++imageNum <= maxNum) {
-                        break;
+    let streamText = "";
+    let thinkText = "";
+    let toolArgsText = "";
+    let streamId = uuidv4();
+    let textStreamDone = false;
+    let toolParts = [];
+    const reader = result.stream.getReader();
+    try {
+        let toolPart = null;
+        while (true) {
+            await context.checkAborted();
+            const { done, value } = await reader.read();
+            if (done) {
+                break;
+            }
+            let chunk = value;
+            switch (chunk.type) {
+                case "text-delta": {
+                    if (toolPart && !chunk.textDelta) {
+                        continue;
                     }
-                    content = {
+                    streamText += chunk.textDelta || "";
+                    await streamCallback.onMessage({
+                        taskId: context.taskId,
+                        agentName: agentNode.name,
+                        nodeId: agentNode.id,
                         type: "text",
-                        text: "[image]",
-                    };
-                    message.content[j] = content;
-                }
-                else if (content.type == "file") {
-                    if (++fileNum <= maxNum) {
-                        break;
+                        streamId,
+                        streamDone: false,
+                        text: streamText,
+                    }, agentContext);
+                    if (toolPart) {
+                        await streamCallback.onMessage({
+                            taskId: context.taskId,
+                            agentName: agentNode.name,
+                            nodeId: agentNode.id,
+                            type: "tool_use",
+                            toolId: toolPart.toolCallId,
+                            toolName: toolPart.toolName,
+                            params: toolPart.args || {},
+                        }, agentContext);
+                        toolPart = null;
                     }
-                    content = {
-                        type: "text",
-                        text: "[file]",
-                    };
-                    message.content[j] = content;
+                    break;
                 }
-            }
-        }
-        else if (message.role == "tool") {
-            for (let j = 0; j < message.content.length; j++) {
-                let toolResult = message.content[j];
-                let toolContent = toolResult.content;
-                if (!toolContent || toolContent.length == 0) {
-                    continue;
+                case "reasoning": {
+                    thinkText += chunk.textDelta || "";
+                    await streamCallback.onMessage({
+                        taskId: context.taskId,
+                        agentName: agentNode.name,
+                        nodeId: agentNode.id,
+                        type: "thinking",
+                        streamId,
+                        streamDone: false,
+                        text: thinkText,
+                    }, agentContext);
+                    break;
+                }
+                case "tool-call-delta": {
+                    if (!textStreamDone) {
+                        textStreamDone = true;
+                        await streamCallback.onMessage({
+                            taskId: context.taskId,
+                            agentName: agentNode.name,
+                            nodeId: agentNode.id,
+                            type: "text",
+                            streamId,
+                            streamDone: true,
+                            text: streamText,
+                        }, agentContext);
+                    }
+                    toolArgsText += chunk.argsTextDelta || "";
+                    await streamCallback.onMessage({
+                        taskId: context.taskId,
+                        agentName: agentNode.name,
+                        nodeId: agentNode.id,
+                        type: "tool_streaming",
+                        toolId: chunk.toolCallId,
+                        toolName: chunk.toolName,
+                        paramsText: toolArgsText,
+                    }, agentContext);
+                    if (toolPart == null) {
+                        toolPart = {
+                            type: "tool-call",
+                            toolCallId: chunk.toolCallId,
+                            toolName: chunk.toolName,
+                            args: {},
+                        };
+                        toolParts.push(toolPart);
+                    }
+                    break;
+                }
+                case "tool-call": {
+                    toolArgsText = "";
+                    let args = chunk.args ? JSON.parse(chunk.args) : {};
+                    let message = {
+                        taskId: context.taskId,
+                        agentName: agentNode.name,
+                        nodeId: agentNode.id,
+                        type: "tool_use",
+                        toolId: chunk.toolCallId,
+                        toolName: chunk.toolName,
+                        params: args,
+                    };
+                    await streamCallback.onMessage(message, agentContext);
+                    if (toolPart == null) {
+                        toolParts.push({
+                            type: "tool-call",
+                            toolCallId: chunk.toolCallId,
+                            toolName: chunk.toolName,
+                            args: message.params || args,
+                        });
+                    }
+                    else {
+                        toolPart.args = message.params || args;
+                        toolPart = null;
+                    }
+                    break;
+                }
+                case "file": {
+                    await streamCallback.onMessage({
+                        taskId: context.taskId,
+                        agentName: agentNode.name,
+                        nodeId: agentNode.id,
+                        type: "file",
+                        mimeType: chunk.mimeType,
+                        data: chunk.data,
+                    }, agentContext);
+                    break;
+                }
+                case "error": {
+                    Log.error(`${agentNode.name} agent error: `, chunk);
+                    await streamCallback.onMessage({
+                        taskId: context.taskId,
+                        agentName: agentNode.name,
+                        nodeId: agentNode.id,
+                        type: "error",
+                        error: chunk.error,
+                    }, agentContext);
+                    throw new Error("LLM Error: " + chunk.error);
+                }
+                case "finish": {
+                    if (!textStreamDone) {
+                        textStreamDone = true;
+                        await streamCallback.onMessage({
+                            taskId: context.taskId,
+                            agentName: agentNode.name,
+                            nodeId: agentNode.id,
+                            type: "text",
+                            streamId,
+                            streamDone: true,
+                            text: streamText,
+                        }, agentContext);
+                    }
+                    if (toolPart) {
+                        await streamCallback.onMessage({
+                            taskId: context.taskId,
+                            agentName: agentNode.name,
+                            nodeId: agentNode.id,
+                            type: "tool_use",
+                            toolId: toolPart.toolCallId,
+                            toolName: toolPart.toolName,
+                            params: toolPart.args || {},
+                        }, agentContext);
+                        toolPart = null;
+                    }
+                    await streamCallback.onMessage({
+                        taskId: context.taskId,
+                        agentName: agentNode.name,
+                        nodeId: agentNode.id,
+                        type: "finish",
+                        finishReason: chunk.finishReason,
+                        usage: chunk.usage,
+                    }, agentContext);
+                    if (chunk.finishReason === "length" &&
+                        messages.length >= 10 &&
+                        !noCompress &&
+                        !retry) {
+                        await compressAgentMessages(agentContext, rlm, messages, tools);
+                        return callAgentLLM(agentContext, rlm, messages, tools, noCompress, toolChoice, true, streamCallback);
+                    }
+                    break;
+                }
+            }
+        }
+    }
+    catch (e) {
+        await context.checkAborted();
+        if (!retry) {
+            await sleep(200);
+            return callAgentLLM(agentContext, rlm, messages, tools, noCompress, toolChoice, true, streamCallback);
+        }
+        throw e;
+    }
+    finally {
+        reader.releaseLock();
+        context.currentStepControllers.delete(stepController);
+    }
+    agentChain.agentResult = streamText;
+    return streamText
+        ? [
+            { type: "text", text: streamText },
+            ...toolParts,
+        ]
+        : toolParts;
+}
+function appendUserConversation(agentContext, messages) {
+    const userPrompts = agentContext.context.conversation
+        .splice(0, agentContext.context.conversation.length)
+        .filter((s) => !!s);
+    if (userPrompts.length > 0) {
+        const prompt = "The user is intervening in the current task, please replan and execute according to the following instructions:\n" + userPrompts.map(s => `- ${s.trim()}`).join("\n");
+        messages.push({
+            role: "user",
+            content: [{ type: "text", text: prompt }],
+        });
+    }
+}
+
+function extractUsedTool(messages, agentTools) {
+    let tools = [];
+    let toolNames = [];
+    for (let i = 0; i < messages.length; i++) {
+        let message = messages[i];
+        if (message.role == "tool") {
+            for (let j = 0; j < message.content.length; j++) {
+                let toolName = message.content[j].toolName;
+                if (toolNames.indexOf(toolName) > -1) {
+                    continue;
+                }
+                toolNames.push(toolName);
+                let tool = agentTools.filter((tool) => tool.name === toolName)[0];
+                if (tool) {
+                    tools.push(tool);
+                }
+            }
+        }
+    }
+    return tools;
+}
+function removeDuplicateToolUse(results) {
+    if (results.length <= 1 ||
+        results.filter((r) => r.type == "tool-call").length <= 1) {
+        return results;
+    }
+    let _results = [];
+    let tool_uniques = [];
+    for (let i = 0; i < results.length; i++) {
+        if (results[i].type === "tool-call") {
+            let tool = results[i];
+            let key = tool.toolName + tool.args;
+            if (tool_uniques.indexOf(key) == -1) {
+                _results.push(results[i]);
+                tool_uniques.push(key);
+            }
+        }
+        else {
+            _results.push(results[i]);
+        }
+    }
+    return _results;
+}
+async function compressAgentMessages(agentContext, rlm, messages, tools) {
+    if (messages.length < 10) {
+        return;
+    }
+    // extract used tool
+    let usedTools = extractUsedTool(messages, tools);
+    let snapshotTool = new TaskSnapshotTool();
+    let newTools = mergeTools(usedTools, [
+        {
+            type: "function",
+            name: snapshotTool.name,
+            description: snapshotTool.description,
+            parameters: snapshotTool.parameters,
+        },
+    ]);
+    // handle messages
+    let lastToolIndex = messages.length - 1;
+    let newMessages = messages;
+    for (let r = newMessages.length - 1; r > 3; r--) {
+        if (newMessages[r].role == "tool") {
+            newMessages = newMessages.slice(0, r + 1);
+            lastToolIndex = r;
+            break;
+        }
+    }
+    newMessages.push({
+        role: "user",
+        content: [
+            {
+                type: "text",
+                text: "Please create a snapshot backup of the current task, keeping only key important information and node completion status.",
+            },
+        ],
+    });
+    // compress snapshot
+    let 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.args == "string"
+        ? JSON.parse(toolCall.args || "{}")
+        : toolCall.args || {};
+    let toolResult = await snapshotTool.execute(args, agentContext);
+    let 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);
+    }
+    // handle original messages
+    let firstToolIndex = 3;
+    for (let i = 0; i < messages.length; i++) {
+        if (messages[0].role == "tool") {
+            firstToolIndex = i;
+            break;
+        }
+    }
+    // system, user, assistant, tool(first), [...], <user>, assistant, tool(last), ...
+    messages.splice(firstToolIndex + 1, lastToolIndex - firstToolIndex - 2, {
+        role: "user",
+        content: toolResult.content.filter((s) => s.type == "text"),
+    });
+}
+function handleLargeContextMessages(messages) {
+    let imageNum = 0;
+    let fileNum = 0;
+    let maxNum = config.maxDialogueImgFileNum;
+    let longTextTools = {};
+    for (let i = messages.length - 1; i >= 0; i--) {
+        let message = messages[i];
+        if (message.role == "user") {
+            for (let j = 0; j < message.content.length; j++) {
+                let content = message.content[j];
+                if (content.type == "image") {
+                    if (++imageNum <= maxNum) {
+                        break;
+                    }
+                    content = {
+                        type: "text",
+                        text: "[image]",
+                    };
+                    message.content[j] = content;
+                }
+                else if (content.type == "file") {
+                    if (++fileNum <= maxNum) {
+                        break;
+                    }
+                    content = {
+                        type: "text",
+                        text: "[file]",
+                    };
+                    message.content[j] = content;
+                }
+            }
+        }
+        else if (message.role == "tool") {
+            for (let j = 0; j < message.content.length; j++) {
+                let toolResult = message.content[j];
+                let toolContent = toolResult.content;
+                if (!toolContent || toolContent.length == 0) {
+                    continue;
                 }
                 for (let r = 0; r < toolContent.length; r++) {
                     let _content = toolContent[r];
@@ -17995,21 +18407,24 @@ class Agent {
             mcpClient && (await mcpClient.close());
         }
     }
-    async runWithContext(agentContext, mcpClient, maxReactNum = 100) {
+    async runWithContext(agentContext, mcpClient, maxReactNum = 100, historyMessages = []) {
         let loopNum = 0;
+        this.agentContext = agentContext;
         let context = agentContext.context;
         let agentNode = agentContext.agentChain.agent;
         const tools = [...this.tools, ...this.system_auto_tools(agentNode)];
-        let messages = [
+        const messages = [
             {
                 role: "system",
                 content: await this.buildSystemPrompt(agentContext, tools),
             },
+            ...historyMessages,
             {
                 role: "user",
                 content: await this.buildUserPrompt(agentContext, tools),
             },
         ];
+        agentContext.messages = messages;
         let rlm = new RetryLanguageModel(context.config.llms, this.llms);
         let agentTools = tools;
         while (loopNum < maxReactNum) {
@@ -18024,7 +18439,7 @@ class Agent {
                 }
             }
             await this.handleMessages(agentContext, messages, tools);
-            let results = await callLLM(agentContext, rlm, messages, this.convertTools(agentTools), false, undefined, false, this.callback);
+            let results = await callAgentLLM(agentContext, rlm, messages, this.convertTools(agentTools), false, undefined, false, this.callback);
             let finalResult = await this.handleCallResult(agentContext, messages, agentTools, results);
             if (finalResult) {
                 return finalResult;
@@ -18034,6 +18449,10 @@ class Agent {
         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 = [];
@@ -18266,29 +18685,6 @@ class Agent {
     async handleMessages(agentContext, messages, tools) {
         // Only keep the last image / file, large tool-text-result
         handleLargeContextMessages(messages);
-        // User dialogue
-        const userPrompts = agentContext.context.conversation
-            .splice(0, agentContext.context.conversation.length)
-            .filter((s) => !!s);
-        if (userPrompts.length > 0) {
-            const lastMessage = messages[messages.length - 1];
-            if (lastMessage.role == "user") {
-                for (let i = 0; i < userPrompts.length; i++) {
-                    lastMessage.content.push({
-                        type: "text",
-                        text: userPrompts[i],
-                    });
-                }
-            }
-            else {
-                messages.push({
-                    role: "user",
-                    content: userPrompts.map((s) => {
-                        return { type: "text", text: s };
-                    }),
-                });
-            }
-        }
     }
     async callInnerTool(fun) {
         let result = await fun();
@@ -18340,222 +18736,9 @@ class Agent {
     get McpClient() {
         return this.mcpClient;
     }
-}
-async function callLLM(agentContext, rlm, messages, tools, noCompress, toolChoice, retry, callback) {
-    if (messages.length >= config.compressThreshold && !noCompress) {
-        await compressAgentMessages(agentContext, rlm, messages, tools);
-    }
-    let context = agentContext.context;
-    let agentChain = agentContext.agentChain;
-    let agentNode = agentChain.agent;
-    let streamCallback = callback ||
-        context.config.callback || {
-        onMessage: async () => { },
-    };
-    let request = {
-        tools: tools,
-        toolChoice,
-        messages: messages,
-        abortSignal: context.controller.signal,
-    };
-    agentChain.agentRequest = request;
-    let result = await rlm.callStream(request);
-    let streamText = "";
-    let thinkText = "";
-    let toolArgsText = "";
-    let streamId = uuidv4();
-    let textStreamDone = false;
-    let toolParts = [];
-    const reader = result.stream.getReader();
-    try {
-        let toolPart = null;
-        while (true) {
-            await context.checkAborted();
-            const { done, value } = await reader.read();
-            if (done) {
-                break;
-            }
-            let chunk = value;
-            switch (chunk.type) {
-                case "text-delta": {
-                    if (toolPart && !chunk.textDelta) {
-                        continue;
-                    }
-                    streamText += chunk.textDelta || "";
-                    await streamCallback.onMessage({
-                        taskId: context.taskId,
-                        agentName: agentNode.name,
-                        nodeId: agentNode.id,
-                        type: "text",
-                        streamId,
-                        streamDone: false,
-                        text: streamText,
-                    }, agentContext);
-                    if (toolPart) {
-                        await streamCallback.onMessage({
-                            taskId: context.taskId,
-                            agentName: agentNode.name,
-                            nodeId: agentNode.id,
-                            type: "tool_use",
-                            toolId: toolPart.toolCallId,
-                            toolName: toolPart.toolName,
-                            params: toolPart.args || {},
-                        }, agentContext);
-                        toolPart = null;
-                    }
-                    break;
-                }
-                case "reasoning": {
-                    thinkText += chunk.textDelta || "";
-                    await streamCallback.onMessage({
-                        taskId: context.taskId,
-                        agentName: agentNode.name,
-                        nodeId: agentNode.id,
-                        type: "thinking",
-                        streamId,
-                        streamDone: false,
-                        text: thinkText,
-                    }, agentContext);
-                    break;
-                }
-                case "tool-call-delta": {
-                    if (!textStreamDone) {
-                        textStreamDone = true;
-                        await streamCallback.onMessage({
-                            taskId: context.taskId,
-                            agentName: agentNode.name,
-                            nodeId: agentNode.id,
-                            type: "text",
-                            streamId,
-                            streamDone: true,
-                            text: streamText,
-                        }, agentContext);
-                    }
-                    toolArgsText += chunk.argsTextDelta || "";
-                    await streamCallback.onMessage({
-                        taskId: context.taskId,
-                        agentName: agentNode.name,
-                        nodeId: agentNode.id,
-                        type: "tool_streaming",
-                        toolId: chunk.toolCallId,
-                        toolName: chunk.toolName,
-                        paramsText: toolArgsText,
-                    }, agentContext);
-                    if (toolPart == null) {
-                        toolPart = {
-                            type: "tool-call",
-                            toolCallId: chunk.toolCallId,
-                            toolName: chunk.toolName,
-                            args: {},
-                        };
-                        toolParts.push(toolPart);
-                    }
-                    break;
-                }
-                case "tool-call": {
-                    toolArgsText = "";
-                    let args = chunk.args ? JSON.parse(chunk.args) : {};
-                    let message = {
-                        taskId: context.taskId,
-                        agentName: agentNode.name,
-                        nodeId: agentNode.id,
-                        type: "tool_use",
-                        toolId: chunk.toolCallId,
-                        toolName: chunk.toolName,
-                        params: args,
-                    };
-                    await streamCallback.onMessage(message, agentContext);
-                    if (toolPart == null) {
-                        toolParts.push({
-                            type: "tool-call",
-                            toolCallId: chunk.toolCallId,
-                            toolName: chunk.toolName,
-                            args: message.params || args,
-                        });
-                    }
-                    else {
-                        toolPart.args = message.params || args;
-                        toolPart = null;
-                    }
-                    break;
-                }
-                case "file": {
-                    await streamCallback.onMessage({
-                        taskId: context.taskId,
-                        agentName: agentNode.name,
-                        nodeId: agentNode.id,
-                        type: "file",
-                        mimeType: chunk.mimeType,
-                        data: chunk.data,
-                    }, agentContext);
-                    break;
-                }
-                case "error": {
-                    Log.error(`${agentNode.name} agent error: `, chunk);
-                    await streamCallback.onMessage({
-                        taskId: context.taskId,
-                        agentName: agentNode.name,
-                        nodeId: agentNode.id,
-                        type: "error",
-                        error: chunk.error,
-                    }, agentContext);
-                    throw new Error("LLM Error: " + chunk.error);
-                }
-                case "finish": {
-                    if (!textStreamDone) {
-                        textStreamDone = true;
-                        await streamCallback.onMessage({
-                            taskId: context.taskId,
-                            agentName: agentNode.name,
-                            nodeId: agentNode.id,
-                            type: "text",
-                            streamId,
-                            streamDone: true,
-                            text: streamText,
-                        }, agentContext);
-                    }
-                    if (toolPart) {
-                        await streamCallback.onMessage({
-                            taskId: context.taskId,
-                            agentName: agentNode.name,
-                            nodeId: agentNode.id,
-                            type: "tool_use",
-                            toolId: toolPart.toolCallId,
-                            toolName: toolPart.toolName,
-                            params: toolPart.args || {},
-                        }, agentContext);
-                        toolPart = null;
-                    }
-                    await streamCallback.onMessage({
-                        taskId: context.taskId,
-                        agentName: agentNode.name,
-                        nodeId: agentNode.id,
-                        type: "finish",
-                        finishReason: chunk.finishReason,
-                        usage: chunk.usage,
-                    }, agentContext);
-                    if (chunk.finishReason === "length" &&
-                        messages.length >= 10 &&
-                        !noCompress &&
-                        !retry) {
-                        await compressAgentMessages(agentContext, rlm, messages, tools);
-                        return callLLM(agentContext, rlm, messages, tools, noCompress, toolChoice, true, streamCallback);
-                    }
-                    break;
-                }
-            }
-        }
-    }
-    finally {
-        reader.releaseLock();
+    get AgentContext() {
+        return this.agentContext;
     }
-    agentChain.agentResult = streamText;
-    return streamText
-        ? [
-            { type: "text", text: streamText },
-            ...toolParts,
-        ]
-        : toolParts;
 }
 
 const AGENT_NAME$5 = "Chat";
@@ -18590,7 +18773,9 @@ Your task is to understand the user's requirements, dynamically plan the user's
 
 ## Output Rules and Format
 <root>
+  <!-- Task Name (Short) -->
   <name>Task Name</name>
+  <!-- Need to break down the task into multi-agent collaboration. Please think step by step and output a detailed thought process. -->
   <thought>Your thought process on user demand planning</thought>
   <!-- Multiple Agents work together to complete the task -->
   <agents>
@@ -18788,21 +18973,39 @@ function getPlanUserPrompt(task_prompt, task_website, ext_prompt) {
 class Planner {
     constructor(context, taskId) {
         this.context = context;
-        this.taskId = taskId;
-    }
-    async plan(taskPrompt) {
-        return await this.doPlan(taskPrompt, false);
-    }
-    async replan(taskPrompt) {
-        return await this.doPlan(taskPrompt, true);
+        this.taskId = taskId || context.taskId;
+    }
+    async plan(taskPrompt, saveHistory = true) {
+        let taskPromptStr;
+        let userPrompt;
+        if (typeof taskPrompt === "string") {
+            taskPromptStr = taskPrompt;
+            userPrompt = {
+                type: "text",
+                text: getPlanUserPrompt(taskPrompt, this.context.variables.get("task_website"), this.context.variables.get("plan_ext_prompt")),
+            };
+        }
+        else {
+            userPrompt = taskPrompt;
+            taskPromptStr = taskPrompt.text || "";
+        }
+        const messages = [
+            {
+                role: "system",
+                content: this.context.variables.get("plan_sys_prompt") ||
+                    (await getPlanSystemPrompt(this.context)),
+            },
+            {
+                role: "user",
+                content: [userPrompt],
+            },
+        ];
+        return await this.doPlan(taskPromptStr, messages, saveHistory);
     }
-    async doPlan(taskPrompt, replan = false) {
-        let config = this.context.config;
-        let chain = this.context.chain;
-        let rlm = new RetryLanguageModel(config.llms, config.planLlms);
-        let messages;
-        if (replan && chain.planRequest && chain.planResult) {
-            messages = [
+    async replan(taskPrompt, saveHistory = true) {
+        const chain = this.context.chain;
+        if (chain.planRequest && chain.planResult) {
+            const messages = [
                 ...chain.planRequest.messages,
                 {
                     role: "assistant",
@@ -18813,37 +19016,28 @@ class Planner {
                     content: [{ type: "text", text: taskPrompt }],
                 },
             ];
+            return await this.doPlan(taskPrompt, messages, saveHistory);
         }
         else {
-            messages = [
-                {
-                    role: "system",
-                    content: this.context.variables.get("plan_sys_prompt") ||
-                        (await getPlanSystemPrompt(this.context)),
-                },
-                {
-                    role: "user",
-                    content: [
-                        {
-                            type: "text",
-                            text: getPlanUserPrompt(taskPrompt, this.context.variables.get("task_website"), this.context.variables.get("plan_ext_prompt")),
-                        },
-                    ],
-                },
-            ];
+            return this.plan(taskPrompt, saveHistory);
         }
-        let request = {
+    }
+    async doPlan(taskPrompt, messages, saveHistory) {
+        const config = this.context.config;
+        const rlm = new RetryLanguageModel(config.llms, config.planLlms);
+        const request = {
             maxTokens: 4096,
             temperature: 0.7,
             messages: messages,
             abortSignal: this.context.controller.signal,
         };
-        let result = await rlm.callStream(request);
+        const result = await rlm.callStream(request);
         const reader = result.stream.getReader();
         let streamText = "";
+        let thinkingText = "";
         try {
             while (true) {
-                await this.context.checkAborted();
+                await this.context.checkAborted(true);
                 const { done, value } = await reader.read();
                 if (done) {
                     break;
@@ -18853,11 +19047,14 @@ class Planner {
                     Log.error("Plan, LLM Error: ", chunk);
                     throw new Error("LLM Error: " + chunk.error);
                 }
+                if (chunk.type == "reasoning") {
+                    thinkingText += chunk.textDelta || "";
+                }
                 if (chunk.type == "text-delta") {
                     streamText += chunk.textDelta || "";
                 }
                 if (config.callback) {
-                    let workflow = parseWorkflow(this.taskId, streamText, false);
+                    let workflow = parseWorkflow(this.taskId, streamText, false, thinkingText);
                     if (workflow) {
                         await config.callback.onMessage({
                             taskId: this.taskId,
@@ -18872,11 +19069,16 @@ class Planner {
         }
         finally {
             reader.releaseLock();
-            Log.info("Planner result: \n" + streamText);
+            if (Log.isEnableInfo()) {
+                Log.info("Planner result: \n" + streamText);
+            }
         }
-        chain.planRequest = request;
-        chain.planResult = streamText;
-        let workflow = parseWorkflow(this.taskId, streamText, true);
+        if (saveHistory) {
+            const chain = this.context.chain;
+            chain.planRequest = request;
+            chain.planResult = streamText;
+        }
+        let workflow = parseWorkflow(this.taskId, streamText, true, thinkingText);
         if (config.callback) {
             await config.callback.onMessage({
                 taskId: this.taskId,
@@ -18886,7 +19088,12 @@ class Planner {
                 workflow: workflow,
             });
         }
-        workflow.taskPrompt = taskPrompt;
+        if (workflow.taskPrompt) {
+            workflow.taskPrompt += "\n" + taskPrompt.trim();
+        }
+        else {
+            workflow.taskPrompt = taskPrompt.trim();
+        }
         return workflow;
     }
 }
@@ -18936,8 +19143,8 @@ class Eko {
         if (!context) {
             throw new Error("The task does not exist");
         }
-        if (context.paused) {
-            context.paused = false;
+        if (context.pause) {
+            context.setPause(false);
         }
         context.conversation = [];
         if (context.controller.signal.aborted) {
@@ -19025,7 +19232,7 @@ class Eko {
     abortTask(taskId, reason) {
         let context = this.taskMap.get(taskId);
         if (context) {
-            context.paused = false;
+            context.setPause(false);
             this.onTaskStatus(context, "abort", reason);
             context.controller.abort(reason);
             return true;
@@ -19034,11 +19241,11 @@ class Eko {
             return false;
         }
     }
-    pauseTask(taskId, paused, reason) {
+    pauseTask(taskId, pause, abortCurrentStep, reason) {
         let context = this.taskMap.get(taskId);
         if (context) {
-            this.onTaskStatus(context, paused ? "pause" : "resume-pause", reason);
-            context.paused = paused;
+            this.onTaskStatus(context, pause ? "pause" : "resume-pause", reason);
+            context.setPause(pause, abortCurrentStep);
             return true;
         }
         else {
@@ -21788,17 +21995,21 @@ exports.Eko = Eko;
 exports.ForeachTaskTool = ForeachTaskTool;
 exports.HumanInteractTool = HumanInteractTool;
 exports.Log = Log;
+exports.Planner = Planner;
 exports.RetryLanguageModel = RetryLanguageModel;
 exports.SimpleSseMcpClient = SimpleSseMcpClient;
 exports.TaskNodeStatusTool = TaskNodeStatusTool;
 exports.VariableStorageTool = VariableStorageTool;
 exports.WatchTriggerTool = WatchTriggerTool;
+exports.buildSimpleAgentWorkflow = buildSimpleAgentWorkflow;
 exports.call_timeout = call_timeout;
 exports.config = config;
 exports.convertToolSchema = convertToolSchema;
 exports.default = Eko;
 exports.extract_page_content = extract_page_content;
 exports.mergeTools = mergeTools;
+exports.parseWorkflow = parseWorkflow;
+exports.resetWorkflowXml = resetWorkflowXml;
 exports.toImage = toImage;
 exports.uuidv4 = uuidv4;
 //# sourceMappingURL=index.cjs.js.map