fleet-python 0.2.91__tar.gz → 0.2.93__tar.gz

{fleet_python-0.2.91/fleet_python.egg-info → fleet_python-0.2.93}/PKG-INFO

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

{fleet_python-0.2.91 → fleet_python-0.2.93}/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.91"
+__version__ = "0.2.93"
 
 __all__ = [
     # Core classes

{fleet_python-0.2.91 → fleet_python-0.2.93}/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.91"
+__version__ = "0.2.93"
 
 __all__ = [
     # Core classes

{fleet_python-0.2.91 → fleet_python-0.2.93}/fleet/_async/base.py

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

{fleet_python-0.2.91 → fleet_python-0.2.93}/fleet/agent/gemini_cua/agent.py

@@ -8,7 +8,7 @@ Env vars:
     FLEET_TASK_PROMPT: Task prompt
     FLEET_TASK_KEY: Task key
     FLEET_MODEL: Model (default: gemini-2.5-pro)
-    FLEET_MAX_STEPS: Max steps (default: 50)
+    FLEET_MAX_STEPS: Max steps (default: 200)
     FLEET_VERBOSE: Enable verbose logging (default: false)
     USE_OAUTH: Use gcloud OAuth instead of API key (default: false)
     GOOG_PROJECT: Google Cloud project for OAuth (default: gemini-agents-area)
@@ -95,22 +95,33 @@ class MCP:
     
     async def __aenter__(self):
         # Connect using streamable-http transport
-        self._client = streamable_http_client(self.url)
-        read, write, _ = await self._client.__aenter__()
-        self._session = ClientSession(read, write)
-        await self._session.__aenter__()
-        await self._session.initialize()
+        print(f"MCP: Connecting to {self.url}...")
+        try:
+            self._client = streamable_http_client(self.url)
+            read, write, _ = await self._client.__aenter__()
+            self._session = ClientSession(read, write)
+            await self._session.__aenter__()
+            await self._session.initialize()
+            print(f"MCP: Connected successfully")
+        except Exception as e:
+            print(f"MCP: Connection failed: {type(e).__name__}: {e}")
+            raise
         
         # Fetch available tools from server
-        result = await self._session.list_tools()
-        self._tools = [
-            {
-                "name": tool.name,
-                "description": tool.description or "",
-                "inputSchema": tool.inputSchema,
-            }
-            for tool in result.tools
-        ]
+        try:
+            result = await self._session.list_tools()
+            self._tools = [
+                {
+                    "name": tool.name,
+                    "description": tool.description or "",
+                    "inputSchema": tool.inputSchema,
+                }
+                for tool in result.tools
+            ]
+            print(f"MCP: Loaded {len(self._tools)} tools")
+        except Exception as e:
+            print(f"MCP: Failed to list tools: {type(e).__name__}: {e}")
+            raise
         return self
     
     async def __aexit__(self, *args):
@@ -212,6 +223,8 @@ class GeminiAgent:
         self.client = get_gemini_client()
         self.transcript: List[Dict] = []
         self.session = session  # Fleet session for live logging
+        self._consecutive_errors = 0
+        self._max_consecutive_errors = 5
     
     async def _execute_tool(self, name: str, args: Dict) -> Dict:
         return await self.mcp.call(name, args)
@@ -287,9 +300,27 @@ STRICT RULES:
                     contents=history,
                     config=config,
                 )
+                self._consecutive_errors = 0  # Reset on success
             except Exception as e:
-                print(f"API error: {e}")
-                return self._result(False, str(e), step, start_time)
+                self._consecutive_errors += 1
+                error_type = type(e).__name__
+                print(f"API error ({error_type}): {e}")
+                print(f"  Consecutive errors: {self._consecutive_errors}/{self._max_consecutive_errors}")
+                
+                if self._consecutive_errors >= self._max_consecutive_errors:
+                    return self._result(False, f"Too many consecutive API errors: {error_type}: {e}", step, start_time)
+                
+                # Check for retryable errors
+                if "429" in str(e) or "quota" in str(e).lower() or "rate" in str(e).lower():
+                    print(f"  Rate limited, waiting 10s...")
+                    await asyncio.sleep(10)
+                    continue
+                elif "503" in str(e) or "500" in str(e) or "overloaded" in str(e).lower():
+                    print(f"  Server error, waiting 5s...")
+                    await asyncio.sleep(5)
+                    continue
+                else:
+                    return self._result(False, f"{error_type}: {e}", step, start_time)
             
             if not response.candidates:
                 print("[WARN] No candidates, retrying...")
@@ -309,6 +340,7 @@ STRICT RULES:
                     if step == 1 and self.session.session_id:
                         print(f"Session: https://fleetai.com/dashboard/sessions/{self.session.session_id}")
                 except Exception as e:
+                    print(f"  [WARN] Session log failed: {type(e).__name__}: {e}")
                     log_verbose(f"  [WARN] Session log failed: {e}")
             
             # Log all parts for debugging
@@ -370,9 +402,28 @@ STRICT RULES:
                     try:
                         result = await self._execute_tool(name, args)
                         log_verbose(f"    Result: isError={result.get('isError', False)}, content_types={[c.get('type') for c in result.get('content', [])]}")
+                        
+                        if result.get("isError"):
+                            self._consecutive_errors += 1
+                            error_text = ""
+                            for c in result.get("content", []):
+                                if c.get("type") == "text":
+                                    error_text = c.get("text", "")[:200]
+                            print(f"    Tool error: {error_text}")
+                        else:
+                            self._consecutive_errors = 0
                     except Exception as e:
-                        print(f"  Error: {e}")
-                        log_verbose(f"    Exception: {type(e).__name__}: {e}")
+                        self._consecutive_errors += 1
+                        error_type = type(e).__name__
+                        print(f"  Tool exception ({error_type}): {e}")
+                        print(f"  Consecutive errors: {self._consecutive_errors}/{self._max_consecutive_errors}")
+                        log_verbose(f"    Exception: {error_type}: {e}")
+                        
+                        # Check if this is a connection/MCP error that we should fail fast on
+                        if "connection" in str(e).lower() or "closed" in str(e).lower():
+                            print(f"  MCP connection lost, failing task")
+                            return self._result(False, f"MCP connection error: {e}", step, start_time)
+                        
                         result = {"content": [{"type": "text", "text": str(e)}], "isError": True}
                     
                     # Build function response with image embedded (per reference format)
@@ -414,7 +465,10 @@ STRICT RULES:
                 history.append(types.Content(role="model", parts=response_parts))
                 log_verbose(f"  Added {len(response_parts)} function response(s) to history")
         
-        return self._result(False, "Max steps reached", max_steps, start_time)
+        # Max steps reached - still mark as completed so verification runs
+        # The agent may have done the task but just didn't say "DONE"
+        print(f"\n⚠ Max steps ({max_steps}) reached - will still run verification")
+        return self._result(True, "Max steps reached", max_steps, start_time, "Max steps reached - task may be complete")
     
     def _result(self, completed: bool, error: Optional[str], steps: int, start_time: float, answer: str = None) -> Dict:
         """Build result dict."""
@@ -437,7 +491,7 @@ async def main():
         "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")),
