fleet-python 0.2.82__tar.gz → 0.2.84__tar.gz

{fleet_python-0.2.82/fleet_python.egg-info → fleet_python-0.2.84}/PKG-INFO

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

{fleet_python-0.2.82 → fleet_python-0.2.84}/fleet/__init__.py

@@ -73,7 +73,7 @@ from . import env
 from . import global_client as _global_client
 from ._async import global_client as _async_global_client
 
-__version__ = "0.2.82"
+__version__ = "0.2.84"
 
 __all__ = [
     # Core classes

{fleet_python-0.2.82 → fleet_python-0.2.84}/fleet/_async/__init__.py

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

{fleet_python-0.2.82 → fleet_python-0.2.84}/fleet/_async/base.py

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

{fleet_python-0.2.82 → fleet_python-0.2.84}/fleet/_async/client.py

@@ -1428,7 +1428,7 @@ class AsyncFleet:
         Returns:
             The job_id string
         """
-        from .models import TraceJobRequest, TraceJobResponse
+        from fleet.models import TraceJobRequest, TraceJobResponse
 
         request = TraceJobRequest(name=name)
         response = await self.client.request(

{fleet_python-0.2.82 → fleet_python-0.2.84}/fleet/agent/gemini_cua/agent.py

@@ -25,6 +25,7 @@ from mcp import ClientSession
 from mcp.client.streamable_http import streamable_http_client
 from google import genai
 from google.genai import types
+import fleet
 from fleet.utils.logging import log_verbose, VERBOSE
 
 # Whitelist hooks for auto-detecting model endpoints (optional)
@@ -136,20 +137,36 @@ class MCP:
         result = await self._session.call_tool(name, args or {})
         duration_ms = int((time.time() - start_time) * 1000)
         
+        # Debug: log raw MCP result structure
+        log_verbose(f"    MCP result.content ({len(result.content)} items):")
+        for i, item in enumerate(result.content):
+            log_verbose(f"      [{i}] type={type(item).__name__}, attrs={dir(item)[:10]}...")
+            if hasattr(item, "type"):
+                log_verbose(f"          .type = {repr(item.type)}")
+            if hasattr(item, "data"):
+                data_preview = str(item.data)[:50] if item.data else "None"
+                log_verbose(f"          .data = {data_preview}...")
+        
+        # Helper to get attribute or dict key
+        def _get(item, key, default=None):
+            if isinstance(item, dict):
+                return item.get(key, default)
+            return getattr(item, key, default)
+        
         # Convert MCP result to dict format expected by agent
         content = []
         for item in result.content:
-            if hasattr(item, "type"):
-                if item.type == "image":
-                    content.append({
-                        "type": "image",
-                        "data": item.data[:100] + "..." if len(item.data) > 100 else item.data,  # Truncate for logging
-                        "mimeType": getattr(item, "mimeType", "image/png"),
-                    })
-                elif item.type == "text":
-                    content.append({"type": "text", "text": item.text})
+            item_type = _get(item, "type")
+            if item_type == "image":
+                content.append({
+                    "type": "image",
+                    "data": _get(item, "data", ""),
+                    "mimeType": _get(item, "mimeType", "image/png"),
+                })
+            elif item_type == "text":
+                content.append({"type": "text", "text": _get(item, "text", "")})
         
-        # Log the call
+        # Log the call (just types, not data)
         self._log({
             "type": "mcp_call",
             "tool": name,
@@ -158,20 +175,7 @@ class MCP:
             "response_content_types": [c.get("type") for c in content],
             "is_error": result.isError if hasattr(result, "isError") else False,
         })
-        
-        # Return full content (not truncated)
-        full_content = []
-        for item in result.content:
-            if hasattr(item, "type"):
-                if item.type == "image":
-                    full_content.append({
-                        "type": "image",
-                        "data": item.data,
-                        "mimeType": getattr(item, "mimeType", "image/png"),
-                    })
-                elif item.type == "text":
-                    full_content.append({"type": "text", "text": item.text})
-        return {"content": full_content, "isError": result.isError if hasattr(result, "isError") else False}
+        return {"content": content, "isError": result.isError if hasattr(result, "isError") else False}
     
     def get_tools(self) -> List[Dict]:
         """Return the list of tools from the server."""
@@ -201,12 +205,13 @@ def get_image_data(result: Dict) -> Optional[str]:
 class GeminiAgent:
     """Gemini Computer Use Agent."""
     
-    def __init__(self, mcp: MCP, model: str):
+    def __init__(self, mcp: MCP, model: str, session=None):
         self.mcp = mcp
         # Strip provider prefix if present
         self.model = model.split("/")[-1] if "/" in model else model
         self.client = get_gemini_client()
         self.transcript: List[Dict] = []
+        self.session = session  # Fleet session for live logging
     
     async def _execute_tool(self, name: str, args: Dict) -> Dict:
         return await self.mcp.call(name, args)
@@ -251,8 +256,13 @@ STRICT RULES:
             max_output_tokens=4096,
             system_instruction=system_prompt,
             tools=[types.Tool(function_declarations=gemini_tools)],
+            thinking_config=types.ThinkingConfig(include_thoughts=True),
         )
         
+        # Set config on session for logging (if session exists)
+        if self.session:
+            self.session.config = config
+        
         history: List[types.Content] = []
         
         user_prompt = f"""###User instruction: {prompt}"""
@@ -292,6 +302,15 @@ STRICT RULES:
                 log_verbose(f"  Candidate: {candidate}")
                 continue
             
+            # Log to Fleet session (live)
+            if self.session:
+                try:
+                    await self.session.log(history, response)
+                    if step == 1 and self.session.session_id:
+                        print(f"Session: https://fleetai.com/dashboard/sessions/{self.session.session_id}")
+                except Exception as e:
+                    log_verbose(f"  [WARN] Session log failed: {e}")
+            
             # Log all parts for debugging
             log_verbose(f"\n  Response parts ({len(candidate.content.parts)}):")
             for i, part in enumerate(candidate.content.parts):
@@ -415,6 +434,8 @@ async def main():
         "url": os.environ.get("FLEET_MCP_URL", "http://localhost:8765"),
         "prompt": os.environ.get("FLEET_TASK_PROMPT", ""),
         "task_key": os.environ.get("FLEET_TASK_KEY", ""),
+        "job_id": os.environ.get("FLEET_JOB_ID"),
+        "instance_id": os.environ.get("FLEET_INSTANCE_ID"),
         "model": os.environ.get("FLEET_MODEL", "gemini-2.5-pro"),
         "max_steps": int(os.environ.get("FLEET_MAX_STEPS", "100")),
     }
