fleet-python 0.2.32__tar.gz → 0.2.34__tar.gz

{fleet_python-0.2.32 → fleet_python-0.2.34}/PKG-INFO

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

fleet_python-0.2.34/examples/exampleResume.py

@@ -0,0 +1,191 @@
+#!/usr/bin/env python3
+"""
+Interactive Browser Snapshot/Resume Example
+
+This script:
+1. Creates an environment and browser
+2. Lets you interact with it manually
+3. Takes a snapshot when you type 'close'
+4. Resumes from the snapshot with a new environment
+"""
+
+import json
+import os
+import sys
+from datetime import datetime
+
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
+
+from fleet import Fleet
+
+def main():
+    # Initialize Fleet client
+    api_key = os.getenv("FLEET_API_KEY")
+    if not api_key:
+        print("Error: FLEET_API_KEY environment variable not set")
+        sys.exit(1)
+    
+    fleet = Fleet(api_key=api_key)
+    
+    # Initialize environment variables
+    env = None
+    new_env = None
+    
+    try:
+        # Step 1: Create environment and browser
+        print("🚀 Creating new environment...")
+        env_key = "fira:v1.3.2"  
+        
+        env = fleet.make(env_key)
+        print(f"✅ Environment created: {env.instance_id}")
+        print(f"📝 Session ID: {env.session_id}")
+        
+        # Start browser
+        print("\n🌐 Starting browser...")
+        browser = env.browser()
+        browser.start(width=1920, height=1080)
+        
+        # Get browser URLs with session ID for automatic logging
+        cdp_page_url = browser.cdp_page_url()
+        cdp_browser_url = browser.cdp_browser_url()
+        devtools_url = browser.devtools_url()
+        
+        print(f"✅ Browser started!")
+        print(f"🔗 CDP Page URL: {cdp_page_url}")
+        print(f"🔗 CDP Browser URL: {cdp_browser_url}")
+        print(f"🔗 DevTools URL: {devtools_url}")
+        
+        # Show connection info for debugging
+        conn_info = browser.get_connection_info()
+        print(f"📊 Logging enabled: {conn_info['logging_enabled']}")
+        if conn_info['logging_enabled']:
+            print(f"📝 All CDP actions will be automatically logged to session: {env.session_id}")
+        
+        # Step 2: Wait for user interaction
+        print("\n" + "="*60)
+        print("🎮 INTERACTIVE MODE")
+        print("="*60)
+        print("You can now interact with the browser manually.")
+        print("Open the DevTools URL in Chrome to see and control the browser.")
+        print("\nType 'close' and press Enter when you're done to save a snapshot.")
+        print("="*60 + "\n")
+        
+        while True:
+            user_input = input(">>> ").strip().lower()
+            
+            if user_input == "close":
+                break
+            elif user_input == "status":
+                print(f"Environment: {env.instance_id}")
+                print(f"Session: {env.session_id}")
+            else:
+                print("Type 'close' to save snapshot and exit, or 'status' to see current info")
+        
+        # Step 3: Take snapshot
+        print("\n📸 Taking snapshot...")
+        snapshot = env.get_snapshot(browser)
+        
+        # Save snapshot to file
+        snapshot_file = f"snapshot_{env.session_id}_{int(datetime.now().timestamp())}.json"
+        with open(snapshot_file, "w") as f:
+            json.dump(snapshot.model_dump(), f, indent=2)
+        
+        print(f"✅ Snapshot saved to: {snapshot_file}")
+        print(f"   - Tool logs: {len(snapshot.tool_logs)} entries")
+        print(f"   - Action logs: {len(snapshot.action_logs)} entries")
+        print(f"   - Page URL: {snapshot.page_url}")
+        print(f"   - Viewport: {snapshot.viewport_size}")
+        
+        # Close original environment
+        print("\n🏁 Closing original environment...")
+        env.close()
+        env = None  # Mark as closed
+        
+        # Step 4: Resume from snapshot
+        print("\n" + "="*60)
+        print("🔄 RESUMING FROM SNAPSHOT")
+        print("="*60)
+        
+        input("\nPress Enter to resume from snapshot...")
+        
+        print("\n🚀 Creating new environment from snapshot...")
+        new_env, validation = fleet.resume(
+            snapshot,
+            validate=True,
+            playback_speed=2.0  # Replay at 2x speed
+        )
+        
+        print(f"✅ Environment resumed: {new_env.instance_id}")
+        print(f"📝 New session ID: {new_env.session_id}")
+        
+        # Show validation results
+        print(f"\n📊 Validation Results:")
+        print(f"   - Success: {validation.success}")
+        print(f"   - Page match: {validation.page_match}")
+        print(f"   - Action log match: {validation.action_log_match}")
+        
+        if validation.discrepancies:
+            print(f"   - Discrepancies ({len(validation.discrepancies)}):")
+            for disc in validation.discrepancies[:5]:  # Show first 5
+                print(f"     • {disc}")
+            if len(validation.discrepancies) > 5:
+                print(f"     • ... and {len(validation.discrepancies) - 5} more")
+        
+        # Get new browser reference
+        new_browser = new_env.browser()
+        print(f"\n🌐 New browser ready!")
+        print(f"🔗 CDP Page URL: {new_browser.cdp_page_url()}")
+        print(f"🔗 DevTools URL: {new_browser.devtools_url()}")
+        print(f"📝 Resume session logging to: {new_env.session_id}")
+        
+        # Step 5: Keep new environment open for inspection
+        print("\n" + "="*60)
+        print("🎮 RESUMED ENVIRONMENT READY")
+        print("="*60)
+        print("The resumed environment is now ready. You can inspect it to verify")
+        print("it matches your original state.")
+        print("\nType 'done' when finished to close the resumed environment.")
+        print("="*60 + "\n")
+        
+        while True:
+            user_input = input(">>> ").strip().lower()
+            
+            if user_input == "done":
+                break
+            elif user_input == "status":
+                print(f"Environment: {new_env.instance_id}")
+                print(f"Session: {new_env.session_id}")
+            else:
+                print("Type 'done' to close the environment, or 'status' to see current info")
+        
+        # Clean up
+        print("\n🏁 Closing resumed environment...")
+        new_env.close()
+        new_env = None  # Mark as closed
+        print("✅ All done!")
+        
+    except KeyboardInterrupt:
+        print("\n\n⚠️  Interrupted by user")
+    except Exception as e:
+        print(f"\n❌ Error: {e}")
+    finally:
+        # Always clean up environments
+        if env is not None:
+            try:
+                print("\n🧹 Cleaning up original environment...")
+                env.close()
+                print("✅ Original environment closed")
+            except Exception as e:
+                print(f"⚠️  Failed to close original environment: {e}")
+        
+        if new_env is not None:
+            try:
+                print("\n🧹 Cleaning up resumed environment...")
+                new_env.close()
+                print("✅ Resumed environment closed")
+            except Exception as e:
+                print(f"⚠️  Failed to close resumed environment: {e}")
+
+
+if __name__ == "__main__":
+    main()

