fleet-python 0.2.125__py3-none-any.whl → 0.2.127__py3-none-any.whl

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/_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/_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/_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/_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/_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/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/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/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."""
@@ -613,7 +661,9 @@ class Fleet:
         )
 
         instance = SyncEnv(client=self.client, **response.json())
-        instance.instance.load()
+        # Resources load lazily on first `db()`/`browser()`/`resources()` access via
+        # `_load_resources()`. Skipping the eager preload avoids fail-fast 502s while
+        # the container is still warming up.
         return instance
 
     def make_for_task(self, task: Task) -> SyncEnv:
@@ -665,7 +715,7 @@ class Fleet:
         else:
             response = self.client.request("GET", f"/v1/env/instances/{instance_id}")
             instance = SyncEnv(client=self.client, **response.json())
-            instance.instance.load()
+            # Resources load lazily on first `db()`/`browser()`/`resources()` access.
             return instance
 
     def _create_url_instance(self, base_url: str) -> SyncEnv:
@@ -806,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/models.py

@@ -52,6 +52,7 @@ class Instance(BaseModel):
     region: str = Field(..., title="Region")
     env_variables: Optional[Dict[str, Any]] = Field(None, title="Env Variables")
     run_id: Optional[str] = Field(None, title="Run Id")
+    multi_env_list: Optional[List[str]] = Field(None, title="Multi Env List")
 
 
 class InstanceRequest(BaseModel):
@@ -369,6 +370,7 @@ class InstanceResponse(BaseModel):
     profile_id: Optional[str] = Field(None, title="Profile Id")
     heartbeat_interval: Optional[int] = Field(None, title="Heartbeat Interval")
     heartbeat_region: Optional[str] = Field(None, title="Heartbeat Region")
+    multi_env_list: Optional[List[str]] = Field(None, title="Multi Env List")
 
 
 class Run(BaseModel):

{fleet_python-0.2.125.dist-info → fleet_python-0.2.127.dist-info}/METADATA

@@ -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.dist-info → fleet_python-0.2.127.dist-info}/RECORD

@@ -24,24 +24,26 @@ examples/openai_simple_example.py,sha256=HmiufucrAZne7tHq9uoEsDWlEhjNC265bQAyIGB
 examples/query_builder_example.py,sha256=-cOMfWGNifYfYEt_Ds73XpwATZvFDL6F4KTkVxdMjzg,3951
 examples/quickstart.py,sha256=1VT39IRRhemsJgxi0O0gprdpcw7HB4pYO97GAYagIcg,3788
 examples/test_cdp_logging.py,sha256=AkCwQCgOTQEI8w3v0knWK_4eXMph7L9x07wj9yIYM10,2836
-fleet/__init__.py,sha256=vTuNhJ9DU4S0LI6od2lKTXT-K5MjS4Q67A5Gz0Exgaw,7977
-fleet/base.py,sha256=0JOFPQUTW1p8JKNbAfxAfZvUQDfNhvgLfzYFAXwos2c,10209
+fleet/__init__.py,sha256=vxo5Rc8G5_nLKQfUmAdRjwF8VsYMDD4Ml9aCZb9oFBc,8193
+fleet/base.py,sha256=HoszFAHJI5ppu3qshLqV8FR7Q_remz57j6Cu1j0bzLM,10209
+fleet/browser.py,sha256=6259Hgsygu9i_txbufOmQJYCyVb6qjPw_2-0aCLTLFU,7511
 fleet/cli.py,sha256=arX1E-fjLXtcV3tVVkPHfEXxl7FDn4zRmf0ssXlXaMg,40104
-fleet/client.py,sha256=usnW6HW_ZZjPPisRt0Tke5muf1QghTTM1fuDnO9IVIk,68771
+fleet/client.py,sha256=ljLkd8ebn7MKD5tLgh-dS0ZjK4w1DLNWBsx8boxWyis,72321
 fleet/config.py,sha256=n_wh9Sahu3gGE7nHJ7kqNFUH1qDiBtF4bgZq9MvIBMU,319
 fleet/exceptions.py,sha256=YqhQonZlxGdLP1HD0DNdKs9Q9BuyeYvK3pc6Glhpl14,5352
 fleet/global_client.py,sha256=frrDAFNM2ywN0JHLtlm9qbE1dQpnQJsavJpb7xSR_bU,1072
 fleet/judge.py,sha256=c41hAPFMfZvA0LLGPmp6BjaOsIKPf5Wz90UNUvBorRg,35044
-fleet/models.py,sha256=7y7AchrAllsEAxel7C68DoeAyfRd90EVhwI7WbceQ3M,25173
+fleet/models.py,sha256=3IMbL_BCTSmOKhiVNuguTJ-y4mVrrcGawRd4_ZnFvXc,25329
 fleet/tasks.py,sha256=8pEzXmgC7RslqsMC_0s6shhr_t2WGIRpTRqo-MAQjdg,20778
 fleet/types.py,sha256=L4Y82xICf1tzyCLqhLYUgEoaIIS5h9T05TyFNHSWs3s,652
-fleet/_async/__init__.py,sha256=sGGPiYYW4XnTBNu6Gg_uXamazcEQBjyNJ-J_lJZWIhA,9116
-fleet/_async/base.py,sha256=Wm9As-9AdttiBV4NMAS-O0mhh6znwn3aCuG3tYpCOSE,9774
-fleet/_async/client.py,sha256=HvgUFN11Ww4KkDq1AreXbNfO3ChqiZyTajM4n_NNLu8,65209
+fleet/_async/__init__.py,sha256=pto8pgZsakpTBmqKytR2wmS2ogmAf8TbzilpnlsgbCQ,9116
+fleet/_async/base.py,sha256=N0twsinB-fmJqBQKYMXDJSTMPaMI55ejKojkr9YHxbk,9774
+fleet/_async/browser.py,sha256=_lU23nuoSg8gwtiGGd4gGvD9ZRQ-gJFo42zxvDdM_ic,6388
+fleet/_async/client.py,sha256=OI3cD7CJokyJqI0IN7_cwns5CEVmZILV9Ow2JmLJcb8,68619
 fleet/_async/exceptions.py,sha256=fUmPwWhnT8SR97lYsRq0kLHQHKtSh2eJS0VQ2caSzEI,5055
 fleet/_async/global_client.py,sha256=4WskpLHbsDEgWW7hXMD09W-brkp4euy8w2ZJ88594rQ,1103
 fleet/_async/judge.py,sha256=Ape82WAveHB9ApbslmoiUnuj5KL-DkdQLThUlOsuxgk,6026
-fleet/_async/models.py,sha256=L04NUHyMIVPu5HiDRNvcGVa-uTakX_TzbBvCma38JxE,13587
+fleet/_async/models.py,sha256=6B_Umf9DYToWENHrvt1ExkBt03X0Th11GDNFL7MEldU,13743
 fleet/_async/tasks.py,sha256=rlY6SmWl3ZABXe5-ky63wfwYETd2K-Na_m7g5KI1GoI,20602
 fleet/_async/env/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fleet/_async/env/client.py,sha256=FqetvDlABeHLaAc8UF_m_2OFEhXy4ZqH7ly_Nh8p3uA,3479
@@ -101,7 +103,7 @@ fleet/verifiers/decorator.py,sha256=RuTjjDijbicNfMSjA7HcTpKueEki5dzNOdTuHS7UoZs,
 fleet/verifiers/parse.py,sha256=qz9AfJrTbjlg-LU-lE8Ciqi7Yt2a8-cs17FdpjTLhMk,8550
 fleet/verifiers/sql_differ.py,sha256=TqTLWyK3uOyLbitT6HYzYEzuSFC39wcyhgk3rcm__k8,6525
 fleet/verifiers/verifier.py,sha256=iqGevW7dSd0J5RdRQjpu-zioy_FYAXnzMfkuB3-QmO0,14601
-fleet_python-0.2.125.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+fleet_python-0.2.127.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
 scripts/fix_sync_imports.py,sha256=X9fWLTpiPGkSHsjyQUDepOJkxOqw1DPj7nd8wFlFqLQ,8368
 scripts/unasync.py,sha256=vWVQxRWX8SRZO5cmzEhpvnG_REhCWXpidIGIpWmEcvI,696
 tests/__init__.py,sha256=Re1SdyxH8NfyL1kjhi7SQkGP1mYeWB-D6UALqdIMd8I,35
@@ -112,8 +114,8 @@ tests/test_instance_dispatch.py,sha256=CvU4C3LBIqsYZdEsEFfontGjyxAZfVYyXnGwxyIvX
 tests/test_sqlite_resource_dual_mode.py,sha256=Mh8jBd-xsIGDYFsOACKKK_5DXMUYlFFS7W-jaY6AjG4,8734
 tests/test_sqlite_shared_memory_behavior.py,sha256=fKx_1BmLS3b8x-9pMgjMycpnaHWY8P-2ZuXEspx6Sbw,4082
 tests/test_verifier_from_string.py,sha256=Lxi3TpFHFb-hG4-UhLKZJkqo84ax9YJY8G6beO-1erM,13581
-fleet_python-0.2.125.dist-info/METADATA,sha256=g7QwS8eQ9E36BDj-47goH6aZAf8Ah9lvBxgU0vvkRME,4240
-fleet_python-0.2.125.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-fleet_python-0.2.125.dist-info/entry_points.txt,sha256=qKIQ326cHR5WyCd16QnrW-1DpcT0YyxVRDb3IlTyzTA,39
-fleet_python-0.2.125.dist-info/top_level.txt,sha256=qb1zIbtEktyhRFZdqVytwg54l64qtoZL0wjHB4bUg3c,29
-fleet_python-0.2.125.dist-info/RECORD,,
+fleet_python-0.2.127.dist-info/METADATA,sha256=zGHs5kaIfn_Pw4svle84Ro_KgURnnKUxe9TAJ8Wdrog,4240
+fleet_python-0.2.127.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+fleet_python-0.2.127.dist-info/entry_points.txt,sha256=qKIQ326cHR5WyCd16QnrW-1DpcT0YyxVRDb3IlTyzTA,39
+fleet_python-0.2.127.dist-info/top_level.txt,sha256=qb1zIbtEktyhRFZdqVytwg54l64qtoZL0wjHB4bUg3c,29
+fleet_python-0.2.127.dist-info/RECORD,,