hyperbrowser 0.48.0__tar.gz → 0.50.0__tar.gz

{hyperbrowser-0.48.0 → hyperbrowser-0.50.0}/PKG-INFO

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

{hyperbrowser-0.48.0 → hyperbrowser-0.50.0}/hyperbrowser/client/async_client.py

@@ -11,6 +11,7 @@ from .managers.async_manager.profile import ProfileManager
 from .managers.async_manager.scrape import ScrapeManager
 from .managers.async_manager.session import SessionManager
 from .managers.async_manager.team import TeamManager
+from .managers.async_manager.computer_action import ComputerActionManager
 
 
 class AsyncHyperbrowser(HyperbrowserBase):
@@ -33,6 +34,7 @@ class AsyncHyperbrowser(HyperbrowserBase):
         self.extensions = ExtensionManager(self)
         self.agents = Agents(self)
         self.team = TeamManager(self)
+        self.computer_action = ComputerActionManager(self)
 
     async def close(self) -> None:
         await self.transport.close()

hyperbrowser-0.50.0/hyperbrowser/client/managers/async_manager/computer_action.py

@@ -0,0 +1,120 @@
+from pydantic import BaseModel
+from typing import Union, List
+from hyperbrowser.models import (
+    SessionDetail,
+    ComputerActionParams,
+    ComputerActionResponse,
+    ClickActionParams,
+    DragActionParams,
+    PressKeysActionParams,
+    MoveMouseActionParams,
+    ScreenshotActionParams,
+    ScrollActionParams,
+    TypeTextActionParams,
+    Coordinate,
+)
+
+
+class ComputerActionManager:
+    def __init__(self, client):
+        self._client = client
+
+    async def _execute_request(
+        self, session: Union[SessionDetail, str], params: ComputerActionParams
+    ) -> ComputerActionResponse:
+        if isinstance(session, str):
+            session = await self._client.sessions.get(session)
+
+        if not session.computer_action_endpoint:
+            raise ValueError("Computer action endpoint not available for this session")
+
+        if isinstance(params, BaseModel):
+            payload = params.model_dump(by_alias=True, exclude_none=True)
+        else:
+            payload = params
+
+        response = await self._client.transport.post(
+            session.computer_action_endpoint,
+            data=payload,
+        )
+        return ComputerActionResponse(**response.data)
+
+    async def click(
+        self,
+        session: Union[SessionDetail, str],
+        x: int,
+        y: int,
+        button: str = "left",
+        num_clicks: int = 1,
+        return_screenshot: bool = False,
+    ) -> ComputerActionResponse:
+        params = ClickActionParams(
+            x=x,
+            y=y,
+            button=button,
+            num_clicks=num_clicks,
+            return_screenshot=return_screenshot,
+        )
+        return await self._execute_request(session, params)
+
+    async def type_text(
+        self,
+        session: Union[SessionDetail, str],
+        text: str,
+        return_screenshot: bool = False,
+    ) -> ComputerActionResponse:
+        params = TypeTextActionParams(text=text, return_screenshot=return_screenshot)
+        return await self._execute_request(session, params)
+
+    async def screenshot(
+        self,
+        session: Union[SessionDetail, str],
+    ) -> ComputerActionResponse:
+        params = ScreenshotActionParams()
+        return await self._execute_request(session, params)
+
+    async def press_keys(
+        self,
+        session: Union[SessionDetail, str],
+        keys: List[str],
+        return_screenshot: bool = False,
+    ) -> ComputerActionResponse:
+        params = PressKeysActionParams(keys=keys, return_screenshot=return_screenshot)
+        return await self._execute_request(session, params)
+
+    async def drag(
+        self,
+        session: Union[SessionDetail, str],
+        path: List[Coordinate],
+        return_screenshot: bool = False,
+    ) -> ComputerActionResponse:
+        params = DragActionParams(path=path, return_screenshot=return_screenshot)
+        return await self._execute_request(session, params)
+
+    async def move_mouse(
+        self,
+        session: Union[SessionDetail, str],
+        x: int,
+        y: int,
+        return_screenshot: bool = False,
+    ) -> ComputerActionResponse:
+        params = MoveMouseActionParams(x=x, y=y, return_screenshot=return_screenshot)
+        return await self._execute_request(session, params)
+
+    async def scroll(
+        self,
+        session: Union[SessionDetail, str],
+        x: int,
+        y: int,
+        scroll_x: int,
+        scroll_y: int,
+        return_screenshot: bool = False,
+    ) -> ComputerActionResponse:
+        params = ScrollActionParams(
+            x=x,
+            y=y,
+            scroll_x=scroll_x,
+            scroll_y=scroll_y,
+            return_screenshot=return_screenshot,
+        )
+        return await self._execute_request(session, params)