fleet_python-0.2.34/examples/test_cdp_logging.py

@@ -0,0 +1,80 @@
+#!/usr/bin/env python3
+"""
+Test CDP Logging Example
+
+This script demonstrates the new automatic CDP logging functionality.
+All CDP commands and events are now logged automatically at the proxy level.
+"""
+
+import os
+import sys
+from datetime import datetime
+
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
+
+from fleet import Fleet
+
+def main():
+    # Initialize Fleet client
+    api_key = os.getenv("FLEET_API_KEY")
+    if not api_key:
+        print("Error: FLEET_API_KEY environment variable not set")
+        sys.exit(1)
+    
+    fleet = Fleet(api_key=api_key)
+    env = None
+    
+    try:
+        # Create environment
+        print("🚀 Creating new environment...")
+        env_key = "fira:v1.3.2"  # Replace with your actual environment key
+        
+        env = fleet.make(env_key)
+        print(f"✅ Environment created: {env.instance_id}")
+        print(f"📝 Session ID: {env.session_id}")
+        
+        # Start browser
+        print("\n🌐 Starting browser with automatic CDP logging...")
+        browser = env.browser()
+        browser.start(width=1920, height=1080)
+        
+        # Show connection information
+        conn_info = browser.get_connection_info()
+        print("\n📊 Connection Information:")
+        print(f"  Session ID: {conn_info['session_id']}")
+        print(f"  CDP Page URL: {conn_info['cdp_page_url']}")
+        print(f"  CDP Browser URL: {conn_info['cdp_browser_url']}")
+        print(f"  Logging Enabled: {conn_info['logging_enabled']}")
+        
+        if conn_info['logging_enabled']:
+            print(f"\n✅ All CDP actions will be automatically logged!")
+            print(f"   - Connect any CDP client to: {conn_info['cdp_page_url']}")
+            print(f"   - All commands and events will be logged to session: {env.session_id}")
+            print(f"   - Use DevTools at: {conn_info['devtools_url']}")
+        else:
+            print(f"\n⚠️  Logging not enabled - no session ID available")
+        
+        print("\n" + "="*60)
+        print("🎯 LOGGING TEST COMPLETE")
+        print("="*60)
+        print("The browser is ready with automatic CDP logging enabled.")
+        print("Connect any CDP client or Playwright to the URLs above.")
+        print("All actions will be automatically captured in the tool_log table.")
+        print("\nPress Enter to close the environment...")
+        print("="*60 + "\n")
+        
+        input()
+        
+    except Exception as e:
+        print(f"\n❌ Error: {e}")
+    finally:
+        if env is not None:
+            try:
+                print("\n🧹 Cleaning up environment...")
+                env.close()
+                print("✅ Environment closed")
+            except Exception as e:
+                print(f"⚠️  Failed to close environment: {e}")
+
+if __name__ == "__main__":
+    main()

