Add Meta Computer Use agent

src/client.ts

@@ -13,6 +13,7 @@ import { TeamService } from "./services/team";
 import { ComputerActionService } from "./services/computer-action";
 import { GeminiComputerUseService } from "./services/agents/gemini-computer-use";
 import { GrokComputerUseService } from "./services/agents/grok-computer-use";
+import { MetaComputerUseService } from "./services/agents/meta-computer-use";
 import { WebService } from "./services/web";
 import { SandboxesService } from "./services/sandboxes";
 import { VolumesService } from "./services/volumes";
@@ -69,6 +70,7 @@ export class HyperbrowserClient {
     hyperAgent: HyperAgentService;
     geminiComputerUse: GeminiComputerUseService;
     grokComputerUse: GrokComputerUseService;
+    metaComputerUse: MetaComputerUseService;
   };
   public readonly team: TeamService;
   public readonly computerAction: ComputerActionService;
@@ -105,6 +107,7 @@ export class HyperbrowserClient {
       hyperAgent: new HyperAgentService(apiKey, baseUrl, timeout),
       geminiComputerUse: new GeminiComputerUseService(apiKey, baseUrl, timeout),
       grokComputerUse: new GrokComputerUseService(apiKey, baseUrl, timeout),
+      metaComputerUse: new MetaComputerUseService(apiKey, baseUrl, timeout),
     };
   }
 }

src/services/agents/meta-computer-use.ts

@@ -0,0 +1,116 @@
+import { HyperbrowserError } from "../../client";
+import { BasicResponse } from "../../types";
+import { POLLING_ATTEMPTS } from "../../types/constants";
+import { sleep } from "../../utils";
+import { BaseService } from "../base";
+import {
+  MetaComputerUseTaskResponse,
+  MetaComputerUseTaskStatusResponse,
+  StartMetaComputerUseTaskParams,
+  StartMetaComputerUseTaskResponse,
+} from "../../types/agents/meta-computer-use";
+
+export class MetaComputerUseService extends BaseService {
+  /**
+   * Start a new Meta Computer Use task job
+   * @param params The parameters for the task job
+   */
+  async start(params: StartMetaComputerUseTaskParams): Promise<StartMetaComputerUseTaskResponse> {
+    try {
+      return await this.request<StartMetaComputerUseTaskResponse>("/task/meta-computer-use", {
+        method: "POST",
+        body: JSON.stringify(params),
+      });
+    } catch (error) {
+      if (error instanceof HyperbrowserError) {
+        throw error;
+      }
+      throw new HyperbrowserError("Failed to start Meta Computer Use task job", undefined);
+    }
+  }
+
+  /**
+   * Get the status of a Meta Computer Use task job
+   * @param id The ID of the task job to get
+   */
+  async getStatus(id: string): Promise<MetaComputerUseTaskStatusResponse> {
+    try {
+      return await this.request<MetaComputerUseTaskStatusResponse>(
+        `/task/meta-computer-use/${id}/status`
+      );
+    } catch (error) {
+      if (error instanceof HyperbrowserError) {
+        throw error;
+      }
+      throw new HyperbrowserError(
+        `Failed to get Meta Computer Use task job ${id} status`,
+        undefined
+      );
+    }
+  }
+
+  /**
+   * Get the result of a Meta Computer Use task job
+   * @param id The ID of the task job to get
+   */
+  async get(id: string): Promise<MetaComputerUseTaskResponse> {
+    try {
+      return await this.request<MetaComputerUseTaskResponse>(`/task/meta-computer-use/${id}`);
+    } catch (error) {
+      if (error instanceof HyperbrowserError) {
+        throw error;
+      }
+      throw new HyperbrowserError(`Failed to get Meta Computer Use task job ${id}`, undefined);
+    }
+  }
+
+  /**
+   * Stop a Meta Computer Use task job
+   * @param id The ID of the task job to stop
+   */
+  async stop(id: string): Promise<BasicResponse> {
+    try {
+      return await this.request<BasicResponse>(`/task/meta-computer-use/${id}/stop`, {
+        method: "PUT",
+      });
+    } catch (error) {
+      if (error instanceof HyperbrowserError) {
+        throw error;
+      }
+      throw new HyperbrowserError(`Failed to stop Meta Computer Use task job ${id}`, undefined);
+    }
+  }
+
+  /**
+   * Start a Meta Computer Use task job and wait for it to complete
+   * @param params The parameters for the task job
+   */
+  async startAndWait(params: StartMetaComputerUseTaskParams): Promise<MetaComputerUseTaskResponse> {
+    const job = await this.start(params);
+    const jobId = job.jobId;
+    if (!jobId) {
+      throw new HyperbrowserError(
+        "Failed to start Meta Computer Use task job, could not get job ID"
+      );
+    }
+
+    let failures = 0;
+    while (true) {
+      try {
+        const { status } = await this.getStatus(jobId);
+        if (status === "completed" || status === "failed" || status === "stopped") {
+          return await this.get(jobId);
+        }
+        failures = 0;
+      } catch (error) {
+        failures++;
+        if (failures >= POLLING_ATTEMPTS) {
+          throw new HyperbrowserError(
+            `Failed to poll Meta Computer Use task job ${jobId} after ${POLLING_ATTEMPTS} attempts: ${error}`
+          );
+        }
+      }
+      await sleep(2000);
+    }
+  }
+}