@@ -430,10 +451,24 @@ async def main():
         print(json.dumps(result))
         return result
     
+    # Create Fleet session for live logging
+    session = None
+    if os.environ.get("FLEET_API_KEY"):
+        session = fleet.session_async(
+            job_id=config["job_id"],
+            model=config["model"],
+            task_key=config["task_key"],
+            instance_id=config["instance_id"],
+        )
+    
     async with MCP(config["url"]) as mcp:
-        agent = GeminiAgent(mcp, config["model"])
+        agent = GeminiAgent(mcp, config["model"], session=session)
         result = await agent.run(config["prompt"], config["max_steps"])
         result["task_key"] = config["task_key"]
+        # Include session_id in result so orchestrator can complete it after verification
+        if session and session.session_id:
+            result["session_id"] = session.session_id
+        
         print(json.dumps(result))
         return result
 

{fleet_python-0.2.82 → fleet_python-0.2.84}/fleet/agent/gemini_cua/mcp_server.py

@@ -18,6 +18,7 @@ from contextlib import asynccontextmanager
 from typing import Optional
 
 from mcp.server.fastmcp import FastMCP
+from mcp.types import ImageContent, TextContent
 from starlette.requests import Request
 from starlette.responses import JSONResponse
 
@@ -227,9 +228,10 @@ def _dy(y: int) -> int:
 
 
 def _screenshot_response(img: bytes) -> list:
