fleet-python 0.2.28__py3-none-any.whl → 0.2.32__py3-none-any.whl

fleet/_async/client.py

@@ -34,7 +34,6 @@ from ..models import (
     TaskRequest,
 )
 from .tasks import Task
-from ..verifiers.parse import extract_function_name, convert_new_to_old_verifier
 
 if TYPE_CHECKING:
     from .verifiers import AsyncVerifierFunction
@@ -51,6 +50,7 @@ from .instance.client import ValidatorType
 from .resources.base import Resource
 from .resources.sqlite import AsyncSQLiteResource
 from .resources.browser import AsyncBrowserResource
+from ..resources.mcp import MCPResource
 
 logger = logging.getLogger(__name__)
 
@@ -69,18 +69,18 @@ class AsyncEnv(EnvironmentBase):
                 self.manager_url, self._client.httpx_client if self._client else None
             )
         return self._instance
-    
+
     def app(self, name: str) -> AsyncInstanceClient:
         if name not in self._apps:
             # Extract base URL by removing the current app path (e.g., /sentry/api/v1/env)
             # manager_url looks like: https://xxx.fleetai.com/sentry/api/v1/env
-            base_url = self.manager_url.split('/api/v1/env')[0]
+            base_url = self.manager_url.split("/api/v1/env")[0]
             # Remove the current app name (e.g., /sentry) to get the root
-            if '/' in base_url:
-                parts = base_url.rsplit('/', 1)
+            if "/" in base_url:
+                parts = base_url.rsplit("/", 1)
                 if len(parts) == 2 and parts[0] != "https:/":
                     base_url = parts[0]
-            
+
             self._apps[name] = AsyncInstanceClient(
                 f"{base_url}/{name}/api/v1/env",
                 self._client.httpx_client if self._client else None,
@@ -104,6 +104,11 @@ class AsyncEnv(EnvironmentBase):
     def browser(self, name: str = "cdp") -> AsyncBrowserResource:
         return self.instance.browser(name)
 
+    @property
+    def mcp(self) -> MCPResource:
+        mcp_url = f"{self.urls.root}mcp"
+        return MCPResource(url=mcp_url, env_key=self.env_key)
+
     def state(self, uri: str) -> Resource:
         return self.instance.state(uri)
 
@@ -125,28 +130,28 @@ class AsyncEnv(EnvironmentBase):
         return await _check_bundle_exists(self._load_client, bundle_hash)
 
     async def execute_verifier_remote(
-        self, 
-        bundle_data: bytes, 
+        self,
+        bundle_data: bytes,
         bundle_sha: str,
         key: str,
         function_name: str,
-        args: tuple, 
+        args: tuple,
         args_array: list,
-        kwargs: dict, 
+        kwargs: dict,
         timeout: Optional[int] = 30,
         needs_upload: bool = True,
     ) -> VerifiersExecuteResponse:
         return await _execute_verifier_remote(
-            self._load_client, 
-            bundle_data, 
+            self._load_client,
+            bundle_data,
             bundle_sha,
             key,
             function_name,
-            args, 
+            args,
             args_array,
-            kwargs, 
+            kwargs,
             timeout,
-            needs_upload
+            needs_upload,
         )
 
     def __getstate__(self):
@@ -170,6 +175,8 @@ class AsyncFleet:
     ):
         if api_key is None:
             api_key = os.getenv("FLEET_API_KEY")
