fleet-python 0.2.126__tar.gz → 0.2.127__tar.gz

{fleet_python-0.2.126/fleet_python.egg-info → fleet_python-0.2.127}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fleet-python
-Version: 0.2.126
+Version: 0.2.127
 Summary: Python SDK for Fleet environments
 Author-email: Fleet AI <nic@fleet.so>
 License: Apache-2.0

{fleet_python-0.2.126 → fleet_python-0.2.127}/fleet/__init__.py

@@ -26,6 +26,8 @@ from .exceptions import (
 )
 from .client import Fleet, SyncEnv, Session
 from ._async.client import AsyncFleet, AsyncEnv, AsyncSession
+from .browser import BrowserLease, host_from_url
+from ._async.browser import AsyncBrowserLease
 from .models import InstanceResponse, Environment, Run
 from .instance.models import Resource, ResetResponse
 
@@ -76,7 +78,7 @@ from . import env
 from . import global_client as _global_client
 from ._async import global_client as _async_global_client
 
-__version__ = "0.2.126"
+__version__ = "0.2.127"
 
 __all__ = [
     # Core classes
@@ -84,6 +86,10 @@ __all__ = [
     "SyncEnv",
     "AsyncFleet",
     "AsyncEnv",
+    # Browser lease (orchestrator-managed /v1/browser)
+    "BrowserLease",
+    "AsyncBrowserLease",
+    "host_from_url",
     # Models
     "InstanceResponse",
     "SyncEnv",

{fleet_python-0.2.126 → fleet_python-0.2.127}/fleet/_async/__init__.py

@@ -44,7 +44,7 @@ from ..types import VerifierFunction
 from .. import env
 from . import global_client as _async_global_client
 
-__version__ = "0.2.126"
+__version__ = "0.2.127"
 
 __all__ = [
     # Core classes

{fleet_python-0.2.126 → fleet_python-0.2.127}/fleet/_async/base.py

@@ -26,7 +26,7 @@ from .exceptions import (
 try:
     from .. import __version__
 except ImportError:
-    __version__ = "0.2.126"
+    __version__ = "0.2.127"
 
 logger = logging.getLogger(__name__)
 

fleet_python-0.2.127/fleet/_async/browser.py

@@ -0,0 +1,191 @@
+# Copyright 2025 Fleet AI
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+"""Async mirror of ``fleet.browser``.
+
+See :mod:`fleet.browser` for design notes. Kept as a separate file so the
+async surface stays cleanly importable without dragging the sync wrapper
+through any asyncio shims.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from typing import Any, Dict, List, Optional, TYPE_CHECKING
+
+from ..browser import host_from_url  # re-export, identical logic
+
+if TYPE_CHECKING:
+    from .base import AsyncWrapper
+
+
+_BROWSER_PATH = "/v1/browser"
+
+
+def _extra_headers(
+    jwt_token: Optional[str] = None, team_id: Optional[str] = None
+) -> Optional[Dict[str, str]]:
+    headers: Dict[str, str] = {}
+    if jwt_token:
+        headers["X-JWT-Token"] = jwt_token
+    if team_id:
+        headers["X-Team-ID"] = team_id
+    return headers or None
+
+
+class AsyncBrowserLease:
+    """Async counterpart of :class:`fleet.browser.BrowserLease`."""
+
+    def __init__(self, client: "AsyncWrapper", data: Dict[str, Any]):
+        self._client = client
+        self._raw: Dict[str, Any] = dict(data)
+        self._jwt_token: Optional[str] = None
+        self._team_id: Optional[str] = None
+        self._apply(data)
+
+    def _apply(self, data: Dict[str, Any]) -> None:
+        self.id: str = data.get("id") or data["lease_id"]
+        self.lease_id: str = data["lease_id"]
+        self.browser_id: Optional[str] = data.get("browser_id")
+        self.host_domain: Optional[str] = data.get("host_domain")
+        self.mcp_url: Optional[str] = data.get("mcp_url")
+        self.cdp_url: Optional[str] = data.get("cdp_url")
+        self.stream_url: Optional[str] = data.get("stream_url")
+        self.status: Optional[str] = data.get("status")
+        self.stream_ready: Optional[bool] = data.get("stream_ready")
+        self.allowed_hosts: Optional[List[str]] = data.get("allowed_hosts")
+        self.created_timestamp_ms: Optional[int] = data.get("created_timestamp_ms")
+        self.expires_timestamp_ms: Optional[int] = data.get("expires_timestamp_ms")
+        self.age_duration_ms: Optional[int] = data.get("age_duration_ms")
+        self.cluster_name: Optional[str] = data.get("cluster_name")
+
+    @property
+    def raw(self) -> Dict[str, Any]:
+        return self._raw
+
+    async def refresh(self) -> "AsyncBrowserLease":
+        response = await self._client.request(
+            "GET",
+            f"{_BROWSER_PATH}/{self.lease_id}",
+            extra_headers=_extra_headers(self._jwt_token, self._team_id),
+        )
+        self._raw = response.json()
+        self._apply(self._raw)
+        return self
+
+    async def wait_until_running(
+        self,
+        timeout: float = 60.0,
+        poll_interval: float = 1.0,
+        require_stream_ready: bool = False,
+    ) -> "AsyncBrowserLease":
+        loop = asyncio.get_event_loop()
+        deadline = loop.time() + timeout
+        while True:
+            await self.refresh()
+            running = self.status == "running"
+            if running and (not require_stream_ready or self.stream_ready):
+                return self
+            if loop.time() >= deadline:
+                raise TimeoutError(
+                    f"Browser lease {self.lease_id} not running after "
+                    f"{timeout}s (status={self.status}, stream_ready={self.stream_ready})"
+                )
+            await asyncio.sleep(poll_interval)
+
+    async def mcp_tools(self) -> Dict[str, Any]:
+        response = await self._client.request(
+            "GET",
+            f"{_BROWSER_PATH}/{self.lease_id}/mcp-tools",
+            extra_headers=_extra_headers(self._jwt_token, self._team_id),
+        )
+        return response.json()
+
+    async def delete(self) -> None:
+        from ..exceptions import FleetAPIError
+
+        try:
+            await self._client.request(
+                "DELETE",
+                f"{_BROWSER_PATH}/{self.lease_id}",
+                extra_headers=_extra_headers(self._jwt_token, self._team_id),
+            )
+        except FleetAPIError as exc:
+            status = getattr(exc, "status_code", None)
+            if status not in (404, 410):
+                raise
+
+    async def __aenter__(self) -> "AsyncBrowserLease":
+        return self
+
+    async def __aexit__(self, exc_type, exc, tb) -> None:
+        await self.delete()
+
+    def __repr__(self) -> str:
+        return (
+            f"AsyncBrowserLease(lease_id={self.lease_id!r}, status={self.status!r}, "
+            f"cdp_url={self.cdp_url!r})"
+        )
+
+
+async def create_browser(
+    client: "AsyncWrapper",
+    *,
+    ttl_seconds: int = 300,
+    lease_id: Optional[str] = None,
+    allowed_hosts: Optional[List[str]] = None,
+    request_timestamp_ms: Optional[int] = None,
+    extra: Optional[Dict[str, Any]] = None,
+    jwt_token: Optional[str] = None,
+    team_id: Optional[str] = None,
+    wait_until_running: bool = False,
+    wait_timeout: float = 60.0,
+) -> AsyncBrowserLease:
+    payload: Dict[str, Any] = {"ttl_seconds": ttl_seconds}
+    if lease_id is not None:
+        payload["lease_id"] = lease_id
+    if allowed_hosts is not None:
+        payload["allowed_hosts"] = allowed_hosts
+    if request_timestamp_ms is not None:
+        payload["request_timestamp_ms"] = request_timestamp_ms
+    if extra:
+        payload.update(extra)
+
+    response = await client.request(
+        "POST",
+        _BROWSER_PATH,
+        json=payload,
+        extra_headers=_extra_headers(jwt_token, team_id),
+    )
+    lease = AsyncBrowserLease(client, response.json())
+    lease._jwt_token = jwt_token
+    lease._team_id = team_id
+    if wait_until_running:
+        await lease.wait_until_running(timeout=wait_timeout)
+    return lease
+
+
+async def get_browser(
+    client: "AsyncWrapper",
+    lease_id: str,
+    *,
+    jwt_token: Optional[str] = None,
+    team_id: Optional[str] = None,
+) -> AsyncBrowserLease:
+    response = await client.request(
+        "GET",
+        f"{_BROWSER_PATH}/{lease_id}",
+        extra_headers=_extra_headers(jwt_token, team_id),
+    )
+    lease = AsyncBrowserLease(client, response.json())
+    lease._jwt_token = jwt_token
+    lease._team_id = team_id
+    return lease
+
+
+__all__ = ["AsyncBrowserLease", "create_browser", "get_browser", "host_from_url"]

{fleet_python-0.2.126 → fleet_python-0.2.127}/fleet/_async/client.py

@@ -171,10 +171,15 @@ from .instance.base import default_httpx_client
 from .instance.client import ValidatorType
 from .resources.base import Resource
 from .resources.sqlite import AsyncSQLiteResource
-from .resources.browser import AsyncBrowserResource
 from .resources.filesystem import AsyncFilesystemResource
 from .resources.mcp import AsyncMCPResource
 from .resources.api import AsyncAPIResource
+from .browser import (
+    AsyncBrowserLease,
+    create_browser as _create_browser_lease,
+    get_browser as _get_browser_lease,
+    host_from_url,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -386,8 +391,51 @@ class AsyncEnv(EnvironmentBase):
     def db(self, name: str = "current") -> AsyncSQLiteResource:
         return self.instance.db(name)
 
-    def browser(self, name: str = "cdp") -> AsyncBrowserResource:
-        return self.instance.browser(name)
+    async def browser(
+        self,
+        ttl_seconds: int = 300,
+        *,
+        lease_id: Optional[str] = None,
+        allowed_hosts: Optional[List[str]] = None,
+        include_root_host: bool = True,
+        wait_until_running: bool = False,
+        wait_timeout: float = 60.0,
+        extra: Optional[Dict[str, Any]] = None,
+        jwt_token: Optional[str] = None,
+        team_id: Optional[str] = None,
+    ) -> AsyncBrowserLease:
+        """Spin up an orchestrator-managed Fleet Browser lease for this env.
+
+        ``await env.browser()`` posts to ``/v1/browser`` and returns an
+        :class:`fleet._async.browser.AsyncBrowserLease` with ``cdp_url`` /
+        ``mcp_url`` / ``stream_url`` and a ``mcp_tools()`` accessor. By
+        default the host derived from ``self.urls.root`` is prepended to
+        ``allowed_hosts`` so the browser can reach the instance — pass
+        ``include_root_host=False`` to opt out.
+        """
+        hosts: Optional[List[str]] = list(allowed_hosts) if allowed_hosts else None
+        if include_root_host and self.urls and self.urls.root:
+            root_host = host_from_url(self.urls.root)
+            if root_host:
+                hosts = hosts or []
+                if root_host not in hosts:
+                    hosts.insert(0, root_host)
+        return await _create_browser_lease(
+            self._load_client,
+            ttl_seconds=ttl_seconds,
+            lease_id=lease_id,
+            allowed_hosts=hosts,
+            extra=extra,
+            jwt_token=jwt_token,
+            team_id=team_id,
+            wait_until_running=wait_until_running,
+            wait_timeout=wait_timeout,
+        )
+
+    @property
+    def root_url(self) -> Optional[str]:
+        """Convenience: ``self.urls.root`` if available."""
+        return self.urls.root if self.urls else None
 
     def fs(self) -> AsyncFilesystemResource:
         """Get a filesystem diff resource for inspecting file changes."""
@@ -796,6 +844,45 @@ class AsyncFleet:
             self.client, bundle_data, args, kwargs, timeout
         )
 
+    async def create_browser(
+        self,
+        ttl_seconds: int = 300,
+        *,
+        lease_id: Optional[str] = None,
+        allowed_hosts: Optional[List[str]] = None,
+        request_timestamp_ms: Optional[int] = None,
+        extra: Optional[Dict[str, Any]] = None,
+        jwt_token: Optional[str] = None,
+        team_id: Optional[str] = None,
+        wait_until_running: bool = False,
+        wait_timeout: float = 60.0,
+    ) -> AsyncBrowserLease:
+        """Create a Fleet Browser lease (``POST /v1/browser``)."""
+        return await _create_browser_lease(
+            self.client,
+            ttl_seconds=ttl_seconds,
+            lease_id=lease_id,
+            allowed_hosts=allowed_hosts,
+            request_timestamp_ms=request_timestamp_ms,
+            extra=extra,
+            jwt_token=jwt_token,
+            team_id=team_id,
+            wait_until_running=wait_until_running,
+            wait_timeout=wait_timeout,
+        )
+
+    async def get_browser(
+        self,
+        lease_id: str,
+        *,
+        jwt_token: Optional[str] = None,
+        team_id: Optional[str] = None,
+    ) -> AsyncBrowserLease:
+        """Inspect an existing browser lease (``GET /v1/browser/{lease_id}``)."""
+        return await _get_browser_lease(
+            self.client, lease_id, jwt_token=jwt_token, team_id=team_id
+        )
+
     async def delete(self, instance_id: str) -> InstanceResponse:
         return await _delete_instance(self.client, instance_id)
 

{fleet_python-0.2.126 → fleet_python-0.2.127}/fleet/base.py

@@ -27,7 +27,7 @@ from .exceptions import (
 try:
     from . import __version__
 except ImportError:
-    __version__ = "0.2.126"
+    __version__ = "0.2.127"
 
 logger = logging.getLogger(__name__)
 

fleet_python-0.2.127/fleet/browser.py

@@ -0,0 +1,216 @@
+# Copyright 2025 Fleet AI
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+"""Fleet Browser API — orchestrator-managed remote browser leases.
+
+Thin wrapper around the `/v1/browser` HTTP surface documented at
+`https://orchestrator.fleetai.com/docs`. A ``BrowserLease`` exposes the
+``cdp_url`` / ``mcp_url`` / ``stream_url`` returned by the create call and
+lets you poll, list MCP tools, and release the lease.
+
+This is intentionally independent of ``fleet.resources.browser`` (the
+in-instance CDP resource); they solve different problems.
+"""
+
+from __future__ import annotations
+
+import time
+from typing import Any, Dict, List, Optional, TYPE_CHECKING
+from urllib.parse import urlparse
+
+if TYPE_CHECKING:
+    from .base import SyncWrapper
+
+
+_BROWSER_PATH = "/v1/browser"
+
+
+def _extra_headers(
+    jwt_token: Optional[str] = None, team_id: Optional[str] = None
+) -> Optional[Dict[str, str]]:
+    headers: Dict[str, str] = {}
+    if jwt_token:
+        headers["X-JWT-Token"] = jwt_token
+    if team_id:
+        headers["X-Team-ID"] = team_id
+    return headers or None
+
+
+def host_from_url(url: str) -> str:
+    """Return the bare hostname for a URL (no scheme, no port, no path).
+
+    Useful when populating ``allowed_hosts`` from ``env.urls.root``.
+    """
+    parsed = urlparse(url if "://" in url else f"https://{url}")
+    return parsed.hostname or url
+
+
+class BrowserLease:
+    """A lease created via ``POST /v1/browser``.
+
+    Attribute names mirror the JSON response. Methods that hit the API
+    reuse the same :class:`SyncWrapper` that created the lease so auth /
+    base URL / retries stay consistent.
+    """
+
+    def __init__(self, client: "SyncWrapper", data: Dict[str, Any]):
+        self._client = client
+        self._raw: Dict[str, Any] = dict(data)
+        self._jwt_token: Optional[str] = None
+        self._team_id: Optional[str] = None
+        self._apply(data)
+
+    def _apply(self, data: Dict[str, Any]) -> None:
+        self.id: str = data.get("id") or data["lease_id"]
+        self.lease_id: str = data["lease_id"]
+        self.browser_id: Optional[str] = data.get("browser_id")
+        self.host_domain: Optional[str] = data.get("host_domain")
+        self.mcp_url: Optional[str] = data.get("mcp_url")
+        self.cdp_url: Optional[str] = data.get("cdp_url")
+        self.stream_url: Optional[str] = data.get("stream_url")
+        self.status: Optional[str] = data.get("status")
+        self.stream_ready: Optional[bool] = data.get("stream_ready")
+        self.allowed_hosts: Optional[List[str]] = data.get("allowed_hosts")
+        self.created_timestamp_ms: Optional[int] = data.get("created_timestamp_ms")
+        self.expires_timestamp_ms: Optional[int] = data.get("expires_timestamp_ms")
+        self.age_duration_ms: Optional[int] = data.get("age_duration_ms")
+        self.cluster_name: Optional[str] = data.get("cluster_name")
+
+    @property
+    def raw(self) -> Dict[str, Any]:
+        """Last server response payload (for fields not surfaced as attrs)."""
+        return self._raw
+
+    def refresh(self) -> "BrowserLease":
+        """Re-fetch the lease (``GET /v1/browser/{lease_id}``)."""
+        response = self._client.request(
+            "GET",
+            f"{_BROWSER_PATH}/{self.lease_id}",
+            extra_headers=_extra_headers(self._jwt_token, self._team_id),
+        )
+        self._raw = response.json()
+        self._apply(self._raw)
+        return self
+
+    def wait_until_running(
+        self,
+        timeout: float = 60.0,
+        poll_interval: float = 1.0,
+        require_stream_ready: bool = False,
+    ) -> "BrowserLease":
+        """Poll until ``status == 'running'`` (or stream_ready, if requested)."""
+        deadline = time.monotonic() + timeout
+        while True:
+            self.refresh()
+            running = self.status == "running"
+            if running and (not require_stream_ready or self.stream_ready):
+                return self
+            if time.monotonic() >= deadline:
+                raise TimeoutError(
+                    f"Browser lease {self.lease_id} not running after "
+                    f"{timeout}s (status={self.status}, stream_ready={self.stream_ready})"
+                )
+            time.sleep(poll_interval)
+
+    def mcp_tools(self) -> Dict[str, Any]:
+        """List MCP tools the browser exposes."""
+        response = self._client.request(
+            "GET",
+            f"{_BROWSER_PATH}/{self.lease_id}/mcp-tools",
+            extra_headers=_extra_headers(self._jwt_token, self._team_id),
+        )
+        return response.json()
+
+    def delete(self) -> None:
+        """Release the lease. Idempotent — ignores 404 if already gone."""
+        from .exceptions import FleetAPIError
+
+        try:
+            self._client.request(
+                "DELETE",
+                f"{_BROWSER_PATH}/{self.lease_id}",
+                extra_headers=_extra_headers(self._jwt_token, self._team_id),
+            )
+        except FleetAPIError as exc:
+            status = getattr(exc, "status_code", None)
+            if status not in (404, 410):
+                raise
+
+    # Context manager so `with client.create_browser(...) as br: ...` cleans up.
+    def __enter__(self) -> "BrowserLease":
+        return self
+
+    def __exit__(self, exc_type, exc, tb) -> None:
+        self.delete()
+
+    def __repr__(self) -> str:
+        return (
+            f"BrowserLease(lease_id={self.lease_id!r}, status={self.status!r}, "
+            f"cdp_url={self.cdp_url!r})"
+        )
+
+
+def create_browser(
+    client: "SyncWrapper",
+    *,
+    ttl_seconds: int = 300,
+    lease_id: Optional[str] = None,
+    allowed_hosts: Optional[List[str]] = None,
+    request_timestamp_ms: Optional[int] = None,
+    extra: Optional[Dict[str, Any]] = None,
+    jwt_token: Optional[str] = None,
+    team_id: Optional[str] = None,
+    wait_until_running: bool = False,
+    wait_timeout: float = 60.0,
+) -> BrowserLease:
+    """POST ``/v1/browser`` and return a :class:`BrowserLease`.
+
+    ``extra`` is merged into the request body so callers can pass
+    fields that aren't first-class kwargs yet — keeps this freeform.
+    """
+    payload: Dict[str, Any] = {"ttl_seconds": ttl_seconds}
+    if lease_id is not None:
+        payload["lease_id"] = lease_id
+    if allowed_hosts is not None:
+        payload["allowed_hosts"] = allowed_hosts
+    if request_timestamp_ms is not None:
+        payload["request_timestamp_ms"] = request_timestamp_ms
+    if extra:
+        payload.update(extra)
+
+    response = client.request(
+        "POST",
+        _BROWSER_PATH,
+        json=payload,
+        extra_headers=_extra_headers(jwt_token, team_id),
+    )
+    lease = BrowserLease(client, response.json())
+    lease._jwt_token = jwt_token
+    lease._team_id = team_id
+    if wait_until_running:
+        lease.wait_until_running(timeout=wait_timeout)
+    return lease
+
+
+def get_browser(
+    client: "SyncWrapper",
+    lease_id: str,
+    *,
+    jwt_token: Optional[str] = None,
+    team_id: Optional[str] = None,
+) -> BrowserLease:
+    """Inspect an existing lease (``GET /v1/browser/{lease_id}``)."""
+    response = client.request(
+        "GET",
+        f"{_BROWSER_PATH}/{lease_id}",
+        extra_headers=_extra_headers(jwt_token, team_id),
+    )
+    lease = BrowserLease(client, response.json())
+    lease._jwt_token = jwt_token
+    lease._team_id = team_id
+    return lease

{fleet_python-0.2.126 → fleet_python-0.2.127}/fleet/client.py

@@ -177,10 +177,15 @@ from .instance.base import default_httpx_client
 from .instance.client import ValidatorType
 from .resources.base import Resource
 from .resources.sqlite import SQLiteResource
-from .resources.browser import BrowserResource
 from .resources.filesystem import FilesystemResource
 from .resources.mcp import SyncMCPResource
 from .resources.api import APIResource
+from .browser import (
+    BrowserLease,
+    create_browser as _create_browser_lease,
+    get_browser as _get_browser_lease,
+    host_from_url,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -398,8 +403,51 @@ class SyncEnv(EnvironmentBase):
     def db(self, name: str = "current") -> SQLiteResource:
         return self.instance.db(name)
 
-    def browser(self, name: str = "cdp") -> BrowserResource:
-        return self.instance.browser(name)
+    def browser(
+        self,
+        ttl_seconds: int = 300,
+        *,
+        lease_id: Optional[str] = None,
+        allowed_hosts: Optional[List[str]] = None,
+        include_root_host: bool = True,
+        wait_until_running: bool = False,
+        wait_timeout: float = 60.0,
+        extra: Optional[Dict[str, Any]] = None,
+        jwt_token: Optional[str] = None,
+        team_id: Optional[str] = None,
+    ) -> BrowserLease:
+        """Spin up an orchestrator-managed Fleet Browser lease for this env.
+
+        ``env.browser()`` posts to ``/v1/browser`` and returns a
+        :class:`fleet.browser.BrowserLease` with ``cdp_url`` / ``mcp_url`` /
+        ``stream_url`` and a ``mcp_tools()`` accessor. By default the host
+        from ``self.urls.root`` is prepended to ``allowed_hosts`` so the
+        browser can reach the instance — pass ``include_root_host=False``
+        to opt out.
+        """
+        hosts: Optional[List[str]] = list(allowed_hosts) if allowed_hosts else None
+        if include_root_host and self.urls and self.urls.root:
+            root_host = host_from_url(self.urls.root)
+            if root_host:
+                hosts = hosts or []
+                if root_host not in hosts:
+                    hosts.insert(0, root_host)
+        return _create_browser_lease(
+            self._load_client,
+            ttl_seconds=ttl_seconds,
+            lease_id=lease_id,
+            allowed_hosts=hosts,
+            extra=extra,
+            jwt_token=jwt_token,
+            team_id=team_id,
+            wait_until_running=wait_until_running,
+            wait_timeout=wait_timeout,
+        )
+
+    @property
+    def root_url(self) -> Optional[str]:
+        """Convenience: ``self.urls.root`` if available (handy paired with spawn_browser)."""
+        return self.urls.root if self.urls else None
 
     def fs(self) -> FilesystemResource:
         """Get a filesystem diff resource for inspecting file changes."""
@@ -808,6 +856,50 @@ class Fleet:
     ) -> VerifiersExecuteResponse:
         return _execute_verifier_remote(self.client, bundle_data, args, kwargs, timeout)
 
+    def create_browser(
+        self,
+        ttl_seconds: int = 300,
+        *,
+        lease_id: Optional[str] = None,
+        allowed_hosts: Optional[List[str]] = None,
+        request_timestamp_ms: Optional[int] = None,
+        extra: Optional[Dict[str, Any]] = None,
+        jwt_token: Optional[str] = None,
+        team_id: Optional[str] = None,
+        wait_until_running: bool = False,
+        wait_timeout: float = 60.0,
+    ) -> BrowserLease:
+        """Create a Fleet Browser lease (``POST /v1/browser``).
+
+        Freeform — pass any of ``allowed_hosts`` / ``lease_id`` /
+        ``request_timestamp_ms`` directly, or use ``extra`` for keys this
+        SDK version doesn't surface yet.
+        """
+        return _create_browser_lease(
+            self.client,
+            ttl_seconds=ttl_seconds,
+            lease_id=lease_id,
+            allowed_hosts=allowed_hosts,
+            request_timestamp_ms=request_timestamp_ms,
+            extra=extra,
+            jwt_token=jwt_token,
+            team_id=team_id,
+            wait_until_running=wait_until_running,
+            wait_timeout=wait_timeout,
+        )
+
+    def get_browser(
+        self,
+        lease_id: str,
+        *,
+        jwt_token: Optional[str] = None,
+        team_id: Optional[str] = None,
+    ) -> BrowserLease:
+        """Inspect an existing browser lease (``GET /v1/browser/{lease_id}``)."""
+        return _get_browser_lease(
+            self.client, lease_id, jwt_token=jwt_token, team_id=team_id
+        )
+
     def delete(self, instance_id: str) -> InstanceResponse:
         return _delete_instance(self.client, instance_id)
 

{fleet_python-0.2.126 → fleet_python-0.2.127/fleet_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fleet-python
-Version: 0.2.126
+Version: 0.2.127
 Summary: Python SDK for Fleet environments
 Author-email: Fleet AI <nic@fleet.so>
 License: Apache-2.0

{fleet_python-0.2.126 → fleet_python-0.2.127}/fleet_python.egg-info/SOURCES.txt

@@ -29,6 +29,7 @@ examples/quickstart.py
 examples/test_cdp_logging.py
 fleet/__init__.py
 fleet/base.py
+fleet/browser.py
 fleet/cli.py
 fleet/client.py
 fleet/config.py
@@ -40,6 +41,7 @@ fleet/tasks.py
 fleet/types.py
 fleet/_async/__init__.py
 fleet/_async/base.py
+fleet/_async/browser.py
 fleet/_async/client.py
 fleet/_async/exceptions.py
 fleet/_async/global_client.py

{fleet_python-0.2.126 → fleet_python-0.2.127}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 [project]
 name = "fleet-python"
 
-version = "0.2.126"
+version = "0.2.127"
 description = "Python SDK for Fleet environments"
 authors = [
     {name = "Fleet AI", email = "nic@fleet.so"},