hyperbrowser 0.30.0__tar.gz → 0.31.0__tar.gz

{hyperbrowser-0.30.0 → hyperbrowser-0.31.0}/PKG-INFO

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

{hyperbrowser-0.30.0 → hyperbrowser-0.31.0}/hyperbrowser/client/async_client.py

@@ -6,6 +6,7 @@ from .managers.async_manager.session import SessionManager
 from .managers.async_manager.scrape import ScrapeManager
 from .managers.async_manager.crawl import CrawlManager
 from .managers.async_manager.extension import ExtensionManager
+from .managers.async_manager.beta import Beta
 from .base import HyperbrowserBase
 from ..transport.async_transport import AsyncTransport
 from ..config import ClientConfig
@@ -29,6 +30,7 @@ class AsyncHyperbrowser(HyperbrowserBase):
         self.extract = ExtractManager(self)
         self.profiles = ProfileManager(self)
         self.extensions = ExtensionManager(self)
+        self.beta = Beta(self)
 
     async def close(self) -> None:
         await self.transport.close()

hyperbrowser-0.31.0/hyperbrowser/client/managers/async_manager/beta/__init__.py

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

hyperbrowser-0.31.0/hyperbrowser/client/managers/async_manager/beta/agents/__init__.py

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

hyperbrowser-0.31.0/hyperbrowser/client/managers/async_manager/beta/agents/browser_use.py

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

hyperbrowser-0.31.0/hyperbrowser/client/managers/sync_manager/beta/__init__.py

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

hyperbrowser-0.31.0/hyperbrowser/client/managers/sync_manager/beta/agents/__init__.py

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

hyperbrowser-0.31.0/hyperbrowser/client/managers/sync_manager/beta/agents/browser_use.py

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

{hyperbrowser-0.30.0 → hyperbrowser-0.31.0}/hyperbrowser/client/sync.py

@@ -5,6 +5,7 @@ from .managers.sync_manager.profile import ProfileManager
 from .managers.sync_manager.session import SessionManager
 from .managers.sync_manager.scrape import ScrapeManager
 from .managers.sync_manager.crawl import CrawlManager
+from .managers.sync_manager.beta import Beta
 from .managers.sync_manager.extension import ExtensionManager
 from .base import HyperbrowserBase
 from ..transport.sync import SyncTransport
@@ -29,6 +30,7 @@ class Hyperbrowser(HyperbrowserBase):
         self.extract = ExtractManager(self)
         self.profiles = ProfileManager(self)
         self.extensions = ExtensionManager(self)
+        self.beta = Beta(self)
 
     def close(self) -> None:
         self.transport.close()

{hyperbrowser-0.30.0 → hyperbrowser-0.31.0}/hyperbrowser/config.py

@@ -8,7 +8,7 @@ class ClientConfig:
     """Configuration for the Hyperbrowser client"""
 
     api_key: str
-    base_url: str = "https://api.hyperbrowser.com"
+    base_url: str = "https://app.hyperbrowser.ai"
 
     @classmethod
     def from_env(cls) -> "ClientConfig":
@@ -17,6 +17,6 @@ class ClientConfig:
             raise ValueError("HYPERBROWSER_API_KEY environment variable is required")
 
         base_url = os.environ.get(
-            "HYPERBROWSER_BASE_URL", "https://api.hyperbrowser.com"
+            "HYPERBROWSER_BASE_URL", "https://app.hyperbrowser.ai"
         )
         return cls(api_key=api_key, base_url=base_url)

hyperbrowser-0.31.0/hyperbrowser/models/__init__.py

