fleet-python 0.2.66b2__py3-none-any.whl → 0.2.105__py3-none-any.whl

fleet/agent/types.py

@@ -0,0 +1,49 @@
+"""Type definitions for Fleet Agent."""
+
+from typing import Any, Dict, List, Optional
+from pydantic import BaseModel, Field
+
+
+class AgentConfig(BaseModel):
+    """Configuration for running an agent."""
+    
+    project_key: Optional[str] = None
+    task_keys: Optional[List[str]] = None
+    agent: str = "gemini_cua"
+    model: str = "gemini-2.5-pro"
+    max_concurrent: int = 4
+    max_steps: int = 200
+    timeout_seconds: int = 600
+    screen_width: int = 1366
+    screen_height: int = 768
+    port_range_start: int = 8800
+    vnc_port_start: int = 6080  # noVNC web port
+    headful: bool = False  # Show browser via noVNC
+    verbose: bool = False  # Enable verbose agent logging
+    api_keys: Dict[str, str] = Field(default_factory=dict)
+
+
+class AgentResult(BaseModel):
+    """Result from agent execution on a single task."""
+    
+    task_key: str
+    final_answer: Optional[str] = None
+    completed: bool = False
+    error: Optional[str] = None
+    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):
+    """Full result including verification."""
+    
+    task_key: str
+    task_prompt: str
+    agent_result: Optional[AgentResult] = None
+    verification_success: Optional[bool] = None
+    verification_score: Optional[float] = None
+    error: Optional[str] = None
+    execution_time_ms: int = 0
+

fleet/agent/utils.py

@@ -0,0 +1,34 @@
+"""Agent utilities."""
+
+from pathlib import Path
+
+AGENT_DIR = Path(__file__).parent
+
+
+def get_agent_path(name_or_path: str) -> Path:
+    """Get path to an agent.
+    
+    Args:
+        name_or_path: Either a built-in agent name (e.g., 'gemini_cua')
+                      or a path to a custom agent directory
+    
+    Returns:
+        Path to agent directory
+    """
+    # Check if it's a path (contains / or . or is absolute)
+    if "/" in name_or_path or name_or_path.startswith(".") or Path(name_or_path).is_absolute():
+        path = Path(name_or_path)
+        if not path.exists():
+            raise ValueError(f"Agent path not found: {name_or_path}")
+        if not (path / "Dockerfile").exists():
+            raise ValueError(f"Invalid agent directory (no Dockerfile): {name_or_path}")
+        return path
+    
+    # Otherwise treat as built-in agent name
+    agent_path = AGENT_DIR / name_or_path
+    if not agent_path.exists():
+        available = [d.name for d in AGENT_DIR.iterdir() 
+                     if d.is_dir() and not d.name.startswith('_')]
+        raise ValueError(f"Agent '{name_or_path}' not found. Available: {available}")
+    return agent_path
+

fleet/base.py

@@ -2,6 +2,8 @@ import httpx
 from typing import Dict, Any, Optional
 import json
 import logging
+import time
+import uuid
 
 from .models import InstanceResponse
 from .config import GLOBAL_BASE_URL
@@ -18,8 +20,15 @@ from .exceptions import (
     FleetVersionNotFoundError,
     FleetBadRequestError,
     FleetPermissionError,
+    FleetConflictError,
 )
 
+# Import version
+try:
+    from . import __version__
+except ImportError:
+    __version__ = "0.2.103"
+
 logger = logging.getLogger(__name__)
 
 
@@ -38,17 +47,20 @@ class BaseWrapper:
             base_url = GLOBAL_BASE_URL
         self.base_url = base_url
 
-    def get_headers(self) -> Dict[str, str]:
+    def get_headers(self, request_id: Optional[str] = None) -> Dict[str, str]:
         headers: Dict[str, str] = {
             "X-Fleet-SDK-Language": "Python",
-            "X-Fleet-SDK-Version": "1.0.0",
+            "X-Fleet-SDK-Version": __version__,
         }
         headers["Authorization"] = f"Bearer {self.api_key}"
-        # Debug log
-        import logging
 
-        logger = logging.getLogger(__name__)
-        logger.debug(f"Headers being sent: {headers}")
+        # Add request ID for idempotency (persists across retries)
+        if request_id:
+            headers["X-Request-ID"] = request_id
+
+        # Add timestamp for all requests
+        headers["X-Request-Timestamp"] = str(int(time.time() * 1000))
+
         return headers
 
 
@@ -67,11 +79,14 @@ class SyncWrapper(BaseWrapper):
         **kwargs,
     ) -> httpx.Response:
         base_url = base_url or self.base_url
+        # Generate unique request ID that persists across retries
+        request_id = str(uuid.uuid4())
+        
         try:
             response = self.httpx_client.request(
                 method,
                 f"{base_url}{url}",
-                headers=self.get_headers(),
+                headers=self.get_headers(request_id=request_id),
                 params=params,
                 json=json,
                 **kwargs,
@@ -93,8 +108,9 @@ class SyncWrapper(BaseWrapper):
 
         # Debug log 500 errors
         if status_code == 500:
-            logger.error(f"Got 500 error from {response.url}")
-            logger.error(f"Response text: {response.text}")
+            # logger.error(f"Got 500 error from {response.url}")
+            # logger.error(f"Response text: {response.text}")
+            pass
 
         # Try to parse error response as JSON
         try:
@@ -229,6 +245,15 @@ class SyncWrapper(BaseWrapper):
         elif status_code == 429:
             # Rate limit errors (not instance limit which is now 403)
             raise FleetRateLimitError(error_message)
+        elif status_code == 409:
+            # Conflict errors (resource already exists)
+            resource_name = None
+            # Try to extract resource name from error message
+            if "'" in error_message:
+                parts = error_message.split("'")
+                if len(parts) >= 2:
+                    resource_name = parts[1]
+            raise FleetConflictError(error_message, resource_name=resource_name)
         else:
             raise FleetAPIError(
                 error_message,