hyperbrowser 1.4.0__tar.gz → 1.4.2__tar.gz

{hyperbrowser-1.4.0 → hyperbrowser-1.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperbrowser
-Version: 1.4.0
+Version: 1.4.2
 Summary: Python SDK for hyperbrowser
 License: MIT
 License-File: LICENSE

{hyperbrowser-1.4.0/hyperbrowser/client/managers/sync_manager → hyperbrowser-1.4.2/hyperbrowser/client/managers/async_manager}/agents/__init__.py

@@ -4,6 +4,7 @@ from .claude_computer_use import ClaudeComputerUseManager
 from .hyper_agent import HyperAgentManager
 from .gemini_computer_use import GeminiComputerUseManager
 from .grok_computer_use import GrokComputerUseManager
+from .meta_computer_use import MetaComputerUseManager
 
 
 class Agents:
@@ -14,3 +15,4 @@ class Agents:
         self.hyper_agent = HyperAgentManager(client)
         self.gemini_computer_use = GeminiComputerUseManager(client)
         self.grok_computer_use = GrokComputerUseManager(client)
+        self.meta_computer_use = MetaComputerUseManager(client)

hyperbrowser-1.4.2/hyperbrowser/client/managers/async_manager/agents/meta_computer_use.py

@@ -0,0 +1,84 @@
+import asyncio
+from typing import Union
+
+from hyperbrowser.client._request import dump_request
+from hyperbrowser.exceptions import HyperbrowserError
+from hyperbrowser.types import (
+    StartMetaComputerUseTaskParams as StartMetaComputerUseTaskParamsDict,
+)
+
+from .....models import (
+    POLLING_ATTEMPTS,
+    BasicResponse,
+    MetaComputerUseTaskResponse,
+    MetaComputerUseTaskStatusResponse,
+    StartMetaComputerUseTaskParams,
+    StartMetaComputerUseTaskResponse,
+)
+
+
+class MetaComputerUseManager:
+    def __init__(self, client):
+        self._client = client
+
+    async def start(
+        self,
+        params: Union[
+            StartMetaComputerUseTaskParamsDict,
+            StartMetaComputerUseTaskParams,
+        ],
+    ) -> StartMetaComputerUseTaskResponse:
+        response = await self._client.transport.post(
+            self._client._build_url("/task/meta-computer-use"),
+            data=dump_request(params, StartMetaComputerUseTaskParams),
+        )
+        return StartMetaComputerUseTaskResponse(**response.data)
+
+    async def get(self, job_id: str) -> MetaComputerUseTaskResponse:
+        response = await self._client.transport.get(
+            self._client._build_url(f"/task/meta-computer-use/{job_id}")
+        )
+        return MetaComputerUseTaskResponse(**response.data)
+
+    async def get_status(self, job_id: str) -> MetaComputerUseTaskStatusResponse:
+        response = await self._client.transport.get(
+            self._client._build_url(f"/task/meta-computer-use/{job_id}/status")
+        )
+        return MetaComputerUseTaskStatusResponse(**response.data)
+
+    async def stop(self, job_id: str) -> BasicResponse:
+        response = await self._client.transport.put(
+            self._client._build_url(f"/task/meta-computer-use/{job_id}/stop")
+        )
+        return BasicResponse(**response.data)
+
+    async def start_and_wait(
+        self,
+        params: Union[
+            StartMetaComputerUseTaskParamsDict,
+            StartMetaComputerUseTaskParams,
+        ],
+    ) -> MetaComputerUseTaskResponse:
+        job_start_resp = await self.start(params)
+        job_id = job_start_resp.job_id
+        if not job_id:
+            raise HyperbrowserError("Failed to start Meta Computer Use task job")
+
+        failures = 0
+        while True:
+            try:
+                job_response = await self.get_status(job_id)
+                if (
+                    job_response.status == "completed"
+                    or job_response.status == "failed"
+                    or job_response.status == "stopped"
+                ):
+                    return await self.get(job_id)
+                failures = 0
+            except Exception as e:
+                failures += 1
+                if failures >= POLLING_ATTEMPTS:
+                    raise HyperbrowserError(
+                        f"Failed to poll Meta Computer Use task job {job_id} after {POLLING_ATTEMPTS} attempts: {e}"
+                    )
+            await asyncio.sleep(2)

{hyperbrowser-1.4.0/hyperbrowser/client/managers/async_manager → hyperbrowser-1.4.2/hyperbrowser/client/managers/sync_manager}/agents/__init__.py

@@ -4,6 +4,7 @@ from .claude_computer_use import ClaudeComputerUseManager
 from .hyper_agent import HyperAgentManager
 from .gemini_computer_use import GeminiComputerUseManager
 from .grok_computer_use import GrokComputerUseManager
+from .meta_computer_use import MetaComputerUseManager
 
 
 class Agents:
@@ -14,3 +15,4 @@ class Agents:
         self.hyper_agent = HyperAgentManager(client)
         self.gemini_computer_use = GeminiComputerUseManager(client)
         self.grok_computer_use = GrokComputerUseManager(client)
+        self.meta_computer_use = MetaComputerUseManager(client)

hyperbrowser-1.4.2/hyperbrowser/client/managers/sync_manager/agents/meta_computer_use.py

@@ -0,0 +1,84 @@
+import time
+from typing import Union
+
+from hyperbrowser.client._request import dump_request
+from hyperbrowser.exceptions import HyperbrowserError
+from hyperbrowser.types import (
+    StartMetaComputerUseTaskParams as StartMetaComputerUseTaskParamsDict,
+)
+
+from .....models import (
+    POLLING_ATTEMPTS,
+    BasicResponse,
+    MetaComputerUseTaskResponse,
+    MetaComputerUseTaskStatusResponse,
+    StartMetaComputerUseTaskParams,
+    StartMetaComputerUseTaskResponse,
+)
+
+
+class MetaComputerUseManager:
+    def __init__(self, client):
+        self._client = client
+
+    def start(
+        self,
+        params: Union[
+            StartMetaComputerUseTaskParamsDict,
+            StartMetaComputerUseTaskParams,
+        ],
+    ) -> StartMetaComputerUseTaskResponse:
+        response = self._client.transport.post(
+            self._client._build_url("/task/meta-computer-use"),
+            data=dump_request(params, StartMetaComputerUseTaskParams),
+        )
+        return StartMetaComputerUseTaskResponse(**response.data)
+
+    def get(self, job_id: str) -> MetaComputerUseTaskResponse:
+        response = self._client.transport.get(
+            self._client._build_url(f"/task/meta-computer-use/{job_id}")
+        )
+        return MetaComputerUseTaskResponse(**response.data)
+
+    def get_status(self, job_id: str) -> MetaComputerUseTaskStatusResponse:
+        response = self._client.transport.get(
+            self._client._build_url(f"/task/meta-computer-use/{job_id}/status")
+        )
+        return MetaComputerUseTaskStatusResponse(**response.data)
+
+    def stop(self, job_id: str) -> BasicResponse:
+        response = self._client.transport.put(
+            self._client._build_url(f"/task/meta-computer-use/{job_id}/stop")
+        )
+        return BasicResponse(**response.data)
+
+    def start_and_wait(
+        self,
+        params: Union[
+            StartMetaComputerUseTaskParamsDict,
+            StartMetaComputerUseTaskParams,
+        ],
+    ) -> MetaComputerUseTaskResponse:
+        job_start_resp = self.start(params)
+        job_id = job_start_resp.job_id
+        if not job_id:
+            raise HyperbrowserError("Failed to start Meta Computer Use task job")
+
+        failures = 0
+        while True:
+            try:
+                job_response = self.get_status(job_id)
+                if (
+                    job_response.status == "completed"
+                    or job_response.status == "failed"
+                    or job_response.status == "stopped"
+                ):
+                    return self.get(job_id)
+                failures = 0
+            except Exception as e:
+                failures += 1
+                if failures >= POLLING_ATTEMPTS:
+                    raise HyperbrowserError(
+                        f"Failed to poll Meta Computer Use task job {job_id} after {POLLING_ATTEMPTS} attempts: {e}"
+                    )
+            time.sleep(2)

{hyperbrowser-1.4.0 → hyperbrowser-1.4.2}/hyperbrowser/models/__init__.py

@@ -127,6 +127,17 @@ from .agents.grok_computer_use import (
     StartGrokComputerUseTaskResponse,
     GrokComputerUseApiKeys,
 )
+from .agents.meta_computer_use import (
+    MetaComputerUseTaskStatus,
+    MetaComputerUseStepReasoning,
+    MetaComputerUseStepResponse,
+    MetaComputerUseTaskData,
+    MetaComputerUseTaskResponse,
+    MetaComputerUseTaskStatusResponse,
+    StartMetaComputerUseTaskParams,
+    StartMetaComputerUseTaskResponse,
+    MetaComputerUseApiKeys,
+)
 from .agents.cua import (
     CuaTaskData,
     CuaTaskResponse,
@@ -160,6 +171,8 @@ from .consts import (
     CuaLlm,
     GrokComputerUseLlm,
     GrokReasoningEffort,
+    MetaComputerUseLlm,
+    MetaReasoningEffort,
     Country,
     DownloadsStatus,
     FetchScreenshotFormat,
@@ -496,6 +509,14 @@ __all__ = [
     "GrokComputerUseTaskStatusResponse",
     "StartGrokComputerUseTaskParams",
     "StartGrokComputerUseTaskResponse",
+    "MetaComputerUseTaskStatus",
+    "MetaComputerUseStepReasoning",
+    "MetaComputerUseStepResponse",
+    "MetaComputerUseTaskData",
+    "MetaComputerUseTaskResponse",
+    "MetaComputerUseTaskStatusResponse",
+    "StartMetaComputerUseTaskParams",
+    "StartMetaComputerUseTaskResponse",
     "CuaTaskStatus",
     "CuaTaskData",
     "CuaTaskResponse",
@@ -506,11 +527,14 @@ __all__ = [
     "ClaudeComputerUseApiKeys",
     "GeminiComputerUseApiKeys",
     "GrokComputerUseApiKeys",
+    "MetaComputerUseApiKeys",
     "CuaApiKeys",
     "CuaBaseUrls",
     "HyperAgentApiKeys",
     "GrokComputerUseLlm",
     "GrokReasoningEffort",
+    "MetaComputerUseLlm",
+    "MetaReasoningEffort",
     "HyperAgentOutputV110",
     "HyperAgentStepV110",
     # crawl

hyperbrowser-1.4.2/hyperbrowser/models/agents/meta_computer_use.py

@@ -0,0 +1,165 @@
+from __future__ import annotations
+
+from typing import Any, List, Literal, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from .cua import CuaStepIncompleteDetails, CuaStepResponseError
+from ..session import CreateSessionParams
+from ..consts import MetaComputerUseLlm, MetaReasoningEffort
+
+MetaComputerUseTaskStatus = Literal[
+    "pending", "running", "completed", "failed", "stopped"
+]
+
+
+class MetaComputerUseApiKeys(BaseModel):
+    """
+    API keys for the Meta Computer Use task.
+    """
+
+    model_config = ConfigDict(
+        populate_by_alias=True,
+    )
+
+    meta: Optional[str] = Field(default=None, serialization_alias="meta")
+
+
+class StartMetaComputerUseTaskParams(BaseModel):
+    """
+    Parameters for creating a new Meta Computer Use task.
+    """
+
+    model_config = ConfigDict(
+        populate_by_alias=True,
+    )
+
+    task: str
+    llm: Optional[MetaComputerUseLlm] = Field(default=None, serialization_alias="llm")
+    reasoning_effort: Optional[MetaReasoningEffort] = Field(
+        default=None, serialization_alias="reasoningEffort"
+    )
+    session_id: Optional[str] = Field(default=None, serialization_alias="sessionId")
+    max_failures: Optional[int] = Field(default=None, serialization_alias="maxFailures")
+    max_steps: Optional[int] = Field(default=None, serialization_alias="maxSteps")
+    keep_browser_open: Optional[bool] = Field(
+        default=None, serialization_alias="keepBrowserOpen"
+    )
+    session_options: Optional[CreateSessionParams] = Field(
+        default=None, serialization_alias="sessionOptions"
+    )
+    use_custom_api_keys: Optional[bool] = Field(
+        default=None, serialization_alias="useCustomApiKeys"
+    )
+    api_keys: Optional[MetaComputerUseApiKeys] = Field(
+        default=None, serialization_alias="apiKeys"
+    )
+    use_computer_action: Optional[bool] = Field(
+        default=None, serialization_alias="useComputerAction"
+    )
+
+
+class StartMetaComputerUseTaskResponse(BaseModel):
+    """
+    Response from starting a Meta Computer Use task.
+    """
+
+    model_config = ConfigDict(
+        populate_by_alias=True,
+    )
+
+    job_id: str = Field(alias="jobId")
+    live_url: Optional[str] = Field(default=None, alias="liveUrl")
+
+
+class MetaComputerUseTaskStatusResponse(BaseModel):
+    """
+    Response from getting a Meta Computer Use task status.
+    """
+
+    model_config = ConfigDict(
+        populate_by_alias=True,
+    )
+
+    status: MetaComputerUseTaskStatus
+
+
+class MetaComputerUseStepReasoning(BaseModel):
+    """
+    Reasoning metadata on a compacted Meta Computer Use step.
+    """
+
+    model_config = ConfigDict(
+        populate_by_alias=True,
+    )
+
+    effort: Optional[str] = Field(default=None, serialization_alias="effort")
+    summary: Optional[str] = Field(default=None, serialization_alias="summary")
+
+
+class MetaComputerUseStepResponse(BaseModel):
+    """
+    Response from a single Meta Computer Use step.
+    """
+
+    model_config = ConfigDict(
+        populate_by_alias=True,
+    )
+
+    created_at: Optional[int] = Field(default=None, serialization_alias="created_at")
+    completed_at: Optional[int] = Field(
+        default=None, serialization_alias="completed_at"
+    )
+    output_text: Optional[str] = Field(default=None, serialization_alias="output_text")
+    error: Optional[CuaStepResponseError] = Field(
+        default=None, serialization_alias="error"
+    )
+    incomplete_details: Optional[CuaStepIncompleteDetails] = Field(
+        default=None, serialization_alias="incomplete_details"
+    )
+    model: Optional[str] = Field(default=None, serialization_alias="model")
+    output: Optional[List[Any]] = Field(default=None, serialization_alias="output")
+    reasoning: Optional[MetaComputerUseStepReasoning] = Field(
+        default=None, serialization_alias="reasoning"
+    )
+    status: Optional[str] = Field(default=None, serialization_alias="status")
+
+
+class MetaComputerUseTaskData(BaseModel):
+    model_config = ConfigDict(
+        populate_by_alias=True,
+    )
+
+    steps: List[MetaComputerUseStepResponse]
+    final_result: Optional[str] = Field(default=None, alias="finalResult")
+
+
+class MetaComputerUseTaskMetadata(BaseModel):
+    model_config = ConfigDict(
+        populate_by_alias=True,
+    )
+
+    input_tokens: Optional[int] = Field(default=None, alias="inputTokens")
+    output_tokens: Optional[int] = Field(default=None, alias="outputTokens")
+    num_task_steps_completed: Optional[int] = Field(
+        default=None, alias="numTaskStepsCompleted"
+    )
+
+
+class MetaComputerUseTaskResponse(BaseModel):
+    """
+    Response from a Meta Computer Use task.
+    """
+
+    model_config = ConfigDict(
+        populate_by_alias=True,
+    )
+
+    job_id: str = Field(alias="jobId")
+    status: MetaComputerUseTaskStatus
+    metadata: Optional[MetaComputerUseTaskMetadata] = Field(
+        default=None, alias="metadata"
+    )
+    data: Optional[MetaComputerUseTaskData] = Field(default=None, alias="data")
+    error: Optional[str] = Field(default=None, alias="error")
+    live_url: Optional[str] = Field(default=None, alias="liveUrl")

{hyperbrowser-1.4.0 → hyperbrowser-1.4.2}/hyperbrowser/models/consts.py

@@ -45,6 +45,7 @@ BrowserUseLlm = Literal[
     "claude-3-5-haiku-20241022",
     "gemini-2.0-flash",
     "gemini-2.5-flash",
+    "gemini-3.8-flash",
 ]
 HyperAgentLlm = Literal[
     "gpt-5.6-luna",
@@ -62,10 +63,12 @@ HyperAgentLlm = Literal[
     "claude-sonnet-4-6",
     "claude-sonnet-4-5",
     "gemini-2.5-flash",
+    "gemini-3.8-flash",
     "gemini-3.7-flash",
     "gemini-3-flash-preview",
 ]
 ClaudeComputerUseLlm = Literal[
+    "claude-fable-5-1",
     "claude-opus-5",
     "claude-opus-4-5",
     "claude-opus-4-6",
@@ -80,6 +83,7 @@ ClaudeComputerUseLlm = Literal[
 ]
 CuaLlm = Literal[
     "computer-use-preview",
+    "gpt-6-astra",
     "gpt-5.6-sol",
     "gpt-5.6-terra",
     "gpt-5.6-luna",
@@ -88,6 +92,7 @@ CuaLlm = Literal[
     "gpt-5.4-mini",
 ]
 GeminiComputerUseLlm = Literal[
+    "gemini-3.8-flash",
     "gemini-3.7-flash",
     "gemini-3.6-flash",
     "gemini-3.5-flash",
@@ -101,6 +106,19 @@ GrokReasoningEffort = Literal[
     "medium",
     "high",
 ]
+MetaComputerUseLlm = Literal[
+    "muse-spark-1.1",
+    "muse-spark-1.2",
+    "muse-spark-1.3",
+]
+MetaReasoningEffort = Literal[
+    "minimal",
+    "low",
+    "medium",
+    "high",
+    "xhigh",
+    "max",
+]
 SessionRegion = Literal[
     "us",
     "us-central",

{hyperbrowser-1.4.0 → hyperbrowser-1.4.2}/hyperbrowser/types/__init__.py

@@ -20,12 +20,14 @@ from .agents import (
     GeminiComputerUseApiKeys,
     GrokComputerUseApiKeys,
     HyperAgentApiKeys,
+    MetaComputerUseApiKeys,
     StartBrowserUseTaskParams,
     StartClaudeComputerUseTaskParams,
     StartCuaTaskParams,
     StartGeminiComputerUseTaskParams,
     StartGrokComputerUseTaskParams,
     StartHyperAgentTaskParams,
+    StartMetaComputerUseTaskParams,
 )
 from .computer_action import (
     ClickActionParams,
@@ -184,12 +186,14 @@ __all__ = [
     "GeminiComputerUseApiKeys",
     "GrokComputerUseApiKeys",
     "HyperAgentApiKeys",
+    "MetaComputerUseApiKeys",
     "StartBrowserUseTaskParams",
     "StartClaudeComputerUseTaskParams",
     "StartCuaTaskParams",
     "StartGeminiComputerUseTaskParams",
     "StartGrokComputerUseTaskParams",
     "StartHyperAgentTaskParams",
+    "StartMetaComputerUseTaskParams",
     "ClickActionParams",
     "ComputerActionMouseButton",
     "ComputerActionParams",

{hyperbrowser-1.4.0 → hyperbrowser-1.4.2}/hyperbrowser/types/agents.py

@@ -10,6 +10,8 @@ from hyperbrowser.models.consts import (
     GeminiComputerUseLlm,
     GrokComputerUseLlm,
     GrokReasoningEffort,
+    MetaComputerUseLlm,
+    MetaReasoningEffort,
     HyperAgentLlm,
     HyperAgentVersion,
 )
@@ -117,6 +119,28 @@ class StartGrokComputerUseTaskParams(TypedDict, total=False):
     use_computer_action: Optional[bool]
 
 
+class MetaComputerUseApiKeys(TypedDict, total=False):
+    """Provider API keys for a Meta Computer Use task."""
+
+    meta: Optional[str]
+
+
+class StartMetaComputerUseTaskParams(TypedDict, total=False):
+    """Parameters for starting a Meta Computer Use task."""
+
+    task: Required[str]
+    llm: Optional[MetaComputerUseLlm]
+    reasoning_effort: Optional[MetaReasoningEffort]
+    session_id: Optional[str]
+    max_failures: Optional[int]
+    max_steps: Optional[int]
+    keep_browser_open: Optional[bool]
+    session_options: Optional[CreateSessionParams]
+    use_custom_api_keys: Optional[bool]
+    api_keys: Optional[MetaComputerUseApiKeys]
+    use_computer_action: Optional[bool]
+
+
 class CuaApiKeys(TypedDict, total=False):
     """Provider API keys for an OpenAI CUA task."""
 
@@ -176,10 +200,12 @@ __all__ = [
     "GeminiComputerUseApiKeys",
     "GrokComputerUseApiKeys",
     "HyperAgentApiKeys",
+    "MetaComputerUseApiKeys",
     "StartBrowserUseTaskParams",
     "StartClaudeComputerUseTaskParams",
     "StartCuaTaskParams",
     "StartGeminiComputerUseTaskParams",
     "StartGrokComputerUseTaskParams",
     "StartHyperAgentTaskParams",
+    "StartMetaComputerUseTaskParams",
 ]

{hyperbrowser-1.4.0 → hyperbrowser-1.4.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "hyperbrowser"
-version = "1.4.0"
+version = "1.4.2"
 description = "Python SDK for hyperbrowser"
 authors = ["Nikhil Shahi <nshahi1998@gmail.com>"]
 license = "MIT"