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

fleet/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 SyncVerifierFunction
@@ -51,6 +50,7 @@ from .instance.client import ValidatorType
 from .resources.base import Resource
 from .resources.sqlite import SQLiteResource
 from .resources.browser import BrowserResource
+from .resources.mcp import MCPResource
 
 logger = logging.getLogger(__name__)
 
@@ -69,18 +69,18 @@ class SyncEnv(EnvironmentBase):
                 self.manager_url, self._client.httpx_client if self._client else None
             )
         return self._instance
-    
+
     def app(self, name: str) -> InstanceClient:
         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] = InstanceClient(
                 f"{base_url}/{name}/api/v1/env",
                 self._client.httpx_client if self._client else None,
@@ -104,6 +104,11 @@ class SyncEnv(EnvironmentBase):
     def browser(self, name: str = "cdp") -> BrowserResource:
         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 SyncEnv(EnvironmentBase):
         return _check_bundle_exists(self._load_client, bundle_hash)
 
     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 _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 Fleet:
     ):
         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 = SyncWrapper(
             api_key=api_key,
@@ -189,23 +196,27 @@ class Fleet:
         response = self.client.request("GET", f"/v1/env/{env_key}")
         return EnvironmentModel(**response.json())
 
-    def make(
-        self, env_key: str, region: Optional[str] = None
-    ) -> SyncEnv:
+    def make(self, env_key: str, region: Optional[str] = None) -> SyncEnv:
         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 = 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 Fleet:
         instance.instance.load()
         return instance
 
+    def make_for_task(self, task: Task) -> SyncEnv:
+        return self.make(env_key=f"{task.env_id}:{task.version}")
+
     def instances(
         self, status: Optional[str] = None, region: Optional[str] = None
     ) -> List[SyncEnv]:
@@ -240,51 +254,114 @@ class Fleet:
     def execute_verifier_remote(
         self, bundle_data: bytes, args: tuple, kwargs: dict, timeout: Optional[int] = 30
     ) -> VerifiersExecuteResponse:
-        return _execute_verifier_remote(
-            self.client, bundle_data, args, kwargs, timeout
-        )
+        return _execute_verifier_remote(self.client, bundle_data, args, kwargs, timeout)
 
     def delete(self, instance_id: str) -> InstanceResponse:
         return _delete_instance(self.client, instance_id)
 
+    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)
+
+    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
+
+    def load_task_from_string(self, task_string: str) -> Task:
+        task_json = json.loads(task_string)
+        return self.load_task_from_json(task_json)
+
+    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
+
     def load_tasks(self, env_key: Optional[str] = None) -> List[Task]:
         """Load tasks for the authenticated team, optionally filtered by environment.
-        
+
         Args:
             env_key: Optional environment key to filter tasks by
-            
+
         Returns:
             List[Task] containing Task objects
         """
         params = {}
         if env_key is not None:
             params["env_key"] = env_key
-            
+
         response = 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 = 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 = 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 = 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 +371,21 @@ class Fleet:
                 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)
-        
+
         return tasks
 
-    def export_tasks(self, env_key: Optional[str] = None, filename: Optional[str] = None):
+    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 +397,38 @@ class Fleet:
                     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
-            
+
     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 +445,13 @@ class Fleet:
                 env_variables=task.env_variables or {},
             )
             try:
-                response = self.client.request("POST", "/v1/tasks", json=payload.model_dump())
+                response = 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
 
-
     def account(self) -> AccountResponse:
         """Get account information including instance limits and usage.
 
@@ -380,108 +460,62 @@ class Fleet:
         """
         response = self.client.request("GET", "/v1/account")
         return AccountResponse(**response.json())
-    
+
     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
     ) -> "SyncVerifierFunction":
