@eko-ai/eko 2.1.8 → 2.1.9

package/dist/index.cjs.js

@@ -9,6 +9,8 @@ const config = {
     platform: "mac",
     maxReactNum: 500,
     maxTokens: 16000,
+    maxRetryNum: 3,
+    agentParallel: false,
     compressThreshold: 80,
     largeTextLength: 5000,
     fileTextMaxLength: 20000,
@@ -323,6 +325,8 @@ function fixXmlTag(code) {
         code += '""';
     }
     else if (endStr == "name" ||
+        endStr == "id" ||
+        endStr == "dependsOn" ||
         endStr == "input" ||
         endStr == "output" ||
         endStr == "items" ||
@@ -388,13 +392,13 @@ class Context {
         this.variables = new Map();
         this.controller = new AbortController();
     }
-    async checkAborted() {
+    async checkAborted(noCheckPause) {
         if (this.controller.signal.aborted) {
             const error = new Error("Operation was interrupted");
             error.name = "AbortError";
             throw error;
         }
-        while (this.pauseStatus > 0) {
+        while (this.pauseStatus > 0 && !noCheckPause) {
             await sleep(500);
             if (this.pauseStatus == 2) {
                 this.currentStepControllers.forEach((c) => {
@@ -14157,10 +14161,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");
         }
@@ -14178,6 +14183,7 @@ class RetryLanguageModel {
             temperature: request.temperature,
             topP: request.topP,
             topK: request.topK,
+            stopSequences: request.stopSequences,
             abortSignal: request.abortSignal,
         });
     }
@@ -14188,25 +14194,29 @@ class RetryLanguageModel {
         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 = this.llms[name];
+                result.llmConfig = llmConfig;
                 return result;
             }
             catch (e) {
@@ -14216,8 +14226,8 @@ class RetryLanguageModel {
                 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);
@@ -14238,6 +14248,7 @@ class RetryLanguageModel {
             temperature: request.temperature,
             topP: request.topP,
             topK: request.topK,
+            stopSequences: request.stopSequences,
             abortSignal: request.abortSignal,
         });
     }
@@ -14248,24 +14259,28 @@ class RetryLanguageModel {
         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;
@@ -14290,8 +14305,8 @@ class RetryLanguageModel {
                     continue;
                 }
                 result.llm = name;
-                result.llmConfig = this.llms[name];
-                result.stream = this.streamWrapper([chunk], reader);
+                result.llmConfig = llmConfig;
+                result.stream = this.streamWrapper([chunk], reader, controller);
                 return result;
             }
             catch (e) {
@@ -14301,8 +14316,8 @@ class RetryLanguageModel {
                 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);
@@ -14383,7 +14398,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) {
@@ -14393,7 +14409,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();
@@ -14402,6 +14422,7 @@ class RetryLanguageModel {
                 controller.enqueue(value);
             },
             cancel: (reason) => {
+                timer && clearTimeout(timer);
                 reader.cancel(reason);
             },
         });
@@ -16906,10 +16927,13 @@ function parseWorkflow(taskId, xml, done, thinking) {
             if (!name) {
                 break;
             }
+            let index = agentNode.getAttribute("id") || i;
+            let dependsOn = agentNode.getAttribute("dependsOn") || "";
             let nodes = [];
             let agent = {
                 name: name,
-                id: taskId + "-" + (i < 10 ? "0" + i : i),
+                id: getAgentId(taskId, index),
+                dependsOn: dependsOn.split(",").filter(idx => idx.trim() != "").map(idx => getAgentId(taskId, idx)),
                 task: agentNode.getElementsByTagName("task")[0]?.textContent || "",
                 nodes: nodes,
                 xml: agentNode.toString(),
@@ -16931,6 +16955,9 @@ function parseWorkflow(taskId, xml, done, thinking) {
         }
     }
 }
+function getAgentId(taskId, index) {
+    return taskId + "-" + (+index < 10 ? "0" + index : index);
+}
 function parseWorkflowNodes(nodes, xmlNodes) {
     for (let i = 0; i < xmlNodes.length; i++) {
         if (xmlNodes[i].nodeType !== 1) {
@@ -17048,6 +17075,7 @@ function buildSimpleAgentWorkflow({ taskId, name, agentName, task, taskNodes, })
         agents: [
             {
                 id: taskId + "-00",
+                dependsOn: [],
                 name: agentName,
                 task: task,
                 nodes: taskNodes.map((node) => {
@@ -17069,6 +17097,7 @@ function resetWorkflowXml(workflow) {
     const agents = [];
     for (let i = 0; i < workflow.agents.length; i++) {
         const agent = workflow.agents[i];
+        const agentDependsAttr = ` id="${i}" dependsOn="${(agent.dependsOn || []).filter(s => parseInt(s.split("-")[s.split("-").length - 1])).join(",")}"`;
         const nodes = agent.nodes
             .map((node) => {
             if (node.type == "forEach") {
@@ -17105,7 +17134,7 @@ ${watchNodes.join("\n")}
             }
         })
             .join("\n");
-        const agentXml = `    <agent name="${agent.name}">
+        const agentXml = `    <agent name="${agent.name}"${agentDependsAttr}>
       <task>${agent.task}</task>
       <nodes>
 ${nodes}
@@ -17172,7 +17201,7 @@ class TaskSnapshotTool {
     }
 }
 
-async function callAgentLLM(agentContext, rlm, messages, tools, noCompress, toolChoice, retry, callback) {
+async function callAgentLLM(agentContext, rlm, messages, tools, noCompress, toolChoice, retryNum = 0, callback, requestHandler) {
     await agentContext.context.checkAborted();
     if (messages.length >= config.compressThreshold && !noCompress) {
         await compressAgentMessages(agentContext, rlm, messages, tools);
@@ -17199,6 +17228,7 @@ async function callAgentLLM(agentContext, rlm, messages, tools, noCompress, tool
         messages: messages,
         abortSignal: signal,
     };
+    requestHandler && requestHandler(request);
     agentChain.agentRequest = request;
     let result;
     try {
@@ -17209,13 +17239,13 @@ async function callAgentLLM(agentContext, rlm, messages, tools, noCompress, tool
         context.currentStepControllers.delete(stepController);
         await context.checkAborted();
         if (!noCompress &&
-            messages.length > 10 &&
+            messages.length >= 5 &&
             ((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);
+        if (retryNum < config.maxRetryNum) {
+            await sleep(200 * (retryNum + 1) * (retryNum + 1));
+            return callAgentLLM(agentContext, rlm, messages, tools, noCompress, toolChoice, ++retryNum, streamCallback);
         }
         throw e;
     }
@@ -17394,11 +17424,11 @@ async function callAgentLLM(agentContext, rlm, messages, tools, noCompress, tool
                         usage: chunk.usage,
                     }, agentContext);
                     if (chunk.finishReason === "length" &&
-                        messages.length >= 10 &&
+                        messages.length >= 5 &&
                         !noCompress &&
-                        !retry) {
+                        retryNum < config.maxRetryNum) {
                         await compressAgentMessages(agentContext, rlm, messages, tools);
-                        return callAgentLLM(agentContext, rlm, messages, tools, noCompress, toolChoice, true, streamCallback);
+                        return callAgentLLM(agentContext, rlm, messages, tools, noCompress, toolChoice, ++retryNum, streamCallback);
                     }
                     break;
                 }
@@ -17407,8 +17437,9 @@ async function callAgentLLM(agentContext, rlm, messages, tools, noCompress, tool
     }
     catch (e) {
         await context.checkAborted();
-        if (!retry) {
-            return callAgentLLM(agentContext, rlm, messages, tools, noCompress, toolChoice, true, streamCallback);
+        if (retryNum < config.maxRetryNum) {
+            await sleep(200 * (retryNum + 1) * (retryNum + 1));
+            return callAgentLLM(agentContext, rlm, messages, tools, noCompress, toolChoice, ++retryNum, streamCallback);
         }
         throw e;
     }
@@ -17429,7 +17460,8 @@ function appendUserConversation(agentContext, messages) {
         .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");
+        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 }],
@@ -17481,9 +17513,17 @@ function removeDuplicateToolUse(results) {
     return _results;
 }
 async function compressAgentMessages(agentContext, rlm, messages, tools) {
-    if (messages.length < 10) {
+    if (messages.length < 5) {
         return;
     }
+    try {
+        doCompressAgentMessages(agentContext, rlm, messages, tools);
+    }
+    catch (e) {
+        Log.error("Error compressing agent messages:", e);
+    }
+}
+async function doCompressAgentMessages(agentContext, rlm, messages, tools) {
     // extract used tool
     let usedTools = extractUsedTool(messages, tools);
     let snapshotTool = new TaskSnapshotTool();
@@ -17605,7 +17645,8 @@ function handleLargeContextMessages(messages) {
                 }
                 for (let r = 0; r < toolContent.length; r++) {
                     let _content = toolContent[r];
-                    if (_content.type == "text" && _content.text?.length > config.largeTextLength) {
+                    if (_content.type == "text" &&
+                        _content.text?.length > config.largeTextLength) {
                         if (!longTextTools[toolResult.toolName]) {
                             longTextTools[toolResult.toolName] = 1;
                             break;
@@ -18378,6 +18419,7 @@ class Agent {
         this.llms = params.llms;
         this.mcpClient = params.mcpClient;
         this.planDescription = params.planDescription;
+        this.requestHandler = params.requestHandler;
     }
     async run(context, agentChain) {
         let mcpClient = this.mcpClient || context.config.defaultMcpClient;
@@ -18423,7 +18465,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 callAgentLLM(agentContext, rlm, messages, this.convertTools(agentTools), false, undefined, 0, this.callback, this.requestHandler);
             let finalResult = await this.handleCallResult(agentContext, messages, agentTools, results);
             if (finalResult) {
                 return finalResult;
@@ -18433,6 +18475,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 = [];
@@ -18721,11 +18767,11 @@ class Agent {
     }
 }
 
-const AGENT_NAME$5 = "Chat";
+const AGENT_NAME$4 = "Chat";
 class BaseChatAgent extends Agent {
     constructor(llms, ext_tools, mcpClient) {
         super({
-            name: AGENT_NAME$5,
+            name: AGENT_NAME$4,
             description: "You are a helpful assistant.",
             tools: ext_tools || [],
             llms: llms,
@@ -18759,8 +18805,13 @@ Your task is to understand the user's requirements, dynamically plan the user's
   <thought>Your thought process on user demand planning</thought>
   <!-- Multiple Agents work together to complete the task -->
   <agents>
-    <!-- The required Agent, where the name can only be an available name in the Agent list -->
-    <agent name="Agent name">
+    <!--
+    Multi-Agent supports parallelism, coordinating parallel tasks through dependencies, and passing dependent context information through node variables.
+    name: The name of the Agent, where the name can only be an available name in the Agent list.
+    id: Use subscript order as ID for dependency relationships between multiple agents.
+    dependsOn: The IDs of agents that the current agent depends on, separated by commas when there are multiple dependencies.
+    -->
+    <agent name="Agent name" id="0" dependsOn="">
       <!-- The current Agent needs to complete the task -->
       <task>current agent task</task>
       <nodes>
@@ -18782,6 +18833,22 @@ Your task is to understand the user's requirements, dynamically plan the user's
         </watch>
       </nodes>
     </agent>
+    <!--
+    Multi-agent Collaboration Dependency Example:
+
+    Execution Flow:
+    1. Agent 0: Initial agent with no dependencies (executes first)
+    2. Agent 1: Depends on Agent 0 completion (executes after Agent 0)
+    3. Agent 2 & 3: Both depend on Agent 1 completion (execute in parallel after Agent 1)
+    4. Agent 4: Depends on both Agent 2 and Agent 3 completion (executes last)
+
+    Dependency Chain: Agent 0 → Agent 1 → (Agent 2 ∥ Agent 3) → Agent 4
+    -->
+    <agent name="Agent name" id="0" dependsOn="">...</agent>
+    <agent name="Agent name" id="1" dependsOn="0">...</agent>
+    <agent name="Agent name" id="2" dependsOn="1">...</agent>
+    <agent name="Agent name" id="3" dependsOn="1">...</agent>
+    <agent name="Agent name" id="4" dependsOn="2,3">...</agent>
   </agents>
 </root>
 
@@ -18794,7 +18861,7 @@ Output result:
   <thought>Alright, the user wrote "hello". That's pretty straightforward. I need to respond in a friendly and welcoming manner.</thought>
   <agents>
     <!-- Chat agents can exist without the <task> and <nodes> nodes. -->
-    <agent name="Chat"></agent>
+    <agent name="Chat" id="0" dependsOn=""></agent>
   </agents>
 </root>`;
 const PLAN_EXAMPLE_LIST = [
@@ -18804,7 +18871,7 @@ Output result:
   <name>Submit resume</name>
   <thought>OK, now the user requests me to create a workflow that involves opening the Boss Zhipin website, finding 10 operation positions in Chengdu, and sending personal resumes to the recruiters based on the job information.</thought>
   <agents>
-    <agent name="Browser">
+    <agent name="Browser" id="0" dependsOn="">
       <task>Open Boss Zhipin, find 10 operation positions in Chengdu, and send a personal introduction to the recruiters based on the page information.</task>
       <nodes>
         <node>Open Boss Zhipin, enter the job search page</node>
@@ -18824,7 +18891,7 @@ Output result:
   <name>Latest AI News</name>
   <thought>OK, users need to collect the latest AI news, summarize it, and send it to a WeChat group named "AI news information" This requires automation, including the steps of data collection, processing, and distribution.</thought>
   <agents>
-    <agent name="Browser">
+    <agent name="Browser" id="0" dependsOn="">
       <task>Search for the latest updates on AI</task>
       <nodes>
         <node>Open Google</node>
@@ -18835,7 +18902,7 @@ Output result:
         <node output="summaryInfo">Summarize search information</node>
       </nodes>
     </agent>
-    <agent name="Computer">
+    <agent name="Computer" id="1" dependsOn="0">
       <task>Send a message to the WeChat group chat "AI news information"</task>
       <nodes>
         <node>Open WeChat</node>
@@ -18851,7 +18918,7 @@ Output result:
   <name>Statistics of Google Team Developers' Geographic Distribution</name>
   <thought>Okay, I need to first visit GitHub, then find Google's organization page on GitHub, extract the team member list, and individually visit each developer's homepage to obtain location information for each developer. This requires using a browser to complete all operations.</thought>
   <agents>
-    <agent name="Browser">
+    <agent name="Browser" id="0" dependsOn="">
       <task>Visit Google GitHub Organization Page and Analyze Developer Geographic Distribution</task>
       <nodes>
         <node>Visit https://github.com/google</node>
@@ -18873,7 +18940,7 @@ Output result:
   <name>Automatic reply to Discord messages</name>
   <thought>OK, monitor the chat messages in Discord group A and automatically reply.</thought>
   <agents>
-    <agent name="Browser">
+    <agent name="Browser" id="0" dependsOn="">
       <task>Open Group A in Discord</task>
       <nodes>
         <node>Open Discord page</node>
@@ -18888,6 +18955,59 @@ Output result:
       </nodes>
     </agent>
   </agents>
+</root>`,
+    `User: Search for information about "fellou," compile the results into a summary profile, then share it across social media platforms including Twitter, Facebook, and Reddit. Finally, export the platform sharing operation results to an Excel file.
+Output result:
+<root>
+<name>Fellou Research and Social Media Campaign</name>
+<thought>The user wants me to research information about 'Fellou', create a summary profile, share it on multiple social media platforms (Twitter, Facebook, Reddit), and then compile the results into an Excel file. This requires multiple agents working together: Browser for research, Browser for social media posting (Twitter, Facebook, and Reddit in parallel), and File for creating the Excel export. I need to break this down into sequential steps with proper variable passing between agents.</thought>
+<agents>
+  <agent name="Browser" id="0" dependsOn="">
+      <task>Research comprehensive information about 'Fellou'</task>
+      <nodes>
+        <node>Search for the latest information about 'Fellou' - its identity, purpose, and core features</node>
+        <node>Search for Fellou's functionalities, capabilities, and technical specifications</node>
+        <node>Search for recent news, updates, announcements, and developments related to Fellou</node>
+        <node>Search for user reviews, feedback, and community discussions about Fellou</node>
+        <node>Search for Fellou's market position, competitors, and industry context</node>
+        <node output="researchData">Compile all research findings into a comprehensive summary profile</node>
+      </nodes>
+    </agent>
+    <agent name="Browser" id="1" dependsOn="0">
+      <task>Share Fellou's summary and collected interaction data on Twitter/X</task>
+      <nodes>
+        <node>Navigate to Twitter/X platform</node>
+        <node input="researchData">Create and post Twitter-optimized content about Fellou (within character limits, using hashtags)</node>
+        <node output="twitterResults">Capture Twitter post URL and initial engagement metrics</node>
+      </nodes>
+    </agent>
+    <agent name="Browser" id="2" dependsOn="0">
+      <task>Share Fellou's summary and collected interaction data on Facebook</task>
+      <nodes>
+        <node>Navigate to Facebook platform</node>
+        <node input="researchData">Create and post Facebook-optimized content about Fellou (longer format, engaging description)</node>
+        <node output="facebookResults">Capture Facebook post URL and initial engagement metrics</node>
+      </nodes>
+    </agent>
+    <agent name="Browser" id="3" dependsOn="0">
+      <task>Share Fellou's summary and collected interaction data on Reddit</task>
+      <nodes>
+        <node>Navigate to Reddit platform</node>
+        <node input="researchData">Find appropriate subreddit and create Reddit-optimized post about Fellou (community-focused, informative)</node>
+        <node output="redditResults">Capture Reddit post URL and initial engagement metrics</node>
+      </nodes>
+    </agent>
+    <agent name="File" id="4" dependsOn="1,2,3">
+      <task>Compile social media results into Excel file</task>
+      <nodes>
+        <node input="twitterResults,facebookResults,redditResults">Create Excel file with social media campaign results</node>
+        <node>Include columns for Platform, Post URL, Content Summary, Timestamp, Initial Likes/Shares/Comments</node>
+        <node>Format the Excel file with proper headers and styling</node>
+        <node>Save the file as 'Fellou_Social_Media_Campaign_Results.xlsx'</node>
+      </nodes>
+    </agent>
+  </agents>
+</agents>
 </root>`,
 ];
 const PLAN_USER_TEMPLATE = `
@@ -18918,7 +19038,7 @@ async function getPlanSystemPrompt(context) {
                 "\n</agent>\n\n";
     }
     let plan_example_list = context.variables.get("plan_example_list") || PLAN_EXAMPLE_LIST;
-    let hasChatAgent = context.agents.filter((a) => a.Name == AGENT_NAME$5).length > 0;
+    let hasChatAgent = context.agents.filter((a) => a.Name == AGENT_NAME$4).length > 0;
     let example_prompt = "";
     const example_list = hasChatAgent
         ? [PLAN_CHAT_EXAMPLE, ...plan_example_list]
@@ -18951,9 +19071,10 @@ function getPlanUserPrompt(task_prompt, task_website, ext_prompt) {
 }
 
 class Planner {
-    constructor(context, taskId) {
+    constructor(context, callback) {
         this.context = context;
-        this.taskId = taskId || context.taskId;
+        this.taskId = context.taskId;
+        this.callback = callback || context.config.callback;
     }
     async plan(taskPrompt, saveHistory = true) {
         let taskPromptStr;
@@ -19017,7 +19138,7 @@ class Planner {
         let thinkingText = "";
         try {
             while (true) {
-                await this.context.checkAborted();
+                await this.context.checkAborted(true);
                 const { done, value } = await reader.read();
                 if (done) {
                     break;
@@ -19033,10 +19154,10 @@ class Planner {
                 if (chunk.type == "text-delta") {
                     streamText += chunk.textDelta || "";
                 }
-                if (config.callback) {
+                if (this.callback) {
                     let workflow = parseWorkflow(this.taskId, streamText, false, thinkingText);
                     if (workflow) {
-                        await config.callback.onMessage({
+                        await this.callback.onMessage({
                             taskId: this.taskId,
                             agentName: "Planer",
                             type: "workflow",
@@ -19059,8 +19180,8 @@ class Planner {
             chain.planResult = streamText;
         }
         let workflow = parseWorkflow(this.taskId, streamText, true, thinkingText);
-        if (config.callback) {
-            await config.callback.onMessage({
+        if (this.callback) {
+            await this.callback.onMessage({
                 taskId: this.taskId,
                 agentName: "Planer",
                 type: "workflow",
@@ -19078,6 +19199,163 @@ class Planner {
     }
 }
 
+function buildAgentTree(agents) {
+    // Detect and handle circular dependencies
+    const safeAgents = detectAndBreakCycles(agents);
+    if (safeAgents.length === 0) {
+        throw new Error("No executable agent");
+    }
+    // Establish dependency relationship mapping
+    const agentMap = new Map();
+    const dependents = new Map();
+    for (const agent of safeAgents) {
+        agentMap.set(agent.id, agent);
+        dependents.set(agent.id, []);
+    }
+    for (const agent of safeAgents) {
+        for (const depId of agent.dependsOn) {
+            if (dependents.has(depId)) {
+                dependents.get(depId).push(agent);
+            }
+        }
+    }
+    let entryAgents = safeAgents.filter((agent) => agent.dependsOn.length === 0);
+    if (entryAgents.length === 0) {
+        entryAgents = safeAgents.filter((agent) => agent.dependsOn.length == 1 && agent.dependsOn[0].endsWith("00"));
+    }
+    const processedAgents = new Set();
+    function buildNodeRecursive(currentAgents) {
+        if (currentAgents.length === 0) {
+            return undefined;
+        }
+        for (const agent of currentAgents) {
+            processedAgents.add(agent.id);
+        }
+        const nextLevelAgents = [];
+        const nextLevelSet = new Set();
+        for (const agent of currentAgents) {
+            const dependentAgents = dependents.get(agent.id) || [];
+            for (const dependentAgent of dependentAgents) {
+                const allDependenciesProcessed = dependentAgent.dependsOn.every((depId) => processedAgents.has(depId));
+                if (allDependenciesProcessed && !nextLevelSet.has(dependentAgent.id)) {
+                    nextLevelAgents.push(dependentAgent);
+                    nextLevelSet.add(dependentAgent.id);
+                }
+            }
+        }
+        const nextNode = buildNodeRecursive(nextLevelAgents);
+        if (currentAgents.length === 1) {
+            return {
+                type: "normal",
+                agent: currentAgents[0],
+                nextAgent: nextNode,
+            };
+        }
+        else {
+            const parallelNodes = currentAgents.map((agent) => ({
+                type: "normal",
+                agent: agent,
+                nextAgent: undefined,
+            }));
+            return {
+                type: "parallel",
+                agents: parallelNodes,
+                nextAgent: nextNode,
+            };
+        }
+    }
+    const rootNode = buildNodeRecursive(entryAgents);
+    if (!rootNode) {
+        throw new Error("Unable to build execution tree");
+    }
+    return rootNode;
+}
+function detectAndBreakCycles(agents) {
+    // Detect cyclic dependencies and return a safe dependency relationship
+    // Use topological sorting algorithm to detect cycles, if a cycle is found, break some dependencies.
+    const agentMap = new Map();
+    const inDegree = new Map();
+    const adjList = new Map();
+    for (const agent of agents) {
+        agentMap.set(agent.id, agent);
+        inDegree.set(agent.id, 0);
+        adjList.set(agent.id, []);
+    }
+    for (const agent of agents) {
+        for (const depId of agent.dependsOn) {
+            if (agentMap.has(depId)) {
+                // depId -> agent.id indicates that the agent depends on depId.
+                adjList.get(depId).push(agent.id);
+                inDegree.set(agent.id, inDegree.get(agent.id) + 1);
+            }
+        }
+    }
+    // Topological Sorting Detects Cycles
+    const queue = [];
+    const processedCount = new Map();
+    for (const [agentId, degree] of inDegree.entries()) {
+        if (degree === 0) {
+            queue.push(agentId);
+        }
+        processedCount.set(agentId, 0);
+    }
+    let processedNodes = 0;
+    while (queue.length > 0) {
+        const currentId = queue.shift();
+        processedNodes++;
+        for (const neighborId of adjList.get(currentId)) {
+            const newInDegree = inDegree.get(neighborId) - 1;
+            inDegree.set(neighborId, newInDegree);
+            if (newInDegree === 0) {
+                queue.push(neighborId);
+            }
+        }
+    }
+    if (processedNodes < agents.length) {
+        console.warn("Detected a circular dependency, automatically disconnecting the circular link...");
+        const cyclicNodes = new Set();
+        for (const [agentId, degree] of inDegree.entries()) {
+            if (degree > 0) {
+                cyclicNodes.add(agentId);
+            }
+        }
+        const fixedAgents = [];
+        for (const agent of agents) {
+            if (cyclicNodes.has(agent.id)) {
+                const filteredDependsOn = agent.dependsOn.filter((depId) => !cyclicNodes.has(depId) || !agentMap.has(depId));
+                // Preserve the shortest path dependency
+                if (filteredDependsOn.length === 0 && agent.dependsOn.length > 0) {
+                    const firstValidDep = agent.dependsOn.find((depId) => agentMap.has(depId));
+                    if (firstValidDep && !cyclicNodes.has(firstValidDep)) {
+                        filteredDependsOn.push(firstValidDep);
+                    }
+                }
+                fixedAgents.push({
+                    ...agent,
+                    dependsOn: filteredDependsOn,
+                });
+                if (filteredDependsOn.length !== agent.dependsOn.length) {
+                    console.warn(`The partial cyclic dependency of agent ${agent.id} has been disconnected.`);
+                }
+            }
+            else {
+                // Non-cyclic node, filter out non-existent dependencies
+                const validDependsOn = agent.dependsOn.filter((depId) => agentMap.has(depId));
+                fixedAgents.push({
+                    ...agent,
+                    dependsOn: validDependsOn,
+                });
+            }
+        }
+        return fixedAgents;
+    }
+    // No loops, just need to filter out non-existent dependencies
+    return agents.map((agent) => ({
+        ...agent,
+        dependsOn: agent.dependsOn.filter((depId) => agentMap.has(depId)),
+    }));
+}
+
 class Eko {
     constructor(config) {
         this.config = config;
@@ -19085,18 +19363,18 @@ class Eko {
     }
     async generate(taskPrompt, taskId = uuidv4(), contextParams) {
         const agents = [...(this.config.agents || [])];
-        let chain = new Chain(taskPrompt);
-        let context = new Context(taskId, this.config, agents, chain);
+        const chain = new Chain(taskPrompt);
+        const context = new Context(taskId, this.config, agents, chain);
         if (contextParams) {
             Object.keys(contextParams).forEach((key) => context.variables.set(key, contextParams[key]));
         }
         try {
             this.taskMap.set(taskId, context);
             if (this.config.a2aClient) {
-                let a2aList = await this.config.a2aClient.listAgents(taskPrompt);
+                const a2aList = await this.config.a2aClient.listAgents(taskPrompt);
                 context.agents = mergeAgents(context.agents, a2aList);
             }
-            let planner = new Planner(context, taskId);
+            const planner = new Planner(context);
             context.workflow = await planner.plan(taskPrompt);
             return context.workflow;
         }
@@ -19106,20 +19384,20 @@ class Eko {
         }
     }
     async modify(taskId, modifyTaskPrompt) {
-        let context = this.taskMap.get(taskId);
+        const context = this.taskMap.get(taskId);
         if (!context) {
             return await this.generate(modifyTaskPrompt, taskId);
         }
         if (this.config.a2aClient) {
-            let a2aList = await this.config.a2aClient.listAgents(modifyTaskPrompt);
+            const a2aList = await this.config.a2aClient.listAgents(modifyTaskPrompt);
             context.agents = mergeAgents(context.agents, a2aList);
         }
-        let planner = new Planner(context, taskId);
+        const planner = new Planner(context);
         context.workflow = await planner.replan(modifyTaskPrompt);
         return context.workflow;
     }
     async execute(taskId) {
-        let context = this.getTask(taskId);
+        const context = this.getTask(taskId);
         if (!context) {
             throw new Error("The task does not exist");
         }
@@ -19149,10 +19427,10 @@ class Eko {
     }
     async initContext(workflow, contextParams) {
         const agents = this.config.agents || [];
-        let chain = new Chain(workflow.taskPrompt || workflow.name);
-        let context = new Context(workflow.taskId, this.config, agents, chain);
+        const chain = new Chain(workflow.taskPrompt || workflow.name);
+        const context = new Context(workflow.taskId, this.config, agents, chain);
         if (this.config.a2aClient) {
-            let a2aList = await this.config.a2aClient.listAgents(workflow.taskPrompt || workflow.name);
+            const a2aList = await this.config.a2aClient.listAgents(workflow.taskPrompt || workflow.name);
             context.agents = mergeAgents(context.agents, a2aList);
         }
         if (contextParams) {
@@ -19163,30 +19441,72 @@ class Eko {
         return context;
     }
     async doRunWorkflow(context) {
-        let agents = context.agents;
-        let workflow = context.workflow;
+        const agents = context.agents;
+        const workflow = context.workflow;
         if (!workflow || workflow.agents.length == 0) {
             throw new Error("Workflow error");
         }
-        let agentMap = agents.reduce((map, item) => {
+        const agentNameMap = agents.reduce((map, item) => {
             map[item.Name] = item;
             return map;
         }, {});
-        let results = [];
-        for (let i = 0; i < workflow.agents.length; i++) {
+        let agentTree = buildAgentTree(workflow.agents);
+        const results = [];
+        while (true) {
             await context.checkAborted();
-            let agentNode = workflow.agents[i];
-            let agent = agentMap[agentNode.name];
-            if (!agent) {
-                throw new Error("Unknown Agent: " + agentNode.name);
-            }
-            let agentChain = new AgentChain(agentNode);
-            context.chain.push(agentChain);
-            agent.result = await agent.run(context, agentChain);
-            results.push(agent.result);
-            if (agentNode.name === "Timer") {
+            if (agentTree.type === "normal") {
+                // normal agent
+                const agent = agentNameMap[agentTree.agent.name];
+                if (!agent) {
+                    throw new Error("Unknown Agent: " + agentTree.agent.name);
+                }
+                const agentNode = agentTree.agent;
+                const agentChain = new AgentChain(agentNode);
+                context.chain.push(agentChain);
+                agentTree.result = await agent.run(context, agentChain);
+                results.push(agentTree.result);
+            }
+            else {
+                // parallel agent
+                const parallelAgents = agentTree.agents;
+                const doRunAgent = async (agentNode, index) => {
+                    const agent = agentNameMap[agentNode.agent.name];
+                    if (!agent) {
+                        throw new Error("Unknown Agent: " + agentNode.agent.name);
+                    }
+                    const agentChain = new AgentChain(agentNode.agent);
+                    agentNode.result = await agent.run(context, agentChain);
+                    return { result: agentNode.result, agentChain, index };
+                };
+                let agent_results = [];
+                let agentParallel = context.variables.get("agentParallel");
+                if (agentParallel === undefined) {
+                    agentParallel = config.agentParallel;
+                }
+                if (agentParallel) {
+                    // parallel execution
+                    const parallelResults = await Promise.all(parallelAgents.map((agent, index) => doRunAgent(agent, index)));
+                    parallelResults.sort((a, b) => a.index - b.index);
+                    parallelResults.forEach(({ agentChain }) => {
+                        context.chain.push(agentChain);
+                    });
+                    agent_results = parallelResults.map(({ result }) => result);
+                }
+                else {
+                    // serial execution
+                    for (let i = 0; i < parallelAgents.length; i++) {
+                        const { result, agentChain } = await doRunAgent(parallelAgents[i], i);
+                        context.chain.push(agentChain);
+                        agent_results.push(result);
+                    }
+                }
+                results.push(agent_results.join("\n\n"));
+            }
+            context.conversation.splice(0, context.conversation.length);
+            if (!agentTree.nextAgent) {
                 break;
             }
+            agentTree = agentTree.nextAgent;
         }
         return {
             success: true,
@@ -19222,7 +19542,7 @@ class Eko {
         }
     }
     pauseTask(taskId, pause, abortCurrentStep, reason) {
-        let context = this.taskMap.get(taskId);
+        const context = this.taskMap.get(taskId);
         if (context) {
             this.onTaskStatus(context, pause ? "pause" : "resume-pause", reason);
             context.setPause(pause, abortCurrentStep);
@@ -19233,7 +19553,7 @@ class Eko {
         }
     }
     chatTask(taskId, userPrompt) {
-        let context = this.taskMap.get(taskId);
+        const context = this.taskMap.get(taskId);
         if (context) {
             context.conversation.push(userPrompt);
             return context.conversation;
@@ -19476,7 +19796,7 @@ function parseChunk(chunk) {
     return chunk_obj;
 }
 
-const AGENT_NAME$4 = "File";
+const AGENT_NAME$3 = "File";
 class BaseFileAgent extends Agent {
     constructor(work_path, llms, ext_tools, mcpClient, planDescription) {
         const _tools_ = [];
@@ -19484,7 +19804,7 @@ class BaseFileAgent extends Agent {
             ? `Your default working path is: ${work_path}`
             : "";
         super({
-            name: AGENT_NAME$4,
+            name: AGENT_NAME$3,
             description: `You are a file agent, handling file-related tasks such as creating, finding, reading, modifying files, etc.${prompt}`,
             tools: _tools_,
             llms: llms,
@@ -19636,7 +19956,7 @@ class BaseFileAgent extends Agent {
                         },
                         glob: {
                             type: "string",
-                            description: "Filename pattern using glob syntax wildcards",
+                            description: "Filename pattern using glob syntax wildcards, Example: **/*.txt",
                         },
                     },
                     required: ["path", "glob"],
@@ -19649,12 +19969,12 @@ class BaseFileAgent extends Agent {
     }
 }
 
-const AGENT_NAME$3 = "Shell";
+const AGENT_NAME$2 = "Shell";
 class BaseShellAgent extends Agent {
     constructor(llms, ext_tools, mcpClient, planDescription) {
         const _tools_ = [];
         super({
-            name: AGENT_NAME$3,
+            name: AGENT_NAME$2,
             description: `Run commands in a bash shell,
 * You must first call create_session to create a new session when using it for the first time.
 * Please execute delete commands with caution, and never perform dangerous operations like \`rm -rf /\`.
@@ -19731,47 +20051,6 @@ class BaseShellAgent extends Agent {
     }
 }
 
-const AGENT_NAME$2 = "Timer";
-class BaseTimerAgent extends Agent {
-    constructor(llms, ext_tools, mcpClient) {
-        super({
-            name: AGENT_NAME$2,
-            description: "You are a scheduled task scheduling agent.",
-            tools: ext_tools || [],
-            llms: llms,
-            mcpClient: mcpClient,
-        });
-        this.addTool(this.schedule_tool());
-    }
-    schedule_tool() {
-        return {
-            name: "task_schedule",
-            description: "Task scheduled trigger, the task is triggered at a scheduled time and will automatically create a scheduled task for execution.",
-            parameters: {
-                type: "object",
-                properties: {
-                    trigger_description: {
-                        type: "string",
-                        description: "Trigger time description.",
-                    },
-                    task_description: {
-                        type: "string",
-                        description: "Main task description, excluding trigger time.",
-                    },
-                    cron: {
-                        type: "string",
-                        description: "The cron expression of the trigger, for example, '0 9 * * *' indicates that it triggers at 9 a.m. every day.",
-                    },
-                },
-                required: ["cron"],
-            },
-            execute: async (args, agentContext) => {
-                return await this.callInnerTool(() => this.task_schedule(agentContext, args.trigger_description, args.task_description, args.cron));
-            },
-        };
-    }
-}
-
 const AGENT_NAME$1 = "Computer";
 class BaseComputerAgent extends Agent {
     constructor(llms, ext_tools, mcpClient, keyboardKeys) {
@@ -21968,7 +22247,6 @@ exports.BaseChatAgent = BaseChatAgent;
 exports.BaseComputerAgent = BaseComputerAgent;
 exports.BaseFileAgent = BaseFileAgent;
 exports.BaseShellAgent = BaseShellAgent;
-exports.BaseTimerAgent = BaseTimerAgent;
 exports.Chain = Chain;
 exports.Context = Context;
 exports.Eko = Eko;
@@ -21981,6 +22259,7 @@ exports.SimpleSseMcpClient = SimpleSseMcpClient;
 exports.TaskNodeStatusTool = TaskNodeStatusTool;
 exports.VariableStorageTool = VariableStorageTool;
 exports.WatchTriggerTool = WatchTriggerTool;
+exports.buildAgentTree = buildAgentTree;
 exports.buildSimpleAgentWorkflow = buildSimpleAgentWorkflow;
 exports.call_timeout = call_timeout;
 exports.config = config;