hyperbrowser 0.41.0__tar.gz → 0.71.0__tar.gz

{hyperbrowser-0.41.0 → hyperbrowser-0.71.0}/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2024 hyperbrowserai
+Copyright (c) 2025 S2 Labs Inc.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

{hyperbrowser-0.41.0 → hyperbrowser-0.71.0}/PKG-INFO

@@ -1,8 +1,9 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: hyperbrowser
-Version: 0.41.0
+Version: 0.71.0
 Summary: Python SDK for hyperbrowser
 License: MIT
+License-File: LICENSE
 Author: Nikhil Shahi
 Author-email: nshahi1998@gmail.com
 Requires-Python: >=3.8,<4.0
@@ -14,6 +15,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Requires-Dist: httpx (>=0.23.0,<1)
 Requires-Dist: jsonref (>=1.1.0)
 Requires-Dist: pydantic (>=2.0,<3)
@@ -123,3 +125,7 @@ def main():
 # Run the asyncio event loop
 main()
 ```
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+

{hyperbrowser-0.41.0 → hyperbrowser-0.71.0}/README.md

@@ -99,4 +99,7 @@ def main():
 
 # Run the asyncio event loop
 main()
-```
+```
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

{hyperbrowser-0.41.0 → hyperbrowser-0.71.0}/hyperbrowser/client/async_client.py

@@ -10,6 +10,8 @@ from .managers.async_manager.extract import ExtractManager
 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):
@@ -31,6 +33,8 @@ class AsyncHyperbrowser(HyperbrowserBase):
         self.profiles = ProfileManager(self)
         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.41.0 → hyperbrowser-0.71.0}/hyperbrowser/client/base.py

@@ -27,7 +27,7 @@ class HyperbrowserBase:
                     base_url
                     if base_url is not None
                     else os.environ.get(
-                        "HYPERBROWSER_BASE_URL", "https://app.hyperbrowser.ai"
+                        "HYPERBROWSER_BASE_URL", "https://api.hyperbrowser.ai"
                     )
                 ),
             )

{hyperbrowser-0.41.0 → hyperbrowser-0.71.0}/hyperbrowser/client/managers/async_manager/agents/__init__.py

@@ -1,6 +1,8 @@
 from .browser_use import BrowserUseManager
 from .cua import CuaManager
 from .claude_computer_use import ClaudeComputerUseManager
+from .hyper_agent import HyperAgentManager
+from .gemini_computer_use import GeminiComputerUseManager
 
 
 class Agents:
@@ -8,3 +10,5 @@ class Agents:
         self.browser_use = BrowserUseManager(client)
         self.cua = CuaManager(client)
         self.claude_computer_use = ClaudeComputerUseManager(client)
+        self.hyper_agent = HyperAgentManager(client)
+        self.gemini_computer_use = GeminiComputerUseManager(client)

{hyperbrowser-0.41.0 → hyperbrowser-0.71.0}/hyperbrowser/client/managers/async_manager/agents/browser_use.py

@@ -1,4 +1,5 @@
 import asyncio
+import jsonref
 
 from hyperbrowser.exceptions import HyperbrowserError
 
@@ -19,6 +20,13 @@ class BrowserUseManager:
     async def start(
         self, params: StartBrowserUseTaskParams
     ) -> StartBrowserUseTaskResponse:
+        if params.output_model_schema:
+            if hasattr(params.output_model_schema, "model_json_schema"):
+                params.output_model_schema = jsonref.replace_refs(
+                    params.output_model_schema.model_json_schema(),
+                    proxies=False,
+                    lazy_load=False,
+                )
         response = await self._client.transport.post(
             self._client._build_url("/task/browser-use"),
             data=params.model_dump(exclude_none=True, by_alias=True),

hyperbrowser-0.71.0/hyperbrowser/client/managers/async_manager/agents/gemini_computer_use.py

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

hyperbrowser-0.71.0/hyperbrowser/client/managers/async_manager/agents/hyper_agent.py

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

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

@@ -0,0 +1,165 @@
+from pydantic import BaseModel
+from typing import Union, List, Optional
+from hyperbrowser.models import (
+    SessionDetail,
+    ComputerActionParams,
+    ComputerActionResponse,
+    ClickActionParams,
+    DragActionParams,
+    PressKeysActionParams,
+    MoveMouseActionParams,
+    ScreenshotActionParams,
+    ScrollActionParams,
+    TypeTextActionParams,
+    Coordinate,
+    HoldKeyActionParams,
+    MouseDownActionParams,
+    MouseUpActionParams,
+    ComputerActionMouseButton,
+    GetClipboardTextActionParams,
+)
+
+
+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: Optional[int] = None,
+        y: Optional[int] = None,
+        button: ComputerActionMouseButton = "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 hold_key(
+        self,
+        session: Union[SessionDetail, str],
+        key: str,
+        duration: int,
+        return_screenshot: bool = False,
+    ) -> ComputerActionResponse:
+        params = HoldKeyActionParams(
+            key=key, duration=duration, return_screenshot=return_screenshot
+        )
+        return await self._execute_request(session, params)
+
+    async def mouse_down(
+        self,
+        session: Union[SessionDetail, str],
+        button: ComputerActionMouseButton = "left",
+        return_screenshot: bool = False,
+    ) -> ComputerActionResponse:
+        params = MouseDownActionParams(
+            button=button, return_screenshot=return_screenshot
+        )
+        return await self._execute_request(session, params)
+
+    async def mouse_up(
+        self,
+        session: Union[SessionDetail, str],
+        button: ComputerActionMouseButton = "left",
+        return_screenshot: bool = False,
+    ) -> ComputerActionResponse:
+        params = MouseUpActionParams(button=button, 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)
+
+    async def get_clipboard_text(
+        self,
+        session: Union[SessionDetail, str],
+        return_screenshot: bool = False,
+    ) -> ComputerActionResponse:
+        params = GetClipboardTextActionParams(return_screenshot=return_screenshot)
+        return await self._execute_request(session, params)

{hyperbrowser-0.41.0 → hyperbrowser-0.71.0}/hyperbrowser/client/managers/async_manager/crawl.py

@@ -103,6 +103,7 @@ class CrawlManager:
                 job_response.total_crawled_pages = tmp_job_response.total_crawled_pages
                 job_response.total_page_batches = tmp_job_response.total_page_batches
                 job_response.batch_size = tmp_job_response.batch_size
+                job_response.error = tmp_job_response.error
                 failures = 0
                 first_check = False
             except Exception as e:

{hyperbrowser-0.41.0 → hyperbrowser-0.71.0}/hyperbrowser/client/managers/async_manager/scrape.py

@@ -111,6 +111,7 @@ class BatchScrapeManager:
                 job_response.total_scraped_pages = tmp_job_response.total_scraped_pages
                 job_response.total_page_batches = tmp_job_response.total_page_batches
                 job_response.batch_size = tmp_job_response.batch_size
+                job_response.error = tmp_job_response.error
                 failures = 0
                 first_check = False
             except Exception as e:

{hyperbrowser-0.41.0 → hyperbrowser-0.71.0}/hyperbrowser/client/managers/async_manager/session.py

@@ -1,19 +1,41 @@
-from typing import List
+from typing import List, Union, IO
 from ....models.session import (
     BasicResponse,
     CreateSessionParams,
     GetSessionDownloadsUrlResponse,
     GetSessionRecordingUrlResponse,
+    GetSessionVideoRecordingUrlResponse,
     SessionDetail,
     SessionListParams,
     SessionListResponse,
     SessionRecording,
+    UploadFileResponse,
+    SessionEventLogListParams,
+    SessionEventLogListResponse,
+    SessionEventLog,
 )
 
 
+class SessionEventLogsManager:
+    def __init__(self, client):
+        self._client = client
+
+    async def list(
+        self,
+        session_id: str,
+        params: SessionEventLogListParams = SessionEventLogListParams(),
+    ) -> List[SessionEventLog]:
+        response = await self._client.transport.get(
+            self._client._build_url(f"/session/{session_id}/event-logs"),
+            params=params.model_dump(exclude_none=True, by_alias=True),
+        )
+        return SessionEventLogListResponse(**response.data)
+
+
 class SessionManager:
     def __init__(self, client):
         self._client = client
+        self.event_logs = SessionEventLogsManager(client)
 
     async def create(self, params: CreateSessionParams = None) -> SessionDetail:
         response = await self._client.transport.post(
@@ -59,8 +81,36 @@ class SessionManager:
         )
         return GetSessionRecordingUrlResponse(**response.data)
 
+    async def get_video_recording_url(
+        self, id: str
+    ) -> GetSessionVideoRecordingUrlResponse:
+        response = await self._client.transport.get(
+            self._client._build_url(f"/session/{id}/video-recording-url")
+        )
+        return GetSessionVideoRecordingUrlResponse(**response.data)
+
     async def get_downloads_url(self, id: str) -> GetSessionDownloadsUrlResponse:
         response = await self._client.transport.get(
             self._client._build_url(f"/session/{id}/downloads-url")
         )
         return GetSessionDownloadsUrlResponse(**response.data)
+
+    async def upload_file(
+        self, id: str, file_input: Union[str, IO]
+    ) -> UploadFileResponse:
+        response = None
+        if isinstance(file_input, str):
+            with open(file_input, "rb") as file_obj:
+                files = {"file": file_obj}
+                response = await self._client.transport.post(
+                    self._client._build_url(f"/session/{id}/uploads"),
+                    files=files,
+                )
+        else:
+            files = {"file": file_input}
+            response = await self._client.transport.post(
+                self._client._build_url(f"/session/{id}/uploads"),
+                files=files,
+            )
+
+        return UploadFileResponse(**response.data)

hyperbrowser-0.71.0/hyperbrowser/client/managers/async_manager/team.py

@@ -0,0 +1,12 @@
+from hyperbrowser.models import TeamCreditInfo
+
+
+class TeamManager:
+    def __init__(self, client):
+        self._client = client
+
+    async def get_credit_info(self) -> TeamCreditInfo:
+        response = await self._client.transport.get(
+            self._client._build_url("/team/credit-info")
+        )
+        return TeamCreditInfo(**response.data)

{hyperbrowser-0.41.0 → hyperbrowser-0.71.0}/hyperbrowser/client/managers/sync_manager/agents/__init__.py

@@ -1,6 +1,8 @@
 from .browser_use import BrowserUseManager
 from .cua import CuaManager
 from .claude_computer_use import ClaudeComputerUseManager
+from .hyper_agent import HyperAgentManager
+from .gemini_computer_use import GeminiComputerUseManager
 
 
 class Agents:
@@ -8,3 +10,5 @@ class Agents:
         self.browser_use = BrowserUseManager(client)
         self.cua = CuaManager(client)
         self.claude_computer_use = ClaudeComputerUseManager(client)
+        self.hyper_agent = HyperAgentManager(client)
+        self.gemini_computer_use = GeminiComputerUseManager(client)

{hyperbrowser-0.41.0 → hyperbrowser-0.71.0}/hyperbrowser/client/managers/sync_manager/agents/browser_use.py

@@ -1,4 +1,5 @@
 import time
+import jsonref
 
 from hyperbrowser.exceptions import HyperbrowserError
 
@@ -17,6 +18,13 @@ class BrowserUseManager:
         self._client = client
 
     def start(self, params: StartBrowserUseTaskParams) -> StartBrowserUseTaskResponse:
+        if params.output_model_schema:
+            if hasattr(params.output_model_schema, "model_json_schema"):
+                params.output_model_schema = jsonref.replace_refs(
+                    params.output_model_schema.model_json_schema(),
+                    proxies=False,
+                    lazy_load=False,
+                )
         response = self._client.transport.post(
             self._client._build_url("/task/browser-use"),
             data=params.model_dump(exclude_none=True, by_alias=True),

{hyperbrowser-0.41.0 → hyperbrowser-0.71.0}/hyperbrowser/client/managers/sync_manager/agents/claude_computer_use.py

@@ -49,7 +49,7 @@ class ClaudeComputerUseManager:
         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")
+            raise HyperbrowserError("Failed to start Claude Computer Use task job")
 
         failures = 0
         while True:

hyperbrowser-0.71.0/hyperbrowser/client/managers/sync_manager/agents/gemini_computer_use.py

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