@@ -0,0 +1,142 @@
+from .consts import (
+    ScrapeFormat,
+    ScrapeWaitUntil,
+    ScrapePageStatus,
+    ScrapeScreenshotFormat,
+    RecordingStatus,
+    DownloadsStatus,
+    POLLING_ATTEMPTS,
+    Country,
+    OperatingSystem,
+    Platform,
+    ISO639_1,
+    State,
+    BrowserUseLlm,
+)
+from .crawl import (
+    CrawlJobStatus,
+    CrawlPageStatus,
+    StartCrawlJobParams,
+    StartCrawlJobResponse,
+    CrawledPage,
+    GetCrawlJobParams,
+    CrawlJobResponse,
+)
+from .extension import CreateExtensionParams, ExtensionResponse
+from .extract import (
+    ExtractJobStatus,
+    StartExtractJobParams,
+    StartExtractJobResponse,
+    ExtractJobResponse,
+)
+from .profile import (
+    CreateProfileResponse,
+    ProfileResponse,
+    ProfileListParams,
+    ProfileListResponse,
+)
+from .scrape import (
+    ScrapeJobStatus,
+    ScreenshotOptions,
+    ScrapeOptions,
+    StartScrapeJobParams,
+    StartScrapeJobResponse,
+    ScrapeJobData,
+    ScrapeJobResponse,
+    StartBatchScrapeJobParams,
+    ScrapedPage,
+    GetBatchScrapeJobParams,
+    StartBatchScrapeJobResponse,
+    BatchScrapeJobResponse,
+)
+from .session import (
+    SessionStatus,
+    BasicResponse,
+    Session,
+    SessionDetail,
+    SessionListParams,
+    SessionListResponse,
+    ScreenConfig,
+    CreateSessionProfile,
+    CreateSessionParams,
+    SessionRecording,
+    GetSessionRecordingUrlResponse,
+    GetSessionDownloadsUrlResponse,
+)
+from .beta.agents.browser_use import (
+    StartBrowserUseTaskParams,
+    StartBrowserUseTaskResponse,
+    BrowserUseTaskStatusResponse,
+    BrowserUseTaskData,
+    BrowserUseTaskResponse,
+)
+
+__all__ = [
+    # consts
+    "BrowserUseLlm",
+    "ScrapeFormat",
+    "ScrapeWaitUntil",
+    "ScrapePageStatus",
+    "ScrapeScreenshotFormat",
+    "RecordingStatus",
+    "DownloadsStatus",
+    "POLLING_ATTEMPTS",
+    "Country",
+    "OperatingSystem",
+    "Platform",
+    "ISO639_1",
+    "State",
+    # crawl
+    "CrawlJobStatus",
+    "CrawlPageStatus",
+    "StartCrawlJobParams",
+    "StartCrawlJobResponse",
+    "CrawledPage",
+    "GetCrawlJobParams",
+    "CrawlJobResponse",
+    # extension
+    "CreateExtensionParams",
+    "ExtensionResponse",
+    # extract
+    "ExtractJobStatus",
+    "StartExtractJobParams",
+    "StartExtractJobResponse",
+    "ExtractJobResponse",
+    # profile
+    "CreateProfileResponse",
+    "ProfileResponse",
+    "ProfileListParams",
+    "ProfileListResponse",
+    # scrape
+    "ScrapeJobStatus",
+    "ScreenshotOptions",
+    "ScrapeOptions",
+    "StartScrapeJobParams",
+    "StartScrapeJobResponse",
+    "ScrapeJobData",
+    "ScrapeJobResponse",
+    "StartBatchScrapeJobParams",
+    "ScrapedPage",
+    "GetBatchScrapeJobParams",
+    "StartBatchScrapeJobResponse",
+    "BatchScrapeJobResponse",
+    # session
+    "SessionStatus",
+    "BasicResponse",
+    "Session",
+    "SessionDetail",
+    "SessionListParams",
+    "SessionListResponse",
+    "ScreenConfig",
+    "CreateSessionProfile",
+    "CreateSessionParams",
+    "SessionRecording",
+    "GetSessionRecordingUrlResponse",
+    "GetSessionDownloadsUrlResponse",
+    # agents
+    "StartBrowserUseTaskParams",
+    "StartBrowserUseTaskResponse",
+    "BrowserUseTaskStatusResponse",
+    "BrowserUseTaskData",
+    "BrowserUseTaskResponse",
+]

hyperbrowser-0.31.0/hyperbrowser/models/beta/agents/browser_use.py