src/types/agents/meta-computer-use.ts

@@ -0,0 +1,75 @@
+import { MetaComputerUseLlm, MetaReasoningEffort, MetaComputerUseTaskStatus } from "../constants";
+import { CreateSessionParams } from "../session";
+
+export interface MetaComputerUseApiKeys {
+  meta?: string;
+}
+
+export interface StartMetaComputerUseTaskParams {
+  task: string;
+  llm?: MetaComputerUseLlm;
+  reasoningEffort?: MetaReasoningEffort;
+  sessionId?: string;
+  maxFailures?: number;
+  maxSteps?: number;
+  keepBrowserOpen?: boolean;
+  sessionOptions?: CreateSessionParams;
+  useCustomApiKeys?: boolean;
+  apiKeys?: MetaComputerUseApiKeys;
+  useComputerAction?: boolean;
+}
+
+export interface StartMetaComputerUseTaskResponse {
+  jobId: string;
+  liveUrl: string | null;
+}
+
+export interface MetaComputerUseTaskStatusResponse {
+  status: MetaComputerUseTaskStatus;
+}
+
+export interface MetaComputerUseStepError {
+  code: string;
+  message: string;
+}
+
+export interface MetaComputerUseStepIncompleteDetails {
+  reason?: string;
+}
+
+export interface MetaComputerUseStepReasoning {
+  effort?: string | null;
+  summary?: string | null;
+}
+
+export interface MetaComputerUseStepResponse {
+  created_at?: number | null;
+  completed_at?: number | null;
+  output_text?: string | null;
+  error?: MetaComputerUseStepError | null;
+  incomplete_details?: MetaComputerUseStepIncompleteDetails | null;
+  model?: string | null;
+  output?: any[];
+  reasoning?: MetaComputerUseStepReasoning | null;
+  status?: string | null;
+}
+
+export interface MetaComputerUseTaskData {
+  steps: MetaComputerUseStepResponse[];
+  finalResult: string | null;
+}
+
+export interface MetaComputerUseTaskMetadata {
+  inputTokens?: number | null;
+  outputTokens?: number | null;
+  numTaskStepsCompleted?: number | null;
+}
+
+export interface MetaComputerUseTaskResponse {
+  jobId: string;
+  status: MetaComputerUseTaskStatus;
+  metadata?: MetaComputerUseTaskMetadata | null;
+  data?: MetaComputerUseTaskData | null;
+  error?: string | null;
+  liveUrl: string | null;
+}

src/types/constants.ts

@@ -23,6 +23,7 @@ export type GeminiComputerUseTaskStatus =
   | "failed"
   | "stopped";
 export type GrokComputerUseTaskStatus = "pending" | "running" | "completed" | "failed" | "stopped";
+export type MetaComputerUseTaskStatus = "pending" | "running" | "completed" | "failed" | "stopped";
 export type ScrapePageStatus = "completed" | "failed" | "pending" | "running";
 export type CrawlPageStatus = "completed" | "failed";
 export type ScrapeWaitUntil = "load" | "domcontentloaded" | "networkidle";
@@ -110,6 +111,10 @@ export type GrokComputerUseLlm = "grok-4.5";
 
 export type GrokReasoningEffort = "low" | "medium" | "high";
 
+export type MetaComputerUseLlm = "muse-spark-1.1" | "muse-spark-1.2" | "muse-spark-1.3";
+
+export type MetaReasoningEffort = "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+
 export type SessionRegion =
   | "us"
   | "us-central"

src/types/index.ts

@@ -102,6 +102,19 @@ export {
   GrokComputerUseApiKeys,
   GrokComputerUseTaskMetadata,
 } from "./agents/grok-computer-use";
+export {
+  StartMetaComputerUseTaskParams,
+  StartMetaComputerUseTaskResponse,
+  MetaComputerUseTaskStatusResponse,
+  MetaComputerUseTaskResponse,
+  MetaComputerUseTaskData,
+  MetaComputerUseStepResponse,
+  MetaComputerUseStepError,
+  MetaComputerUseStepIncompleteDetails,
+  MetaComputerUseStepReasoning,
+  MetaComputerUseApiKeys,
+  MetaComputerUseTaskMetadata,
+} from "./agents/meta-computer-use";
 export {
   BasicResponse,
   BrowserMemorySize,
@@ -244,6 +257,8 @@ export {
   GeminiComputerUseLlm,
   GrokComputerUseLlm,
   GrokReasoningEffort,
+  MetaComputerUseLlm,
+  MetaReasoningEffort,
   ScrapeScreenshotFormat,
   ScrapeJobStatus,
   CrawlJobStatus,
@@ -264,6 +279,7 @@ export {
   CuaTaskStatus,
   GeminiComputerUseTaskStatus,
   GrokComputerUseTaskStatus,
+  MetaComputerUseTaskStatus,
   SessionEventLogType,
   SessionRegion,
   BrowserUseVersion,