{fleet_python-0.2.32 → fleet_python-0.2.34}/fleet/client.py

@@ -50,7 +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
+from ..resources.mcp import MCPResource
 
 logger = logging.getLogger(__name__)
 
@@ -254,7 +254,9 @@ 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)
@@ -265,7 +267,9 @@ class Fleet:
 
         return self.load_task_array_from_string(tasks_data)
 
-    def load_task_array_from_string(self, serialized_tasks: List[Dict]) -> List[Task]:
+    def load_task_array_from_string(
+        self, serialized_tasks: List[Dict]
+    ) -> List[Task]:
         tasks = []
 
         json_tasks = json.loads(serialized_tasks)
@@ -303,11 +307,20 @@ class Fleet:
         )
         return task
 
-    def load_tasks(self, env_key: Optional[str] = None) -> List[Task]:
-        """Load tasks for the authenticated team, optionally filtered by environment.
+    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
@@ -315,6 +328,10 @@ class Fleet:
         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 = self.client.request("GET", "/v1/tasks", params=params)
         task_list_response = TaskListResponse(**response.json())
@@ -375,6 +392,10 @@ class Fleet:
             )
             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
 
     def export_tasks(
@@ -464,7 +485,7 @@ class Fleet:
     def _create_verifier_from_data(
         self, verifier_id: str, verifier_key: str, verifier_code: str, verifier_sha: str
     ) -> "SyncVerifierFunction":
-        """Create a SyncVerifierFunction from verifier data.
+        """Create an AsyncVerifierFunction from verifier data.
 
         Args:
             verifier_id: The verifier ID
@@ -473,10 +494,16 @@ class Fleet:
             verifier_sha: The verifier SHA256
 
         Returns:
-            SyncVerifierFunction created from the verifier code
+            AsyncVerifierFunction created from the verifier code
         """
-        from .tasks import verifier_from_string
+        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 ', '')
         
         # Use verifier_from_string to create the verifier
         verifier_func = verifier_from_string(
@@ -486,10 +513,10 @@ class Fleet:
             sha256=verifier_sha,
         )
         
-        # Ensure we return a SyncVerifierFunction
+        # Ensure we return an AsyncVerifierFunction
         if not isinstance(verifier_func, SyncVerifierFunction):
             raise TypeError(
-                f"Expected SyncVerifierFunction but got {type(verifier_func).__name__}"
+                f"Expected AsyncVerifierFunction but got {type(verifier_func).__name__}"
             )
         
         # Store the original verifier code for reference

{fleet_python-0.2.32 → fleet_python-0.2.34}/fleet/env/client.py

@@ -7,7 +7,7 @@ def make(env_key: str, region: Optional[str] = None) -> SyncEnv:
     return Fleet().make(env_key, region=region)
 
 
-def make_for_task(task: Task) -> SyncEnv:
+def make_for_task_async(task: Task) -> SyncEnv:
     return Fleet().make_for_task(task)
 
 

{fleet_python-0.2.32 → fleet_python-0.2.34}/fleet/global_client.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from typing import Optional
 
 from .client import Fleet