@@ -0,0 +1,177 @@
+from typing import Literal, Optional, Union
+from pydantic import BaseModel, ConfigDict, Field
+
+from ...consts import BrowserUseLlm
+from ...session import CreateSessionParams
+
+BrowserUseTaskStatus = Literal["pending", "running", "completed", "failed", "stopped"]
+
+
+class StartBrowserUseTaskParams(BaseModel):
+    """
+    Parameters for creating a new browser use task.
+    """
+
+    model_config = ConfigDict(
+        populate_by_alias=True,
+    )
+
+    task: str
+    llm: Optional[BrowserUseLlm] = Field(default=None, serialization_alias="llm")
+    session_id: Optional[str] = Field(default=None, serialization_alias="sessionId")
+    validate_output: Optional[bool] = Field(
+        default=None, serialization_alias="validateOutput"
+    )
+    use_vision: Optional[bool] = Field(default=None, serialization_alias="useVision")
+    use_vision_for_planner: Optional[bool] = Field(
+        default=None, serialization_alias="useVisionForPlanner"
+    )
+    max_actions_per_step: Optional[int] = Field(
+        default=None, serialization_alias="maxActionsPerStep"
+    )
+    max_input_tokens: Optional[int] = Field(
+        default=None, serialization_alias="maxInputTokens"
+    )
+    planner_llm: Optional[BrowserUseLlm] = Field(
+        default=None, serialization_alias="plannerLlm"
+    )
+    page_extraction_llm: Optional[BrowserUseLlm] = Field(
+        default=None, serialization_alias="pageExtractionLlm"
+    )
+    planner_interval: Optional[int] = Field(
+        default=None, serialization_alias="plannerInterval"
+    )
+    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 StartBrowserUseTaskResponse(BaseModel):
+    """
+    Response from starting a browser use task.
+    """
+
+    model_config = ConfigDict(
+        populate_by_alias=True,
+    )
+
+    job_id: str = Field(alias="jobId")
+
+
+class BrowserUseTaskStatusResponse(BaseModel):
+    """
+    Response from getting a browser use task status.
+    """
+
+    model_config = ConfigDict(
+        populate_by_alias=True,
+    )
+
+    status: BrowserUseTaskStatus
+
+
+class BrowserUseAgentBrain(BaseModel):
+    evaluation_previous_goal: str
+    memory: str
+    next_goal: str
+
+
+class BrowserUseAgentOutput(BaseModel):
+    current_state: BrowserUseAgentBrain
+    action: list[dict]
+
+
+class BrowserUseActionResult(BaseModel):
+    is_done: Optional[bool] = False
+    success: Optional[bool] = None
+    extracted_content: Optional[str] = None
+    error: Optional[str] = None
+    include_in_memory: bool = False
+
+
+class BrowserUseStepMetadata(BaseModel):
+    step_start_time: float
+    step_end_time: float
+    input_tokens: int
+    step_number: int
+
+
+class BrowserUseTabInfo(BaseModel):
+    page_id: int
+    url: str
+    title: str
+
+
+class BrowserUseCoordinates(BaseModel):
+    x: int
+    y: int
+
+
+class BrowserUseCoordinateSet(BaseModel):
+    top_left: BrowserUseCoordinates
+    top_right: BrowserUseCoordinates
+    bottom_left: BrowserUseCoordinates
+    bottom_right: BrowserUseCoordinates
+    center: BrowserUseCoordinates
+    width: int
+    height: int
+
+
+class BrowserUseViewportInfo(BaseModel):
+    scroll_x: int
+    scroll_y: int
+    width: int
+    height: int
+
+
+class BrowserUseDOMHistoryElement(BaseModel):
+    tag_name: str
+    xpath: str
+    highlight_index: Optional[int]
+    entire_parent_branch_path: list[str]
+    attributes: dict[str, str]
+    shadow_root: bool = False
+    css_selector: Optional[str] = None
+    page_coordinates: Optional[BrowserUseCoordinateSet] = None
+    viewport_coordinates: Optional[BrowserUseCoordinateSet] = None
+    viewport_info: Optional[BrowserUseViewportInfo] = None
+
+
+class BrowserUseBrowserStateHistory(BaseModel):
+    url: str
+    title: str
+    tabs: list[BrowserUseTabInfo]
+    interacted_element: Union[
+        list[Union[BrowserUseDOMHistoryElement, None]], list[None]
+    ]
+    screenshot: Optional[str] = None
+
+
+class BrowserUseAgentHistory(BaseModel):
+    model_output: Union[BrowserUseAgentOutput, None]
+    result: list[BrowserUseActionResult]
+    state: BrowserUseBrowserStateHistory
+    metadata: Optional[BrowserUseStepMetadata] = None
+
+
+class BrowserUseTaskData(BaseModel):
+    history: list[BrowserUseAgentHistory]
+
+
+class BrowserUseTaskResponse(BaseModel):
+    """
+    Response from a browser use task.
+    """
+
+    model_config = ConfigDict(
+        populate_by_alias=True,
+    )
+
+    job_id: str = Field(alias="jobId")
+    status: BrowserUseTaskStatus
+    data: Optional[BrowserUseTaskData] = Field(default=None, alias="data")
+    error: Optional[str] = Field(default=None, alias="error")

{hyperbrowser-0.30.0 → hyperbrowser-0.31.0}/hyperbrowser/models/consts.py

@@ -13,6 +13,16 @@ DownloadsStatus = Literal[
 
 POLLING_ATTEMPTS = 5
 
+BrowserUseLlm = Literal[
+    "gpt-4o",
+    "gpt-4o-mini",
+    "claude-3-7-sonnet-20250219",
+    "claude-3-5-haiku-20241022",
+    "gemini-2.0-flash",
+    "gemini-2.0-flash-thinking",
+    "gemini-2.0-pro",
+]
+
 Country = Literal[
     "AD",
     "AE",

{hyperbrowser-0.30.0 → hyperbrowser-0.31.0}/hyperbrowser/models/extract.py

@@ -55,4 +55,4 @@ class ExtractJobResponse(BaseModel):
     job_id: str = Field(alias="jobId")
     status: ExtractJobStatus
     error: Optional[str] = None
-    data: Optional[Any] = None
+    data: Optional[dict] = None

{hyperbrowser-0.30.0 → hyperbrowser-0.31.0}/pyproject.toml

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