fleet-python 0.2.128__tar.gz → 0.2.130__tar.gz

{fleet_python-0.2.128/fleet_python.egg-info → fleet_python-0.2.130}/PKG-INFO

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

{fleet_python-0.2.128 → fleet_python-0.2.130}/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.128"
+__version__ = "0.2.130"
 
 __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.128 → fleet_python-0.2.130}/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.128"
+__version__ = "0.2.130"
 
 __all__ = [
     # Core classes

{fleet_python-0.2.128 → fleet_python-0.2.130}/fleet/_async/base.py

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

fleet_python-0.2.130/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.128 → fleet_python-0.2.130}/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."""
@@ -484,6 +532,7 @@ class AsyncEnv(EnvironmentBase):
         verifier_runtime_version: Optional[str] = None,
         async_: bool = False,
         poll_interval: float = 5.0,
+        cost_team_id: Optional[str] = None,
     ) -> VerifiersExecuteResponse:
         return await _execute_verifier_remote(
             self._load_client,
@@ -499,6 +548,7 @@ class AsyncEnv(EnvironmentBase):
             verifier_runtime_version,
             async_=async_,
             poll_interval=poll_interval,
+            cost_team_id=cost_team_id,
         )
 
     def __getstate__(self):
@@ -605,7 +655,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:
@@ -657,7 +709,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:
@@ -798,6 +850,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)
 
@@ -1731,6 +1822,7 @@ async def _execute_verifier_remote(
     verifier_runtime_version: Optional[str] = None,
     async_: bool = False,
     poll_interval: float = 5.0,
+    cost_team_id: Optional[str] = None,
 ) -> VerifiersExecuteResponse:
     # Pickle args and kwargs together
     # The first arg should be None as a placeholder for env
@@ -1758,6 +1850,9 @@ async def _execute_verifier_remote(
     if verifier_runtime_version:
         request_data["verifier_runtime_version"] = verifier_runtime_version
 
+    if cost_team_id is not None:
+        request_data["cost_team_id"] = cost_team_id
+
     # Async submit-and-poll path. When async_ is False the behavior below is
     # identical to the original synchronous request.
     if async_:

{fleet_python-0.2.128 → fleet_python-0.2.130}/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):
@@ -221,6 +222,9 @@ class VerifiersCheckResponse(BaseModel):
 
 
 class VerifiersExecuteRequest(BaseModel):
+    cost_team_id: Optional[str] = Field(
+        None, description="Team to attribute verifier costs to", title="Cost Team Id"
+    )
     key: Optional[str] = Field(
         None, description="Key of the verifier artifact", title="Key"
     )
@@ -373,6 +377,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.128 → fleet_python-0.2.130}/fleet/_async/tasks.py

@@ -85,6 +85,7 @@ class Task(BaseModel):
         self,
         env,
         *args,
+        cost_team_id: Optional[str] = None,
         async_: bool = False,
         poll_interval: float = 5.0,
         **kwargs,
@@ -108,7 +109,12 @@ class Task(BaseModel):
             import inspect
 
             result = self.verifier.remote(
-                env, *args, async_=async_, poll_interval=poll_interval, **kwargs
+                env,
+                *args,
+                cost_team_id=cost_team_id,
+                async_=async_,
+                poll_interval=poll_interval,
+                **kwargs,
             )
 
             # If the result is a coroutine, we need to run it
@@ -130,7 +136,12 @@ class Task(BaseModel):
             raise ValueError("No verifier function found for this task")
 
     async def verify_async(
-        self, *args, async_: bool = False, poll_interval: float = 5.0, **kwargs
+        self,
+        *args,
+        cost_team_id: Optional[str] = None,
+        async_: bool = False,
+        poll_interval: float = 5.0,
+        **kwargs,
     ) -> float:
         """Verify the task using the verifier function (async version).
 