+    """Return screenshot as proper MCP content types."""
     return [
-        {"type": "image", "data": base64.b64encode(img).decode(), "mimeType": "image/png"},
-        {"type": "text", "text": f"URL: {computer.current_url}"}
+        ImageContent(type="image", data=base64.b64encode(img).decode(), mimeType="image/png"),
+        TextContent(type="text", text=f"URL: {computer.current_url}"),
     ]
 
 

{fleet_python-0.2.82 → fleet_python-0.2.84}/fleet/agent/orchestrator.py

@@ -21,15 +21,14 @@ import asyncio
 import json
 import logging
 import os
-import subprocess
 import time
+from datetime import datetime
 from pathlib import Path
 from typing import Dict, List, Optional, Tuple
 
+import fleet
 from .utils import get_agent_path
 from .types import AgentConfig, AgentResult, TaskResult
-from fleet.proxy import ProxyManager
-from fleet.eval import TrafficUploader
 
 logger = logging.getLogger(__name__)
 
@@ -45,11 +44,6 @@ class AgentOrchestrator:
         self._docker_image: Optional[str] = None
         # Track available ports (recycled when tasks complete)
         self._available_ports: List[Tuple[int, int]] = []
-        # MITM proxy for traffic capture
-        self._proxy: Optional[ProxyManager] = None
-        self._proxy_env: Dict[str, str] = {}
-        # Traffic uploader (tails proxy log, ships to backend)
-        self._uploader: Optional[TrafficUploader] = None
     
     async def _get_next_ports(self) -> Tuple[int, int]:
         """Get next available MCP port and VNC port."""
@@ -75,38 +69,18 @@ class AgentOrchestrator:
         from rich.console import Console
         from rich.live import Live
         from rich.spinner import Spinner
-        import uuid
         
         console = Console()
         
-        # Generate job ID for this run
-        self._job_id = f"eval_{uuid.uuid4().hex[:12]}"
-        console.print(f"Eval job: {self._job_id}")
+        # Create job via Fleet API
+        job_name = f"eval-{self.config.agent}-{datetime.now().strftime('%Y%m%d_%H%M%S')}"
+        self._job_id = await fleet.job_async(name=job_name)
+        console.print(f"Job: https://fleetai.com/dashboard/jobs/{self._job_id}")
         
         # Create log directory: ~/.fleet/logs/{job_id}/
         self._log_dir = Path.home() / ".fleet" / "logs" / self._job_id
         self._log_dir.mkdir(parents=True, exist_ok=True)
         
-        # Start MITM proxy for traffic capture
-        self._proxy = ProxyManager()
-        try:
-            self._proxy_env = await self._proxy.start()
-            console.print(f"Proxy started, logging to: {self._proxy.log_path}")
-            
-            # Start traffic uploader (tails proxy log, ships raw to backend)
-            self._uploader = TrafficUploader(
-                job_id=self._job_id,
-                log_file=self._proxy.log_path,
-                whitelist=None,  # No filter - upload everything
-            )
-            await self._uploader.start()
-        except Exception as e:
-            console.print(f"[yellow]⚠[/yellow] Proxy failed to start: {e}")
-            console.print("[dim]  Proxy requires aiohttp: pip install aiohttp[/dim]")
-            self._proxy = None
-            self._proxy_env = {}
-            self._uploader = None
-        
         # Load tasks with spinner
         with Live(Spinner("dots", text=f"Loading tasks from {self.config.project_key}..."), console=console, transient=True):
             if self.config.task_keys:
@@ -168,16 +142,6 @@ class AgentOrchestrator:
             else:
                 final.append(r)
         
-        # Stop uploader first (flushes remaining entries)
-        if self._uploader:
-            await self._uploader.stop()
-            stats = self._uploader.stats
-            console.print(f"Traffic: {stats['read']} read, {stats['uploaded']} uploaded")
-        
-        # Stop proxy
-        if self._proxy:
-            await self._proxy.stop()
-        
         # Show logs location
         if hasattr(self, '_log_dir') and self._log_dir.exists():
             session_logs = list(self._log_dir.glob("*.jsonl"))
@@ -280,12 +244,14 @@ class AgentOrchestrator:
                 port=port,
                 task_prompt=task_prompt,
                 task_key=task_key,
