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

fleet/__init__.py

@@ -26,8 +26,6 @@ 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
 
@@ -78,7 +76,7 @@ from . import env
 from . import global_client as _global_client
 from ._async import global_client as _async_global_client
 
-__version__ = "0.2.127"
+__version__ = "0.2.128"
 
 __all__ = [
     # Core classes
@@ -86,10 +84,6 @@ __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.127"
+__version__ = "0.2.128"
 
 __all__ = [
     # Core classes

fleet/_async/base.py

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

fleet/_async/client.py

@@ -171,15 +171,10 @@ 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__)
 
@@ -391,51 +386,8 @@ class AsyncEnv(EnvironmentBase):
     def db(self, name: str = "current") -> AsyncSQLiteResource:
         return self.instance.db(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 browser(self, name: str = "cdp") -> AsyncBrowserResource:
+        return self.instance.browser(name)
 
     def fs(self) -> AsyncFilesystemResource:
         """Get a filesystem diff resource for inspecting file changes."""
@@ -530,6 +482,8 @@ class AsyncEnv(EnvironmentBase):
         timeout: Optional[int] = 30,
         needs_upload: bool = True,
         verifier_runtime_version: Optional[str] = None,
+        async_: bool = False,
+        poll_interval: float = 5.0,
     ) -> VerifiersExecuteResponse:
         return await _execute_verifier_remote(
             self._load_client,
@@ -543,6 +497,8 @@ class AsyncEnv(EnvironmentBase):
             timeout,
             needs_upload,
             verifier_runtime_version,
+            async_=async_,
+            poll_interval=poll_interval,
         )
 
     def __getstate__(self):
@@ -649,9 +605,7 @@ class AsyncFleet:
         )
 
         instance = AsyncEnv(client=self.client, **response.json())
-        # 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.
+        await instance.instance.load()
         return instance
 
     async def make_for_task(self, task: Task) -> AsyncEnv:
@@ -703,7 +657,7 @@ class AsyncFleet:
         else:
             response = await self.client.request("GET", f"/v1/env/instances/{instance_id}")
             instance = AsyncEnv(client=self.client, **response.json())
-            # Resources load lazily on first `db()`/`browser()`/`resources()` access.
+            await instance.instance.load()
             return instance
 
     def _create_url_instance(self, base_url: str) -> AsyncEnv:
@@ -844,45 +798,6 @@ 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)
 
@@ -1814,6 +1729,8 @@ async def _execute_verifier_remote(
     timeout: Optional[int] = 30,
     needs_upload: bool = True,
     verifier_runtime_version: Optional[str] = None,
+    async_: bool = False,
+    poll_interval: float = 5.0,
 ) -> VerifiersExecuteResponse:
     # Pickle args and kwargs together
     # The first arg should be None as a placeholder for env