@@ -148,7 +159,11 @@ class Task(BaseModel):
 
         if self.verifier:
             result = self.verifier.remote(
-                *args, async_=async_, poll_interval=poll_interval, **kwargs
+                *args,
+                cost_team_id=cost_team_id,
+                async_=async_,
+                poll_interval=poll_interval,
+                **kwargs,
             )
             # If it's a coroutine, await it
             import inspect
@@ -161,7 +176,12 @@ class Task(BaseModel):
             raise ValueError("No verifier function found for this task")
 
     async def verify_detailed_async(
-        self, *args, async_: bool = False, poll_interval: float = 5.0, **kwargs
+        self,
+        *args,
+        cost_team_id: Optional[str] = None,
+        async_: bool = False,
+        poll_interval: float = 5.0,
+        **kwargs,
     ) -> "VerifiersExecuteResponse":
         """Verify the task and return the full execute response model.
 
@@ -179,7 +199,11 @@ class Task(BaseModel):
 
         if self.verifier:
             result = self.verifier.remote_with_response(
-                *args, async_=async_, poll_interval=poll_interval, **kwargs
+                *args,
+                cost_team_id=cost_team_id,
+                async_=async_,
+                poll_interval=poll_interval,
+                **kwargs,
             )
             # If it's a coroutine, await it
             import inspect
@@ -195,6 +219,7 @@ class Task(BaseModel):
         self,
         env,
         *args,
+        cost_team_id: Optional[str] = None,
         async_: bool = False,
         poll_interval: float = 5.0,
         **kwargs,
@@ -219,7 +244,12 @@ class Task(BaseModel):
 
             # Check if verifier has remote_with_response method (for decorated verifiers)
             result = self.verifier.remote_with_response(
-                env, *args, async_=async_, poll_interval=poll_interval, **kwargs
+                env,
+                *args,
+                cost_team_id=cost_team_id,
+                async_=async_,
+                poll_interval=poll_interval,
+                **kwargs,
             )
 
             # If the result is a coroutine, we need to run it

{fleet_python-0.2.128 → fleet_python-0.2.130}/fleet/_async/verifiers/verifier.py

@@ -158,6 +158,7 @@ class AsyncVerifierFunction:
         self,
         env: AsyncEnv,
         *args,
+        cost_team_id: Optional[str] = None,
         async_: bool = False,
         poll_interval: float = 5.0,
         **kwargs,
@@ -171,7 +172,12 @@ class AsyncVerifierFunction:
         request blocks until the verifier finishes).
         """
         response = await self.remote_with_response(
-            env, *args, async_=async_, poll_interval=poll_interval, **kwargs
+            env,
+            *args,
+            cost_team_id=cost_team_id,
+            async_=async_,
+            poll_interval=poll_interval,
+            **kwargs,
         )
 
         # Handle response
@@ -247,6 +253,7 @@ Remote traceback:
         self,
         env: "AsyncEnv",
         *args,
+        cost_team_id: Optional[str] = None,
         async_: bool = False,
         poll_interval: float = 5.0,
         **kwargs,
@@ -281,6 +288,7 @@ Remote traceback:
                     kwargs=kwargs,
                     needs_upload=True,
                     verifier_runtime_version=self.verifier_runtime_version,
+                    cost_team_id=cost_team_id,
                     async_=async_,
                     poll_interval=poll_interval,
                 )
@@ -300,6 +308,7 @@ Remote traceback:
                     kwargs=kwargs,
                     needs_upload=False,
                     verifier_runtime_version=self.verifier_runtime_version,
+                    cost_team_id=cost_team_id,
                     async_=async_,
                     poll_interval=poll_interval,
                 )
@@ -323,6 +332,7 @@ Remote traceback:
                     kwargs=kwargs,
                     needs_upload=True,
                     verifier_runtime_version=self.verifier_runtime_version,
+                    cost_team_id=cost_team_id,
                     async_=async_,
                     poll_interval=poll_interval,
                 )

{fleet_python-0.2.128 → fleet_python-0.2.130}/fleet/base.py

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