+                instance_id=env.instance_id,
             )
             logger.debug(f"[{short_key}] Agent done: completed={agent_result.completed}")
             
             # 4. Run verification
             verification_success = None
             verification_score = None
+            verifier_execution_id = None
             
             if agent_result.completed and task.verifier:
                 logger.info(f"[{task_key}] Running verification...")
@@ -295,12 +261,27 @@ class AgentOrchestrator:
                         final_answer=agent_result.final_answer,
                     )
                     verification_success = v.success
+                    verifier_execution_id = v.execution_id
                     # Score is in v.result (the verifier function's return value)
                     verification_score = v.result if isinstance(v.result, (int, float)) else None
                     logger.info(f"[{task_key}] Verification: {verification_success}")
                 except Exception as e:
                     logger.error(f"[{task_key}] Verification error: {e}")
             
+            # 5. Complete/fail session (session was created by agent, we just complete it)
+            session_id = getattr(agent_result, 'session_id', None)
+            if session_id:
+                try:
+                    # Create session object to complete it
+                    session = fleet.session_async(session_id=session_id)
+                    if verification_success:
+                        await session.complete(verifier_execution_id=verifier_execution_id)
+                    else:
+                        await session.fail(verifier_execution_id=verifier_execution_id)
+                    logger.info(f"[{task_key}] Session: https://fleetai.com/dashboard/sessions/{session_id}")
+                except Exception as e:
+                    logger.error(f"[{task_key}] Session complete error: {e}")
+            
             return TaskResult(
                 task_key=task_key,
                 task_prompt=task_prompt,
@@ -414,6 +395,7 @@ class AgentOrchestrator:
         port: int,
         task_prompt: str,
         task_key: str,
+        instance_id: Optional[str] = None,
     ) -> AgentResult:
         """Run agent process."""
         agent_path = get_agent_path(self.config.agent)
@@ -431,6 +413,7 @@ class AgentOrchestrator:
             "FLEET_JOB_ID": self._job_id,
             "FLEET_TASK_PROMPT": task_prompt,
             "FLEET_TASK_KEY": task_key,
+            "FLEET_INSTANCE_ID": instance_id or "",
             "FLEET_MODEL": self.config.model,
             "FLEET_MAX_STEPS": str(self.config.max_steps),
             "FLEET_SCREEN_WIDTH": str(self.config.screen_width),
@@ -438,8 +421,6 @@ class AgentOrchestrator:
             "FLEET_VERBOSE": "true" if self.config.verbose else "false",
         })
         env.update(self.config.api_keys)
-        # Add proxy env vars for traffic capture
-        env.update(self._proxy_env)
         
         proc = await asyncio.create_subprocess_exec(
             "python", str(agent_script),
@@ -494,6 +475,7 @@ class AgentOrchestrator:
                 steps_taken=result_json.get("steps_taken", 0),
                 execution_time_ms=result_json.get("execution_time_ms", 0),
                 transcript=result_json.get("transcript", []),
+                session_id=result_json.get("session_id"),
             )
         
         # Include stderr in error message

{fleet_python-0.2.82 → fleet_python-0.2.84}/fleet/agent/types.py

@@ -33,6 +33,7 @@ class AgentResult(BaseModel):
     steps_taken: int = 0
     execution_time_ms: int = 0
     transcript: List[Dict[str, Any]] = Field(default_factory=list)
+    session_id: Optional[str] = None  # Fleet session ID for completion
 
 
 class TaskResult(BaseModel):

{fleet_python-0.2.82 → fleet_python-0.2.84}/fleet/base.py

@@ -27,7 +27,7 @@ from .exceptions import (
 try:
     from . import __version__
 except ImportError:
-    __version__ = "0.2.82"
+    __version__ = "0.2.84"
 
 logger = logging.getLogger(__name__)
 

{fleet_python-0.2.82 → fleet_python-0.2.84/fleet_python.egg-info}/PKG-INFO

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

{fleet_python-0.2.82 → fleet_python-0.2.84}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 [project]
 name = "fleet-python"
 
-version = "0.2.82"
+version = "0.2.84"
 description = "Python SDK for Fleet environments"
 authors = [
     {name = "Fleet AI", email = "nic@fleet.so"},