@@ -1841,6 +1758,11 @@ async def _execute_verifier_remote(
     if verifier_runtime_version:
         request_data["verifier_runtime_version"] = verifier_runtime_version
 
+    # Async submit-and-poll path. When async_ is False the behavior below is
+    # identical to the original synchronous request.
+    if async_:
+        request_data["async"] = True
+
     # Debug logging
     # logger.debug(
     #     f"Sending verifier execute request: key={key}, sha256={bundle_sha[:8]}..., function_name={function_name}"
@@ -1862,4 +1784,21 @@ async def _execute_verifier_remote(
     response_json = response.json()
     # logger.debug(f"Verifier execute response: {response_json}")
 
-    return VerifiersExecuteResponse(**response_json)
+    if not async_:
+        return VerifiersExecuteResponse(**response_json)
+
+    # Async: the submit returns a job handle; poll until the job reaches a
+    # terminal state (completed/failed). Branch on `status`, never `success`.
+    job_id = response_json.get("job_id")
+    if not job_id:
+        # No job handle returned (e.g. server ran it inline) - surface as-is.
+        return VerifiersExecuteResponse(**response_json)
+
+    while True:
+        poll_response = await client.request(
+            "GET", f"/v1/verifiers/jobs/{job_id}"
+        )
+        poll_json = poll_response.json()
+        if poll_json.get("status") in ("completed", "failed"):
+            return VerifiersExecuteResponse(**poll_json)
+        await asyncio.sleep(poll_interval)

fleet/_async/models.py

@@ -51,7 +51,6 @@ 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):
@@ -259,6 +258,12 @@ class VerifiersExecuteRequest(BaseModel):
     display_src: Optional[str] = Field(
         None, description="Display source code", title="Display Src"
     )
+    async_: Optional[bool] = Field(
+        None,
+        alias="async",
+        description="Submit asynchronously and return a job handle instead of waiting",
+        title="Async",
+    )
 
 
 class VerifiersExecuteResponse(BaseModel):
@@ -303,6 +308,16 @@ class VerifiersExecuteResponse(BaseModel):
     stdout: Optional[str] = Field(
         None, description="Captured stdout from execution", title="Stdout"
     )
+    status: Optional[str] = Field(
+        None,
+        description="Job status for async execution (pending/running/completed/failed)",
+        title="Status",
+    )
+    job_id: Optional[str] = Field(
+        None,
+        description="Job handle for async execution; poll GET /v1/verifiers/jobs/{job_id}",
+        title="Job Id",
+    )
 
 
 class DescribeResponse(BaseModel):
@@ -358,7 +373,6 @@ 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/_async/tasks.py

@@ -81,11 +81,23 @@ class Task(BaseModel):
         # Allow arbitrary types for the verifier field
         arbitrary_types_allowed = True
 
-    def verify(self, env, *args, **kwargs) -> float:
+    def verify(
+        self,
+        env,
+        *args,
+        async_: bool = False,
+        poll_interval: float = 5.0,
+        **kwargs,
+    ) -> float:
         """Verify the task using the verifier function (sync version).
 
         For sync environments, calls the sync verifier directly.
         For async verifiers, automatically runs them with asyncio.run().
+
+        When ``async_`` is True the verifier is submitted to run in the
+        background and polled (every ``poll_interval`` seconds) until it
+        completes, avoiding HTTP/edge idle timeouts for long-running
+        verifiers. When False the behavior is unchanged.
         """
         # If verifier doesn't exist but verifier_func does, rebuild it
         if not self.verifier and self.verifier_func:
@@ -95,7 +107,9 @@ class Task(BaseModel):
             import asyncio
             import inspect
 
-            result = self.verifier.remote(env, *args, **kwargs)
+            result = self.verifier.remote(
+                env, *args, async_=async_, poll_interval=poll_interval, **kwargs
+            )
 
             # If the result is a coroutine, we need to run it
             if inspect.iscoroutine(result):
@@ -115,18 +129,27 @@ class Task(BaseModel):
         else:
             raise ValueError("No verifier function found for this task")
 
-    async def verify_async(self, *args, **kwargs) -> float:
+    async def verify_async(
+        self, *args, async_: bool = False, poll_interval: float = 5.0, **kwargs
+    ) -> float:
         """Verify the task using the verifier function (async version).
 
         For async environments, awaits the async verifier.
         Works with both sync and async verifiers in async contexts.
+
+        When ``async_`` is True the verifier is submitted to run in the
+        background and polled (every ``poll_interval`` seconds) until it
+        completes, avoiding HTTP/edge idle timeouts for long-running
+        verifiers. When False the behavior is unchanged.
         """
         # If verifier doesn't exist but verifier_func does, rebuild it
         if not self.verifier and self.verifier_func:
             self._rebuild_verifier()
 
         if self.verifier:
-            result = self.verifier.remote(*args, **kwargs)
+            result = self.verifier.remote(
+                *args, async_=async_, poll_interval=poll_interval, **kwargs
+            )
             # If it's a coroutine, await it
             import inspect
 
@@ -138,19 +161,26 @@ class Task(BaseModel):
             raise ValueError("No verifier function found for this task")
 
     async def verify_detailed_async(
-        self, *args, **kwargs
+        self, *args, async_: bool = False, poll_interval: float = 5.0, **kwargs
     ) -> "VerifiersExecuteResponse":
         """Verify the task and return the full execute response model.
 
         For async environments, awaits the async verifier.
         Works with both sync and async verifiers in async contexts.
+
+        When ``async_`` is True the verifier is submitted to run in the
+        background and polled (every ``poll_interval`` seconds) until it
+        completes, avoiding HTTP/edge idle timeouts for long-running
+        verifiers. When False the behavior is unchanged.
         """
         # If verifier doesn't exist but verifier_func does, rebuild it
         if not self.verifier and self.verifier_func:
             self._rebuild_verifier()
 
         if self.verifier:
-            result = self.verifier.remote_with_response(*args, **kwargs)
+            result = self.verifier.remote_with_response(
+                *args, async_=async_, poll_interval=poll_interval, **kwargs
+            )
             # If it's a coroutine, await it
             import inspect
 
@@ -161,11 +191,23 @@ class Task(BaseModel):
         else:
             raise ValueError("No verifier function found for this task")
 
-    def verify_detailed(self, env, *args, **kwargs) -> "VerifiersExecuteResponse":
+    def verify_detailed(
+        self,
+        env,
+        *args,
+        async_: bool = False,
+        poll_interval: float = 5.0,
+        **kwargs,
+    ) -> "VerifiersExecuteResponse":
         """Verify the task and return the full execute response model (sync version).
 
         For sync environments, calls the sync verifier directly.
         For async verifiers, automatically runs them with asyncio.run().
+
+        When ``async_`` is True the verifier is submitted to run in the
+        background and polled (every ``poll_interval`` seconds) until it
+        completes, avoiding HTTP/edge idle timeouts for long-running
+        verifiers. When False the behavior is unchanged.
         """
         # If verifier doesn't exist but verifier_func does, rebuild it
         if not self.verifier and self.verifier_func:
@@ -176,7 +218,9 @@ class Task(BaseModel):
             import inspect
 
             # Check if verifier has remote_with_response method (for decorated verifiers)
-            result = self.verifier.remote_with_response(env, *args, **kwargs)
+            result = self.verifier.remote_with_response(
+                env, *args, async_=async_, poll_interval=poll_interval, **kwargs
+            )
 
             # If the result is a coroutine, we need to run it
             if inspect.iscoroutine(result):

fleet/_async/verifiers/verifier.py

@@ -154,9 +154,25 @@ class AsyncVerifierFunction:
             # Return error score 0
             return 0.0
 
-    async def remote(self, env: AsyncEnv, *args, **kwargs) -> float:
-        """Remote execution of the verifier function with SHA-based bundle caching."""
-        response = await self.remote_with_response(env, *args, **kwargs)
+    async def remote(
+        self,
+        env: AsyncEnv,
+        *args,
+        async_: bool = False,
+        poll_interval: float = 5.0,
+        **kwargs,
+    ) -> float:
+        """Remote execution of the verifier function with SHA-based bundle caching.
+
+        When ``async_`` is True the verifier is submitted to run in the
+        background and the result is polled (every ``poll_interval`` seconds)
+        until it completes — this avoids HTTP/edge idle timeouts for
+        long-running verifiers. When False the behavior is unchanged (the
+        request blocks until the verifier finishes).
+        """
+        response = await self.remote_with_response(
+            env, *args, async_=async_, poll_interval=poll_interval, **kwargs
+        )
 
         # Handle response
         if response.stdout:
@@ -228,9 +244,20 @@ Remote traceback:
         )
 
     async def remote_with_response(
-        self, env: "AsyncEnv", *args, **kwargs
+        self,
+        env: "AsyncEnv",
+        *args,
+        async_: bool = False,
+        poll_interval: float = 5.0,
+        **kwargs,
     ) -> "VerifiersExecuteResponse":
