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

fleet/__init__.py

@@ -76,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.126"
+__version__ = "0.2.128"
 
 __all__ = [
     # Core classes

fleet/_async/__init__.py

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

fleet/_async/base.py

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

fleet/_async/client.py

@@ -482,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,
@@ -495,6 +497,8 @@ class AsyncEnv(EnvironmentBase):
             timeout,
             needs_upload,
             verifier_runtime_version,
+            async_=async_,
+            poll_interval=poll_interval,
         )
 
     def __getstate__(self):
@@ -601,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:
@@ -655,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:
@@ -1727,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
@@ -1754,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}"
@@ -1775,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.126"
+    __version__ = "0.2.128"
 
 logger = logging.getLogger(__name__)
 

fleet/client.py

@@ -22,6 +22,7 @@ import httpx
 import json
 import logging
 import os
+import time
 from datetime import date, datetime
 from decimal import Decimal
 from enum import Enum
@@ -494,6 +495,8 @@ class SyncEnv(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 _execute_verifier_remote(
             self._load_client,
@@ -507,6 +510,8 @@ class SyncEnv(EnvironmentBase):
             timeout,
             needs_upload,
             verifier_runtime_version,
+            async_=async_,
+            poll_interval=poll_interval,
         )
 
     def __getstate__(self):
@@ -613,9 +618,7 @@ class Fleet:
         )
 
         instance = SyncEnv(client=self.client, **response.json())
-        # 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.
+        instance.instance.load()
         return instance
 
     def make_for_task(self, task: Task) -> SyncEnv:
@@ -667,7 +670,7 @@ class Fleet:
         else:
             response = self.client.request("GET", f"/v1/env/instances/{instance_id}")
             instance = SyncEnv(client=self.client, **response.json())
-            # Resources load lazily on first `db()`/`browser()`/`resources()` access.
+            instance.instance.load()
             return instance
 
     def _create_url_instance(self, base_url: str) -> SyncEnv:
@@ -1841,6 +1844,8 @@ 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
@@ -1868,6 +1873,11 @@ 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}"
@@ -1889,4 +1899,19 @@ 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 = 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)
+        time.sleep(poll_interval)

fleet/models.py

@@ -52,7 +52,6 @@ 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):
@@ -267,6 +266,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):
@@ -311,6 +316,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):
@@ -370,7 +385,6 @@ 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/tasks.py

@@ -83,11 +83,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:
@@ -97,7 +109,9 @@ class Task(BaseModel):
             import inspect
 
             # Check if verifier has remote method (for decorated verifiers)
-            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):
@@ -117,18 +131,27 @@ class Task(BaseModel):
         else:
             raise ValueError("No verifier function found for this task")
 
-    def verify_async(self, *args, **kwargs) -> float:
+    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
 
@@ -139,11 +162,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.
 
         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:
@@ -153,7 +188,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):
@@ -173,18 +210,27 @@ class Task(BaseModel):
         else:
             raise ValueError("No verifier function found for this task")
 
