fleet-python 0.2.88__tar.gz → 0.2.90__tar.gz

{fleet_python-0.2.88/fleet_python.egg-info → fleet_python-0.2.90}/PKG-INFO

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

{fleet_python-0.2.88 → fleet_python-0.2.90}/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.88"
+__version__ = "0.2.90"
 
 __all__ = [
     # Core classes

{fleet_python-0.2.88 → fleet_python-0.2.90}/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.88"
+__version__ = "0.2.90"
 
 __all__ = [
     # Core classes

{fleet_python-0.2.88 → fleet_python-0.2.90}/fleet/_async/base.py

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

{fleet_python-0.2.88 → fleet_python-0.2.90}/fleet/agent/orchestrator.py

@@ -18,14 +18,15 @@ Usage:
 """
 
 import asyncio
+import atexit
 import json
 import logging
 import os
+import signal
 import sys
 import time
-from datetime import datetime
 from pathlib import Path
-from typing import Dict, List, Optional, Tuple
+from typing import Dict, List, Optional, Set, Tuple
 
 import fleet
 from .utils import get_agent_path
@@ -33,10 +34,130 @@ from .types import AgentConfig, AgentResult, TaskResult
 
 logger = logging.getLogger(__name__)
 
+# Global tracking of running containers for cleanup on exit
+_running_containers: Set[str] = set()
+_cleanup_registered = False
+
+
+def _cleanup_all_containers():
+    """Kill all tracked running containers. Called on exit/signal."""
+    import subprocess
+
+    if not _running_containers:
+        return
+
+    containers = list(_running_containers)
+    logger.debug(f"Cleaning up {len(containers)} container(s)...")
+
+    for container_id in containers:
+        try:
+            # Use docker kill for immediate termination
+            subprocess.run(
+                ["docker", "kill", container_id],
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+                timeout=5,
+            )
+            _running_containers.discard(container_id)
+        except Exception as e:
+            logger.debug(f"Failed to kill container {container_id[:12]}: {e}")
+
+
+def _register_cleanup():
+    """Register cleanup handlers (only once)."""
+    global _cleanup_registered
+    if _cleanup_registered:
+        return
+    _cleanup_registered = True
+
+    # Register atexit handler
+    atexit.register(_cleanup_all_containers)
+
+    # Register signal handlers for graceful shutdown
+    def signal_handler(signum, frame):
+        _cleanup_all_containers()
+        # Re-raise to allow normal signal handling
+        signal.default_int_handler(signum, frame)
+
+    try:
+        signal.signal(signal.SIGINT, signal_handler)
+        signal.signal(signal.SIGTERM, signal_handler)
+    except (ValueError, OSError):
+        # Can't set signal handlers in some contexts (e.g., non-main thread)
+        pass
+
+
+def _cleanup_orphaned_containers(image_prefix: str = "fleet-cua-"):
+    """Kill any orphaned containers from previous runs.
+
+    This handles cases where a previous run was force-killed (SIGKILL)
+    and containers were left running, which could cause port conflicts.
+    """
+    import subprocess
+
+    try:
+        # List running containers with our image prefix
+        result = subprocess.run(
+            [
+                "docker",
+                "ps",
+                "--filter",
+                f"ancestor={image_prefix}",
+                "-q",
+                "--format",
+                "{{.ID}} {{.Image}}",
+            ],
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+
+        if result.returncode != 0:
+            return
+
+        # Parse container IDs - we need to filter by image name pattern
+        # Use docker ps with format to get both ID and image
+        result = subprocess.run(
+            ["docker", "ps", "--format", "{{.ID}}\t{{.Image}}"],
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+
+        if result.returncode != 0 or not result.stdout.strip():
+            return
+
+        orphaned = []
+        for line in result.stdout.strip().split("\n"):
+            if not line:
+                continue
+            parts = line.split("\t")
+            if len(parts) >= 2:
+                container_id, image = parts[0], parts[1]
+                if image.startswith(image_prefix):
+                    orphaned.append(container_id)
+
+        if orphaned:
+            logger.info(
+                f"Cleaning up {len(orphaned)} orphaned container(s) from previous run..."
+            )
+            for container_id in orphaned:
+                try:
+                    subprocess.run(
+                        ["docker", "kill", container_id],
+                        stdout=subprocess.DEVNULL,
+                        stderr=subprocess.DEVNULL,
+                        timeout=5,
+                    )
+                except Exception:
+                    pass
+    except Exception as e:
+        logger.debug(f"Failed to check for orphaned containers: {e}")
+
 
 class AgentOrchestrator:
     """Orchestrates running agents on Fleet tasks."""
-    
+
     def __init__(self, config: AgentConfig):
         self.config = config
         self._port_counter = config.port_range_start
@@ -45,7 +166,9 @@ class AgentOrchestrator:
         self._docker_image: Optional[str] = None
         # Track available ports (recycled when tasks complete)
         self._available_ports: List[Tuple[int, int]] = []
-    
+        # Register global cleanup handlers
+        _register_cleanup()
+
     async def _get_next_ports(self) -> Tuple[int, int]:
         """Get next available MCP port and VNC port."""
         async with self._port_lock:
@@ -58,51 +181,60 @@ class AgentOrchestrator:
             self._port_counter += 1
             self._vnc_port_counter += 1
             return port, vnc_port
-    
+
     async def _release_ports(self, port: int, vnc_port: int):
         """Return ports to the pool for reuse."""
         async with self._port_lock:
             self._available_ports.append((port, vnc_port))
-    
+
     async def run(self) -> List[TaskResult]:
         """Run agents on all tasks."""
         from fleet._async import load_tasks
         from rich.console import Console
         from rich.live import Live
         from rich.spinner import Spinner
-        
+
         console = Console()
-        
-        # 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)
+
+        # Create job via Fleet API (name generated server-side)
+        self._job_id = await fleet.job_async()
         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)
-        
+
         # Load tasks with spinner
-        with Live(Spinner("dots", text=f"Loading tasks from {self.config.project_key}..."), console=console, transient=True):
+        with Live(
+            Spinner("dots", text=f"Loading tasks from {self.config.project_key}..."),
+            console=console,
+            transient=True,
+        ):
             if self.config.task_keys:
                 tasks = await load_tasks(keys=self.config.task_keys)
             elif self.config.project_key:
                 tasks = await load_tasks(project_key=self.config.project_key)
             else:
                 raise ValueError("Either project_key or task_keys required")
-        
+
         console.print(f"Loaded {len(tasks)} tasks")
-        
+
         # Build Docker image
         agent_path = get_agent_path(self.config.agent)
         await self._build_docker_image(agent_path)
-        
+
         # Run tasks with concurrency limit and progress
-        from rich.progress import Progress, SpinnerColumn, TextColumn, BarColumn, TaskProgressColumn
-        
+        from rich.progress import (
+            Progress,
+            SpinnerColumn,
+            TextColumn,
+            BarColumn,
+            TaskProgressColumn,
+        )
+
         semaphore = asyncio.Semaphore(self.config.max_concurrent)
         results = [None] * len(tasks)
-        
+
         with Progress(
             SpinnerColumn(),
             TextColumn("[progress.description]{task.description}"),
@@ -111,18 +243,18 @@ class AgentOrchestrator:
             console=console,
         ) as progress:
             task_progress = progress.add_task("Running tasks", total=len(tasks))
-            
+
             async def run_with_semaphore(idx, task):
                 async with semaphore:
                     result = await self._run_task(task)
                     progress.update(task_progress, advance=1)
                     return idx, result
-            
+
             completed = await asyncio.gather(
                 *[run_with_semaphore(i, t) for i, t in enumerate(tasks)],
                 return_exceptions=True,
             )
-        
+
         # Convert to ordered list
         for item in completed:
             if isinstance(item, Exception):
@@ -130,74 +262,85 @@ class AgentOrchestrator:
                 continue
             idx, result = item
             results[idx] = result
-        
+
         # Fill any gaps with error results
         final = []
         for i, r in enumerate(results):
             if r is None:
-                final.append(TaskResult(
-                    task_key=tasks[i].key,
-                    task_prompt=tasks[i].prompt,
-                    error="Task failed unexpectedly",
-                ))
+                final.append(
+                    TaskResult(
+                        task_key=tasks[i].key,
+                        task_prompt=tasks[i].prompt,
+                        error="Task failed unexpectedly",
+                    )
+                )
             else:
                 final.append(r)
-        
+
         # Show logs location
-        if hasattr(self, '_log_dir') and self._log_dir.exists():
+        if hasattr(self, "_log_dir") and self._log_dir.exists():
             session_logs = list(self._log_dir.glob("*.jsonl"))
             console.print(f"Logs: {self._log_dir}/ ({len(session_logs)} sessions)")
-        
+
         return final
-    
+
     async def _build_docker_image(self, agent_path: Path):
         """Build Docker image for CUA server."""
         from rich.console import Console
         from rich.live import Live
         from rich.spinner import Spinner
-        
+
         console = Console()
         dockerfile = agent_path / "Dockerfile"
         if not dockerfile.exists():
             raise FileNotFoundError(f"Dockerfile not found in {agent_path}")
-        
+
         image_name = f"fleet-cua-{agent_path.name}"
-        
+
+        # Clean up any orphaned containers from previous runs (prevents port conflicts)
+        _cleanup_orphaned_containers(image_name)
+
         # Build context is the agent directory (all files are self-contained)
-        with Live(Spinner("dots", text=f"Building Docker image {image_name}..."), console=console, transient=True):
+        with Live(
+            Spinner("dots", text=f"Building Docker image {image_name}..."),
+            console=console,
+            transient=True,
+        ):
             proc = await asyncio.create_subprocess_exec(
-                "docker", "build",
-                "-t", image_name,
+                "docker",
+                "build",
+                "-t",
+                image_name,
                 str(agent_path),  # Build context is agent directory
                 stdout=asyncio.subprocess.PIPE,
                 stderr=asyncio.subprocess.PIPE,
             )
             stdout, stderr = await proc.communicate()
-        
+
         if proc.returncode != 0:
             console.print(f"[red]✗[/red] Docker build failed")
             console.print(stderr.decode())
             raise RuntimeError(f"Docker build failed: {stderr.decode()}")
-        
+
         self._docker_image = image_name
         console.print(f"Docker image ready: {image_name}")
-    
+
     async def _run_task(self, task) -> TaskResult:
         """Run agent on a single task."""
         from fleet.env import make_async
-        
+
         start = time.time()
         task_key = task.key
         task_prompt = task.prompt
         short_key = task_key[:20]
-        
+
         logger.debug(f"[{short_key}] Starting")
-        
+
         env = None
         container_id = None
         port = None
         vnc_port = None
-        
+
         try:
             # 1. Create Fleet environment
             logger.debug(f"[{short_key}] Creating env...")
@@ -209,9 +352,9 @@ class AgentOrchestrator:
             )
             env_url = env.urls.root
             logger.debug(f"[{short_key}] Env: {env_url}")
-            
+
             await asyncio.sleep(3)  # Wait for env to be ready
-            
+
             # 2. Start Docker container with CUA server
             port, vnc_port = await self._get_next_ports()
             logger.debug(f"[{short_key}] Starting container on port {port}...")
@@ -223,17 +366,17 @@ class AgentOrchestrator:
                 task_key=task_key,
             )
             logger.debug(f"[{short_key}] Container: {container_id[:12]}")
-            
+
             # Always show instance URL
             print(f"[{short_key}] Instance: {env_url}")
             if self.config.headful:
                 print(f"[{short_key}] Browser:  http://localhost:{vnc_port}/vnc.html")
-            
+
             # Wait for server to be ready
             logger.debug(f"[{short_key}] Waiting for CUA server...")
             await self._wait_for_server(port)
             logger.debug(f"[{short_key}] CUA server ready")
-            
+
             # 3. Run agent
             logger.debug(f"[{short_key}] Running agent...")
             agent_result = await self._run_agent(
@@ -242,13 +385,15 @@ class AgentOrchestrator:
                 task_key=task_key,
                 instance_id=env.instance_id,
             )
-            logger.debug(f"[{short_key}] Agent done: completed={agent_result.completed}")
-            
+            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...")
                 try:
@@ -259,25 +404,31 @@ class AgentOrchestrator:
                     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
+                    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)
+            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)
+                        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}")
+                    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,
@@ -286,7 +437,7 @@ class AgentOrchestrator:
                 verification_score=verification_score,
                 execution_time_ms=int((time.time() - start) * 1000),
             )
-        
+
         except Exception as e:
             logger.exception(f"[{short_key}] Failed: {e}")
             return TaskResult(
@@ -295,7 +446,7 @@ class AgentOrchestrator:
                 error=str(e),
                 execution_time_ms=int((time.time() - start) * 1000),
             )
-        
+
         finally:
             # Cleanup
             if container_id:
@@ -307,7 +458,7 @@ class AgentOrchestrator:
                     await env.close()
                 except:
                     pass
-    
+
     async def _start_container(
         self,
         port: int,
@@ -318,62 +469,95 @@ class AgentOrchestrator:
     ) -> str:
         """Start Docker container with CUA server."""
         headless = "false" if self.config.headful else "true"
-        
+
         cmd = [
-            "docker", "run", "-d", "--rm",
-            "-p", f"{port}:8765",
-            "-e", f"FLEET_ENV_URL={env_url}",
-            "-e", f"FLEET_TASK_PROMPT={task_prompt}",
-            "-e", f"FLEET_TASK_KEY={task_key}",
-            "-e", f"SCREEN_WIDTH={self.config.screen_width}",
-            "-e", f"SCREEN_HEIGHT={self.config.screen_height}",
-            "-e", f"HEADLESS={headless}",
+            "docker",
+            "run",
+            "-d",
+            "--rm",
+            "-p",
+            f"{port}:8765",
+            "-e",
+            f"FLEET_ENV_URL={env_url}",
+            "-e",
+            f"FLEET_TASK_PROMPT={task_prompt}",
+            "-e",
+            f"FLEET_TASK_KEY={task_key}",
+            "-e",
+            f"SCREEN_WIDTH={self.config.screen_width}",
+            "-e",
+            f"SCREEN_HEIGHT={self.config.screen_height}",
+            "-e",
+            f"HEADLESS={headless}",
         ]
-        
+
         # Add noVNC port mapping if headful
         if self.config.headful:
             cmd.extend(["-p", f"{vnc_port}:6080"])
-        
+
         cmd.append(self._docker_image)
-        
+
         proc = await asyncio.create_subprocess_exec(
             *cmd,
             stdout=asyncio.subprocess.PIPE,
             stderr=asyncio.subprocess.PIPE,
         )
         stdout, stderr = await proc.communicate()
-        
+
         if proc.returncode != 0:
-            raise RuntimeError(f"Container start failed: {stderr.decode()}")
-        
-        return stdout.decode().strip()
-    
+            stderr_str = stderr.decode()
+            # Check for port conflict
+            if (
+                "port is already allocated" in stderr_str
+                or "address already in use" in stderr_str.lower()
+            ):
+                raise RuntimeError(
+                    f"Port conflict on {port} or {vnc_port}. Try again or check for orphaned containers with: docker ps"
+                )
+            raise RuntimeError(f"Container start failed: {stderr_str}")
+
+        container_id = stdout.decode().strip()
+
+        # Track container globally for cleanup on exit
+        _running_containers.add(container_id)
+
+        return container_id
+
     async def _stop_container(self, container_id: str):
         """Stop Docker container and capture logs."""
         # Get logs before stopping
         log_proc = await asyncio.create_subprocess_exec(
-            "docker", "logs", "--tail", "50", container_id,
+            "docker",
+            "logs",
+            "--tail",
+            "50",
+            container_id,
             stdout=asyncio.subprocess.PIPE,
             stderr=asyncio.subprocess.STDOUT,
         )
         logs, _ = await log_proc.communicate()
         if logs:
             logger.debug(f"Container {container_id[:12]} logs:\n{logs.decode()}")
-        
+
         proc = await asyncio.create_subprocess_exec(
-            "docker", "stop", container_id,
+            "docker",
+            "stop",
+            container_id,
             stdout=asyncio.subprocess.DEVNULL,
             stderr=asyncio.subprocess.DEVNULL,
         )
         await proc.wait()
-    
+
+        # Remove from global tracking
+        _running_containers.discard(container_id)
+
     async def _wait_for_server(self, port: int, timeout: int = 60):
         """Wait for CUA server to be ready."""
         import aiohttp
-        
+
         url = f"http://localhost:{port}/health"
         start = time.time()
-        
+
         while time.time() - start < timeout:
             try:
                 async with aiohttp.ClientSession() as session:
@@ -383,9 +567,9 @@ class AgentOrchestrator:
             except:
                 pass
             await asyncio.sleep(1)
-        
+
         raise TimeoutError(f"CUA server not ready after {timeout}s")
-    
+
     async def _run_agent(
         self,
         port: int,
@@ -396,35 +580,40 @@ class AgentOrchestrator:
         """Run agent process."""
         agent_path = get_agent_path(self.config.agent)
         agent_script = agent_path / "agent.py"
-        
+
         # Set up environment
         env = os.environ.copy()
-        
+
         # Session log file: ~/.fleet/logs/{job_id}/{task_key}.jsonl
         session_log_file = self._log_dir / f"{task_key}.jsonl"
-        
-        env.update({
-            "FLEET_MCP_URL": f"http://localhost:{port}",
-            "FLEET_SESSION_LOG": str(session_log_file),  # Unified session log (MCP + HTTP)
-            "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),
-            "FLEET_SCREEN_HEIGHT": str(self.config.screen_height),
-            "FLEET_VERBOSE": "true" if self.config.verbose else "false",
-        })
+
+        env.update(
+            {
+                "FLEET_MCP_URL": f"http://localhost:{port}",
+                "FLEET_SESSION_LOG": str(
+                    session_log_file
+                ),  # Unified session log (MCP + HTTP)
+                "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),
+                "FLEET_SCREEN_HEIGHT": str(self.config.screen_height),
+                "FLEET_VERBOSE": "true" if self.config.verbose else "false",
+            }
+        )
         env.update(self.config.api_keys)
-        
+
         proc = await asyncio.create_subprocess_exec(
-            sys.executable, str(agent_script),
+            sys.executable,
+            str(agent_script),
             stdout=asyncio.subprocess.PIPE,
             stderr=asyncio.subprocess.PIPE,
             env=env,
         )
-        
+
         try:
             stdout, stderr = await asyncio.wait_for(
                 proc.communicate(),
@@ -438,11 +627,11 @@ class AgentOrchestrator:
                 completed=False,
                 error="Agent timeout",
             )
-        
+
         # Parse result from stdout/stderr
         stdout_str = stdout.decode()
         stderr_str = stderr.decode()
-        
+
         # Show full output in verbose mode
         if self.config.verbose:
             logger.info(f"Agent stdout:\n{stdout_str}")
@@ -452,13 +641,13 @@ class AgentOrchestrator:
             logger.debug(f"Agent stdout: {stdout_str[:500]}")
             if stderr_str:
                 logger.debug(f"Agent stderr: {stderr_str[:500]}")
-        
+
         # Always show stderr if agent crashed (non-zero exit or has stderr)
         if proc.returncode != 0 or stderr_str:
             short_key = task_key[:20]
             if stderr_str:
                 print(f"[{short_key}] Agent stderr: {stderr_str[:500]}")
-        
+
         result_json = None
         for line in stdout_str.split("\n"):
             line = line.strip()
@@ -467,7 +656,7 @@ class AgentOrchestrator:
                     result_json = json.loads(line)
                 except:
                     continue
-        
+
         if result_json:
             return AgentResult(
                 task_key=result_json.get("task_key", task_key),
@@ -479,12 +668,12 @@ class AgentOrchestrator:
                 transcript=result_json.get("transcript", []),
                 session_id=result_json.get("session_id"),
             )
-        
+
         # Include stderr in error message
         error_msg = f"Agent failed. stdout: {stdout_str[:300]}"
         if stderr_str:
             error_msg += f" | stderr: {stderr_str[:300]}"
-        
+
         return AgentResult(
             task_key=task_key,
             completed=False,
@@ -505,7 +694,7 @@ async def run_agent(
     verbose: bool = False,
 ) -> List[TaskResult]:
     """Run agent on Fleet tasks.
-    
+
     Args:
         project_key: Fleet project to run on
         task_keys: Specific tasks (alternative to project_key)
@@ -517,7 +706,7 @@ async def run_agent(
         api_keys: API keys (e.g., {"GEMINI_API_KEY": "xxx"})
         headful: Show browser via noVNC
         verbose: Enable verbose agent logging
-    
+
     Returns:
         List of TaskResult
     """
@@ -533,7 +722,6 @@ async def run_agent(
         timeout_seconds=timeout_seconds,
         api_keys=api_keys or {},
     )
-    
+
     orchestrator = AgentOrchestrator(config)
     return await orchestrator.run()
-

{fleet_python-0.2.88 → fleet_python-0.2.90}/fleet/base.py

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

{fleet_python-0.2.88 → fleet_python-0.2.90}/fleet/cli.py

@@ -732,15 +732,6 @@ def eval_run(
         return
     
     client = get_client()
-    base_url = os.getenv("FLEET_BASE_URL", CLI_DEFAULT_BASE_URL)
-    
-    # Generate a default name if not provided
-    if not name:
-        model_short = model[0].split("/")[-1].split("-")[0] if model else "eval"
-        if project_key:
-            name = f"{project_key}-{model_short}"
-        else:
-            name = f"all-tasks-{model_short}"
     
     # Parse BYOK keys
     byok_keys = None

{fleet_python-0.2.88 → fleet_python-0.2.90/fleet_python.egg-info}/PKG-INFO

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

{fleet_python-0.2.88 → fleet_python-0.2.90}/pyproject.toml

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