-from .config import DEFAULT_MAX_RETRIES, DEFAULT_TIMEOUT
+from ..config import DEFAULT_MAX_RETRIES, DEFAULT_TIMEOUT
 
 
 _default_client: Optional[Fleet] = None

{fleet_python-0.2.32 → fleet_python-0.2.34}/fleet/instance/client.py

@@ -63,7 +63,9 @@ 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
         )

fleet_python-0.2.34/fleet/resources/mcp.py

@@ -0,0 +1,55 @@
+from typing import Dict
+
+
+class SyncMCPResource:
+    def __init__(self, url: str, env_key: str):
+        self.url = url
+        self._env_key = env_key
+
+    def openai(self) -> Dict[str, str]:
+        return {
+            "type": "mcp",
+            "server_label": self._env_key,
+            "server_url": self.url,
+            "require_approval": "never",
+        }
+
+    def anthropic(self) -> Dict[str, str]:
+        return {
+            "type": "url",
+            "url": self.url,
+            "name": self._env_key,
+        }
+
+    def list_tools(self):
+        import aiohttp
+
+        """
+        Make an async request to list available tools from the MCP endpoint.
+        
+        Returns:
+            List of available tools with name, description, and input_schema
+        """
+        with aiohttp.ClientSession() as session:
+            payload = {"jsonrpc": "2.0", "method": "tools/list", "params": {}, "id": 2}
+
+            with session.post(self.url, json=payload) as response:
+                data = response.json()
+
+                # Extract tools from the response
+                if "result" in data and "tools" in data["result"]:
+                    tools = data["result"]["tools"]
+
+                    available_tools = [
+                        {
+                            "name": tool.get("name"),
+                            "description": tool.get("description"),
+                            "input_schema": tool.get("inputSchema"),
+                        }
+                        for tool in tools
+                    ]
+
+                    return available_tools
+                else:
+                    # Handle error or empty response
+                    return []

{fleet_python-0.2.32 → fleet_python-0.2.34}/fleet/resources/sqlite.py

@@ -651,7 +651,9 @@ class SQLiteResource(Resource):
         )
         return DescribeResponse(**response.json())
 
-    def query(self, query: str, args: Optional[List[Any]] = None) -> QueryResponse:
+    def query(
+        self, query: str, args: Optional[List[Any]] = None
+    ) -> QueryResponse:
         return self._query(query, args, read_only=True)
 
     def exec(self, query: str, args: Optional[List[Any]] = None) -> QueryResponse:
