@eko-ai/eko 2.1.7-alpha.7 → 2.1.7

package/dist/index.cjs.js

@@ -363,10 +363,8 @@ function fixXmlTag(code) {
         const top = stack.pop();
         if (top.startsWith("<")) {
             let arr = top.match(/<(\w+)/);
-            if (arr) {
-                const tagName = arr[1];
-                missingParts.push(`</${tagName}>`);
-            }
+            const tagName = arr[1];
+            missingParts.push(`</${tagName}>`);
         }
         else {
             missingParts.push(top);
@@ -378,9 +376,8 @@ 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;
@@ -389,19 +386,14 @@ class Context {
         this.controller = new AbortController();
     }
     async checkAborted() {
+        // this.controller.signal.throwIfAborted();
         if (this.controller.signal.aborted) {
             const error = new Error("Operation was interrupted");
             error.name = "AbortError";
             throw error;
         }
-        while (this.pauseStatus > 0) {
+        while (this.paused) {
             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";
@@ -418,21 +410,9 @@ 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) {
@@ -14185,7 +14165,6 @@ 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 llm = await this.getLLM(name);
@@ -14201,19 +14180,16 @@ class RetryLanguageModel {
                 options.providerMetadata[llm.provider] = this.llms[name].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 = this.llms[name];
                 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,
@@ -14223,7 +14199,7 @@ class RetryLanguageModel {
                 Log.error(`LLM error, name: ${name} => `, e);
             }
         }
-        return Promise.reject(lastError ? lastError : new Error("No LLM available"));
+        return Promise.reject(new Error("No LLM available"));
     }
     async callStream(request) {
         return await this.doStream({
@@ -14245,7 +14221,6 @@ 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 llm = await this.getLLM(name);
@@ -14265,9 +14240,9 @@ class RetryLanguageModel {
                 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) => {
@@ -14289,8 +14264,6 @@ class RetryLanguageModel {
                     reader.releaseLock();
                     continue;
                 }
-                result.llm = name;
-                result.llmConfig = this.llms[name];
                 result.stream = this.streamWrapper([chunk], reader);
                 return result;
             }
@@ -14298,7 +14271,6 @@ class RetryLanguageModel {
                 if (e?.name === "AbortError") {
                     throw e;
                 }
-                lastError = e;
                 if (Log.isEnableInfo()) {
                     Log.info(`LLM stream request, name: ${name} => `, {
                         tools: options.mode?.tools,
@@ -14308,7 +14280,7 @@ class RetryLanguageModel {
                 Log.error(`LLM error, name: ${name} => `, e);
             }
         }
-        return Promise.reject(lastError ? lastError : new Error("No LLM available"));
+        return Promise.reject(new Error("No LLM available"));
     }
     async getLLM(name) {
         const llm = this.llms[name];
@@ -14406,12 +14378,6 @@ class RetryLanguageModel {
             },
         });
     }
-    get Llms() {
-        return this.llms;
-    }
-    get Names() {
-        return this.names;
-    }
 }
 
 var domParser = {};
@@ -16859,21 +16825,11 @@ function requireDomParser () {
 
 var domParserExports = requireDomParser();
 
-function parseWorkflow(taskId, xml, done, thinking) {
-    let _workflow = null;
+function parseWorkflow(taskId, xml, done) {
     try {
-        if (thinking) {
-            _workflow = {
-                taskId: taskId,
-                name: "",
-                thought: thinking,
-                agents: [],
-                xml: xml,
-            };
-        }
         let sIdx = xml.indexOf("<root>");
         if (sIdx == -1) {
-            return _workflow;
+            return null;
         }
         xml = xml.substring(sIdx);
         let eIdx = xml.indexOf("</root>");
@@ -16887,14 +16843,13 @@ function parseWorkflow(taskId, xml, done, thinking) {
         const doc = parser.parseFromString(xml, "text/xml");
         let root = doc.documentElement;
         if (root.tagName !== "root") {
-            return _workflow;
+            return null;
         }
-        const agents = [];
-        const thought = root.getElementsByTagName("thought")[0]?.textContent || "";
+        let agents = [];
         const workflow = {
             taskId: taskId,
             name: root.getElementsByTagName("name")[0]?.textContent || "",
-            thought: thinking ? thinking + "\n" + thought : thought,
+            thought: root.getElementsByTagName("thought")[0]?.textContent || "",
             agents: agents,
             xml: xml,
         };
@@ -16927,7 +16882,7 @@ function parseWorkflow(taskId, xml, done, thinking) {
             throw e;
         }
         else {
-            return _workflow;
+            return null;
         }
     }
 }
@@ -17005,7 +16960,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();
@@ -17037,92 +16992,6 @@ 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 {
@@ -17172,425 +17041,158 @@ class TaskSnapshotTool {
     }
 }
 
-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);
+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]);
+        }
     }
-    if (!toolChoice) {
-        // Append user dialogue
-        appendUserConversation(agentContext, messages);
+    return _results;
+}
+async function compressAgentMessages(agentContext, rlm, messages, tools) {
+    if (messages.length < 10) {
+        return;
     }
-    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,
+    // 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 request = {
-        tools: tools,
-        toolChoice,
-        messages: messages,
-        abortSignal: signal,
-    };
-    agentChain.agentRequest = request;
-    let result;
-    try {
-        context.currentStepControllers.add(stepController);
-        result = await rlm.callStream(request);
+    // 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;
+        }
     }
-    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);
+    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);
+    }
+    // handle original messages
+    let firstToolIndex = 3;
+    for (let i = 0; i < messages.length; i++) {
+        if (messages[0].role == "tool") {
+            firstToolIndex = i;
+            break;
         }
-        throw e;
     }
