test-wuying-agentbay-sdk 0.13.0-beta.20251210151030 → 0.13.0-beta.20251210170519

package/dist/index.mjs

@@ -3718,9 +3718,9 @@ init_esm_shims();
 
 // src/agent/agent.ts
 init_esm_shims();
-var _Agent = class _Agent {
+var _ComputerUseAgent = class _ComputerUseAgent {
   /**
-   * Initialize an Agent object.
+   * Initialize an Computer Agent object.
    *
    * @param session - The Session instance that this Agent belongs to.
    */
@@ -3732,16 +3732,17 @@ var _Agent = class _Agent {
    *
    * @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.
+   * @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.executeTask('Open notepad', 10);
-   *   console.log(`Task status: ${taskResult.taskStatus}`);
-   *   await result.session.delete();
+   *   const taskResult = await result.session.agent.computer.executeTask('Open
+   * notepad', 10); console.log(`Task status: ${taskResult.taskStatus}`); await
+   * result.session.delete();
    * }
    * ```
    */
@@ -3755,7 +3756,8 @@ var _Agent = class _Agent {
           success: false,
           errorMessage: result.errorMessage,
           taskStatus: "failed",
-          taskId: ""
+          taskId: "",
+          taskResult: "Task Failed"
         };
       }
       let content;
@@ -3767,7 +3769,8 @@ var _Agent = class _Agent {
           success: false,
           errorMessage: `Failed to parse response: ${err}`,
           taskStatus: "failed",
-          taskId: ""
+          taskId: "",
+          taskResult: "Invalid execution response."
         };
       }
       const taskId = content.task_id;
@@ -3777,7 +3780,8 @@ var _Agent = class _Agent {
           success: false,
           errorMessage: "Task ID not found in response",
           taskStatus: "failed",
-          taskId: ""
+          taskId: "",
+          taskResult: "Invalid task ID."
         };
       }
       let triedTime = 0;
@@ -3785,59 +3789,355 @@ var _Agent = class _Agent {
         const query = await this.getTaskStatus(taskId);
         if (!query.success) {
           return {
-            requestId: result.requestId,
+            requestId: query.requestId,
             success: false,
             errorMessage: query.errorMessage,
             taskStatus: "failed",
-            taskId
+            taskId,
+            taskResult: ""
           };
         }
-        let statusContent;
-        try {
-          statusContent = JSON.parse(query.output);
-        } catch (err) {
-          return {
-            requestId: result.requestId,
-            success: false,
-            errorMessage: `Failed to parse status response: ${err}`,
-            taskStatus: "failed",
-            taskId
-          };
+        switch (query.taskStatus) {
+          case "finished":
+            return {
+              requestId: query.requestId,
+              success: true,
+              errorMessage: "",
+              taskId,
+              taskStatus: "finished",
+              taskResult: query.taskProduct
+            };
+          case "failed":
+            return {
+              requestId: query.requestId,
+              success: false,
+              errorMessage: query.errorMessage || "Failed to execute task.",
+              taskId,
+              taskStatus: "failed",
+              taskResult: ""
+            };
+          case "unsupported":
+            return {
+              requestId: query.requestId,
+              success: false,
+              errorMessage: query.errorMessage || "Unsupported task.",
+              taskId,
+              taskStatus: "unsupported",
+              taskResult: ""
+            };
         }
-        const taskStatus = statusContent.status;
-        if (!taskStatus) {
+        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"
+      };
+    }
+  }
+  /**
+   * 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);
+      if (!result.success) {
+        return {
+          requestId: result.requestId,
+          success: false,
+          errorMessage: result.errorMessage,
+          taskAction: "",
+          taskProduct: "",
+          taskStatus: "failed"
+        };
+      }
+      let queryResult;
+      try {
+        queryResult = JSON.parse(result.data);
+        return {
+          requestId: result.requestId,
+          success: true,
+          errorMessage: "",
+          taskAction: queryResult.action || "",
+          taskProduct: queryResult.product || "",
+          taskStatus: queryResult.status || "failed"
+        };
+      } catch (error) {
+        return {
+          requestId: result.requestId,
+          success: false,
+          errorMessage: `Failed to get task status: ${error}`,
+          taskAction: "",
+          taskProduct: "",
+          taskStatus: "failed"
+        };
+      }
+    } catch (error) {
+      return {
+        requestId: "",
+        success: false,
+        errorMessage: `Failed to get task status: ${error}`,
+        taskAction: "",
+        taskProduct: "",
+        taskStatus: "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: '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);
+      let content;
+      try {
+        content = JSON.parse(result.data);
+      } catch (err) {
+        return {
+          requestId: result.requestId,
+          success: false,
+          errorMessage: `Failed to parse response: ${err}`,
+          taskId,
+          taskStatus: "failed",
+          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: ""
+        };
+      }
+      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: ""
+      };
+    }
+  }
+};
+__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;
+  }
+  /**
+   * Initialize the browser agent with specific options.
+   * @param options - agent initialization options
+   * @returns  InitializationResult 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) {
+   *   options:AgentOptions = new AgentOptions(use_vision=False,
+   * output_schema=""); const initResult = await
+   * result.session.agent.browser.initialize(options); console.log(`Initialize
+   * success: ${initResult.success}`); await result.session.delete();
+   * }
+   * ```
+   */
+  async initialize(options) {
+    const args = {
+      use_vision: options.use_vision,
+      output_schema: options.output_schema
+    };
+    try {
+      const result = await this.session.callMcpTool("browser_use_initialize", args);
+      if (!result.success) {
+        return {
+          success: false,
+          errorMessage: result.errorMessage
+        };
+      } else {
+        return {
+          success: true,
+          errorMessage: ""
+        };
+      }
+    } catch (error) {
+      return {
+        success: false,
+        errorMessage: `Failed to initialize: ${error}`
+      };
+    }
+  }
+  /**
+   * 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: 'linux_latest' });
+   * if (result.success) {
+   *   const taskResult = await
+   * result.session.agent.browser.executeTask('Navigate to baidu and query the
+   * weather of Shanghai', 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("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;
+      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: result.requestId,
+            requestId: query.requestId,
             success: false,
-            errorMessage: "Task status not found in response",
+            errorMessage: query.errorMessage,
             taskStatus: "failed",
-            taskId
+            taskId,
+            taskResult: ""
           };
         }
-        switch (taskStatus) {
+        switch (query.taskStatus) {
           case "finished":
             return {
-              requestId: result.requestId,
+              requestId: query.requestId,
               success: true,
               errorMessage: "",
               taskId,
-              taskStatus
+              taskStatus: "finished",
+              taskResult: query.taskProduct
             };
           case "failed":
             return {
-              requestId: result.requestId,
+              requestId: query.requestId,
               success: false,
-              errorMessage: "Failed to execute task.",
+              errorMessage: query.errorMessage || "Failed to execute task.",
               taskId,
-              taskStatus
+              taskStatus: "failed",
+              taskResult: ""
             };
           case "unsupported":
             return {
-              requestId: result.requestId,
+              requestId: query.requestId,
               success: false,
-              errorMessage: "Unsupported task.",
+              errorMessage: query.errorMessage || "Unsupported task.",
               taskId,
-              taskStatus
+              taskStatus: "unsupported",
+              taskResult: ""
             };
         }
         logDebug(`Task ${taskId} is still running, please wait for a while.`);
@@ -3849,7 +4149,8 @@ var _Agent = class _Agent {
         success: false,
         errorMessage: "Task execution timed out",
         taskStatus: "timeout",
-        taskId
+        taskId,
+        taskResult: "Task Timed Out"
       };
     } catch (error) {
       return {
@@ -3857,7 +4158,8 @@ var _Agent = class _Agent {
         success: false,
         errorMessage: `Failed to execute: ${error}`,
         taskStatus: "failed",
-        taskId: ""
+        taskId: "",
+        taskResult: "Task Failed"
       };
     }
   }
@@ -3872,37 +4174,59 @@ var _Agent = class _Agent {
    * 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.executeTask('Open calculator', 10);
-   *   const statusResult = await result.session.agent.getTaskStatus(taskResult.taskId);
-   *   console.log(`Status: ${JSON.parse(statusResult.output).status}`);
-   *   await result.session.delete();
+   *   const taskResult = await
+   * result.session.agent.browser.executeTask(Navigate to baidu and query the
+   * weather of Shanghai, 10); const statusResult = await
+   * result.session.agent.browser.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("browser_use_get_task_status", args);
       if (!result.success) {
         return {
           requestId: result.requestId,
           success: false,
           errorMessage: result.errorMessage,
-          output: ""
+          taskAction: "",
+          taskProduct: "",
+          taskStatus: "failed"
+        };
+      }
+      let queryResult;
+      try {
+        queryResult = JSON.parse(result.data);
+        return {
+          requestId: result.requestId,
+          success: true,
+          errorMessage: "",
+          taskAction: queryResult.action || "",
+          taskProduct: queryResult.product || "",
+          taskStatus: queryResult.status || "failed"
+        };
+      } catch (error) {
+        return {
+          requestId: result.requestId,
+          success: false,
+          errorMessage: `Failed to get task status: ${error}`,
+          taskAction: "",
+          taskProduct: "",
+          taskStatus: "failed"
         };
       }
-      return {
-        requestId: result.requestId,
-        success: true,
-        output: result.data,
-        errorMessage: ""
-      };
     } catch (error) {
       return {
         requestId: "",
         success: false,
         errorMessage: `Failed to get task status: ${error}`,
-        output: ""
+        taskAction: "",
+        taskProduct: "",
+        taskStatus: "failed"
       };
     }
   }
@@ -3910,15 +4234,18 @@ var _Agent = class _Agent {
    * 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.
+   * @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.executeTask('Open notepad', 5);
-   *   const terminateResult = await result.session.agent.terminateTask(taskResult.taskId);
+   *   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();
    * }
@@ -3928,7 +4255,7 @@ var _Agent = class _Agent {
     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("browser_use_terminate_task", args);
       let content;
       try {
         content = JSON.parse(result.data);
@@ -3938,7 +4265,8 @@ var _Agent = class _Agent {
           success: false,
           errorMessage: `Failed to parse response: ${err}`,
           taskId,
-          taskStatus: "failed"
+          taskStatus: "failed",
+          taskResult: ""
         };
       }
       const terminatedTaskId = content.task_id || taskId;
@@ -3949,7 +4277,8 @@ var _Agent = class _Agent {
           success: true,
           errorMessage: "",
           taskId: terminatedTaskId,
-          taskStatus: status
+          taskStatus: status,
+          taskResult: ""
         };
       }
       return {
@@ -3957,7 +4286,8 @@ var _Agent = class _Agent {
         success: false,
         errorMessage: result.errorMessage,
         taskId: terminatedTaskId,
-        taskStatus: status
+        taskStatus: status,
+        taskResult: ""
       };
     } catch (error) {
       return {
@@ -3965,11 +4295,25 @@ var _Agent = class _Agent {
         success: false,
         errorMessage: `Failed to terminate: ${error}`,
         taskId,
-        taskStatus: "failed"
+        taskStatus: "failed",
+        taskResult: ""
       };
     }
   }
 };
+__name(_BrowserUseAgent, "BrowserUseAgent");
+var BrowserUseAgent = _BrowserUseAgent;
+var _Agent = class _Agent {
+  /**
+   * Initialize an Agent object.
+   *
+   * @param session - The Session instance that this Agent belongs to.
+   */
+  constructor(session) {
+    this.computer = new ComputerUseAgent(session);
+    this.browser = new BrowserUseAgent(session);
+  }
+};
 __name(_Agent, "Agent");
 var Agent = _Agent;
 
@@ -13337,6 +13681,7 @@ export {
   BrowserFingerprintGenerator,
   BrowserOptionClass,
   BrowserProxyClass,
+  BrowserUseAgent,
   CallMcpToolRequest,
   CallMcpToolResponse,
   CallMcpToolResponseBody,
@@ -13347,6 +13692,7 @@ export {
   Code,
   Command,
   Computer,
+  ComputerUseAgent,
   Context,
   ContextManager,
   ContextService,