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

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

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

fleet_python-0.2.35/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.35/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.35}/fleet/__init__.py

@@ -46,8 +46,11 @@ from ._async.verifiers import (
     AsyncVerifierFunction,
 )
 
-# Import async tasks (default tasks are async for modern usage)
-from ._async.tasks import Task
+# Import async tasks (default tasks are async for modern usage)  
+from ._async.tasks import Task, load_tasks
+
+# Import sync load_tasks function
+from .tasks import load_tasks as load_tasks_sync
 
 # Import shared types
 from .types import VerifierFunction
@@ -94,19 +97,14 @@ __all__ = [
     "configure",
     "get_client",
     "reset_client",
+    # Module-level functions (async is default)
+    "load_tasks",
+    "load_tasks_sync",
     # Version
     "__version__",
 ]
 
 
-def load_tasks(env_key: Optional[str] = None) -> List[Task]:
-    """Load tasks without explicitly creating a client.
-
-    Example:
-        tasks = fleet.load_tasks(env_key="fira")
-    """
-    # Use global client by default so users can configure once
-    return _global_client.get_client().load_tasks(env_key=env_key)
 
 
 def configure(

{fleet_python-0.2.32 → fleet_python-0.2.35}/fleet/_async/__init__.py

@@ -35,7 +35,7 @@ from .verifiers import (
 )
 
 # Import async tasks
-from .tasks import Task
+from .tasks import Task, load_tasks
 
 # Import shared types
 from ..types import VerifierFunction
@@ -93,33 +93,6 @@ __all__ = [
 ]
 
 
-async def load_tasks(
-    env_key: Optional[str] = None,
-    keys: Optional[List[str]] = None,
-    version: Optional[str] = None,
-    team_id: Optional[str] = None
-) -> List[Task]:
-    """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
-
-    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 global client by default so users can configure once
-    return await _async_global_client.get_client().load_tasks(
-        env_key=env_key, 
-        keys=keys, 
-        version=version, 
-        team_id=team_id
-    )
-
-
 async def list_envs() -> List[Environment]:
     """List all available environments."""
     return await _async_global_client.get_client().list_envs()

{fleet_python-0.2.32 → fleet_python-0.2.35}/fleet/_async/client.py

@@ -50,7 +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
+from .resources.mcp import AsyncMCPResource
 
 logger = logging.getLogger(__name__)
 
@@ -105,9 +105,9 @@ class AsyncEnv(EnvironmentBase):
         return self.instance.browser(name)
 
     @property
-    def mcp(self) -> MCPResource:
+    def mcp(self) -> AsyncMCPResource:
         mcp_url = f"{self.urls.root}mcp"
-        return MCPResource(url=mcp_url, env_key=self.env_key)
+        return AsyncMCPResource(url=mcp_url, env_key=self.env_key)
 
     def state(self, uri: str) -> Resource:
         return self.instance.state(uri)
@@ -507,12 +507,6 @@ class AsyncFleet:
             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
 

{fleet_python-0.2.32 → fleet_python-0.2.35}/fleet/_async/tasks.py

@@ -125,6 +125,56 @@ class Task(BaseModel):
         return await AsyncFleet().make(env_key=self.env_key, region=region)
 
 
+def verifier_from_string(
+    verifier_func: str,
+    verifier_id: str,
+    verifier_key: str,
+    sha256: str = ""
+) -> 'VerifierFunction':
+    """Create a verifier function from string code.
+    
+    Args:
+        verifier_func: The verifier function code as a string
+        verifier_id: Unique identifier for the verifier
+        verifier_key: Key/name for the verifier
+        sha256: SHA256 hash of the verifier code
+        
+    Returns:
+        VerifierFunction instance that can be used to verify tasks
+    """
+    try:
+        import inspect
+        from .verifiers import verifier, AsyncVerifierFunction
+        
+        # Create a local namespace for executing the code
+        local_namespace = {}
+        
+        # Execute the verifier code in the namespace
+        exec(verifier_func, globals(), local_namespace)
+        
+        # Find the function that was defined
+        func_obj = None
+        for name, obj in local_namespace.items():
+            if inspect.isfunction(obj):
+                func_obj = obj
+                break
+        
+        if func_obj is None:
+            raise ValueError("No function found in verifier code")
+        
+        # Create an AsyncVerifierFunction instance
+        verifier_instance = AsyncVerifierFunction(func_obj, verifier_key, verifier_id)
+        
+        # Store additional metadata
+        verifier_instance._verifier_code = verifier_func
+        verifier_instance._sha256 = sha256
+        
+        return verifier_instance
+        
+    except Exception as e:
+        raise ValueError(f"Failed to create verifier from string: {e}")
+
+
 async def load_tasks(
     env_key: Optional[str] = None,
     keys: Optional[List[str]] = None,

{fleet_python-0.2.32 → fleet_python-0.2.35}/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 SyncMCPResource
 
 logger = logging.getLogger(__name__)
 
@@ -105,9 +105,9 @@ class SyncEnv(EnvironmentBase):
         return self.instance.browser(name)
 
     @property
-    def mcp(self) -> MCPResource:
+    def mcp(self) -> SyncMCPResource:
         mcp_url = f"{self.urls.root}mcp"
-        return MCPResource(url=mcp_url, env_key=self.env_key)
+        return SyncMCPResource(url=mcp_url, env_key=self.env_key)
 
     def state(self, uri: str) -> Resource:
         return self.instance.state(uri)
@@ -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,10 @@ 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 .verifiers.verifier import SyncVerifierFunction
+        from .verifiers import SyncVerifierFunction
         
         # Use verifier_from_string to create the verifier
         verifier_func = verifier_from_string(
@@ -486,12 +507,6 @@ class Fleet:
             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
 

{fleet_python-0.2.32 → fleet_python-0.2.35}/fleet/env/__init__.py

@@ -2,7 +2,7 @@
 
 from .client import (
     make,
-    make_for_task,
+    make_for_task_async,
     list_envs,
     list_regions,
     get,
@@ -22,7 +22,7 @@ from .._async.env.client import (
 
 __all__ = [
     "make",
-    "make_for_task",
+    "make_for_task_async",
     "list_envs",
     "list_regions",
     "list_instances",

{fleet_python-0.2.32 → fleet_python-0.2.35}/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.35}/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.35/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 []