hyperbrowser 0.36.0__tar.gz → 0.38.0__tar.gz

{hyperbrowser-0.36.0 → hyperbrowser-0.38.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: hyperbrowser
-Version: 0.36.0
+Version: 0.38.0
 Summary: Python SDK for hyperbrowser
 License: MIT
 Author: Nikhil Shahi

hyperbrowser-0.38.0/hyperbrowser/client/managers/async_manager/agents/__init__.py

@@ -0,0 +1,10 @@
+from .browser_use import BrowserUseManager
+from .cua import CuaManager
+from .claude_computer_use import ClaudeComputerUseManager
+
+
+class Agents:
+    def __init__(self, client):
+        self.browser_use = BrowserUseManager(client)
+        self.cua = CuaManager(client)
+        self.claude_computer_use = ClaudeComputerUseManager(client)

hyperbrowser-0.38.0/hyperbrowser/client/managers/async_manager/agents/claude_computer_use.py

@@ -0,0 +1,71 @@
+import asyncio
+
+from hyperbrowser.exceptions import HyperbrowserError
+
+from .....models import (
+    POLLING_ATTEMPTS,
+    BasicResponse,
+    ClaudeComputerUseTaskResponse,
+    ClaudeComputerUseTaskStatusResponse,
+    StartClaudeComputerUseTaskParams,
+    StartClaudeComputerUseTaskResponse,
+)
+
+
+class ClaudeComputerUseManager:
+    def __init__(self, client):
+        self._client = client
+
+    async def start(
+        self, params: StartClaudeComputerUseTaskParams
+    ) -> StartClaudeComputerUseTaskResponse:
+        response = await self._client.transport.post(
+            self._client._build_url("/task/claude-computer-use"),
+            data=params.model_dump(exclude_none=True, by_alias=True),
+        )
+        return StartClaudeComputerUseTaskResponse(**response.data)
+
+    async def get(self, job_id: str) -> ClaudeComputerUseTaskResponse:
+        response = await self._client.transport.get(
+            self._client._build_url(f"/task/claude-computer-use/{job_id}")
+        )
+        return ClaudeComputerUseTaskResponse(**response.data)
+
+    async def get_status(self, job_id: str) -> ClaudeComputerUseTaskStatusResponse:
+        response = await self._client.transport.get(
+            self._client._build_url(f"/task/claude-computer-use/{job_id}/status")
+        )
+        return ClaudeComputerUseTaskStatusResponse(**response.data)
+
+    async def stop(self, job_id: str) -> BasicResponse:
+        response = await self._client.transport.put(
+            self._client._build_url(f"/task/claude-computer-use/{job_id}/stop")
+        )
+        return BasicResponse(**response.data)
+
+    async def start_and_wait(
+        self, params: StartClaudeComputerUseTaskParams
+    ) -> ClaudeComputerUseTaskResponse:
+        job_start_resp = await self.start(params)
+        job_id = job_start_resp.job_id
+        if not job_id:
+            raise HyperbrowserError("Failed to start Claude 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 Claude Computer Use task job {job_id} after {POLLING_ATTEMPTS} attempts: {e}"
+                    )
+            await asyncio.sleep(2)

hyperbrowser-0.38.0/hyperbrowser/client/managers/async_manager/agents/cua.py

@@ -0,0 +1,67 @@
+import asyncio
+
+from hyperbrowser.exceptions import HyperbrowserError
+
+from .....models import (
+    POLLING_ATTEMPTS,
+    BasicResponse,
+    CuaTaskResponse,
+    CuaTaskStatusResponse,
+    StartCuaTaskParams,
+    StartCuaTaskResponse,
+)
+
+
+class CuaManager:
+    def __init__(self, client):
+        self._client = client
+
+    async def start(self, params: StartCuaTaskParams) -> StartCuaTaskResponse:
+        response = await self._client.transport.post(
+            self._client._build_url("/task/cua"),
+            data=params.model_dump(exclude_none=True, by_alias=True),
+        )
+        return StartCuaTaskResponse(**response.data)
+
+    async def get(self, job_id: str) -> CuaTaskResponse:
+        response = await self._client.transport.get(
+            self._client._build_url(f"/task/cua/{job_id}")
+        )
+        return CuaTaskResponse(**response.data)
+
+    async def get_status(self, job_id: str) -> CuaTaskStatusResponse:
+        response = await self._client.transport.get(
+            self._client._build_url(f"/task/cua/{job_id}/status")
+        )
+        return CuaTaskStatusResponse(**response.data)
+
+    async def stop(self, job_id: str) -> BasicResponse:
+        response = await self._client.transport.put(
+            self._client._build_url(f"/task/cua/{job_id}/stop")
+        )
+        return BasicResponse(**response.data)
+
+    async def start_and_wait(self, params: StartCuaTaskParams) -> CuaTaskResponse:
+        job_start_resp = await self.start(params)
+        job_id = job_start_resp.job_id
+        if not job_id:
+            raise HyperbrowserError("Failed to start CUA 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 CUA task job {job_id} after {POLLING_ATTEMPTS} attempts: {e}"
+                    )
+            await asyncio.sleep(2)

hyperbrowser-0.38.0/hyperbrowser/client/managers/sync_manager/agents/__init__.py

@@ -0,0 +1,10 @@
+from .browser_use import BrowserUseManager
+from .cua import CuaManager
+from .claude_computer_use import ClaudeComputerUseManager
+
+
+class Agents:
+    def __init__(self, client):
+        self.browser_use = BrowserUseManager(client)
+        self.cua = CuaManager(client)
+        self.claude_computer_use = ClaudeComputerUseManager(client)

hyperbrowser-0.38.0/hyperbrowser/client/managers/sync_manager/agents/claude_computer_use.py

@@ -0,0 +1,71 @@
+import time
+
+from hyperbrowser.exceptions import HyperbrowserError
+
+from .....models import (
+    POLLING_ATTEMPTS,
+    BasicResponse,
+    ClaudeComputerUseTaskResponse,
+    ClaudeComputerUseTaskStatusResponse,
+    StartClaudeComputerUseTaskParams,
+    StartClaudeComputerUseTaskResponse,
+)
+
+
+class ClaudeComputerUseManager:
+    def __init__(self, client):
+        self._client = client
+
+    def start(
+        self, params: StartClaudeComputerUseTaskParams
+    ) -> StartClaudeComputerUseTaskResponse:
+        response = self._client.transport.post(
+            self._client._build_url("/task/claude-computer-use"),
+            data=params.model_dump(exclude_none=True, by_alias=True),
+        )
+        return StartClaudeComputerUseTaskResponse(**response.data)
+
+    def get(self, job_id: str) -> ClaudeComputerUseTaskResponse:
+        response = self._client.transport.get(
+            self._client._build_url(f"/task/claude-computer-use/{job_id}")
+        )
+        return ClaudeComputerUseTaskResponse(**response.data)
+
+    def get_status(self, job_id: str) -> ClaudeComputerUseTaskStatusResponse:
+        response = self._client.transport.get(
+            self._client._build_url(f"/task/claude-computer-use/{job_id}/status")
+        )
+        return ClaudeComputerUseTaskStatusResponse(**response.data)
+
+    def stop(self, job_id: str) -> BasicResponse:
+        response = self._client.transport.put(
+            self._client._build_url(f"/task/claude-computer-use/{job_id}/stop")
+        )
+        return BasicResponse(**response.data)
+
+    def start_and_wait(
+        self, params: StartClaudeComputerUseTaskParams
+    ) -> ClaudeComputerUseTaskResponse:
+        job_start_resp = self.start(params)
+        job_id = job_start_resp.job_id
+        if not job_id:
+            raise HyperbrowserError("Failed to start CUA 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 Claude Computer Use task job {job_id} after {POLLING_ATTEMPTS} attempts: {e}"
+                    )
+            time.sleep(2)

hyperbrowser-0.38.0/hyperbrowser/client/managers/sync_manager/agents/cua.py

@@ -0,0 +1,67 @@
+import time
+
+from hyperbrowser.exceptions import HyperbrowserError
+
+from .....models import (
+    POLLING_ATTEMPTS,
+    BasicResponse,
+    CuaTaskResponse,
+    CuaTaskStatusResponse,
+    StartCuaTaskParams,
+    StartCuaTaskResponse,
+)
+
+
+class CuaManager:
+    def __init__(self, client):
+        self._client = client
+
+    def start(self, params: StartCuaTaskParams) -> StartCuaTaskResponse:
+        response = self._client.transport.post(
+            self._client._build_url("/task/cua"),
+            data=params.model_dump(exclude_none=True, by_alias=True),
+        )
+        return StartCuaTaskResponse(**response.data)
+
+    def get(self, job_id: str) -> CuaTaskResponse:
+        response = self._client.transport.get(
+            self._client._build_url(f"/task/cua/{job_id}")
+        )
+        return CuaTaskResponse(**response.data)
+
+    def get_status(self, job_id: str) -> CuaTaskStatusResponse:
+        response = self._client.transport.get(
+            self._client._build_url(f"/task/cua/{job_id}/status")
+        )
+        return CuaTaskStatusResponse(**response.data)
+
+    def stop(self, job_id: str) -> BasicResponse:
+        response = self._client.transport.put(
+            self._client._build_url(f"/task/cua/{job_id}/stop")
+        )
+        return BasicResponse(**response.data)
+
+    def start_and_wait(self, params: StartCuaTaskParams) -> CuaTaskResponse:
+        job_start_resp = self.start(params)
+        job_id = job_start_resp.job_id
+        if not job_id:
+            raise HyperbrowserError("Failed to start CUA 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 CUA task job {job_id} after {POLLING_ATTEMPTS} attempts: {e}"
+                    )
+            time.sleep(2)

{hyperbrowser-0.36.0 → hyperbrowser-0.38.0}/hyperbrowser/models/__init__.py

@@ -5,6 +5,20 @@ from .agents.browser_use import (
     StartBrowserUseTaskParams,
     StartBrowserUseTaskResponse,
 )
+from .agents.claude_computer_use import (
+    ClaudeComputerUseTaskData,
+    ClaudeComputerUseTaskResponse,
+    ClaudeComputerUseTaskStatusResponse,
+    StartClaudeComputerUseTaskParams,
+    StartClaudeComputerUseTaskResponse,
+)
+from .agents.cua import (
+    CuaTaskData,
+    CuaTaskResponse,
+    CuaTaskStatusResponse,
+    StartCuaTaskParams,
+    StartCuaTaskResponse,
+)
 from .consts import (
     ISO639_1,
     POLLING_ATTEMPTS,
@@ -97,6 +111,18 @@ __all__ = [
     "BrowserUseTaskStatusResponse",
     "StartBrowserUseTaskParams",
     "StartBrowserUseTaskResponse",
+    "ClaudeComputerUseTaskStatus",
+    "ClaudeComputerUseTaskData",
+    "ClaudeComputerUseTaskResponse",
+    "ClaudeComputerUseTaskStatusResponse",
+    "StartClaudeComputerUseTaskParams",
+    "StartClaudeComputerUseTaskResponse",
+    "CuaTaskStatus",
+    "CuaTaskData",
+    "CuaTaskResponse",
+    "CuaTaskStatusResponse",
+    "StartCuaTaskParams",
+    "StartCuaTaskResponse",
     # crawl
     "CrawledPage",
     "CrawlJobResponse",

{hyperbrowser-0.36.0 → hyperbrowser-0.38.0}/hyperbrowser/models/agents/browser_use.py

@@ -183,4 +183,3 @@ class BrowserUseTaskResponse(BaseModel):
     data: Optional[BrowserUseTaskData] = Field(default=None, alias="data")
     error: Optional[str] = Field(default=None, alias="error")
     live_url: Optional[str] = Field(default=None, alias="liveUrl")
-    live_url: Optional[str] = Field(default=None, alias="liveUrl")

hyperbrowser-0.38.0/hyperbrowser/models/agents/claude_computer_use.py

@@ -0,0 +1,97 @@
+from typing import Any, Literal, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from ..session import CreateSessionParams
+
+ClaudeComputerUseTaskStatus = Literal[
+    "pending", "running", "completed", "failed", "stopped"
+]
+
+
+class StartClaudeComputerUseTaskParams(BaseModel):
+    """
+    Parameters for creating a new Claude Computer Use task.
+    """
+
+    model_config = ConfigDict(
+        populate_by_alias=True,
+    )
+
+    task: str
+    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"
+    )
+
+
+class StartClaudeComputerUseTaskResponse(BaseModel):
+    """
+    Response from starting a Claude 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 ClaudeComputerUseTaskStatusResponse(BaseModel):
+    """
+    Response from getting a Claude Computer Use task status.
+    """
+
+    model_config = ConfigDict(
+        populate_by_alias=True,
+    )
+
+    status: ClaudeComputerUseTaskStatus
+
+
+class ClaudeComputerUseStepResponse(BaseModel):
+    """
+    Response from a single Claude Computer Use step.
+    """
+
+    model_config = ConfigDict(
+        populate_by_alias=True,
+    )
+
+    role: str
+    type: str
+    model: str
+    content: list[Any]
+    stop_reason: Optional[str] = Field(default=None)
+    stop_sequence: Optional[str] = Field(default=None)
+
+
+class ClaudeComputerUseTaskData(BaseModel):
+    model_config = ConfigDict(
+        populate_by_alias=True,
+    )
+
+    steps: list[ClaudeComputerUseStepResponse]
+    final_result: Optional[str] = Field(default=None, alias="finalResult")
+
+
+class ClaudeComputerUseTaskResponse(BaseModel):
+    """
+    Response from a Claude Computer Use task.
+    """
+
+    model_config = ConfigDict(
+        populate_by_alias=True,
+    )
+
+    job_id: str = Field(alias="jobId")
+    status: ClaudeComputerUseTaskStatus
+    data: Optional[ClaudeComputerUseTaskData] = Field(default=None, alias="data")
+    error: Optional[str] = Field(default=None, alias="error")
+    live_url: Optional[str] = Field(default=None, alias="liveUrl")

hyperbrowser-0.38.0/hyperbrowser/models/agents/cua.py

@@ -0,0 +1,131 @@
+from typing import Any, Literal, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from ..session import CreateSessionParams
+
+CuaTaskStatus = Literal["pending", "running", "completed", "failed", "stopped"]
+
+
+class StartCuaTaskParams(BaseModel):
+    """
+    Parameters for creating a new CUA task.
+    """
+
+    model_config = ConfigDict(
+        populate_by_alias=True,
+    )
+
+    task: str
+    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"
+    )
+
+
+class StartCuaTaskResponse(BaseModel):
+    """
+    Response from starting a CUA task.
+    """
+
+    model_config = ConfigDict(
+        populate_by_alias=True,
+    )
+
+    job_id: str = Field(alias="jobId")
+    live_url: Optional[str] = Field(default=None, alias="liveUrl")
+
+
+class CuaTaskStatusResponse(BaseModel):
+    """
+    Response from getting a CUA task status.
+    """
+
+    model_config = ConfigDict(
+        populate_by_alias=True,
+    )
+
+    status: CuaTaskStatus
+
+
+class CuaStepResponseError(BaseModel):
+    """
+    Error details for a CUA step response.
+    """
+
+    model_config = ConfigDict(
+        populate_by_alias=True,
+    )
+
+    code: str
+    message: str
+
+
+class CuaStepIncompleteDetails(BaseModel):
+    """
+    Details about why a CUA step is incomplete.
+    """
+
+    model_config = ConfigDict(
+        populate_by_alias=True,
+    )
+
+    reason: Optional[str] = Field(default=None)
+
+
+class CuaStepReasoning(BaseModel):
+    """
+    Reasoning information for a CUA step.
+    """
+
+    model_config = ConfigDict(
+        populate_by_alias=True,
+    )
+
+    effort: Optional[str] = Field(default=None)
+    generate_summary: Optional[str] = Field(default=None)
+
+
+class CuaStepResponse(BaseModel):
+    """
+    Response from a single CUA step.
+    """
+
+    created_at: int
+    output_text: str
+    error: Optional[CuaStepResponseError] = None
+    incomplete_details: Optional[CuaStepIncompleteDetails] = None
+    model: str
+    output: list[Any]
+    reasoning: Optional[CuaStepReasoning] = None
+    status: Optional[str] = None
+
+
+class CuaTaskData(BaseModel):
+    model_config = ConfigDict(
+        populate_by_alias=True,
+    )
+
+    steps: list[CuaStepResponse]
+    final_result: Optional[str] = Field(default=None, alias="finalResult")
+
+
+class CuaTaskResponse(BaseModel):
+    """
+    Response from a CUA task.
+    """
+
+    model_config = ConfigDict(
+        populate_by_alias=True,
+    )
+
+    job_id: str = Field(alias="jobId")
+    status: CuaTaskStatus
+    data: Optional[CuaTaskData] = Field(default=None, alias="data")
+    error: Optional[str] = Field(default=None, alias="error")
+    live_url: Optional[str] = Field(default=None, alias="liveUrl")

{hyperbrowser-0.36.0 → hyperbrowser-0.38.0}/pyproject.toml

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

hyperbrowser-0.36.0/hyperbrowser/client/managers/async_manager/agents/__init__.py

@@ -1,6 +0,0 @@
-from .browser_use import BrowserUseManager
-
-
-class Agents:
-    def __init__(self, client):
-        self.browser_use = BrowserUseManager(client)

hyperbrowser-0.36.0/hyperbrowser/client/managers/sync_manager/agents/__init__.py

@@ -1,6 +0,0 @@
-from .browser_use import BrowserUseManager
-
-
-class Agents:
-    def __init__(self, client):
-        self.browser_use = BrowserUseManager(client)