-    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;
+    // 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;
                     }
-                    streamText += chunk.textDelta || "";
-                    await streamCallback.onMessage({
-                        taskId: context.taskId,
-                        agentName: agentNode.name,
-                        nodeId: agentNode.id,
+                    content = {
                         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;
+                        text: "[image]",
+                    };
+                    message.content[j] = content;
+                }
+                else if (content.type == "file") {
+                    if (++fileNum <= maxNum) {
+                        break;
                     }
-                    break;
+                    content = {
+                        type: "text",
+                        text: "[file]",
+                    };
+                    message.content[j] = content;
                 }
-                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) {
-        if (e?.name === "AbortError") {
-            throw e;
-        }
-        if (!retry && (e + "").indexOf("network error") > -1) {
-            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;
+            }
+        }
+        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];
@@ -18393,24 +17995,21 @@ class Agent {
             mcpClient && (await mcpClient.close());
         }
     }
-    async runWithContext(agentContext, mcpClient, maxReactNum = 100, historyMessages = []) {
+    async runWithContext(agentContext, mcpClient, maxReactNum = 100) {
         let loopNum = 0;
-        this.agentContext = agentContext;
         let context = agentContext.context;
         let agentNode = agentContext.agentChain.agent;
         const tools = [...this.tools, ...this.system_auto_tools(agentNode)];
-        const messages = [
+        let 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) {
@@ -18425,7 +18024,7 @@ class Agent {
                 }
             }
             await this.handleMessages(agentContext, messages, tools);
-            let results = await callAgentLLM(agentContext, rlm, messages, this.convertTools(agentTools), false, undefined, false, this.callback);
+            let results = await callLLM(agentContext, rlm, messages, this.convertTools(agentTools), false, undefined, false, this.callback);
             let finalResult = await this.handleCallResult(agentContext, messages, agentTools, results);
             if (finalResult) {
                 return finalResult;
@@ -18667,6 +18266,29 @@ 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();
@@ -18718,9 +18340,222 @@ class Agent {
     get McpClient() {
         return this.mcpClient;
     }
-    get AgentContext() {
-        return this.agentContext;
+}
+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();
     }
+    agentChain.agentResult = streamText;
+    return streamText
+        ? [
+            { type: "text", text: streamText },
+            ...toolParts,
+        ]
+        : toolParts;
 }
 
 const AGENT_NAME$5 = "Chat";
@@ -18755,9 +18590,7 @@ 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>
@@ -18955,39 +18788,21 @@ function getPlanUserPrompt(task_prompt, task_website, ext_prompt) {
 class Planner {
     constructor(context, taskId) {
         this.context = context;
-        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);
+        this.taskId = taskId;
     }
-    async replan(taskPrompt, saveHistory = true) {
-        const chain = this.context.chain;
-        if (chain.planRequest && chain.planResult) {
-            const messages = [
+    async plan(taskPrompt) {
+        return await this.doPlan(taskPrompt, false);
+    }
+    async replan(taskPrompt) {
+        return await this.doPlan(taskPrompt, true);
+    }
+    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 = [
                 ...chain.planRequest.messages,
                 {
                     role: "assistant",
@@ -18998,25 +18813,34 @@ class Planner {
                     content: [{ type: "text", text: taskPrompt }],
                 },
             ];
-            return await this.doPlan(taskPrompt, messages, saveHistory);
         }
         else {
-            return this.plan(taskPrompt, saveHistory);
+            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")),
+                        },
+                    ],
+                },
+            ];
         }
-    }
-    async doPlan(taskPrompt, messages, saveHistory) {
-        const config = this.context.config;
-        const rlm = new RetryLanguageModel(config.llms, config.planLlms);
-        const request = {
+        let request = {
             maxTokens: 4096,
             temperature: 0.7,
             messages: messages,
             abortSignal: this.context.controller.signal,
         };
-        const result = await rlm.callStream(request);
+        let result = await rlm.callStream(request);
         const reader = result.stream.getReader();
         let streamText = "";
-        let thinkingText = "";
         try {
             while (true) {
                 await this.context.checkAborted();
@@ -19029,14 +18853,11 @@ 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, thinkingText);
+                    let workflow = parseWorkflow(this.taskId, streamText, false);
                     if (workflow) {
                         await config.callback.onMessage({
                             taskId: this.taskId,
@@ -19051,16 +18872,11 @@ class Planner {
         }
         finally {
             reader.releaseLock();
-            if (Log.isEnableInfo()) {
-                Log.info("Planner result: \n" + streamText);
-            }
+            Log.info("Planner result: \n" + streamText);
         }
-        if (saveHistory) {
-            const chain = this.context.chain;
-            chain.planRequest = request;
-            chain.planResult = streamText;
-        }
-        let workflow = parseWorkflow(this.taskId, streamText, true, thinkingText);
+        chain.planRequest = request;
+        chain.planResult = streamText;
+        let workflow = parseWorkflow(this.taskId, streamText, true);
         if (config.callback) {
             await config.callback.onMessage({
                 taskId: this.taskId,
@@ -19070,12 +18886,7 @@ class Planner {
                 workflow: workflow,
             });
         }
-        if (workflow.taskPrompt) {
-            workflow.taskPrompt += "\n" + taskPrompt.trim();
-        }
-        else {
-            workflow.taskPrompt = taskPrompt.trim();
-        }
+        workflow.taskPrompt = taskPrompt;
         return workflow;
     }
 }
@@ -19125,8 +18936,8 @@ class Eko {
         if (!context) {
             throw new Error("The task does not exist");
         }
-        if (context.pause) {
-            context.setPause(false);
+        if (context.paused) {
+            context.paused = false;
         }
         context.conversation = [];
         if (context.controller.signal.aborted) {
@@ -19214,7 +19025,7 @@ class Eko {
     abortTask(taskId, reason) {
         let context = this.taskMap.get(taskId);
         if (context) {
-            context.setPause(false);
+            context.paused = false;
             this.onTaskStatus(context, "abort", reason);
             context.controller.abort(reason);
             return true;
@@ -19223,11 +19034,11 @@ class Eko {
             return false;
         }
     }
-    pauseTask(taskId, pause, abortCurrentStep, reason) {
+    pauseTask(taskId, paused, reason) {
         let context = this.taskMap.get(taskId);
         if (context) {
-            this.onTaskStatus(context, pause ? "pause" : "resume-pause", reason);
-            context.setPause(pause, abortCurrentStep);
+            this.onTaskStatus(context, paused ? "pause" : "resume-pause", reason);
+            context.paused = paused;
             return true;
         }
         else {
@@ -21977,21 +21788,17 @@ 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