hyperbrowser-0.50.0/hyperbrowser/client/managers/sync_manager/computer_action.py

@@ -0,0 +1,120 @@
+from pydantic import BaseModel
+from typing import Union, List
+from hyperbrowser.models import (
+    SessionDetail,
+    ComputerActionParams,
+    ComputerActionResponse,
+    ClickActionParams,
+    DragActionParams,
+    PressKeysActionParams,
+    MoveMouseActionParams,
+    ScreenshotActionParams,
+    ScrollActionParams,
+    TypeTextActionParams,
+    Coordinate,
+)
+
+
+class ComputerActionManager:
+    def __init__(self, client):
+        self._client = client
+
+    def _execute_request(
+        self, session: Union[SessionDetail, str], params: ComputerActionParams
+    ) -> ComputerActionResponse:
+        if isinstance(session, str):
+            session = self._client.sessions.get(session)
+
+        if not session.computer_action_endpoint:
+            raise ValueError("Computer action endpoint not available for this session")
+
+        if isinstance(params, BaseModel):
+            payload = params.model_dump(by_alias=True, exclude_none=True)
+        else:
+            payload = params
+
+        response = self._client.transport.post(
+            session.computer_action_endpoint,
+            data=payload,
+        )
+        return ComputerActionResponse(**response.data)
+
+    def click(
+        self,
+        session: Union[SessionDetail, str],
+        x: int,
+        y: int,
+        button: str = "left",
+        num_clicks: int = 1,
+        return_screenshot: bool = False,
+    ) -> ComputerActionResponse:
+        params = ClickActionParams(
+            x=x,
+            y=y,
+            button=button,
+            num_clicks=num_clicks,
+            return_screenshot=return_screenshot,
+        )
+        return self._execute_request(session, params)
+
+    def type_text(
+        self,
+        session: Union[SessionDetail, str],
+        text: str,
+        return_screenshot: bool = False,
+    ) -> ComputerActionResponse:
+        params = TypeTextActionParams(text=text, return_screenshot=return_screenshot)
+        return self._execute_request(session, params)
+
+    def screenshot(
+        self,
+        session: Union[SessionDetail, str],
+    ) -> ComputerActionResponse:
+        params = ScreenshotActionParams()
+        return self._execute_request(session, params)
+
+    def press_keys(
+        self,
+        session: Union[SessionDetail, str],
+        keys: List[str],
+        return_screenshot: bool = False,
+    ) -> ComputerActionResponse:
+        params = PressKeysActionParams(keys=keys, return_screenshot=return_screenshot)
+        return self._execute_request(session, params)
+
+    def drag(
+        self,
+        session: Union[SessionDetail, str],
+        path: List[Coordinate],
+        return_screenshot: bool = False,
+    ) -> ComputerActionResponse:
+        params = DragActionParams(path=path, return_screenshot=return_screenshot)
+        return self._execute_request(session, params)
+
+    def move_mouse(
+        self,
+        session: Union[SessionDetail, str],
+        x: int,
+        y: int,
+        return_screenshot: bool = False,
+    ) -> ComputerActionResponse:
+        params = MoveMouseActionParams(x=x, y=y, return_screenshot=return_screenshot)
+        return self._execute_request(session, params)
+
+    def scroll(
+        self,
+        session: Union[SessionDetail, str],
+        x: int,
+        y: int,
+        scroll_x: int,
+        scroll_y: int,
+        return_screenshot: bool = False,
+    ) -> ComputerActionResponse:
+        params = ScrollActionParams(
+            x=x,
+            y=y,
+            scroll_x=scroll_x,
+            scroll_y=scroll_y,
+            return_screenshot=return_screenshot,
+        )
+        return self._execute_request(session, params)

{hyperbrowser-0.48.0 → hyperbrowser-0.50.0}/hyperbrowser/client/sync.py

