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

{fleet_python-0.2.125/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.125
+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.125 → 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.125"
+__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.125 → 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.125"
+__version__ = "0.2.127"
 
 __all__ = [
     # Core classes

{fleet_python-0.2.125 → 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.125"
+    __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.125 → 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."""
@@ -601,7 +649,9 @@ class AsyncFleet:
         )
 
         instance = AsyncEnv(client=self.client, **response.json())
-        await instance.instance.load()
+        # Resources are loaded lazily on first `db()`/`browser()`/`resources()` access
+        # via `_load_resources()`, so we don't preload here. Eagerly loading would
+        # fail-fast with a 502 while the container is still warming up.
         return instance
 
     async def make_for_task(self, task: Task) -> AsyncEnv:
@@ -653,7 +703,7 @@ class AsyncFleet:
         else:
             response = await self.client.request("GET", f"/v1/env/instances/{instance_id}")
             instance = AsyncEnv(client=self.client, **response.json())
-            await instance.instance.load()
+            # Resources load lazily on first `db()`/`browser()`/`resources()` access.
             return instance
 
     def _create_url_instance(self, base_url: str) -> AsyncEnv:
@@ -794,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.125 → fleet_python-0.2.127}/fleet/_async/models.py

@@ -51,6 +51,7 @@ class Instance(BaseModel):
     team_id: str = Field(..., title="Team Id")
     region: str = Field(..., title="Region")
     env_variables: Optional[Dict[str, Any]] = Field(None, title="Env Variables")
+    multi_env_list: Optional[List[str]] = Field(None, title="Multi Env List")
 
 
 class InstanceRequest(BaseModel):
@@ -357,6 +358,7 @@ class InstanceResponse(BaseModel):
     data_version: Optional[str] = Field(None, title="Data Version")
     urls: Optional[InstanceURLs] = Field(None, title="Urls")
     health: Optional[bool] = Field(None, title="Health")
+    multi_env_list: Optional[List[str]] = Field(None, title="Multi Env List")
 
 
 class AccountResponse(BaseModel):

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

@@ -27,7 +27,7 @@ from .exceptions import (
 try:
     from . import __version__
 except ImportError:
-    __version__ = "0.2.125"
+    __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