-        """Remote execution of the verifier function that returns the full response model."""
+        """Remote execution of the verifier function that returns the full response model.
+
+        When ``async_`` is True the verifier is submitted asynchronously and
+        polled (every ``poll_interval`` seconds) until it reaches a terminal
+        state; the returned response is the completed/failed job result. When
+        False the request blocks until the verifier finishes (unchanged).
+        """
         args_array = list(args)
         args_array.append({"env": env.instance_id})
         args = tuple(args_array)
@@ -254,6 +281,8 @@ Remote traceback:
                     kwargs=kwargs,
                     needs_upload=True,
                     verifier_runtime_version=self.verifier_runtime_version,
+                    async_=async_,
+                    poll_interval=poll_interval,
                 )
 
                 # logger.debug(f"Bundle {bundle_sha[:8]}... uploaded successfully")
@@ -271,6 +300,8 @@ Remote traceback:
                     kwargs=kwargs,
                     needs_upload=False,
                     verifier_runtime_version=self.verifier_runtime_version,
+                    async_=async_,
+                    poll_interval=poll_interval,
                 )
 
             return response
@@ -292,6 +323,8 @@ Remote traceback:
                     kwargs=kwargs,
                     needs_upload=True,
                     verifier_runtime_version=self.verifier_runtime_version,
+                    async_=async_,
+                    poll_interval=poll_interval,
                 )
                 return response
             else:

fleet/base.py

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