-        """Create an AsyncVerifierFunction from verifier data.
-        
+        """Create a SyncVerifierFunction 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
+            SyncVerifierFunction created from the verifier code
         """
+        from .tasks import verifier_from_string
         from .verifiers.verifier import SyncVerifierFunction
-
-        # Convert async verifier code to sync
-        if 'async def' in verifier_code:
-            verifier_code = verifier_code.replace('async def', 'def')
-        if 'await ' in verifier_code:
-            verifier_code = verifier_code.replace('await ', '')
-        
-        # 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 = SyncVerifierFunction(
-            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 a SyncVerifierFunction
+        if not isinstance(verifier_func, SyncVerifierFunction):
+            raise TypeError(
+                f"Expected SyncVerifierFunction but got {type(verifier_func).__name__}"
+            )
+        
         # Store the original verifier code for reference
         verifier_func._verifier_code = verifier_code
-        
+
         return verifier_func
-    
+
     def _load_verifier(self, verifier_id: str) -> "SyncVerifierFunction":
         """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 = self.client.request("GET", f"/v1/verifier/{verifier_id}")
         verifier_data = response.json()
-        
+
         # Use the common method to create verifier
         return 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", ""),
         )
 
 
@@ -526,23 +560,29 @@ 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 = 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/config.py

@@ -1,9 +1,10 @@
-DEFAULT_MAX_RETRIES = 5
-DEFAULT_TIMEOUT = 60.0
+DEFAULT_MAX_RETRIES = 3
+DEFAULT_TIMEOUT = 180.0
 
 GLOBAL_BASE_URL = "https://orchestrator.fleetai.com"
 REGION_BASE_URL = {
     "us-west-1": "https://us-west-1.fleetai.com",
     "us-east-1": "https://us-east-1.fleetai.com",
     "eu-west-2": "https://eu-west-2.fleetai.com",
+    "staging": "https://staging.fleetai.com",
 }

fleet/env/__init__.py

@@ -1,6 +1,14 @@
 """Fleet env module - convenience functions for environment management."""
 
-from .client import make, list_envs, list_regions, get, list_instances, account
+from .client import (
+    make,
+    make_for_task,
+    list_envs,
+    list_regions,
+    get,
+    list_instances,
+    account,
+)
 
 # Import async versions from _async
 from .._async.env.client import (
@@ -14,6 +22,7 @@ from .._async.env.client import (
 
 __all__ = [
     "make",
+    "make_for_task",
     "list_envs",
     "list_regions",
     "list_instances",

fleet/env/client.py

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

fleet/global_client.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+from typing import Optional
+
+from .client import Fleet
+from .config import DEFAULT_MAX_RETRIES, DEFAULT_TIMEOUT
+
+
+_default_client: Optional[Fleet] = None
+
+
+def get_client() -> Fleet:
+    """Get the global default AsyncFleet client, creating it if needed."""
+    global _default_client
+    if _default_client is None:
+        _default_client = Fleet()
+    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,
+) -> Fleet:
+    """Configure the global default AsyncFleet client.
+
+    Returns the configured client instance.
+    """
+    global _default_client
+    _default_client = Fleet(
+        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/instance/__init__.py

@@ -19,5 +19,5 @@ __all__ = [
     "ChromeStartRequest",
     "ChromeStartResponse",
     "ChromeStatusResponse",
-    "ExecuteFunctionResponse"
+    "ExecuteFunctionResponse",
 ]

fleet/instance/client.py

@@ -63,9 +63,7 @@ class InstanceClient:
     def load(self) -> None:
         self._load_resources()
 
-    def reset(
-        self, reset_request: Optional[ResetRequest] = None
-    ) -> ResetResponse:
+    def reset(self, reset_request: Optional[ResetRequest] = None) -> ResetResponse:
         response = self.client.request(
             "POST", "/reset", json=reset_request.model_dump() if reset_request else None
         )
@@ -130,7 +128,7 @@ class InstanceClient:
 
     def _load_resources(self) -> None:
         if self._resources is None:
-            response = self.client.request("GET", "/resources")
+            response = self.client.request("GET", "/resources", timeout=1.0)
             if response.status_code != 200:
                 self._resources = []
                 return