+        "max_steps": int(os.environ.get("FLEET_MAX_STEPS", "200")),
     }
     
     print(f"Gemini CUA Agent")

{fleet_python-0.2.91 → fleet_python-0.2.93}/fleet/agent/gemini_cua/mcp_server.py

@@ -57,10 +57,20 @@ async def lifespan(app):
     )
     
     try:
+        logger.info("Starting Playwright browser...")
         await computer.start()
+        logger.info(f"Browser started, navigated to: {computer.current_url}")
         yield
+    except Exception as e:
+        logger.error(f"Browser startup FAILED: {type(e).__name__}: {e}")
+        raise
     finally:
-        await computer.stop()
+        logger.info("Stopping Playwright browser...")
+        try:
+            await computer.stop()
+            logger.info("Browser stopped")
+        except Exception as e:
+            logger.error(f"Browser stop error: {type(e).__name__}: {e}")
 
 
 mcp = FastMCP("cua-server", lifespan=lifespan, host="0.0.0.0", port=PORT)
@@ -74,7 +84,13 @@ mcp = FastMCP("cua-server", lifespan=lifespan, host="0.0.0.0", port=PORT)
 async def computer_screenshot() -> list:
     """Takes a screenshot of the computer screen. Use this to see what's on screen."""
     logger.info("computer_screenshot()")