@@ -693,8 +695,12 @@ class SQLiteResource(Resource):
             AsyncSnapshotDiff: Object containing the differences between the two databases
         """
         # Create snapshots of both databases
-        before_snapshot = self.snapshot(name=f"before_{datetime.utcnow().isoformat()}")
-        after_snapshot = other.snapshot(name=f"after_{datetime.utcnow().isoformat()}")
+        before_snapshot = self.snapshot(
+            name=f"before_{datetime.utcnow().isoformat()}"
+        )
+        after_snapshot = other.snapshot(
+            name=f"after_{datetime.utcnow().isoformat()}"
+        )
 
         # Return the diff between the snapshots
         return before_snapshot.diff(after_snapshot, ignore_config)

fleet_python-0.2.34/fleet/tasks.py

@@ -0,0 +1,155 @@
+"""Fleet SDK Task Model."""
+
+from __future__ import annotations
+
+import re
+from datetime import datetime
+from typing import Any, Dict, Optional, List
+from uuid import UUID
+
+from pydantic import BaseModel, Field, validator
+
+# Import the shared VerifierFunction type that works for both async and sync
+from fleet.types import VerifierFunction
+
+
+class Task(BaseModel):
+    """A task model representing a single task in the Fleet system."""
+
+    key: str = Field(..., description="Unique task key identifier")
+    prompt: str = Field(..., description="Task prompt or instruction")
+    env_id: str = Field(..., description="Environment identifier")
+    env_variables: Optional[Dict[str, Any]] = Field(
+        default_factory=dict, description="Environment variables"
+    )
+    created_at: Optional[datetime] = Field(None, description="Task creation timestamp")
+    version: Optional[str] = Field(None, description="Task version")
+    verifier_func: Optional[str] = Field(None, description="Verifier function code")
+    verifier: Optional[Any] = Field(
+        None, description="Verifier function with decorator (async or sync)"
+    )
+    verifier_id: Optional[str] = Field(None, description="Verifier identifier")
+    verifier_sha: Optional[str] = Field(None, description="Verifier SHA256 hash")
+    metadata: Optional[Dict[str, Any]] = Field(
+        default_factory=dict, description="Additional task metadata"
+    )
+
+    @validator("key")
+    def validate_key_format(cls, v):
+        """Validate key follows kebab-case format."""
+        if not re.match(r"^[a-z0-9]+(-[a-z0-9]+)*$", v):
+            raise ValueError(
+                f"Invalid task key format: {v}. Must follow kebab-case format."
+            )
+        return v
+
+    @validator("created_at", pre=True, always=True)
+    def set_created_at(cls, v):
+        """Set created_at to current time if not provided."""
+        return v or datetime.now()
+
+    @property
+    def env_key(self) -> str:
+        """Get the environment key combining env_id and version."""
+        if self.version:
+            return f"{self.env_id}:{self.version}"
+        return self.env_id
+
+    class Config:
+        """Pydantic model configuration."""
+
+        json_encoders = {
+            datetime: lambda v: v.isoformat(),
+        }
+        # Allow arbitrary types for the verifier field
+        arbitrary_types_allowed = True
+
+    def verify(self, env, *args, **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().
+        """
+        if self.verifier:
+            import inspect
+
+            result = self.verifier.remote(env, *args, **kwargs)
+
+            # If the result is a coroutine, we need to run it
+            if inspect.iscoroutine(result):
+                # Check if we're already in an event loop
+                try:
+                    loop = asyncio.get_running_loop()
+                    # We're in an async context, can't use asyncio.run()
+                    raise RuntimeError(
+                        "Cannot run async verifier in sync mode while event loop is running. "
+                        "Use await task.verify_async() instead."
+                    )
+                except RuntimeError:
+                    # No event loop running, safe to use asyncio.run()
+                    return asyncio.run(result)
+            else:
+                return result
+        else:
+            raise ValueError("No verifier function found for this task")
+
+    def verify_async(self, *args, **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.
+        """
+        if self.verifier:
+            result = self.verifier.remote(*args, **kwargs)
+            # If it's a coroutine, await it
+            import inspect
+
+            if inspect.iscoroutine(result):
+                return result
+            else:
+                return result
+        else:
+            raise ValueError("No verifier function found for this task")
+
+    def make_env(self, region: Optional[str] = None):
+        """Create an environment instance for this task's environment.
+
+        Uses the task's env_id (and version if present) to create the env.
+        """
+        if not self.env_id:
+            raise ValueError("Task has no env_id defined")
+        # Deferred import to avoid circular dependencies
+        from .client import Fleet
+
+        return Fleet().make(env_key=self.env_key, region=region)
+
+
+def load_tasks(
+    env_key: Optional[str] = None,
+    keys: Optional[List[str]] = None,
+    version: Optional[str] = None,
+    team_id: Optional[str] = None
+) -> List[Task]:
+    """Convenience function to load tasks 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
+        team_id: Optional team_id to filter by (admin only)
+
+    Examples:
+        tasks = await fleet.load_tasks(env_key="fira")
+        tasks = await fleet.load_tasks(keys=["task1", "task2"])
+        tasks = await fleet.load_tasks(env_key="fira", version="v1.0")
+    """
+    # Use the global client by default so users can pre-configure it once
+    from .global_client import get_client
+
+    client = get_client()
+    return client.load_tasks(
+        env_key=env_key, 
+        keys=keys, 
+        version=version, 
+        team_id=team_id
+    )

{fleet_python-0.2.32 → fleet_python-0.2.34}/fleet/verifiers/verifier.py

@@ -162,6 +162,13 @@ class SyncVerifierFunction:
 
     def remote(self, env: SyncEnv, *args, **kwargs) -> float:
         """Remote execution of the verifier function with SHA-based bundle caching."""
+        # Async verifiers are now supported by the backend
+        # if self._is_async:
+        #     raise NotImplementedError(
+        #         f"Async verifier '{self.key}' cannot be executed remotely. "
+        #         "The remote execution environment only supports synchronous functions. "
+        #         "Please provide a synchronous version of your verifier."
+        #     )
 
         args_array = list(args)
         args_array.append({"env": env.instance_id})