-    def verify_detailed_async(self, *args, **kwargs) -> "VerifiersExecuteResponse":
+    def verify_detailed_async(
+        self, *args, async_: bool = False, poll_interval: float = 5.0, **kwargs
+    ) -> "VerifiersExecuteResponse":
         """Verify the task and return the full execute response model (async version).
 
         For async environments, returns a coroutine that when awaited returns the response.
         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
+            )
             # Return the result (could be a coroutine or a value)
             return result
         else:

fleet/verifiers/verifier.py

@@ -165,9 +165,25 @@ class SyncVerifierFunction:
             # Return error score 0
             return 0.0
 
-    def remote(self, env: "SyncEnv", *args, **kwargs) -> float:
-        """Remote execution of the verifier function with SHA-based bundle caching."""
-        response = self.remote_with_response(env, *args, **kwargs)
+    def remote(
+        self,
+        env: "SyncEnv",
+        *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 = self.remote_with_response(
+            env, *args, async_=async_, poll_interval=poll_interval, **kwargs
+        )
 
         # Handle response
         if response.stdout:
@@ -239,9 +255,20 @@ Remote traceback:
         )
 
     def remote_with_response(
-        self, env: "SyncEnv", *args, **kwargs
+        self,
+        env: "SyncEnv",
+        *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)
@@ -265,6 +292,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")
@@ -283,6 +312,8 @@ Remote traceback:
                     kwargs=kwargs,
                     needs_upload=False,
                     verifier_runtime_version=self.verifier_runtime_version,
+                    async_=async_,
+                    poll_interval=poll_interval,
                 )
                 return response
 
@@ -303,6 +334,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_python-0.2.126.dist-info → fleet_python-0.2.128.dist-info}/METADATA

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

{fleet_python-0.2.126.dist-info → fleet_python-0.2.128.dist-info}/RECORD

@@ -24,25 +24,25 @@ 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=-N0S1jb3G3DdT9YTvnx1MHIG6EvnuaYAiGnVgmuPzEE,7977
-fleet/base.py,sha256=GNJFLzknbftMyLbMAViPaTf5WPtMBE26Yp4RO2e8TIc,10209
+fleet/__init__.py,sha256=eCbHM32E7To3Q5t7VJsd6sGQ4_WmrTCNdYT8rfjq8d4,7977
+fleet/base.py,sha256=2Y_9_1pJ3gDzgK_hAMrSvmsSKQgpmCEOX0XXTpq6YB4,10209
 fleet/cli.py,sha256=arX1E-fjLXtcV3tVVkPHfEXxl7FDn4zRmf0ssXlXaMg,40104
-fleet/client.py,sha256=lBy0bqHbXbyOoWk_47bsRglVHpOjM6sv-H8sJIhlwm4,69003
+fleet/client.py,sha256=RzUMoP-XsBcvZkQHUnKic5swflcpsAI9mdIGEusB18I,69820
 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=3IMbL_BCTSmOKhiVNuguTJ-y4mVrrcGawRd4_ZnFvXc,25329
-fleet/tasks.py,sha256=8pEzXmgC7RslqsMC_0s6shhr_t2WGIRpTRqo-MAQjdg,20778
+fleet/models.py,sha256=_HhgxeN563wG8MAHFGnFqzPlZKXRPDY2J1Ipp6Jiea0,25702
+fleet/tasks.py,sha256=7-bXf-H2EpnKMAT7t0XDiAePn6R76vi-OgTlD1bDt6Q,22500
 fleet/types.py,sha256=L4Y82xICf1tzyCLqhLYUgEoaIIS5h9T05TyFNHSWs3s,652
-fleet/_async/__init__.py,sha256=o2YQI5-Ew6CNQDZAtBEzYwcRTFTGNyackKm1KlI9u1I,9116
-fleet/_async/base.py,sha256=9tKbiydjwXikc27LLjkY2xkROnMv3YRuwV4QId5B0Yo,9774
-fleet/_async/client.py,sha256=AwslVbMmn8CDXswqdNIVuLu-8Kc2fxB5PbggyvHp_1w,65455
+fleet/_async/__init__.py,sha256=8EM5RKgPnzSw9NnaUZwwV-IyMXYHFX4MJTDRpuAdcqk,9116
+fleet/_async/base.py,sha256=OSRe1j7wKhP4LGnjGruQUXU2Qeao7UWx-1CsEJpiAnk,9774
+fleet/_async/client.py,sha256=Tm9et3n-cAa21fdkOp7FFD9xqi5LeuMvZxm8AuAiqnU,66283
 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=6B_Umf9DYToWENHrvt1ExkBt03X0Th11GDNFL7MEldU,13743
-fleet/_async/tasks.py,sha256=rlY6SmWl3ZABXe5-ky63wfwYETd2K-Na_m7g5KI1GoI,20602
+fleet/_async/models.py,sha256=MWNyzxEdODDvgngMCEXpTpOoUd6HN0oIt3Oul8aVJ90,14116
+fleet/_async/tasks.py,sha256=r8HPRchH354hUauf3PruMY4i-jqjfwbIfafwrWEFlZo,22310
 fleet/_async/env/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fleet/_async/env/client.py,sha256=FqetvDlABeHLaAc8UF_m_2OFEhXy4ZqH7ly_Nh8p3uA,3479
 fleet/_async/instance/__init__.py,sha256=PtmJq8J8bh0SOQ2V55QURz5GJfobozwtQoqhaOk3_tI,515
@@ -57,7 +57,7 @@ fleet/_async/resources/mcp.py,sha256=TLEsLiFhfVfZFs0Fu_uDPm-h4FPdvqgQblYqs-PTHhc
 fleet/_async/resources/sqlite.py,sha256=1ej04wsDlTxnmIB5mqRX6qfx-k0pyx01FUzWqTgylRI,106844
 fleet/_async/verifiers/__init__.py,sha256=1WTlCNq4tIFbbXaQu5Bf2WppZq0A8suhtZbxMTSOwxI,465
 fleet/_async/verifiers/bundler.py,sha256=9aWWXFsovBPcndE06IATn5jaeli5fRORAYeenF9heN0,26264
-fleet/_async/verifiers/verifier.py,sha256=iSa-rO-E1R3IQTFS9Z7jbQvQVtsDkilITQP9IIQU2JA,14556
+fleet/_async/verifiers/verifier.py,sha256=Afy_6pHtxq4kPwAe-ZalCJ8u9fQI7xalIf_uNn_HUhs,15744
 fleet/agent/__init__.py,sha256=BuiElLoL_OTq_tmEMD85Zc1x3x9iUerYM7TxLpD22aI,737
 fleet/agent/orchestrator.py,sha256=ciZFctuv_MOmn_IoK021YpDsPLvuG40YLywsX-oA2j4,30308
 fleet/agent/types.py,sha256=SjJbMju13EPjTPnH7igv860RhCIIKCIQnGEgc8GnHZM,1476
@@ -100,8 +100,8 @@ fleet/verifiers/db.py,sha256=CwuEaH1xpLdzhH3OpP0Fb5PAezIp4WhAMX4Kvo1WcCU,73138
 fleet/verifiers/decorator.py,sha256=RuTjjDijbicNfMSjA7HcTpKueEki5dzNOdTuHS7UoZs,3262
 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.126.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+fleet/verifiers/verifier.py,sha256=DQ2m90AOEAhgNT2X7wl5NGDJY6NTSkkMsmLNXhOfs-A,15789
+fleet_python-0.2.128.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 +112,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.126.dist-info/METADATA,sha256=gQhrThOnPTJ8uYTQJVfx2eMqpa_hVsfVVQ5FTrgx7sU,4240
-fleet_python-0.2.126.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-fleet_python-0.2.126.dist-info/entry_points.txt,sha256=qKIQ326cHR5WyCd16QnrW-1DpcT0YyxVRDb3IlTyzTA,39
-fleet_python-0.2.126.dist-info/top_level.txt,sha256=qb1zIbtEktyhRFZdqVytwg54l64qtoZL0wjHB4bUg3c,29
-fleet_python-0.2.126.dist-info/RECORD,,
+fleet_python-0.2.128.dist-info/METADATA,sha256=OxrOpgm1103DZCLYDKkkPKCZUQkwlwuZnPOYtBkN8SE,4240
+fleet_python-0.2.128.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+fleet_python-0.2.128.dist-info/entry_points.txt,sha256=qKIQ326cHR5WyCd16QnrW-1DpcT0YyxVRDb3IlTyzTA,39
+fleet_python-0.2.128.dist-info/top_level.txt,sha256=qb1zIbtEktyhRFZdqVytwg54l64qtoZL0wjHB4bUg3c,29
+fleet_python-0.2.128.dist-info/RECORD,,