hyperbrowser 1.10.0__tar.gz → 1.11.0__tar.gz

{hyperbrowser-1.10.0 → hyperbrowser-1.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperbrowser
-Version: 1.10.0
+Version: 1.11.0
 Summary: Python SDK for hyperbrowser
 License: MIT
 License-File: LICENSE
@@ -62,6 +62,40 @@ Profile names must match `^[A-Za-z0-9._-]+$`.
 
 `base_url` and `HYPERBROWSER_BASE_URL` accept either `https://host` or `https://host/api`. The client normalizes both to the same control-plane base URL.
 
+## WebMCP page tools
+
+Create a session with `{"enable_web_mcp": True}` (default: false), then navigate
+to a page that exposes WebMCP tools using Playwright. With that session open:
+
+```python
+discovery = client.sessions.webmcp.list_tools(session.id)
+# Select a tool using its name, source page/frame, and input schema.
+tool = next(tool for tool in discovery.tools if tool.name == "search")
+result = client.sessions.webmcp.invoke(session.id, {
+    "tool_ref": tool.tool_ref,
+    "input": {"query": "flights to Tokyo"},  # Match the selected tool's schema.
+})
+print(result.status, result.output)
+```
+
+For long-running tools or forms awaiting human submission, use
+`client.sessions.webmcp.start(session_id, params)`, then
+`client.sessions.webmcp.get_result(session_id, invocation_id, {"wait_seconds": 30})`
+until the status is terminal. `client.sessions.webmcp.cancel(session_id, invocation_id)`
+requests best-effort cancellation. Blocking invocation defaults to 60 seconds
+(maximum 120); `start` defaults to 300 seconds (maximum 3,600) via `timeout_seconds`.
+All five methods also work with `AsyncHyperbrowser` by adding `await`.
+
+Discover tools again after navigation. Invocations never automatically retry;
+losing a response can leave an unknown outcome. Handles are ephemeral and
+terminal results expire after 10 minutes or earlier eviction. Check result
+status and truncation metadata before using output. Tool input and output keys
+are not renamed. Request TypedDicts are available in `hyperbrowser.types`, and
+Pydantic request/response models in `hyperbrowser.models`.
+
+See the [WebMCP guide](https://hyperbrowser.ai/docs/sessions/webmcp) for complete
+examples, cancellation behavior, human submission, and limits.
+
 ## Usage
 
 Hyperbrowser 1.0 accepts plain dictionaries for request parameters. Method

{hyperbrowser-1.10.0 → hyperbrowser-1.11.0}/README.md

@@ -34,6 +34,40 @@ Profile names must match `^[A-Za-z0-9._-]+$`.
 
 `base_url` and `HYPERBROWSER_BASE_URL` accept either `https://host` or `https://host/api`. The client normalizes both to the same control-plane base URL.
 
+## WebMCP page tools
+
+Create a session with `{"enable_web_mcp": True}` (default: false), then navigate
+to a page that exposes WebMCP tools using Playwright. With that session open:
+
+```python
+discovery = client.sessions.webmcp.list_tools(session.id)
+# Select a tool using its name, source page/frame, and input schema.
+tool = next(tool for tool in discovery.tools if tool.name == "search")
+result = client.sessions.webmcp.invoke(session.id, {
+    "tool_ref": tool.tool_ref,
+    "input": {"query": "flights to Tokyo"},  # Match the selected tool's schema.
+})
+print(result.status, result.output)
+```
+
+For long-running tools or forms awaiting human submission, use
+`client.sessions.webmcp.start(session_id, params)`, then
+`client.sessions.webmcp.get_result(session_id, invocation_id, {"wait_seconds": 30})`
+until the status is terminal. `client.sessions.webmcp.cancel(session_id, invocation_id)`
+requests best-effort cancellation. Blocking invocation defaults to 60 seconds
+(maximum 120); `start` defaults to 300 seconds (maximum 3,600) via `timeout_seconds`.
+All five methods also work with `AsyncHyperbrowser` by adding `await`.
+
+Discover tools again after navigation. Invocations never automatically retry;
+losing a response can leave an unknown outcome. Handles are ephemeral and
+terminal results expire after 10 minutes or earlier eviction. Check result
+status and truncation metadata before using output. Tool input and output keys
+are not renamed. Request TypedDicts are available in `hyperbrowser.types`, and
+Pydantic request/response models in `hyperbrowser.models`.
+
+See the [WebMCP guide](https://hyperbrowser.ai/docs/sessions/webmcp) for complete
+examples, cancellation behavior, human submission, and limits.
+
 ## Usage
 
 Hyperbrowser 1.0 accepts plain dictionaries for request parameters. Method

{hyperbrowser-1.10.0 → hyperbrowser-1.11.0}/hyperbrowser/client/managers/async_manager/session.py

@@ -1,4 +1,6 @@
 import warnings
+
+from .webmcp import WebMCPManager
 from collections.abc import Mapping
 from typing import IO, List, Optional, Union, overload
 
@@ -68,6 +70,7 @@ class SessionManager:
     def __init__(self, client):
         self._client = client
         self.event_logs = SessionEventLogsManager(client)
+        self.webmcp = WebMCPManager(client)
 
     async def create(
         self,

hyperbrowser-1.11.0/hyperbrowser/client/managers/async_manager/webmcp.py

@@ -0,0 +1,98 @@
+from typing import Optional, Union
+from urllib.parse import quote
+
+from hyperbrowser.client._request import coerce_request, dump_request
+from hyperbrowser.models.webmcp import (
+    WebMCPInvocation,
+    WebMCPInvokeParams,
+    WebMCPInvokeResult,
+    WebMCPResultParams,
+    WebMCPStartParams,
+    WebMCPToolsResponse,
+)
+from hyperbrowser.types.webmcp import (
+    WebMCPInvokeParams as WebMCPInvokeParamsDict,
+    WebMCPResultParams as WebMCPResultParamsDict,
+    WebMCPStartParams as WebMCPStartParamsDict,
+)
+
+
+class WebMCPManager:
+    """Discover and invoke page tools in sessions created with enable_web_mcp=True."""
+
+    def __init__(self, client):
+        self._client = client
+
+    def _url(self, session_id: str, suffix: str) -> str:
+        return self._client._build_url(
+            f"/session/{quote(session_id, safe='')}/webmcp{suffix}"
+        )
+
+    async def list_tools(self, session_id: str) -> WebMCPToolsResponse:
+        """Discover document-bound tools across the session's tabs and frames."""
+        response = await self._client.transport.get(
+            self._url(session_id, "/tools"), timeout=max(self._client.timeout, 40)
+        )
+        return WebMCPToolsResponse(**response.data)
+
+    async def invoke(
+        self,
+        session_id: str,
+        params: Union[WebMCPInvokeParamsDict, WebMCPInvokeParams],
+    ) -> WebMCPInvokeResult:
+        """Invoke once and wait. A form can return awaiting_submission with a handle.
+
+        This POST is never automatically retried: losing its response can leave the
+        outcome unknown, and repeating it could duplicate a side effect.
+        """
+        request = coerce_request(params, WebMCPInvokeParams)
+        response = await self._client.transport.post(
+            self._url(session_id, "/invoke"),
+            data=dump_request(request, WebMCPInvokeParams),
+            timeout=max(self._client.timeout, request.timeout_seconds + 35),
+        )
+        return WebMCPInvokeResult(**response.data)
+
+    async def start(
+        self,
+        session_id: str,
+        params: Union[WebMCPStartParamsDict, WebMCPStartParams],
+    ) -> WebMCPInvocation:
+        """Start once and return a handle; use get_result to observe its outcome."""
+        response = await self._client.transport.post(
+            self._url(session_id, "/invocations"),
+            data=dump_request(params, WebMCPStartParams),
+            timeout=max(self._client.timeout, 40),
+        )
+        return WebMCPInvocation(**response.data)
+
+    async def get_result(
+        self,
+        session_id: str,
+        invocation_id: str,
+        params: Optional[Union[WebMCPResultParamsDict, WebMCPResultParams]] = None,
+    ) -> WebMCPInvocation:
+        """Read or long-poll once. Running/awaiting_submission can remain pending.
+
+        Handles are in memory. Terminal results expire after 10 minutes and may
+        be evicted sooner; browser shutdown or receiver restart also loses them.
+        """
+        request = coerce_request(
+            params if params is not None else {}, WebMCPResultParams
+        )
+        response = await self._client.transport.get(
+            self._url(session_id, f"/invocations/{quote(invocation_id, safe='')}"),
+            params=dump_request(request, WebMCPResultParams),
+            timeout=max(self._client.timeout, request.wait_seconds + 20),
+        )
+        return WebMCPInvocation(**response.data)
+
+    async def cancel(self, session_id: str, invocation_id: str) -> WebMCPInvocation:
+        """Request best-effort cancellation. Completion can win; side effects persist."""
+        response = await self._client.transport.post(
+            self._url(
+                session_id, f"/invocations/{quote(invocation_id, safe='')}/cancel"
+            ),
+            timeout=max(self._client.timeout, 20),
+        )
+        return WebMCPInvocation(**response.data)

{hyperbrowser-1.10.0 → hyperbrowser-1.11.0}/hyperbrowser/client/managers/sync_manager/session.py

@@ -1,4 +1,6 @@
 import warnings
+
+from .webmcp import WebMCPManager
 from collections.abc import Mapping
 from typing import IO, List, Optional, Union, overload
 
@@ -68,6 +70,7 @@ class SessionManager:
     def __init__(self, client):
         self._client = client
         self.event_logs = SessionEventLogsManager(client)
+        self.webmcp = WebMCPManager(client)
 
     def create(
         self,

hyperbrowser-1.11.0/hyperbrowser/client/managers/sync_manager/webmcp.py

@@ -0,0 +1,98 @@
+from typing import Optional, Union
+from urllib.parse import quote
+
+from hyperbrowser.client._request import coerce_request, dump_request
+from hyperbrowser.models.webmcp import (
+    WebMCPInvocation,
+    WebMCPInvokeParams,
+    WebMCPInvokeResult,
+    WebMCPResultParams,
+    WebMCPStartParams,
+    WebMCPToolsResponse,
+)
+from hyperbrowser.types.webmcp import (
+    WebMCPInvokeParams as WebMCPInvokeParamsDict,
+    WebMCPResultParams as WebMCPResultParamsDict,
+    WebMCPStartParams as WebMCPStartParamsDict,
+)
+
+
+class WebMCPManager:
+    """Discover and invoke page tools in sessions created with enable_web_mcp=True."""
+
+    def __init__(self, client):
+        self._client = client
+
+    def _url(self, session_id: str, suffix: str) -> str:
+        return self._client._build_url(
+            f"/session/{quote(session_id, safe='')}/webmcp{suffix}"
+        )
+
+    def list_tools(self, session_id: str) -> WebMCPToolsResponse:
+        """Discover document-bound tools across the session's tabs and frames."""
+        response = self._client.transport.get(
+            self._url(session_id, "/tools"), timeout=max(self._client.timeout, 40)
+        )
+        return WebMCPToolsResponse(**response.data)
+
+    def invoke(
+        self,
+        session_id: str,
+        params: Union[WebMCPInvokeParamsDict, WebMCPInvokeParams],
+    ) -> WebMCPInvokeResult:
+        """Invoke once and wait. A form can return awaiting_submission with a handle.
+
+        This POST is never automatically retried: losing its response can leave the
+        outcome unknown, and repeating it could duplicate a side effect.
+        """
+        request = coerce_request(params, WebMCPInvokeParams)
+        response = self._client.transport.post(
+            self._url(session_id, "/invoke"),
+            data=dump_request(request, WebMCPInvokeParams),
+            timeout=max(self._client.timeout, request.timeout_seconds + 35),
+        )
+        return WebMCPInvokeResult(**response.data)
+
+    def start(
+        self,
+        session_id: str,
+        params: Union[WebMCPStartParamsDict, WebMCPStartParams],
+    ) -> WebMCPInvocation:
+        """Start once and return a handle; use get_result to observe its outcome."""
+        response = self._client.transport.post(
+            self._url(session_id, "/invocations"),
+            data=dump_request(params, WebMCPStartParams),
+            timeout=max(self._client.timeout, 40),
+        )
+        return WebMCPInvocation(**response.data)
+
+    def get_result(
+        self,
+        session_id: str,
+        invocation_id: str,
+        params: Optional[Union[WebMCPResultParamsDict, WebMCPResultParams]] = None,
+    ) -> WebMCPInvocation:
+        """Read or long-poll once. Running/awaiting_submission can remain pending.
+
+        Handles are in memory. Terminal results expire after 10 minutes and may
+        be evicted sooner; browser shutdown or receiver restart also loses them.
+        """
+        request = coerce_request(
+            params if params is not None else {}, WebMCPResultParams
+        )
+        response = self._client.transport.get(
+            self._url(session_id, f"/invocations/{quote(invocation_id, safe='')}"),
+            params=dump_request(request, WebMCPResultParams),
+            timeout=max(self._client.timeout, request.wait_seconds + 20),
+        )
+        return WebMCPInvocation(**response.data)
+
+    def cancel(self, session_id: str, invocation_id: str) -> WebMCPInvocation:
+        """Request best-effort cancellation. Completion can win; side effects persist."""
+        response = self._client.transport.post(
+            self._url(
+                session_id, f"/invocations/{quote(invocation_id, safe='')}/cancel"
+            ),
+            timeout=max(self._client.timeout, 20),
+        )
+        return WebMCPInvocation(**response.data)

{hyperbrowser-1.10.0 → hyperbrowser-1.11.0}/hyperbrowser/models/__init__.py

@@ -1,3 +1,18 @@
+from .webmcp import (
+    WebMCPAnnotations,
+    WebMCPFrame,
+    WebMCPSource,
+    WebMCPTool,
+    WebMCPToolsResponse,
+    WebMCPInvokeParams,
+    WebMCPStartParams,
+    WebMCPResultParams,
+    WebMCPInvokeStatus,
+    WebMCPInvocationStatus,
+    WebMCPInvokeResult,
+    WebMCPInvocationError,
+    WebMCPInvocation,
+)
 from .web.batch_fetch import (
     StartBatchFetchJobParams,
     StartBatchFetchJobResponse,
@@ -439,6 +454,20 @@ from .sandbox import (
 from .team import TeamCreditInfo
 
 __all__ = [
+    "WebMCPAnnotations",
+    "WebMCPFrame",
+    "WebMCPSource",
+    "WebMCPTool",
+    "WebMCPToolsResponse",
+    "WebMCPInvokeParams",
+    "WebMCPStartParams",
+    "WebMCPResultParams",
+    "WebMCPInvokeStatus",
+    "WebMCPInvocationStatus",
+    "WebMCPInvokeResult",
+    "WebMCPInvocationError",
+    "WebMCPInvocation",
+
     # consts
     "ISO639_1",
     "POLLING_ATTEMPTS",

{hyperbrowser-1.10.0 → hyperbrowser-1.11.0}/hyperbrowser/models/session.py

@@ -129,6 +129,8 @@ class SessionLaunchState(BaseModel):
         populate_by_alias=True,
     )
 
+    enable_web_mcp: Optional[bool] = Field(default=None, alias="enableWebMcp")
+
     use_ultra_stealth: Optional[bool] = Field(default=None, alias="useUltraStealth")
     use_stealth: Optional[bool] = Field(default=None, alias="useStealth")
     use_proxy: Optional[bool] = Field(default=None, alias="useProxy")
@@ -411,6 +413,10 @@ class CreateSessionParams(BaseModel):
         populate_by_alias=True,
     )
 
+    enable_web_mcp: Optional[bool] = Field(
+        default=None, serialization_alias="enableWebMcp"
+    )
+
     use_ultra_stealth: bool = Field(
         default=False, serialization_alias="useUltraStealth"
     )

hyperbrowser-1.11.0/hyperbrowser/models/webmcp.py

@@ -0,0 +1,126 @@
+"""WebMCP request models and page-tool discovery/invocation responses."""
+
+from datetime import datetime
+from typing import Any, Dict, List, Literal, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class WebMCPInvokeParams(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="forbid")
+
+    tool_ref: str = Field(min_length=1, max_length=4096, serialization_alias="toolRef")
+    input: Dict[str, Any] = Field(default_factory=dict)
+    timeout_seconds: int = Field(
+        default=60, ge=1, le=120, strict=True, serialization_alias="timeoutSeconds"
+    )
+
+
+class WebMCPStartParams(WebMCPInvokeParams):
+    timeout_seconds: int = Field(
+        default=300, ge=1, le=3600, strict=True, serialization_alias="timeoutSeconds"
+    )
+
+
+class WebMCPResultParams(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="forbid")
+
+    wait_seconds: int = Field(
+        default=0, ge=0, le=30, strict=True, serialization_alias="waitSeconds"
+    )
+
+
+class WebMCPAnnotations(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    read_only: bool = Field(alias="readOnly")
+    untrusted_content: bool = Field(alias="untrustedContent")
+    consequential: bool
+    autosubmit: bool
+    destructive: Optional[bool] = None
+    idempotent: Optional[bool] = None
+    open_world: Optional[bool] = Field(default=None, alias="openWorld")
+
+
+class WebMCPFrame(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    id: str
+    url: str
+    is_main_frame: bool = Field(alias="isMainFrame")
+
+
+class WebMCPSource(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    provider: Literal["native", "polyfill"]
+    tab_id: str = Field(alias="tabId")
+    page_url: str = Field(alias="pageUrl")
+    page_title: str = Field(alias="pageTitle")
+    frame: WebMCPFrame
+
+
+class WebMCPTool(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    tool_ref: str = Field(alias="toolRef")
+    name: str
+    title: Optional[str] = None
+    description: str
+    input_schema: Optional[Dict[str, Any]] = Field(default=None, alias="inputSchema")
+    output_schema: Optional[Dict[str, Any]] = Field(default=None, alias="outputSchema")
+    annotations: WebMCPAnnotations
+    declarative: bool
+    backend_node_id: Optional[int] = Field(default=None, alias="backendNodeId")
+    source: WebMCPSource
+
+
+class WebMCPToolsResponse(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    tools: List[WebMCPTool]
+    native_supported: bool = Field(alias="nativeSupported")
+    truncated: bool
+
+
+WebMCPInvokeStatus = Literal["completed", "error", "canceled", "awaiting_submission"]
+WebMCPInvocationStatus = Literal[
+    "running",
+    "awaiting_submission",
+    "completed",
+    "error",
+    "canceled",
+    "outcome_unknown",
+]
+
+
+class WebMCPInvokeResult(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    invocation_id: Optional[str] = Field(default=None, alias="invocationId")
+    status: WebMCPInvokeStatus
+    output: Any = None
+    error_text: Optional[str] = Field(default=None, alias="errorText")
+    output_bytes: int = Field(alias="outputBytes")
+    output_truncated: bool = Field(default=False, alias="outputTruncated")
+    output_preview: Optional[str] = Field(default=None, alias="outputPreview")
+    untrusted_content: bool = Field(alias="untrustedContent")
+    duration_ms: int = Field(alias="durationMs")
+
+
+class WebMCPInvocationError(BaseModel):
+    code: str
+    message: str
+
+
+class WebMCPInvocation(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    invocation_id: str = Field(alias="invocationId")
+    tool_ref: str = Field(alias="toolRef")
+    status: WebMCPInvocationStatus
+    cancellation_requested: bool = Field(alias="cancellationRequested")
+    created_at: datetime = Field(alias="createdAt")
+    expires_at: Optional[datetime] = Field(default=None, alias="expiresAt")
+    result: Optional[WebMCPInvokeResult] = None
+    error: Optional[WebMCPInvocationError] = None

{hyperbrowser-1.10.0 → hyperbrowser-1.11.0}/hyperbrowser/transport/async_transport.py

@@ -64,6 +64,7 @@ class AsyncTransport(TransportStrategy):
                     )
                 return APIResponse.from_status(response.status_code)
         except httpx.HTTPStatusError as e:
+            error_data = None
             try:
                 error_data = response.json()
                 message = error_data.get("message") or error_data.get("error") or str(e)
@@ -71,6 +72,13 @@ class AsyncTransport(TransportStrategy):
                 message = str(e)
             raise HyperbrowserError(
                 message,
+                code=(
+                    error_data.get("code")
+                    if isinstance(error_data, dict)
+                    and isinstance(error_data.get("code"), str)
+                    else None
+                ),
+                details=error_data,
                 status_code=response.status_code,
                 response=response,
                 original_error=e,
@@ -108,15 +116,23 @@ class AsyncTransport(TransportStrategy):
             )
 
     async def get(
-        self, url: str, params: Optional[dict] = None, follow_redirects: bool = False
+        self,
+        url: str,
+        params: Optional[dict] = None,
+        follow_redirects: bool = False,
+        *,
+        timeout: Optional[float] = None,
     ) -> APIResponse:
         if params:
             params = {k: v for k, v in params.items() if v is not None}
+        kwargs = {}
+        if timeout is not None:
+            kwargs["timeout"] = timeout
         failed_attempt = 1
         while True:
             try:
                 response = await self.client.get(
-                    url, params=params, follow_redirects=follow_redirects
+                    url, params=params, follow_redirects=follow_redirects, **kwargs
                 )
                 return await self._handle_response(response)
             except BaseException as cause:

{hyperbrowser-1.10.0 → hyperbrowser-1.11.0}/hyperbrowser/transport/base.py

@@ -55,7 +55,14 @@ class TransportStrategy(ABC):
         pass
 
     @abstractmethod
-    def get(self, url: str, params: Optional[dict] = None) -> APIResponse:
+    def get(
+        self,
+        url: str,
+        params: Optional[dict] = None,
+        follow_redirects: bool = False,
+        *,
+        timeout: Optional[float] = None,
+    ) -> APIResponse:
         pass
 
     @abstractmethod

{hyperbrowser-1.10.0 → hyperbrowser-1.11.0}/hyperbrowser/transport/sync.py

@@ -42,6 +42,7 @@ class SyncTransport(TransportStrategy):
                     )
                 return APIResponse.from_status(response.status_code)
         except httpx.HTTPStatusError as e:
+            error_data = None
             try:
                 error_data = response.json()
                 message = error_data.get("message") or error_data.get("error") or str(e)
@@ -49,6 +50,13 @@ class SyncTransport(TransportStrategy):
                 message = str(e)
             raise HyperbrowserError(
                 message,
+                code=(
+                    error_data.get("code")
+                    if isinstance(error_data, dict)
+                    and isinstance(error_data.get("code"), str)
+                    else None
+                ),
+                details=error_data,
                 status_code=response.status_code,
                 response=response,
                 original_error=e,
@@ -89,15 +97,23 @@ class SyncTransport(TransportStrategy):
             )
 
     def get(
-        self, url: str, params: Optional[dict] = None, follow_redirects: bool = False
+        self,
+        url: str,
+        params: Optional[dict] = None,
+        follow_redirects: bool = False,
+        *,
+        timeout: Optional[float] = None,
     ) -> APIResponse:
         if params:
             params = {k: v for k, v in params.items() if v is not None}
+        kwargs = {}
+        if timeout is not None:
+            kwargs["timeout"] = timeout
         failed_attempt = 1
         while True:
             try:
                 response = self.client.get(
-                    url, params=params, follow_redirects=follow_redirects
+                    url, params=params, follow_redirects=follow_redirects, **kwargs
                 )
                 return self._handle_response(response)
             except BaseException as cause:

{hyperbrowser-1.10.0 → hyperbrowser-1.11.0}/hyperbrowser/types/__init__.py

@@ -5,6 +5,11 @@ known request keys to their wire aliases while leaving user-owned mappings, such
 as JSON Schema objects, untouched.
 """
 
+from .webmcp import (
+    WebMCPInvokeParams,
+    WebMCPStartParams,
+    WebMCPResultParams,
+)
 from ._json import (
     JSONSchema,
     JSONSchemaInput,
@@ -178,6 +183,10 @@ from .web import (
 
 
 __all__ = [
+    "WebMCPInvokeParams",
+    "WebMCPStartParams",
+    "WebMCPResultParams",
+
     "JSONSchema",
     "JSONSchemaInput",
     "JSONSchemaObject",

{hyperbrowser-1.10.0 → hyperbrowser-1.11.0}/hyperbrowser/types/session.py

@@ -117,6 +117,7 @@ class StartSessionFromSnapshotParams(TypedDict):
 class CreateSessionParams(TypedDict, total=False):
     """Configuration for creating a browser session."""
 
+    enable_web_mcp: Optional[bool]
     use_ultra_stealth: bool
     use_stealth: bool
     use_proxy: bool

hyperbrowser-1.11.0/hyperbrowser/types/webmcp.py

@@ -0,0 +1,22 @@
+"""Typed dictionary requests for session WebMCP tools."""
+
+from typing import Any, Dict
+from typing_extensions import Required, TypedDict
+
+
+class WebMCPInvokeParams(TypedDict, total=False):
+    """Blocking invocation; timeout_seconds is 1–120 (default 60)."""
+
+    tool_ref: Required[str]
+    input: Dict[str, Any]
+    timeout_seconds: int
+
+
+class WebMCPStartParams(WebMCPInvokeParams):
+    """Start an invocation; timeout_seconds is 1–3600 (default 300)."""
+
+
+class WebMCPResultParams(TypedDict, total=False):
+    """Wait at most 0–30 seconds (default 0) for an invocation result."""
+
+    wait_seconds: int

{hyperbrowser-1.10.0 → hyperbrowser-1.11.0}/pyproject.toml

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