-    return _screenshot_response(await computer.screenshot())
+    try:
+        result = await computer.screenshot()
+        logger.info(f"computer_screenshot() -> {len(result)} bytes")
+        return _screenshot_response(result)
+    except Exception as e:
+        logger.error(f"computer_screenshot() FAILED: {type(e).__name__}: {e}")
+        raise
 
 
 @mcp.tool()
@@ -88,7 +104,11 @@ async def mouse_click(x: int, y: int, button: str, repeats: int = 1) -> None:
         repeats: The number of times to click. Default is 1.
     """
     logger.info(f"mouse_click({x}, {y}, {button}, {repeats})")
-    await computer.mouse_click(_dx(x), _dy(y), button, repeats)
+    try:
+        await computer.mouse_click(_dx(x), _dy(y), button, repeats)
+    except Exception as e:
+        logger.error(f"mouse_click FAILED: {type(e).__name__}: {e}")
+        raise
 
 
 @mcp.tool()
@@ -172,7 +192,11 @@ async def type_text(input_text: str, press_enter: bool) -> None:
         press_enter: Whether to press enter after typing.
     """
     logger.info(f"type_text({input_text[:50]}{'...' if len(input_text) > 50 else ''}, enter={press_enter})")
-    await computer.type_text(input_text, press_enter)
+    try:
+        await computer.type_text(input_text, press_enter)
+    except Exception as e:
+        logger.error(f"type_text FAILED: {type(e).__name__}: {e}")
+        raise
 
 
 @mcp.tool()

{fleet_python-0.2.91 → fleet_python-0.2.93}/fleet/agent/orchestrator.py

@@ -168,6 +168,50 @@ class AgentOrchestrator:
         self._available_ports: List[Tuple[int, int]] = []
         # Register global cleanup handlers
         _register_cleanup()
+        # Stats tracking
+        self._stats = {"started": 0, "completed": 0, "failed": 0, "errors": {}}
+
+    def _track_error(self, category: str, message: str):
+        """Track an error for summary statistics."""
+        if category not in self._stats["errors"]:
+            self._stats["errors"][category] = []
+        # Keep up to 5 examples per category
+        if len(self._stats["errors"][category]) < 5:
+            self._stats["errors"][category].append(message[:200])
+
+    def _print_stats(self):
+        """Print summary statistics."""
+        from rich.console import Console
+        from rich.table import Table
+        
+        console = Console()
+        
+        total = self._stats["started"]
+        completed = self._stats["completed"]
+        failed = self._stats["failed"]
+        
+        console.print()
+        console.print("[bold]Run Summary:[/bold]")
+        console.print(f"  Started:   {total}")
+        console.print(f"  Completed: [green]{completed}[/green] ({100*completed/total:.1f}%)" if total > 0 else "  Completed: 0")
+        console.print(f"  Failed:    [red]{failed}[/red] ({100*failed/total:.1f}%)" if total > 0 else "  Failed: 0")
+        
+        if self._stats["errors"]:
+            console.print()
+            console.print("[bold]Error Breakdown:[/bold]")
+            table = Table(show_header=True, header_style="bold")
+            table.add_column("Category")
+            table.add_column("Count")
+            table.add_column("Example")
+            
+            for category, examples in sorted(self._stats["errors"].items(), key=lambda x: -len(x[1])):
+                table.add_row(
+                    category,
+                    str(len(examples)),
+                    examples[0][:80] + "..." if len(examples[0]) > 80 else examples[0]
+                )
+            
+            console.print(table)
 
     async def _get_next_ports(self) -> Tuple[int, int]:
         """Get next available MCP port and VNC port."""