+        if base_url is None:
+            base_url = os.getenv("FLEET_BASE_URL")
         self._httpx_client = httpx_client or default_httpx_client(max_retries, timeout)
         self.client = AsyncWrapper(
             api_key=api_key,
@@ -189,23 +196,27 @@ class AsyncFleet:
         response = await self.client.request("GET", f"/v1/env/{env_key}")
         return EnvironmentModel(**response.json())
 
-    async def make(
-        self, env_key: str, region: Optional[str] = None
-    ) -> AsyncEnv:
+    async def make(self, env_key: str, region: Optional[str] = None) -> AsyncEnv:
         if ":" in env_key:
             env_key_part, version = env_key.split(":", 1)
-            if not version.startswith("v") and len(version) != 0 and version[0].isdigit():
+            if (
+                not version.startswith("v")
+                and len(version) != 0
+                and version[0].isdigit()
+            ):
                 version = f"v{version}"
         else:
             env_key_part = env_key
             version = None
 
-        request = InstanceRequest(env_key=env_key_part, version=version, region=region, created_from="sdk")
+        request = InstanceRequest(
+            env_key=env_key_part, version=version, region=region, created_from="sdk"
+        )
         region_base_url = REGION_BASE_URL.get(region)
         response = await self.client.request(
             "POST",
             "/v1/env/instances",
-            json=request.model_dump(),
+            json=request.model_dump(exclude_none=True),
             base_url=region_base_url,
         )
 
@@ -213,6 +224,9 @@ class AsyncFleet:
         await instance.instance.load()
         return instance
 
+    async def make_for_task(self, task: Task) -> AsyncEnv:
+        return await self.make(env_key=f"{task.env_id}:{task.version}")
+
     async def instances(
         self, status: Optional[str] = None, region: Optional[str] = None
     ) -> List[AsyncEnv]:
@@ -247,44 +261,124 @@ class AsyncFleet:
     async def delete(self, instance_id: str) -> InstanceResponse:
         return await _delete_instance(self.client, instance_id)
 
-    async def load_tasks(self, env_key: Optional[str] = None) -> List[Task]:
-        """Load tasks for the authenticated team, optionally filtered by environment.
-        
+    async def load_tasks_from_file(self, filename: str) -> List[Task]:
+        with open(filename, "r", encoding="utf-8") as f:
+            tasks_data = f.read()
+
+        return self.load_task_array_from_string(tasks_data)
+
+    async def load_task_array_from_string(
+        self, serialized_tasks: List[Dict]
+    ) -> List[Task]:
+        tasks = []
+
+        json_tasks = json.loads(serialized_tasks)
+        for json_task in json_tasks:
+            parsed_task = self.load_task_from_json(json_task)
+            tasks.append(parsed_task)
+        return tasks
+
+    async def load_task_from_string(self, task_string: str) -> Task:
+        task_json = json.loads(task_string)
+        return self.load_task_from_json(task_json)
+
+    async def load_task_from_json(self, task_json: Dict) -> Task:
+        try:
+            if "verifier_id" in task_json and task_json["verifier_id"]:
+                verifier = self._create_verifier_from_data(
+                    verifier_id=task_json["verifier_id"],
+                    verifier_key=task_json["key"],
+                    verifier_code=task_json["verifier_func"],
+                    verifier_sha=task_json.get("verifier_sha", ""),
+                )
+        except Exception as e:
+            logger.warning(f"Failed to create verifier {task_json['key']}: {e}")
+
+        task = Task(
+            key=task_json["key"],
+            prompt=task_json["prompt"],
+            env_id=task_json["env_id"],  # Use env_id from the data
+            created_at=task_json["created_at"],
+            version=task_json.get("version"),
+            env_variables=task_json.get("env_variables", {}),
+            verifier_func=task_json.get("verifier_func"),  # Set verifier code
+            verifier=verifier,  # Use created verifier or None
+            metadata=task_json.get("metadata", {}),  # Default empty metadata
+        )
+        return task
+
+    async def load_tasks(
+        self, 
+        env_key: Optional[str] = None,
+        keys: Optional[List[str]] = None,
+        version: Optional[str] = None,
+        team_id: Optional[str] = None
+    ) -> List[Task]:
+        """Load tasks for the authenticated team, with optional filtering.
+
         Args:
             env_key: Optional environment key to filter tasks by
-            
+            keys: Optional list of task keys to filter by
+            version: Optional version to filter tasks by (client-side filter)
+            team_id: Optional team_id to filter by (admin only)
+
         Returns:
             List[Task] containing Task objects
         """
         params = {}
         if env_key is not None:
             params["env_key"] = env_key
-            
+        if keys is not None:
+            params["task_keys"] = keys
+        if team_id is not None:
+            params["team_id"] = team_id
+
         response = await self.client.request("GET", "/v1/tasks", params=params)
         task_list_response = TaskListResponse(**response.json())
-        
+
         # Transform TaskResponse objects to Task objects
         tasks = []
         for task_response in task_list_response.tasks:
             # Create verifier function if verifier data is present
             verifier = None
             verifier_func = task_response.verifier_func
-            
+
             if task_response.verifier:
-                # Use verifier code from the embedded verifier object
-                verifier_func = task_response.verifier.code
-                
-                # Create VerifierFunction from the embedded data
-                try:
-                    verifier = await self._create_verifier_from_data(
-                        verifier_id=task_response.verifier.verifier_id,
-                        verifier_key=task_response.verifier.key,
-                        verifier_code=task_response.verifier.code,
-                        verifier_sha=task_response.verifier.sha256
-                    )
-                except Exception as e:
-                    logger.warning(f"Failed to create verifier {task_response.verifier.key}: {e}")
-            
+                embedded_code = task_response.verifier.code or ""
+                is_embedded_error = embedded_code.strip().startswith(
+                    "<error loading code:"
+                )
+                if not is_embedded_error:
+                    # Only override if the embedded code looks valid
+                    verifier_func = embedded_code
+                    # Create VerifierFunction from the embedded data
+                    try:
+                        verifier = await self._create_verifier_from_data(
+                            verifier_id=task_response.verifier.verifier_id,
+                            verifier_key=task_response.verifier.key,
+                            verifier_code=embedded_code,
+                            verifier_sha=task_response.verifier.sha256,
+                        )
+                    except Exception as e:
+                        logger.warning(
+                            f"Failed to create verifier {task_response.verifier.key}: {e}"
+                        )
+                else:
+                    # Fallback: try fetching by ID if embedded code failed to load
+                    try:
+                        logger.warning(
+                            f"Embedded verifier code missing for {task_response.verifier.key} (NoSuchKey). "
+                            f"Attempting to refetch by id {task_response.verifier.verifier_id}"
+                        )
+                        verifier = await self._load_verifier(
+                            task_response.verifier.verifier_id
+                        )
+                    except Exception as e:
+                        logger.warning(
+                            f"Refetch by verifier id failed for {task_response.verifier.key}: {e}. "
+                            "Leaving verifier unset."
+                        )
+
             task = Task(
                 key=task_response.key,
                 prompt=task_response.prompt,
@@ -294,19 +388,25 @@ class AsyncFleet:
                 env_variables=task_response.env_variables or {},
                 verifier_func=verifier_func,  # Set verifier code
                 verifier=verifier,  # Use created verifier or None
-                metadata={}  # Default empty metadata
+                metadata={},  # Default empty metadata
             )
             tasks.append(task)
-        
+
+        # Apply client-side filtering for version if specified
+        if version is not None:
+            tasks = [task for task in tasks if task.version == version]
+
         return tasks
 
-    async def export_tasks(self, env_key: Optional[str] = None, filename: Optional[str] = None):
+    async def export_tasks(
+        self, env_key: Optional[str] = None, filename: Optional[str] = None
+    ):
         """Export tasks for the authenticated team, optionally filtered by environment.
-        
+
         Args:
             env_key: Optional environment key to filter tasks by
             filename: Optional filename to write tasks to. If not provided, defaults to 'tasks.json' or 'tasks_{env_key}.json'
-            
+
         Returns:
             str: Path to the exported file if tasks were written, None if no tasks found
         """
@@ -318,38 +418,38 @@ class AsyncFleet:
                     filename = f"tasks_{env_key}.json"
                 else:
                     filename = "tasks.json"
-            
+
             # Convert tasks to serializable format
             tasks_data = []
             for task in tasks:
                 task_dict = task.model_dump()
                 # Remove non-serializable verifier object, keep verifier_func (code string)
-                if 'verifier' in task_dict:
-                    task_dict.pop('verifier')
+                if "verifier" in task_dict:
+                    task_dict.pop("verifier")
                 tasks_data.append(task_dict)
-            
+
             # Write to JSON file
-            with open(filename, 'w', encoding='utf-8') as f:
+            with open(filename, "w", encoding="utf-8") as f:
                 json.dump(tasks_data, f, indent=2, default=str)
-            
+
             logger.info(f"Exported {len(tasks)} tasks to {filename}")
             return filename
         else:
             logger.info("No tasks found to export")
             return None
-            
+
     async def import_tasks(self, filename: str):
         """Import tasks from a JSON file.
-        
+
         Args:
             filename: Path to the JSON file of Task objects to import
-            
+
         Returns:
             List[Task] containing imported Task objects
         """
-        with open(filename, 'r', encoding='utf-8') as f:
+        with open(filename, "r", encoding="utf-8") as f:
             tasks_data = json.load(f)
-            
+
         # Create tasks from the loaded data
         tasks = []
         for task_data in tasks_data:
@@ -366,12 +466,13 @@ class AsyncFleet:
                 env_variables=task.env_variables or {},
             )
             try:
-                response = await self.client.request("POST", "/v1/tasks", json=payload.model_dump())
+                response = await self.client.request(
+                    "POST", "/v1/tasks", json=payload.model_dump()
+                )
             except Exception as e:
                 logger.error(f"Failed to import task {task.key}: {e}")
                 continue
 
-
     async def account(self) -> AccountResponse:
         """Get account information including instance limits and usage.
 
@@ -380,102 +481,62 @@ class AsyncFleet:
         """
         response = await self.client.request("GET", "/v1/account")
         return AccountResponse(**response.json())
-    
+
     async def _create_verifier_from_data(
-        self, 
-        verifier_id: str,
-        verifier_key: str,
-        verifier_code: str,
-        verifier_sha: str
+        self, verifier_id: str, verifier_key: str, verifier_code: str, verifier_sha: str
     ) -> "AsyncVerifierFunction":
         """Create an AsyncVerifierFunction from verifier data.
-        
+
         Args:
             verifier_id: The verifier ID
             verifier_key: The verifier key
             verifier_code: The verifier code
             verifier_sha: The verifier SHA256
-            
+
         Returns:
             AsyncVerifierFunction created from the verifier code
         """
+        from ..tasks import verifier_from_string
         from .verifiers.verifier import AsyncVerifierFunction
         
-        # Check if this is a new format verifier (has before/after parameters)
-        if 'before: DatabaseSnapshot' in verifier_code and 'after: DatabaseSnapshot' in verifier_code:
-            # Convert new format to old format
-            verifier_code = convert_new_to_old_verifier(verifier_code)
-            # Update function name since wrapper adds _wrapper suffix
-            original_name = extract_function_name(verifier_code.split('\n')[0])
-            if original_name and original_name.endswith('_wrapper'):
-                function_name = original_name
-            else:
-                function_name = extract_function_name(verifier_code)
-        else:
-            # Extract function name from code
-            function_name = extract_function_name(verifier_code)
-        
-        if not function_name:
-            raise ValueError(f"Could not extract function name from verifier {verifier_id}")
-        
-        # Create a function object from the code
-        # Import necessary classes for the namespace
-        from ..verifiers.db import IgnoreConfig, DatabaseSnapshot
-        
-        # Create a namespace for the function
-        namespace = {
-            '__builtins__': __builtins__,
-            'Environment': object,  # Placeholder, will be provided at runtime
-            'IgnoreConfig': IgnoreConfig,
-            'DatabaseSnapshot': DatabaseSnapshot,
-            'TASK_FAILED_SCORE': 0,
-            'TASK_SUCCESSFUL_SCORE': 1,
-        }
-        
-        # Execute the code to define the function
-        exec(verifier_code, namespace)
-        
-        # Get the function object
-        if function_name not in namespace:
-            raise ValueError(f"Function {function_name} not found in verifier code")
-        
-        func = namespace[function_name]
-        
-        # Create and return AsyncVerifierFunction with SHA if available
-        # Since the function was created via exec, we need to provide the raw code
-        verifier_func = AsyncVerifierFunction(
-            func=func,
-            key=verifier_key,
-            extra_requirements=[],
+        # Use verifier_from_string to create the verifier
+        verifier_func = verifier_from_string(
+            verifier_func=verifier_code,
             verifier_id=verifier_id,
-            sha256=verifier_sha,  # Pass SHA directly to constructor
-            raw_code=verifier_code  # Provide raw code since func won't have extractable source
+            verifier_key=verifier_key,
+            sha256=verifier_sha,
         )
         
+        # Ensure we return an AsyncVerifierFunction
+        if not isinstance(verifier_func, AsyncVerifierFunction):
+            raise TypeError(
+                f"Expected AsyncVerifierFunction but got {type(verifier_func).__name__}"
+            )
+        
         # Store the original verifier code for reference
         verifier_func._verifier_code = verifier_code
-        
+
         return verifier_func
-    
+
     async def _load_verifier(self, verifier_id: str) -> "AsyncVerifierFunction":
         """Load a verifier by ID and create an AsyncVerifierFunction.
-        
+
         Args:
             verifier_id: The verifier ID to fetch
-            
+
         Returns:
             AsyncVerifierFunction created from the verifier code
         """
         # Fetch verifier from API
         response = await self.client.request("GET", f"/v1/verifier/{verifier_id}")
         verifier_data = response.json()
-        
+
         # Use the common method to create verifier
         return await self._create_verifier_from_data(
             verifier_id=verifier_id,
             verifier_key=verifier_data["key"],
             verifier_code=verifier_data["code"],
-            verifier_sha=verifier_data.get("sha256", "")
+            verifier_sha=verifier_data.get("sha256", ""),
         )
 
 
@@ -520,23 +581,29 @@ async def _execute_verifier_remote(
         "timeout": timeout,
         "region": "us-west-1",  # TODO: make configurable
     }
-    
+
     # Add bundle data only if upload is needed
     if needs_upload:
         bundle_b64 = base64.b64encode(bundle_data).decode("utf-8")
         request_data["bundle"] = bundle_b64
-    
+
     # Debug logging
-    logger.debug(f"Sending verifier execute request: key={key}, sha256={bundle_sha[:8]}..., function_name={function_name}")
+    logger.debug(
+        f"Sending verifier execute request: key={key}, sha256={bundle_sha[:8]}..., function_name={function_name}"
+    )
     logger.debug(f"Request has bundle: {needs_upload}")
     logger.debug(f"Using client with base_url: {client.base_url}")
     logger.debug(f"Request data keys: {list(request_data.keys())}")
-    logger.debug(f"Bundle size: {len(request_data.get('bundle', ''))} chars" if 'bundle' in request_data else "No bundle")
+    logger.debug(
+        f"Bundle size: {len(request_data.get('bundle', ''))} chars"
+        if "bundle" in request_data
+        else "No bundle"
+    )
 
     # Note: This should be called on the instance URL, not the orchestrator
     # The instance has manager URLs for verifier execution
     response = await client.request("POST", "/v1/verifiers/execute", json=request_data)
-    
+
     # Debug the response
     response_json = response.json()
     logger.debug(f"Verifier execute response: {response_json}")

fleet/_async/env/client.py

@@ -1,4 +1,4 @@
-from ..client import AsyncFleet, AsyncEnv
+from ..client import AsyncFleet, AsyncEnv, Task
 from ...models import Environment as EnvironmentModel, AccountResponse
 from typing import List, Optional
 
@@ -7,6 +7,10 @@ async def make_async(env_key: str, region: Optional[str] = None) -> AsyncEnv:
     return await AsyncFleet().make(env_key, region=region)
 
 
+async def make_for_task_async(task: Task) -> AsyncEnv:
+    return await AsyncFleet().make_for_task(task)
+
+
 async def list_envs_async() -> List[EnvironmentModel]:
     return await AsyncFleet().list_envs()
 

fleet/_async/global_client.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+from typing import Optional
+
+from .client import AsyncFleet
+from ..config import DEFAULT_MAX_RETRIES, DEFAULT_TIMEOUT
+
+
+_default_client: Optional[AsyncFleet] = None
+
+
+def get_client() -> AsyncFleet:
+    """Get the global default AsyncFleet client, creating it if needed."""
+    global _default_client
+    if _default_client is None:
+        _default_client = AsyncFleet()
+    return _default_client
+
+
+def configure(
+    api_key: Optional[str] = None,
+    base_url: Optional[str] = None,
+    max_retries: int = DEFAULT_MAX_RETRIES,
+    timeout: float = DEFAULT_TIMEOUT,
+) -> AsyncFleet:
+    """Configure the global default AsyncFleet client.
+
+    Returns the configured client instance.
+    """
+    global _default_client
+    _default_client = AsyncFleet(
+        api_key=api_key,
+        base_url=base_url,
+        max_retries=max_retries,
+        timeout=timeout,
+    )
+    return _default_client
+
+
+def reset_client() -> None:
+    """Reset the global default client. A new one will be created on next access."""
+    global _default_client
+    _default_client = None

fleet/_async/instance/client.py

@@ -130,7 +130,7 @@ class AsyncInstanceClient:
 
     async def _load_resources(self) -> None:
         if self._resources is None:
-            response = await self.client.request("GET", "/resources")
+            response = await self.client.request("GET", "/resources", timeout=1.0)
             if response.status_code != 200:
                 self._resources = []
                 return