@@ -11,6 +11,7 @@ from .managers.sync_manager.profile import ProfileManager
 from .managers.sync_manager.scrape import ScrapeManager
 from .managers.sync_manager.session import SessionManager
 from .managers.sync_manager.team import TeamManager
+from .managers.sync_manager.computer_action import ComputerActionManager
 
 
 class Hyperbrowser(HyperbrowserBase):
@@ -33,6 +34,7 @@ class Hyperbrowser(HyperbrowserBase):
         self.extensions = ExtensionManager(self)
         self.agents = Agents(self)
         self.team = TeamManager(self)
+        self.computer_action = ComputerActionManager(self)
 
     def close(self) -> None:
         self.transport.close()

{hyperbrowser-0.48.0 → hyperbrowser-0.50.0}/hyperbrowser/models/__init__.py

@@ -4,6 +4,7 @@ from .agents.browser_use import (
     BrowserUseTaskStatusResponse,
     StartBrowserUseTaskParams,
     StartBrowserUseTaskResponse,
+    BrowserUseApiKeys,
 )
 from .agents.claude_computer_use import (
     ClaudeComputerUseTaskData,
@@ -11,6 +12,7 @@ from .agents.claude_computer_use import (
     ClaudeComputerUseTaskStatusResponse,
     StartClaudeComputerUseTaskParams,
     StartClaudeComputerUseTaskResponse,
+    ClaudeComputerUseApiKeys,
 )
 from .agents.cua import (
     CuaTaskData,
@@ -18,6 +20,7 @@ from .agents.cua import (
     CuaTaskStatusResponse,
     StartCuaTaskParams,
     StartCuaTaskResponse,
+    CuaApiKeys,
 )
 from .agents.hyper_agent import (
     HyperAgentActionOutput,
@@ -29,6 +32,7 @@ from .agents.hyper_agent import (
     HyperAgentTaskStatusResponse,
     StartHyperAgentTaskParams,
     StartHyperAgentTaskResponse,
+    HyperAgentApiKeys,
 )
 from .consts import (
     ISO639_1,
@@ -88,6 +92,19 @@ from .scrape import (
     StartScrapeJobParams,
     StartScrapeJobResponse,
 )
+from .computer_action import (
+    ClickActionParams,
+    ComputerAction,
+    ComputerActionParams,
+    ComputerActionResponse,
+    Coordinate,
+    DragActionParams,
+    MoveMouseActionParams,
+    PressKeysActionParams,
+    ScreenshotActionParams,
+    ScrollActionParams,
+    TypeTextActionParams,
+)
 from .session import (
     BasicResponse,
     CreateSessionParams,
@@ -151,6 +168,10 @@ __all__ = [
     "CuaTaskStatusResponse",
     "StartCuaTaskParams",
     "StartCuaTaskResponse",
+    "BrowserUseApiKeys",
+    "ClaudeComputerUseApiKeys",
+    "CuaApiKeys",
+    "HyperAgentApiKeys",
     # crawl
     "CrawledPage",
     "CrawlJobResponse",
@@ -207,4 +228,16 @@ __all__ = [
     "UploadFileResponse",
     # team
     "TeamCreditInfo",
+    # computer action
+    "ClickActionParams",
+    "ComputerAction",
+    "ComputerActionParams",
+    "ComputerActionResponse",
+    "Coordinate",
+    "DragActionParams",
+    "MoveMouseActionParams",
+    "PressKeysActionParams",
+    "ScreenshotActionParams",
+    "ScrollActionParams",
+    "TypeTextActionParams",
 ]

{hyperbrowser-0.48.0 → hyperbrowser-0.50.0}/hyperbrowser/models/agents/browser_use.py

@@ -8,6 +8,20 @@ from ..session import CreateSessionParams
 BrowserUseTaskStatus = Literal["pending", "running", "completed", "failed", "stopped"]
 
 
+class BrowserUseApiKeys(BaseModel):
+    """
+    API keys for the browser use task.
+    """
+
+    model_config = ConfigDict(
+        populate_by_alias=True,
+    )
+
+    openai: Optional[str] = Field(default=None, serialization_alias="openai")
+    anthropic: Optional[str] = Field(default=None, serialization_alias="anthropic")
+    google: Optional[str] = Field(default=None, serialization_alias="google")
+
+
 class StartBrowserUseTaskParams(BaseModel):
     """
     Parameters for creating a new browser use task.
@@ -62,6 +76,12 @@ class StartBrowserUseTaskParams(BaseModel):
     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[BrowserUseApiKeys] = Field(
+        default=None, serialization_alias="apiKeys"
+    )
 
 
 class StartBrowserUseTaskResponse(BaseModel):

{hyperbrowser-0.48.0 → hyperbrowser-0.50.0}/hyperbrowser/models/agents/claude_computer_use.py

@@ -10,6 +10,18 @@ ClaudeComputerUseTaskStatus = Literal[
 ]
 
 
+class ClaudeComputerUseApiKeys(BaseModel):
+    """
+    API keys for the Claude Computer Use task.
+    """
+
+    model_config = ConfigDict(
+        populate_by_alias=True,
+    )
+
+    anthropic: Optional[str] = Field(default=None, serialization_alias="anthropic")
+
+
 class StartClaudeComputerUseTaskParams(BaseModel):
     """
     Parameters for creating a new Claude Computer Use task.
@@ -30,6 +42,12 @@ class StartClaudeComputerUseTaskParams(BaseModel):
     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[ClaudeComputerUseApiKeys] = Field(
+        default=None, serialization_alias="apiKeys"
+    )
 
 
 class StartClaudeComputerUseTaskResponse(BaseModel):

{hyperbrowser-0.48.0 → hyperbrowser-0.50.0}/hyperbrowser/models/agents/cua.py

@@ -7,6 +7,18 @@ from ..session import CreateSessionParams
 CuaTaskStatus = Literal["pending", "running", "completed", "failed", "stopped"]
 
 
+class CuaApiKeys(BaseModel):
+    """
+    API keys for the CUA task.
+    """
+
+    model_config = ConfigDict(
+        populate_by_alias=True,
+    )
+
+    openai: Optional[str] = Field(default=None, serialization_alias="openai")
+
+
 class StartCuaTaskParams(BaseModel):
     """
     Parameters for creating a new CUA task.
@@ -26,6 +38,10 @@ class StartCuaTaskParams(BaseModel):
     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[CuaApiKeys] = Field(default=None, serialization_alias="apiKeys")
 
 
 class StartCuaTaskResponse(BaseModel):

{hyperbrowser-0.48.0 → hyperbrowser-0.50.0}/hyperbrowser/models/agents/hyper_agent.py

@@ -8,6 +8,20 @@ from ..session import CreateSessionParams
 HyperAgentTaskStatus = Literal["pending", "running", "completed", "failed", "stopped"]
 
 
+class HyperAgentApiKeys(BaseModel):
+    """
+    API keys for the HyperAgent task.
+    """
+
+    model_config = ConfigDict(
+        populate_by_alias=True,
+    )
+
+    openai: Optional[str] = Field(default=None, serialization_alias="openai")
+    anthropic: Optional[str] = Field(default=None, serialization_alias="anthropic")
+    google: Optional[str] = Field(default=None, serialization_alias="google")
+
+
 class StartHyperAgentTaskParams(BaseModel):
     """
     Parameters for creating a new HyperAgent task.
@@ -27,6 +41,12 @@ class StartHyperAgentTaskParams(BaseModel):
     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[HyperAgentApiKeys] = Field(
+        default=None, serialization_alias="apiKeys"
+    )
 
 
 class StartHyperAgentTaskResponse(BaseModel):

hyperbrowser-0.50.0/hyperbrowser/models/computer_action.py

@@ -0,0 +1,135 @@
+from enum import Enum
+from typing import List, Literal, Optional, Union
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class ComputerAction(str, Enum):
+    """Computer action types."""
+
+    CLICK = "click"
+    DRAG = "drag"
+    PRESS_KEYS = "press_keys"
+    MOVE_MOUSE = "move_mouse"
+    SCREENSHOT = "screenshot"
+    SCROLL = "scroll"
+    TYPE_TEXT = "type_text"
+
+
+class Coordinate(BaseModel):
+    """Coordinate model for drag actions."""
+
+    x: int
+    y: int
+
+
+class ClickActionParams(BaseModel):
+    """Parameters for click action."""
+
+    model_config = ConfigDict(use_enum_values=True)
+
+    action: Literal[ComputerAction.CLICK] = ComputerAction.CLICK
+    x: int
+    y: int
+    button: Literal["left", "right", "middle", "back", "forward", "wheel"] = Field(
+        default="left"
+    )
+    num_clicks: int = Field(serialization_alias="numClicks", default=1)
+    return_screenshot: bool = Field(
+        serialization_alias="returnScreenshot", default=False
+    )
+
+
+class DragActionParams(BaseModel):
+    """Parameters for drag action."""
+
+    model_config = ConfigDict(use_enum_values=True)
+
+    action: Literal[ComputerAction.DRAG] = ComputerAction.DRAG
+    path: List[Coordinate]
+    return_screenshot: bool = Field(
+        serialization_alias="returnScreenshot", default=False
+    )
+
+
+class PressKeysActionParams(BaseModel):
+    """Parameters for press keys action."""
+
+    model_config = ConfigDict(use_enum_values=True)
+
+    action: Literal[ComputerAction.PRESS_KEYS] = ComputerAction.PRESS_KEYS
+    keys: List[str]
+    return_screenshot: bool = Field(
+        serialization_alias="returnScreenshot", default=False
+    )
+
+
+class MoveMouseActionParams(BaseModel):
+    """Parameters for move mouse action."""
+
+    model_config = ConfigDict(use_enum_values=True)
+
+    action: Literal[ComputerAction.MOVE_MOUSE] = ComputerAction.MOVE_MOUSE
+    x: int = Field(ge=0)
+    y: int = Field(ge=0)
+    return_screenshot: bool = Field(
+        serialization_alias="returnScreenshot", default=False
+    )
+
+
+class ScreenshotActionParams(BaseModel):
+    """Parameters for screenshot action."""
+
+    model_config = ConfigDict(use_enum_values=True)
+
+    action: Literal[ComputerAction.SCREENSHOT] = ComputerAction.SCREENSHOT
+
+
+class ScrollActionParams(BaseModel):
+    """Parameters for scroll action."""
+
+    model_config = ConfigDict(use_enum_values=True)
+
+    action: Literal[ComputerAction.SCROLL] = ComputerAction.SCROLL
+    x: int
+    y: int
+    scroll_x: int = Field(serialization_alias="scrollX")
+    scroll_y: int = Field(serialization_alias="scrollY")
+    return_screenshot: bool = Field(
+        serialization_alias="returnScreenshot", default=False
+    )
+
+
+class TypeTextActionParams(BaseModel):
+    """Parameters for type text action."""
+
+    model_config = ConfigDict(use_enum_values=True)
+
+    action: Literal[ComputerAction.TYPE_TEXT] = ComputerAction.TYPE_TEXT
+    text: str
+    return_screenshot: bool = Field(
+        serialization_alias="returnScreenshot", default=False
+    )
+
+
+ComputerActionParams = Union[
+    ClickActionParams,
+    DragActionParams,
+    PressKeysActionParams,
+    MoveMouseActionParams,
+    ScreenshotActionParams,
+    ScrollActionParams,
+    TypeTextActionParams,
+]
+
+
+class ComputerActionResponse(BaseModel):
+    """Response from computer action API."""
+
+    model_config = ConfigDict(
+        populate_by_alias=True,
+    )
+
+    success: bool
+    screenshot: Optional[str] = None
+    error: Optional[str] = None
+    message: Optional[str] = None

{hyperbrowser-0.48.0 → hyperbrowser-0.50.0}/hyperbrowser/models/session.py

@@ -1,5 +1,6 @@
 from datetime import datetime
 from typing import Any, List, Literal, Optional, Union
+from .computer_action import ComputerActionParams, ComputerActionResponse
 
 from pydantic import BaseModel, ConfigDict, Field, field_validator
 
@@ -64,6 +65,9 @@ class SessionDetail(Session):
     )
 
     ws_endpoint: Optional[str] = Field(alias="wsEndpoint", default=None)
+    computer_action_endpoint: Optional[str] = Field(
+        alias="computerActionEndpoint", default=None
+    )
     live_url: str = Field(alias="liveUrl")
     token: str = Field(alias="token")
 

{hyperbrowser-0.48.0 → hyperbrowser-0.50.0}/pyproject.toml

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