@@ -282,7 +326,10 @@ class AgentOrchestrator:
             session_logs = list(self._log_dir.glob("*.jsonl"))
             console.print(f"Logs: {self._log_dir}/ ({len(session_logs)} sessions)")
 
-        return final
+        # Print summary statistics
+        self._print_stats()
+
+        return final, self._job_id
 
     async def _build_docker_image(self, agent_path: Path):
         """Build Docker image for CUA server."""
@@ -334,15 +381,18 @@ class AgentOrchestrator:
         task_prompt = task.prompt
         short_key = task_key[:20]
 
-        logger.debug(f"[{short_key}] Starting")
+        self._stats["started"] += 1
+        logger.debug(f"[{short_key}] Starting (total started: {self._stats['started']})")
 
         env = None
         container_id = None
         port = None
         vnc_port = None
+        current_phase = "init"
 
         try:
             # 1. Create Fleet environment
+            current_phase = "create_env"
             logger.debug(f"[{short_key}] Creating env...")
             env = await make_async(
                 env_key=task.env_key,
@@ -356,6 +406,7 @@ class AgentOrchestrator:
             await asyncio.sleep(3)  # Wait for env to be ready
 
             # 2. Start Docker container with CUA server
+            current_phase = "start_container"
             port, vnc_port = await self._get_next_ports()
             logger.debug(f"[{short_key}] Starting container on port {port}...")
             container_id = await self._start_container(
@@ -373,11 +424,13 @@ class AgentOrchestrator:
                 print(f"[{short_key}] Browser:  http://localhost:{vnc_port}/vnc.html")
 
             # Wait for server to be ready
+            current_phase = "wait_for_server"
             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
+            current_phase = "run_agent"
             logger.debug(f"[{short_key}] Running agent...")
             agent_result = await self._run_agent(
                 port=port,
@@ -388,14 +441,17 @@ class AgentOrchestrator:
             logger.debug(
                 f"[{short_key}] Agent done: completed={agent_result.completed}"
             )
+            if agent_result.error and agent_result.error != "Max steps reached":
+                print(f"[{short_key}] Agent error: {agent_result.error[:200]}")
 
             # 4. Run verification
+            current_phase = "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...")
+                logger.info(f"[{short_key}] Running verification...")
                 try:
                     v = await task.verify_detailed_async(
                         env=env,
@@ -407,9 +463,21 @@ class AgentOrchestrator:
                     verification_score = (
                         v.result if isinstance(v.result, (int, float)) else None
                     )
-                    logger.info(f"[{task_key}] Verification: {verification_success}")
+                    logger.info(f"[{short_key}] Verification: {verification_success}")
+                    if verification_success:
+                        self._stats["completed"] += 1
+                    else:
+                        self._stats["failed"] += 1
+                        print(f"[{short_key}] Verification FAILED: score={verification_score}")
                 except Exception as e:
-                    logger.error(f"[{task_key}] Verification error: {e}")
+                    logger.error(f"[{short_key}] Verification error: {e}")
+                    self._stats["failed"] += 1
+                    self._track_error("verification_error", str(e))
+            elif not agent_result.completed:
+                self._stats["failed"] += 1
+                error_msg = agent_result.error or "unknown"
+                self._track_error("agent_not_completed", error_msg)
+                print(f"[{short_key}] Agent did not complete: {error_msg}")
 
             # 5. Complete/fail session (session was created by agent, we just complete it)
             session_id = getattr(agent_result, "session_id", None)
@@ -439,11 +507,24 @@ class AgentOrchestrator:
             )
 
         except Exception as e:
-            logger.exception(f"[{short_key}] Failed: {e}")
+            import traceback
+            error_type = type(e).__name__
+            error_msg = str(e)
+            tb = traceback.format_exc()
+            
+            # Categorize the error
+            error_category = f"{current_phase}:{error_type}"
+            self._track_error(error_category, error_msg)
+            self._stats["failed"] += 1
+            
+            # Always print errors for visibility
+            print(f"[{short_key}] EXCEPTION in {current_phase}: {error_type}: {error_msg[:200]}")
+            logger.error(f"[{short_key}] Traceback:\n{tb}")
+            
             return TaskResult(
                 task_key=task_key,
                 task_prompt=task_prompt,
-                error=str(e),
+                error=f"[{current_phase}] {error_type}: {error_msg}",
                 execution_time_ms=int((time.time() - start) * 1000),
             )
 
@@ -687,12 +768,12 @@ async def run_agent(
     agent: str = "gemini_cua",
     model: str = "gemini-2.5-pro",
     max_concurrent: int = 4,
-    max_steps: int = 100,
+    max_steps: int = 200,
     timeout_seconds: int = 600,
     api_keys: Optional[Dict[str, str]] = None,
     headful: bool = False,
     verbose: bool = False,
-) -> List[TaskResult]:
+) -> Tuple[List[TaskResult], str]:
     """Run agent on Fleet tasks.
 
     Args:
@@ -708,7 +789,7 @@ async def run_agent(
         verbose: Enable verbose agent logging
 
     Returns:
-        List of TaskResult
+        Tuple of (List of TaskResult, job_id)
     """
     config = AgentConfig(
         project_key=project_key,

{fleet_python-0.2.91 → fleet_python-0.2.93}/fleet/agent/types.py

@@ -12,7 +12,7 @@ class AgentConfig(BaseModel):
     agent: str = "gemini_cua"
     model: str = "gemini-2.5-pro"
     max_concurrent: int = 4
-    max_steps: int = 100
+    max_steps: int = 200
     timeout_seconds: int = 600
     screen_width: int = 1366
     screen_height: int = 768

{fleet_python-0.2.91 → fleet_python-0.2.93}/fleet/base.py

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

{fleet_python-0.2.91 → fleet_python-0.2.93}/fleet/cli.py

@@ -94,6 +94,53 @@ def get_client() -> Fleet:
     return Fleet(api_key=api_key, base_url=base_url)
 
 
+def _run_oversight(job_id: str, model: str = "anthropic/claude-sonnet-4"):
+    """Run oversight summarization on a completed job."""
+    import httpx
+    
+    api_key = os.getenv("FLEET_API_KEY")
+    if not api_key:
+        console.print("[yellow]Warning:[/yellow] FLEET_API_KEY not set, skipping oversight")
+        return
+    
+    base_url = os.getenv("FLEET_BASE_URL", CLI_DEFAULT_BASE_URL)
+    oversight_url = f"{base_url}/v1/summarize/job"
+    
+    console.print()
+    console.print("[bold]Running Oversight Analysis...[/bold]")
+    
+    try:
+        with httpx.Client(timeout=300) as client:
+            response = client.post(
+                oversight_url,
+                headers={
+                    "accept": "application/json",
+                    "Authorization": f"Bearer {api_key}",
+                    "Content-Type": "application/json",
+                },
+                json={
+                    "job_id": job_id,
+                    "model": model,
+                    "max_context_tokens": 180000,
+                    "force_new_summary": False,
+                    "max_concurrent": 20,
+                },
+            )
+            
+            if response.status_code == 200:
+                result = response.json()
+                console.print(f"[green]✓[/green] Oversight analysis started")
+                if "summary_id" in result:
+                    console.print(f"  Summary ID: [cyan]{result['summary_id']}[/cyan]")
+                # Show link to dashboard
+                console.print(f"  View: [cyan]https://fleetai.com/dashboard/jobs/{job_id}[/cyan]")
+            else:
+                console.print(f"[yellow]Warning:[/yellow] Oversight API returned {response.status_code}")
+                console.print(f"  {response.text[:200]}")
+    except Exception as e:
+        console.print(f"[yellow]Warning:[/yellow] Oversight request failed: {e}")
+
+
 # Jobs commands
 
 
@@ -326,6 +373,15 @@ def list_job_sessions(
         console.print(f"[dim]  Session transcript: flt sessions transcript {first_session_id}[/dim]")
 
 
+@jobs_app.command("oversight")
+def run_job_oversight(
+    job_id: str = typer.Argument(..., help="Job ID to analyze"),
+    model: str = typer.Option("anthropic/claude-sonnet-4", "--model", "-m", help="Model for oversight analysis"),
+):
+    """Run AI oversight analysis on a job."""
+    _run_oversight(job_id, model)
+
+
 # Sessions commands
 
 
@@ -488,6 +544,8 @@ def _run_local_agent(
     output_json: bool,
     verbose: bool = False,
     headful: bool = False,
+    oversight: bool = False,
+    oversight_model: str = "anthropic/claude-sonnet-4",
 ):
     """Run agent locally with Docker-based browser control."""
     import asyncio
@@ -563,8 +621,9 @@ def _run_local_agent(
     console.print("[dim]Starting agent...[/dim]")
     console.print()
     
+    job_id = None
     try:
-        results = asyncio.run(run())
+        results, job_id = asyncio.run(run())
     except KeyboardInterrupt:
         console.print()
         console.print("[yellow]Cancelled.[/yellow]")
@@ -633,6 +692,10 @@ def _run_local_agent(
         console.print(f"[bold]Pass Rate:[/bold] [{color}]{passed}/{total} ({rate:.1f}%)[/{color}]")
         if errors:
             console.print(f"[bold]Errors:[/bold] [red]{errors}[/red]")
+    
+    # Run oversight if requested
+    if oversight and job_id:
+        _run_oversight(job_id, oversight_model)
 
 
 def _listen_for_detach_key(stop_event: threading.Event):
@@ -688,6 +751,9 @@ def eval_run(
     local: Optional[str] = typer.Option(None, "--local", "-l", help="Run locally. Use 'gemini_cua' for built-in or path for custom agent"),
     headful: bool = typer.Option(False, "--headful", help="Show browser via noVNC (local mode)"),
     verbose: bool = typer.Option(False, "--verbose", "-v", help="Show debug output"),
+    # Oversight
+    oversight: bool = typer.Option(False, "--oversight", help="Run AI oversight analysis on job completion"),
+    oversight_model: str = typer.Option("anthropic/claude-sonnet-4", "--oversight-model", help="Model for oversight analysis"),
 ):
     """
     Run an evaluation on a project or specific tasks.
@@ -721,13 +787,15 @@ def eval_run(
             task_keys=task_keys,
             model=model[0] if model else "gemini-2.5-pro",
             agent=local if local else "gemini_cua",
-            max_steps=max_steps or 100,
+            max_steps=max_steps or 200,
             max_duration=max_duration,
             max_concurrent=max_concurrent,
             byok=byok,
             output_json=output_json,
             verbose=verbose,
             headful=headful,
+            oversight=oversight,
+            oversight_model=oversight_model,
         )
         return
     
@@ -938,6 +1006,10 @@ def eval_run(
                         console.print(f"  {task_name}: {tg.passed_sessions}/{tg.total_sessions} ({task_rate:.0f}%)")
         except:
             pass
+        
+        # Run oversight if requested and job completed (not detached)
+        if oversight and not detached:
+            _run_oversight(job_id, oversight_model)
 
     finally:
         # Signal the keyboard listener thread to stop
@@ -948,6 +1020,8 @@ def eval_run(
             console.print()
             console.print("[yellow]Detached. Eval continues running in background.[/yellow]")
             console.print(f"[dim]Check status: flt jobs get {job_id}[/dim]")
+            if oversight:
+                console.print(f"[dim]Run oversight manually: flt jobs oversight {job_id}[/dim]")
 
 
 def main():

{fleet_python-0.2.91 → fleet_python-0.2.93/fleet_python.egg-info}/PKG-INFO

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

{fleet_python-0.2.91 → fleet_python-0.2.93}/pyproject.toml

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