test-wuying-agentbay-sdk 0.13.1-beta.20251223203147 → 0.13.1-beta.20251224094729

package/dist/index.mjs

@@ -2325,11 +2325,20 @@ var LOG_LEVEL_VALUES = {
 };
 var currentRequestId = "";
 var currentLogLevel = process.env.LOG_LEVEL || process.env.AGENTBAY_LOG_LEVEL || "INFO";
+var currentLogFormat = process.env.AGENTBAY_LOG_FORMAT || "pretty";
+if (["sls", "compact"].includes(String(currentLogFormat).toLowerCase())) {
+  currentLogFormat = "sls";
+} else {
+  currentLogFormat = "pretty";
+}
 var fileLoggingEnabled = false;
 var logFilePath = null;
 var logFileMaxSize = 10 * 1024 * 1024;
 var consoleLoggingEnabled = true;
 function shouldUseColors() {
+  if (currentLogFormat === "sls") {
+    return false;
+  }
   if (process.env.DISABLE_COLORS === "true") {
     return false;
   }
@@ -2371,6 +2380,9 @@ var SENSITIVE_FIELDS = [
   "authorization"
 ];
 function getLogLevelEmoji(level) {
+  if (currentLogFormat === "sls") {
+    return level;
+  }
   switch (level) {
     case "DEBUG":
       return "\u{1F41B} DEBUG";
@@ -2390,6 +2402,13 @@ function shouldLog(level) {
 }
 __name(shouldLog, "shouldLog");
 function formatLogMessage(level, message, forFile = false) {
+  if (currentLogFormat === "sls") {
+    let formattedMessage2 = `${level}: ${message}`;
+    if (currentRequestId) {
+      formattedMessage2 += ` [RequestId=${currentRequestId}]`;
+    }
+    return formattedMessage2;
+  }
   let formattedMessage = `${getLogLevelEmoji(level)}: ${message}`;
   if (currentRequestId) {
     formattedMessage += ` [RequestId=${currentRequestId}]`;
@@ -2537,6 +2556,23 @@ function setupLogger(config) {
   if (config.enableConsole !== void 0) {
     consoleLoggingEnabled = config.enableConsole;
   }
+  if (config.format) {
+    if (["sls", "compact"].includes(String(config.format).toLowerCase())) {
+      currentLogFormat = "sls";
+    } else {
+      currentLogFormat = "pretty";
+    }
+  } else {
+    const envFormat = process.env.AGENTBAY_LOG_FORMAT;
+    if (envFormat) {
+      if (["sls", "compact"].includes(String(envFormat).toLowerCase())) {
+        currentLogFormat = "sls";
+      } else {
+        currentLogFormat = "pretty";
+      }
+    }
+  }
+  useColors = shouldUseColors();
 }
 __name(setupLogger, "setupLogger");
 function log(message, ...args) {
@@ -2644,6 +2680,22 @@ ${error.stack}`;
 __name(logError, "logError");
 function logAPICall(apiName, requestData) {
   if (!shouldLog("INFO")) return;
+  if (currentLogFormat === "sls") {
+    let message2 = `API Call: ${apiName}`;
+    if (requestData) {
+      const maskedData = maskSensitiveData(requestData);
+      if (typeof maskedData === "string") {
+        message2 += `, ${maskedData}`;
+      } else {
+        message2 += `, ${JSON.stringify(maskedData)}`;
+      }
+    }
+    if (consoleLoggingEnabled) {
+      process.stdout.write(message2 + "\n");
+    }
+    writeToFile(message2);
+    return;
+  }
   const message = `\u{1F517} API Call: ${apiName}`;
   const savedRequestId = currentRequestId;
   currentRequestId = "";
@@ -2661,6 +2713,35 @@ function logAPICall(apiName, requestData) {
 }
 __name(logAPICall, "logAPICall");
 function logAPIResponseWithDetails(apiName, requestId, success = true, keyFields, fullResponse) {
+  if (currentLogFormat === "sls") {
+    if (!shouldLog(success ? "INFO" : "ERROR")) return;
+    const status = success ? "API Response" : "API Response Failed";
+    let msg = `${status}: ${apiName}`;
+    if (requestId) {
+      msg += `, RequestId=${requestId}`;
+    }
+    if (keyFields) {
+      for (const [key, value] of Object.entries(keyFields)) {
+        const maskedValue = maskSensitiveData({ [key]: value });
+        msg += `, ${key}=${maskedValue[key]}`;
+      }
+    }
+    if (success) {
+      if (consoleLoggingEnabled) {
+        process.stdout.write(msg + "\n");
+      }
+      writeToFile(msg);
+    } else {
+      if (consoleLoggingEnabled) {
+        process.stderr.write(msg + "\n");
+      }
+      writeToFile(msg);
+    }
+    if (fullResponse && shouldLog("DEBUG")) {
+      logDebug(`Full Response: ${fullResponse}`);
+    }
+    return;
+  }
   if (success) {
     if (shouldLog("INFO")) {
       let mainMessage = `\u2705 API Response: ${apiName}`;
@@ -2732,6 +2813,16 @@ function logCodeExecutionOutput(requestId, rawOutput) {
       return;
     }
     const actualOutput = texts.join("");
+    if (currentLogFormat === "sls") {
+      const header2 = `Code Execution Output (RequestID: ${requestId}):`;
+      if (consoleLoggingEnabled) {
+        process.stdout.write(header2 + "\n");
+        process.stdout.write(actualOutput + "\n");
+      }
+      writeToFile(header2);
+      writeToFile(actualOutput);
+      return;
+    }
     const header = `\u{1F4CB} Code Execution Output (RequestID: ${requestId}):`;
     if (useColors) {
       process.stdout.write(`${ANSI_GREEN}\u2139\uFE0F  INFO: ${header}${ANSI_RESET}
@@ -2761,6 +2852,10 @@ function logCodeExecutionOutput(requestId, rawOutput) {
 __name(logCodeExecutionOutput, "logCodeExecutionOutput");
 function logInfoWithColor(message, color = ANSI_RED) {
   if (!shouldLog("INFO")) return;
+  if (currentLogFormat === "sls") {
+    logInfo(message);
+    return;
+  }
   const emoji = "\u2139\uFE0F  INFO";
   const fullMessage = `${emoji}: ${message}`;
   if (useColors) {
@@ -3886,41 +3981,35 @@ init_esm_shims();
 
 // src/agent/agent.ts
 init_esm_shims();
-var _ComputerUseAgent = class _ComputerUseAgent {
-  /**
-   * Initialize an Computer Agent object.
-   *
-   * @param session - The Session instance that this Agent belongs to.
-   */
+var _BaseTaskAgent = class _BaseTaskAgent {
   constructor(session) {
     this.session = session;
   }
+  /**
+   * Get the full MCP tool name based on prefix and action.
+   */
+  getToolName(action) {
+    const toolMap = {
+      execute: "execute_task",
+      get_status: "get_task_status",
+      terminate: "terminate_task"
+    };
+    const baseName = toolMap[action] || action;
+    if (this.toolPrefix) {
+      return `${this.toolPrefix}_${baseName}`;
+    }
+    return baseName;
+  }
   /**
    * Execute a specific task described in human language.
-   *
-   * @param task - Task description in human language.
-   * @param maxTryTimes - Maximum number of retry attempts.
-   * @returns ExecutionResult containing success status, task output, and error
-   *     message if any.
-   *
-   * @example
-   * ```typescript
-   * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
-   * const result = await agentBay.create({ imageId: 'windows_latest' });
-   * if (result.success) {
-   *   const taskResult = await result.session.agent.computer.executeTask(
-   *     'Open notepad',
-   *     10
-   *   );
-   *   console.log(`Task status: ${taskResult.taskStatus}`);
-   *   await result.session.delete();
-   * }
-   * ```
    */
   async executeTask(task, maxTryTimes) {
     try {
       const args = { task, max_try_times: maxTryTimes };
-      const result = await this.session.callMcpTool("flux_execute_task", args);
+      const result = await this.session.callMcpTool(
+        this.getToolName("execute"),
+        args
+      );
       if (!result.success) {
         return {
           requestId: result.requestId,
@@ -3944,7 +4033,7 @@ var _ComputerUseAgent = class _ComputerUseAgent {
           taskResult: "Invalid execution response."
         };
       }
-      const taskId = content.task_id;
+      const taskId = content.taskId || content.task_id;
       if (!taskId) {
         return {
           requestId: result.requestId,
@@ -3969,13 +4058,13 @@ var _ComputerUseAgent = class _ComputerUseAgent {
           };
         }
         switch (query.taskStatus) {
-          case "finished":
+          case "completed":
             return {
               requestId: query.requestId,
               success: true,
               errorMessage: "",
               taskId,
-              taskStatus: "finished",
+              taskStatus: "completed",
               taskResult: query.taskProduct
             };
           case "failed":
@@ -3987,6 +4076,15 @@ var _ComputerUseAgent = class _ComputerUseAgent {
               taskStatus: "failed",
               taskResult: ""
             };
+          case "cancelled":
+            return {
+              requestId: query.requestId,
+              success: false,
+              errorMessage: query.errorMessage || "Task was cancelled.",
+              taskId,
+              taskStatus: "cancelled",
+              taskResult: ""
+            };
           case "unsupported":
             return {
               requestId: query.requestId,
@@ -4022,32 +4120,20 @@ var _ComputerUseAgent = class _ComputerUseAgent {
   }
   /**
    * Get the status of the task with the given task ID.
-   *
-   * @param taskId - Task ID
-   * @returns QueryResult containing the task status
-   *
-   * @example
-   * ```typescript
-   * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
-   * const result = await agentBay.create({ imageId: 'windows_latest' });
-   * if (result.success) {
-   *   const taskResult = await result.session.agent.computer.executeTask('Open
-   * calculator', 10); const statusResult = await
-   * result.session.agent.computer.getTaskStatus(taskResult.taskId);
-   * console.log(`Status:
-   * ${JSON.parse(statusResult.output).status}`); await result.session.delete();
-   * }
-   * ```
    */
   async getTaskStatus(taskId) {
     try {
       const args = { task_id: taskId };
-      const result = await this.session.callMcpTool("flux_get_task_status", args);
+      const result = await this.session.callMcpTool(
+        this.getToolName("get_status"),
+        args
+      );
       if (!result.success) {
         return {
           requestId: result.requestId,
           success: false,
           errorMessage: result.errorMessage,
+          taskId,
           taskAction: "",
           taskProduct: "",
           taskStatus: "failed"
@@ -4056,19 +4142,27 @@ var _ComputerUseAgent = class _ComputerUseAgent {
       let queryResult;
       try {
         queryResult = JSON.parse(result.data);
+        const contentTaskId = queryResult.taskId || queryResult.task_id || taskId;
+        const taskProduct = queryResult.result || queryResult.product || "";
+        const stream = Array.isArray(queryResult.stream) ? queryResult.stream : void 0;
+        const error = queryResult.error || void 0;
         return {
           requestId: result.requestId,
           success: true,
           errorMessage: "",
+          taskId: contentTaskId,
           taskAction: queryResult.action || "",
-          taskProduct: queryResult.product || "",
-          taskStatus: queryResult.status || "failed"
+          taskProduct,
+          taskStatus: queryResult.status || "completed",
+          stream,
+          error
         };
       } catch (error) {
         return {
           requestId: result.requestId,
           success: false,
           errorMessage: `Failed to get task status: ${error}`,
+          taskId,
           taskAction: "",
           taskProduct: "",
           taskStatus: "failed"
@@ -4079,6 +4173,7 @@ var _ComputerUseAgent = class _ComputerUseAgent {
         requestId: "",
         success: false,
         errorMessage: `Failed to get task status: ${error}`,
+        taskId,
         taskAction: "",
         taskProduct: "",
         taskStatus: "failed"
@@ -4087,33 +4182,15 @@ var _ComputerUseAgent = class _ComputerUseAgent {
   }
   /**
    * Terminate a task with a specified task ID.
-   *
-   * @param taskId - The ID of the running task.
-   * @returns ExecutionResult containing success status, task output, and
-   *     error message if any.
-   *
-   * @example
-   * ```typescript
-   * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
-   * const result = await agentBay.create({ imageId: 'windows_latest' });
-   * if (result.success) {
-   *   const taskResult = await result.session.agent.computer.executeTask(
-   *     'Open notepad',
-   *     5
-   *   );
-   *   const terminateResult = await result.session.agent.computer.terminateTask(
-   *     taskResult.taskId
-   *   );
-   *   console.log(`Terminated: ${terminateResult.taskStatus}`);
-   *   await result.session.delete();
-   * }
-   * ```
    */
   async terminateTask(taskId) {
     logDebug("Terminating task");
     try {
       const args = { task_id: taskId };
-      const result = await this.session.callMcpTool("flux_terminate_task", args);
+      const result = await this.session.callMcpTool(
+        this.getToolName("terminate"),
+        args
+      );
       let content;
       try {
         content = JSON.parse(result.data);
@@ -4127,8 +4204,8 @@ var _ComputerUseAgent = class _ComputerUseAgent {
           taskResult: ""
         };
       }
-      const terminatedTaskId = content.task_id || taskId;
-      const status = content.status || "unknown";
+      const terminatedTaskId = content.taskId || content.task_id || taskId;
+      const status = content.status || "cancelling";
       if (result.success) {
         return {
           requestId: result.requestId,
@@ -4159,17 +4236,20 @@ var _ComputerUseAgent = class _ComputerUseAgent {
     }
   }
 };
+__name(_BaseTaskAgent, "BaseTaskAgent");
+var BaseTaskAgent = _BaseTaskAgent;
+var _ComputerUseAgent = class _ComputerUseAgent extends (BaseTaskAgent.default || BaseTaskAgent) {
+  constructor() {
+    super(...arguments);
+    this.toolPrefix = "flux";
+  }
+};
 __name(_ComputerUseAgent, "ComputerUseAgent");
 var ComputerUseAgent = _ComputerUseAgent;
-var _BrowserUseAgent = class _BrowserUseAgent {
-  /**
-   * Initialize an Browser Agent object.
-   * @description Browser Use Agent is in BETA ⚠️ .
-   *
-   * @param session - The Session instance that this Agent belongs to.
-   */
-  constructor(session) {
-    this.session = session;
+var _BrowserUseAgent = class _BrowserUseAgent extends (BaseTaskAgent.default || BaseTaskAgent) {
+  constructor() {
+    super(...arguments);
+    this.toolPrefix = "browser_use";
   }
   /**
    * Initialize the browser agent with specific options.
@@ -4214,276 +4294,345 @@ var _BrowserUseAgent = class _BrowserUseAgent {
       };
     }
   }
+};
+__name(_BrowserUseAgent, "BrowserUseAgent");
+var BrowserUseAgent = _BrowserUseAgent;
+var _MobileUseAgent = class _MobileUseAgent extends (BaseTaskAgent.default || BaseTaskAgent) {
+  constructor() {
+    super(...arguments);
+    this.toolPrefix = "";
+  }
   /**
-   * Execute a specific task described in human language.
+   * Execute a task in human language without waiting for completion
+   * (non-blocking). This is a fire-and-return interface that immediately
+   * provides a task ID. Call getTaskStatus to check the task status.
    *
    * @param task - Task description in human language.
-   * @param maxTryTimes - Maximum number of retry attempts.
-   * @returns ExecutionResult containing success status, task output, and
-   *     error message if any.
+   * @param maxSteps - Maximum number of steps (clicks/swipes/etc.) allowed.
+   *                   Used to prevent infinite loops or excessive resource
+   *                   consumption. Default is 50.
+   * @param maxStepRetries - Maximum retry times for MCP tool call failures
+   *                         at SDK level. Used to retry when callMcpTool fails
+   *                         (e.g., network errors, timeouts). Default is 3.
+   * @returns ExecutionResult containing success status, task ID, task status,
+   *     and error message if any.
    *
    * @example
    * ```typescript
    * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
-   * const result = await agentBay.create({ imageId: 'linux_latest' });
+   * const result = await agentBay.create({ imageId: 'mobile_latest' });
    * if (result.success) {
-   *   const taskResult = await result.session.agent.browser.executeTask(
-   *     'Navigate to baidu and query the weather of Shanghai',
-   *     10
+   *   const execResult = await result.session.agent.mobile.executeTask(
+   *     'Open WeChat app', 100, 5
    *   );
-   *   console.log(`Task status: ${taskResult.taskStatus}`);
+   *   console.log(`Task ID: ${execResult.taskId}`);
    *   await result.session.delete();
    * }
    * ```
    */
-  async executeTask(task, maxTryTimes) {
-    try {
-      const args = { task, max_try_times: maxTryTimes };
-      const result = await this.session.callMcpTool("browser_use_execute_task", args);
-      if (!result.success) {
-        return {
-          requestId: result.requestId,
-          success: false,
-          errorMessage: result.errorMessage,
-          taskStatus: "failed",
-          taskId: "",
-          taskResult: "Task Failed"
-        };
-      }
-      let content;
+  async executeTask(task, maxSteps = 50, maxStepRetries = 3) {
+    const args = {
+      task,
+      max_steps: maxSteps
+    };
+    let lastError;
+    let lastRequestId = "";
+    for (let attempt = 0; attempt < maxStepRetries; attempt++) {
       try {
-        content = JSON.parse(result.data);
-      } catch (err) {
-        return {
-          requestId: result.requestId,
-          success: false,
-          errorMessage: `Failed to parse response: ${err}`,
-          taskStatus: "failed",
-          taskId: "",
-          taskResult: "Invalid execution response."
-        };
-      }
-      const taskId = content.task_id;
-      if (!taskId) {
-        return {
-          requestId: result.requestId,
-          success: false,
-          errorMessage: "Task ID not found in response",
-          taskStatus: "failed",
-          taskId: "",
-          taskResult: "Invalid task ID."
-        };
-      }
-      let triedTime = 0;
-      while (triedTime < maxTryTimes) {
-        const query = await this.getTaskStatus(taskId);
-        if (!query.success) {
-          return {
-            requestId: query.requestId,
-            success: false,
-            errorMessage: query.errorMessage,
-            taskStatus: "failed",
-            taskId,
-            taskResult: ""
-          };
-        }
-        switch (query.taskStatus) {
-          case "finished":
+        const result = await this.session.callMcpTool(
+          this.getToolName("execute"),
+          args
+        );
+        lastRequestId = result.requestId;
+        if (result.success) {
+          let content;
+          try {
+            content = JSON.parse(result.data);
+          } catch (err) {
             return {
-              requestId: query.requestId,
-              success: true,
-              errorMessage: "",
-              taskId,
-              taskStatus: "finished",
-              taskResult: query.taskProduct
+              requestId: result.requestId,
+              success: false,
+              errorMessage: `Failed to parse response: ${err}`,
+              taskStatus: "failed",
+              taskId: "",
+              taskResult: "Invalid execution response."
             };
-          case "failed":
+          }
+          const taskId = content.taskId || content.task_id;
+          if (!taskId) {
             return {
-              requestId: query.requestId,
+              requestId: result.requestId,
               success: false,
-              errorMessage: query.errorMessage || "Failed to execute task.",
-              taskId,
+              errorMessage: "Task ID not found in response",
               taskStatus: "failed",
-              taskResult: ""
+              taskId: "",
+              taskResult: "Invalid task ID."
             };
-          case "unsupported":
+          }
+          return {
+            requestId: result.requestId,
+            success: true,
+            errorMessage: "",
+            taskId,
+            taskStatus: "running",
+            taskResult: ""
+          };
+        } else {
+          lastError = result.errorMessage || "Failed to execute task";
+          if (attempt < maxStepRetries - 1) {
+            logDebug(
+              `Attempt ${attempt + 1}/${maxStepRetries} failed, retrying...`
+            );
+            await new Promise((resolve2) => setTimeout(resolve2, 1e3));
+            continue;
+          } else {
             return {
-              requestId: query.requestId,
+              requestId: result.requestId,
               success: false,
-              errorMessage: query.errorMessage || "Unsupported task.",
-              taskId,
-              taskStatus: "unsupported",
-              taskResult: ""
+              errorMessage: lastError,
+              taskStatus: "failed",
+              taskId: "",
+              taskResult: "Task Failed"
             };
+          }
+        }
+      } catch (error) {
+        lastError = `Failed to execute: ${error}`;
+        if (attempt < maxStepRetries - 1) {
+          logDebug(
+            `Attempt ${attempt + 1}/${maxStepRetries} raised exception, retrying...`
+          );
+          await new Promise((resolve2) => setTimeout(resolve2, 1e3));
+          continue;
+        } else {
+          return {
+            requestId: lastRequestId,
+            success: false,
+            errorMessage: lastError,
+            taskStatus: "failed",
+            taskId: "",
+            taskResult: "Task Failed"
+          };
         }
-        logDebug(`Task ${taskId} is still running, please wait for a while.`);
-        await new Promise((resolve2) => setTimeout(resolve2, 3e3));
-        triedTime++;
       }
-      return {
-        requestId: result.requestId,
-        success: false,
-        errorMessage: "Task execution timed out",
-        taskStatus: "timeout",
-        taskId,
-        taskResult: "Task Timed Out"
-      };
-    } catch (error) {
-      return {
-        requestId: "",
-        success: false,
-        errorMessage: `Failed to execute: ${error}`,
-        taskStatus: "failed",
-        taskId: "",
-        taskResult: "Task Failed"
-      };
     }
+    return {
+      requestId: lastRequestId,
+      success: false,
+      errorMessage: `Failed after ${maxStepRetries} attempts: ${lastError || "Unknown error"}`,
+      taskStatus: "failed",
+      taskId: "",
+      taskResult: "Task Failed"
+    };
   }
   /**
-   * Get the status of the task with the given task ID.
+   * Execute a specific task described in human language synchronously.
+   * This is a synchronous interface that blocks until the task is completed or
+   * an error occurs, or timeout happens. The default polling interval is
+   * 3 seconds.
    *
-   * @param taskId - Task ID
-   * @returns QueryResult containing the task status
+   * @param task - Task description in human language.
+   * @param maxSteps - Maximum number of steps (clicks/swipes/etc.) allowed.
+   *                   Used to prevent infinite loops or excessive resource
+   *                   consumption. Default is 50.
+   * @param maxStepRetries - Maximum retry times for MCP tool call failures
+   *                         at SDK level. Used to retry when callMcpTool fails
+   *                         (e.g., network errors, timeouts). Default is 3.
+   * @param maxTryTimes - Maximum number of polling attempts (each 3 seconds).
+   *                      Used to control how long to wait for task completion.
+   *                      Default is 300 (about 15 minutes).
+   * @returns ExecutionResult containing success status, task ID, task status,
+   *     and error message if any.
    *
    * @example
    * ```typescript
    * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
-   * const result = await agentBay.create({ imageId: 'linux_latest' });
+   * const result = await agentBay.create({ imageId: 'mobile_latest' });
    * if (result.success) {
-   *   const taskResult = await result.session.agent.browser.executeTask(
-   *     'Navigate to baidu and query the weather of Shanghai',
-   *     10
+   *   const execResult = await result.session.agent.mobile.executeTaskAndWait(
+   *     'Open WeChat app', 100, 3, 200
    *   );
-   *   const statusResult = await result.session.agent.browser.getTaskStatus(
-   *     taskResult.taskId
-   *   );
-   *   console.log(`Status: ${statusResult.taskStatus}`);
+   *   console.log(`Task result: ${execResult.taskResult}`);
    *   await result.session.delete();
    * }
    * ```
    */
-  async getTaskStatus(taskId) {
-    try {
-      const args = { task_id: taskId };
-      const result = await this.session.callMcpTool("browser_use_get_task_status", args);
-      if (!result.success) {
-        return {
-          requestId: result.requestId,
-          success: false,
-          errorMessage: result.errorMessage,
-          taskAction: "",
-          taskProduct: "",
-          taskStatus: "failed"
-        };
-      }
-      let queryResult;
+  async executeTaskAndWait(task, maxSteps = 50, maxStepRetries = 3, maxTryTimes = 300) {
+    const args = {
+      task,
+      max_steps: maxSteps
+    };
+    let taskId;
+    let lastError;
+    let lastRequestId = "";
+    for (let attempt = 0; attempt < maxStepRetries; attempt++) {
       try {
-        queryResult = JSON.parse(result.data);
-        return {
-          requestId: result.requestId,
-          success: true,
-          errorMessage: "",
-          taskAction: queryResult.action || "",
-          taskProduct: queryResult.product || "",
-          taskStatus: queryResult.status || "failed"
-        };
+        const result = await this.session.callMcpTool(
+          this.getToolName("execute"),
+          args
+        );
+        lastRequestId = result.requestId;
+        if (result.success) {
+          let content;
+          try {
+            content = JSON.parse(result.data);
+          } catch (err) {
+            return {
+              requestId: result.requestId,
+              success: false,
+              errorMessage: `Failed to parse response: ${err}`,
+              taskStatus: "failed",
+              taskId: "",
+              taskResult: "Invalid execution response."
+            };
+          }
+          taskId = content.taskId || content.task_id;
+          if (!taskId) {
+            return {
+              requestId: result.requestId,
+              success: false,
+              errorMessage: "Task ID not found in response",
+              taskStatus: "failed",
+              taskId: "",
+              taskResult: "Invalid task ID."
+            };
+          }
+          break;
+        } else {
+          lastError = result.errorMessage || "Failed to execute task";
+          if (attempt < maxStepRetries - 1) {
+            logDebug(
+              `Attempt ${attempt + 1}/${maxStepRetries} failed, retrying...`
+            );
+            await new Promise((resolve2) => setTimeout(resolve2, 1e3));
+            continue;
+          } else {
+            return {
+              requestId: result.requestId,
+              success: false,
+              errorMessage: lastError,
+              taskStatus: "failed",
+              taskId: "",
+              taskResult: "Task Failed"
+            };
+          }
+        }
       } catch (error) {
-        return {
-          requestId: result.requestId,
-          success: false,
-          errorMessage: `Failed to get task status: ${error}`,
-          taskAction: "",
-          taskProduct: "",
-          taskStatus: "failed"
-        };
+        lastError = `Failed to execute: ${error}`;
+        if (attempt < maxStepRetries - 1) {
+          logDebug(
+            `Attempt ${attempt + 1}/${maxStepRetries} raised exception, retrying...`
+          );
+          await new Promise((resolve2) => setTimeout(resolve2, 1e3));
+          continue;
+        } else {
+          return {
+            requestId: lastRequestId,
+            success: false,
+            errorMessage: lastError,
+            taskStatus: "failed",
+            taskId: "",
+            taskResult: "Task Failed"
+          };
+        }
       }
-    } catch (error) {
+    }
+    if (!taskId) {
       return {
-        requestId: "",
+        requestId: lastRequestId,
         success: false,
-        errorMessage: `Failed to get task status: ${error}`,
-        taskAction: "",
-        taskProduct: "",
-        taskStatus: "failed"
+        errorMessage: `Failed to get task_id after ${maxStepRetries} attempts: ${lastError || "Unknown error"}`,
+        taskStatus: "failed",
+        taskId: "",
+        taskResult: "Task Failed"
       };
     }
-  }
-  /**
-   * Terminate a task with a specified task ID.
-   *
-   * @param taskId - The ID of the running task.
-   * @returns ExecutionResult containing success status, task output, and
-   *     error message if any.
-   *
-   * @example
-   * ```typescript
-   * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
-   * const result = await agentBay.create({ imageId: 'linux_latest' });
-   * if (result.success) {
-   *   const taskResult = await result.session.agent.browser.executeTask(
-   *     'Navigate to baidu and query the weather of Shanghai',
-   *     10
-   *   );
-   *   const terminateResult = await result.session.agent.browser.terminateTask(
-   *     taskResult.taskId
-   *   );
-   *   console.log(`Terminated: ${terminateResult.taskStatus}`);
-   *   await result.session.delete();
-   * }
-   * ```
-   */
-  async terminateTask(taskId) {
-    logDebug("Terminating task");
-    try {
-      const args = { task_id: taskId };
-      const result = await this.session.callMcpTool("browser_use_terminate_task", args);
-      let content;
-      try {
-        content = JSON.parse(result.data);
-      } catch (err) {
+    let triedTime = 0;
+    const processedTimestamps = /* @__PURE__ */ new Set();
+    while (triedTime < maxTryTimes) {
+      const query = await this.getTaskStatus(taskId);
+      if (!query.success) {
         return {
-          requestId: result.requestId,
+          requestId: query.requestId,
           success: false,
-          errorMessage: `Failed to parse response: ${err}`,
-          taskId,
+          errorMessage: query.errorMessage,
           taskStatus: "failed",
+          taskId,
           taskResult: ""
         };
       }
-      const terminatedTaskId = content.task_id || taskId;
-      const status = content.status || "unknown";
-      if (result.success) {
-        return {
-          requestId: result.requestId,
-          success: true,
-          errorMessage: "",
-          taskId: terminatedTaskId,
-          taskStatus: status,
-          taskResult: ""
-        };
+      if (query.stream) {
+        for (const streamItem of query.stream) {
+          const timestamp = streamItem.timestamp_ms;
+          if (timestamp !== void 0 && !processedTimestamps.has(timestamp)) {
+            processedTimestamps.add(timestamp);
+            const content = streamItem.content || "";
+            const reasoning = streamItem.reasoning || "";
+            if (content) {
+              process.stdout.write(content);
+            }
+            if (reasoning) {
+            }
+          }
+        }
       }
-      return {
-        requestId: result.requestId,
-        success: false,
-        errorMessage: result.errorMessage,
-        taskId: terminatedTaskId,
-        taskStatus: status,
-        taskResult: ""
-      };
-    } catch (error) {
-      return {
-        requestId: "",
-        success: false,
-        errorMessage: `Failed to terminate: ${error}`,
-        taskId,
-        taskStatus: "failed",
-        taskResult: ""
-      };
+      if (query.error) {
+      }
+      switch (query.taskStatus) {
+        case "completed":
+          return {
+            requestId: query.requestId,
+            success: true,
+            errorMessage: "",
+            taskId,
+            taskStatus: "completed",
+            taskResult: query.taskProduct
+          };
+        case "failed":
+          return {
+            requestId: query.requestId,
+            success: false,
+            errorMessage: query.errorMessage || "Failed to execute task.",
+            taskId,
+            taskStatus: "failed",
+            taskResult: ""
+          };
+        case "cancelled":
+          return {
+            requestId: query.requestId,
+            success: false,
+            errorMessage: query.errorMessage || "Task was cancelled.",
+            taskId,
+            taskStatus: "cancelled",
+            taskResult: ""
+          };
+        case "unsupported":
+          return {
+            requestId: query.requestId,
+            success: false,
+            errorMessage: query.errorMessage || "Unsupported task.",
+            taskId,
+            taskStatus: "unsupported",
+            taskResult: ""
+          };
+      }
+      logDebug(`\u23F3 Task ${taskId} running \u{1F680}: ${query.taskAction}.`);
+      await new Promise((resolve2) => setTimeout(resolve2, 3e3));
+      triedTime++;
     }
+    logDebug("\u26A0\uFE0F task execution timeout!");
+    return {
+      requestId: lastRequestId,
+      success: false,
+      errorMessage: "Task timeout.",
+      taskStatus: "failed",
+      taskId,
+      taskResult: "Task timeout."
+    };
   }
 };
-__name(_BrowserUseAgent, "BrowserUseAgent");
-var BrowserUseAgent = _BrowserUseAgent;
+__name(_MobileUseAgent, "MobileUseAgent");
+var MobileUseAgent = _MobileUseAgent;
 var _Agent = class _Agent {
   /**
    * Initialize an Agent object.
@@ -4493,6 +4642,7 @@ var _Agent = class _Agent {
   constructor(session) {
     this.computer = new ComputerUseAgent(session);
     this.browser = new BrowserUseAgent(session);
+    this.mobile = new MobileUseAgent(session);
   }
 };
 __name(_Agent, "Agent");