amd-gaia 0.15.1__py3-none-any.whl → 0.15.3__py3-none-any.whl

gaia/agents/base/console.py

@@ -2,6 +2,7 @@
 # SPDX-License-Identifier: MIT
 
 import json
+import subprocess
 import threading
 import time
 from abc import ABC, abstractmethod
@@ -57,7 +58,7 @@ class OutputHandler(ABC):
     # === Core Progress/State Methods (Required) ===
 
     @abstractmethod
-    def print_processing_start(self, query: str, max_steps: int):
+    def print_processing_start(self, query: str, max_steps: int, model_id: str = None):
         """Print processing start message."""
         ...
 
@@ -204,13 +205,14 @@ class OutputHandler(ABC):
 
 
 class ProgressIndicator:
-    """A simple progress indicator that shows a spinner or dots animation."""
+    """A simple progress indicator that shows a spinner or dots animation with elapsed time."""
 
-    def __init__(self, message="Processing"):
+    def __init__(self, message="Processing", show_timer=False):
         """Initialize the progress indicator.
 
         Args:
             message: The message to display before the animation
+            show_timer: If True, show elapsed time
         """
         self.message = message
         self.is_running = False
@@ -220,6 +222,9 @@ class ProgressIndicator:
         self.spinner_idx = 0
         self.dot_idx = 0
         self.rich_spinner = None
+        self.show_timer = show_timer
+        self.start_time = None
+        self._update_timer_thread = None  # Timer update thread
         if RICH_AVAILABLE:
             self.rich_spinner = Spinner("dots", text=message)
             self.live = None
@@ -259,19 +264,23 @@ class ProgressIndicator:
 
                 time.sleep(0.1)
 
-    def start(self, message=None):
+    def start(self, message=None, show_timer=None):
         """Start the progress indicator.
 
         Args:
             message: Optional new message to display
+            show_timer: Optional override for showing timer
         """
         if message:
             self.message = message
+        if show_timer is not None:
+            self.show_timer = show_timer
 
         if self.is_running:
             return
 
         self.is_running = True
+        self.start_time = time.time()
 
         if RICH_AVAILABLE:
             if self.rich_spinner:
@@ -281,11 +290,31 @@ class ProgressIndicator:
                     self.rich_spinner, refresh_per_second=10, transient=True
                 )
                 self.live.start()
+
+                # Update with timer if enabled
+                if self.show_timer:
+                    self._update_timer_thread = threading.Thread(
+                        target=self._update_timer
+                    )
+                    self._update_timer_thread.daemon = True
+                    self._update_timer_thread.start()
         else:
             self.thread = threading.Thread(target=self._animate)
             self.thread.daemon = True
             self.thread.start()
 
+    def _update_timer(self):
+        """Update spinner text with elapsed time."""
+        while self.is_running and self.live:
+            elapsed = time.time() - self.start_time
+            timer_text = f"{self.message} ({int(elapsed)}s)"
+            try:
+                self.rich_spinner.text = timer_text
+                self.live.update(self.rich_spinner)
+                time.sleep(1.0)  # Update every 1 second
+            except Exception:
+                break
+
     def stop(self):
         """Stop the progress indicator."""
         if not self.is_running:
@@ -293,6 +322,13 @@ class ProgressIndicator:
 
         self.is_running = False
 
+        # Stop timer thread if running
+        if RICH_AVAILABLE and hasattr(self, "_update_timer_thread"):
+            try:
+                self._update_timer_thread.join(timeout=0.5)
+            except Exception:
+                pass
+
         if RICH_AVAILABLE and self.live:
             self.live.stop()
         elif self.thread:
@@ -404,7 +440,6 @@ class AgentConsole(OutputHandler):
             else:
                 # Regular JSON output
                 # Convert to formatted JSON string with safe fallback for non-serializable types (e.g., numpy.float32)
-                print(data)
                 try:
                     json_str = json.dumps(data, indent=2)
                 except TypeError:
@@ -463,21 +498,28 @@ class AgentConsole(OutputHandler):
             print(f"\n⏸️  Paused after step: {description}")
             print("Press Enter to continue, or 'n'/'q' to stop...")
 
-    def print_processing_start(self, query: str, max_steps: int) -> None:
+    def print_processing_start(
+        self, query: str, max_steps: int, model_id: str = None
+    ) -> None:
         """
         Print the initial processing message.
 
         Args:
             query: The user query being processed
             max_steps: Maximum number of steps allowed (kept for API compatibility)
+            model_id: Optional model ID to display
         """
         if self.rich_available:
             self.console.print(f"\n[bold blue]🤖 Processing:[/bold blue] '{query}'")
             self.console.print("=" * 50)
+            if model_id:
+                self.console.print(f"[dim]Model: {model_id}[/dim]")
             self.console.print()
         else:
             print(f"\n🤖 Processing: '{query}'")
             print("=" * 50)
+            if model_id:
+                print(f"Model: {model_id}")
             print()
 
     def print_separator(self, length: int = 50) -> None:
@@ -803,6 +845,162 @@ class AgentConsole(OutputHandler):
         else:
             print(f"\n✅ SUCCESS: {message}\n")
 
+    def print_image(
+        self, image_path: str, caption: str = None, prompt_to_open: bool = False
+    ) -> None:
+        """
+        Display an image in terminal and optionally prompt to open in viewer.
+
+        Args:
+            image_path: Path to the image file
+            caption: Optional caption to display
+            prompt_to_open: If True, prompt user to open in default viewer after display
+        """
+        import os
+        import sys
+        from pathlib import Path
+
+        path = Path(image_path)
+        if not path.exists():
+            return
+
+        if self.rich_available:
+            try:
+                # Try term-image with Sixel protocol for full resolution
+                # Sixel works in: Windows Terminal Preview, iTerm2, Kitty, WezTerm, etc.
+                from term_image.image import from_file
+
+                # Load image with auto-detected best protocol
+                img = from_file(str(path))
+
+                # Try to enable Sixel if supported
+                try:
+                    # Set render method to auto-detect best available (Sixel, Kitty, iTerm2)
+                    img.set_render_method("auto")
+                except Exception:
+                    pass
+
+                # Set size maintaining aspect ratio
+                # Terminal characters are ~2:1 (height:width), so use fit_to_width
+                img.set_size(columns=60, fit_to_width=True)
+
+                # Render the image
+                if caption:
+                    # Create a panel around the rendered image
+                    rendered = str(img)
+                    self.console.print(
+                        Panel(
+                            rendered,
+                            title=f"🖼️  {caption}",
+                            border_style="cyan",
+                            padding=(0, 0),
+                        ),
+                        justify="center",
+                    )
+                else:
+                    # Print image directly with centering
+                    # Note: term-image returns ANSI escape codes with actual image data
+                    print(
+                        str(img)
+                    )  # Use plain print to avoid Rich interfering with image codes
+
+                self.console.print()
+
+            except (ImportError, Exception):
+                # Fallback to rich-pixels for broader compatibility
+                try:
+                    from PIL import Image
+                    from rich_pixels import Pixels
+
+                    # Load image to check dimensions
+                    pil_img = Image.open(path)
+                    img_width, img_height = pil_img.size
+                    aspect_ratio = img_width / img_height
+
+                    # Terminal characters are roughly 2:1 (height:width)
+                    # A char is ~2x taller than wide, so to show square image as square:
+                    # need width_chars = height_chars * 2
+                    # For proper aspect: width_chars = height_chars * 2 * image_aspect_ratio
+                    target_height = 50  # rows
+                    target_width = int(target_height * 2.0 * aspect_ratio)  # columns
+
+                    # Resize to these dimensions maintaining aspect
+                    pixels = Pixels.from_image_path(
+                        str(path), resize=(target_width, target_height)
+                    )
+
+                    if caption:
+                        self.console.print(
+                            Panel(
+                                pixels,
+                                title=f"🖼️  {caption}",
+                                border_style="cyan",
+                                padding=(0, 0),
+                            ),
+                            justify="center",
+                        )
+                    else:
+                        self.console.print(pixels, justify="center")
+                    self.console.print()
+
+                except ImportError:
+                    # No image libraries, show file info only
+                    try:
+                        from PIL import Image
+
+                        img = Image.open(path)
+                        info = f"[cyan]{path.name}[/cyan]\n"
+                        info += f"[dim]Size: {img.width}x{img.height} | Format: {img.format} | File: {path.stat().st_size:,} bytes[/dim]"
+
+                        if caption:
+                            self.console.print(
+                                Panel(
+                                    info, title=f"🖼️  {caption}", border_style="cyan"
+                                ),
+                                justify="center",
+                            )
+                        else:
+                            self.console.print(
+                                Panel(info, border_style="cyan"), justify="center"
+                            )
+                    except Exception:
+                        # Fallback to just showing the path
+                        self.console.print(
+                            f"[cyan]🖼️  Image: {path}[/cyan]", justify="center"
+                        )
+
+            # Prompt to open in default viewer
+            if prompt_to_open and sys.platform == "win32":
+                try:
+                    response = (
+                        input("\nOpen image in default viewer? [Y/n]: ").strip().lower()
+                    )
+                    if response in ("", "y", "yes"):
+                        if sys.platform == "win32":
+                            os.startfile(str(path))  # pylint: disable=no-member
+                        elif sys.platform == "darwin":
+                            subprocess.run(["open", str(path)], check=False)
+                        else:
+                            subprocess.run(["xdg-open", str(path)], check=False)
+                except (KeyboardInterrupt, EOFError):
+                    pass  # User cancelled
+        else:
+            # Text-only terminal
+            print(f"\n🖼️  Image: {path}")
+            if caption:
+                print(f"   {caption}")
+
+            # Prompt to open in default viewer
+            if prompt_to_open and sys.platform == "win32":
+                try:
+                    response = input("\nOpen image? [Y/n]: ").strip().lower()
+                    if response in ("", "y", "yes"):
+                        os.startfile(str(path))  # pylint: disable=no-member
+                except (KeyboardInterrupt, EOFError):
+                    pass
+
+            print()
+
     def print_diff(self, diff: str, filename: str) -> None:
         """
         Print a code diff with syntax highlighting.
@@ -974,12 +1172,13 @@ class AgentConsole(OutputHandler):
         # Print the table in a panel
         self.console.print(Panel(table, border_style="blue"))
 
-    def start_progress(self, message: str) -> None:
+    def start_progress(self, message: str, show_timer: bool = False) -> None:
         """
         Start the progress indicator.
 
         Args:
             message: Message to display with the indicator
+            show_timer: If True, show elapsed time in progress message
         """
         # If file preview is active, pause it temporarily
         self._paused_preview = False
@@ -993,7 +1192,7 @@ class AgentConsole(OutputHandler):
             except Exception:
                 pass
 
-        self.progress.start(message)
+        self.progress.start(message, show_timer=show_timer)
 
     def stop_progress(self) -> None:
         """Stop the progress indicator."""
@@ -1233,6 +1432,132 @@ class AgentConsole(OutputHandler):
         else:
             print(f"✅ Model {status}: {model_name}")
 
+    # === Download Progress Methods ===
+
+    def print_download_start(self, model_name: str) -> None:
+        """
+        Print download starting notification.
+
+        Args:
+            model_name: Name of the model being downloaded
+        """
+        if self.rich_available and self.console:
+            self.console.print()
+            self.console.print(
+                f"[bold blue]📥 Downloading:[/bold blue] [cyan]{model_name}[/cyan]"
+            )
+        else:
+            rprint(f"\n📥 Downloading: {model_name}")
+
+    def print_download_progress(
+        self,
+        percent: int,
+        bytes_downloaded: int,
+        bytes_total: int,
+        speed_mbps: float = 0.0,
+    ) -> None:
+        """
+        Print download progress with a progress bar that updates in place.
+
+        Args:
+            percent: Download percentage (0-100)
+            bytes_downloaded: Bytes downloaded so far
+            bytes_total: Total bytes to download
+            speed_mbps: Download speed in MB/s (optional)
+        """
+        import sys
+
+        # Format sizes
+        if bytes_total > 1024**3:  # > 1 GB
+            dl_str = f"{bytes_downloaded / 1024**3:.2f} GB"
+            total_str = f"{bytes_total / 1024**3:.2f} GB"
+        elif bytes_total > 1024**2:  # > 1 MB
+            dl_str = f"{bytes_downloaded / 1024**2:.0f} MB"
+            total_str = f"{bytes_total / 1024**2:.0f} MB"
+        else:
+            dl_str = f"{bytes_downloaded / 1024:.0f} KB"
+            total_str = f"{bytes_total / 1024:.0f} KB"
+
+        # Progress bar characters
+        bar_width = 25
+        filled = int(bar_width * percent / 100)
+        bar = "━" * filled + "─" * (bar_width - filled)
+
+        # Build progress line with optional speed
+        progress_line = f"   [{bar}] {percent:3d}%  {dl_str} / {total_str}"
+        if speed_mbps > 0.1:
+            progress_line += f" @ {speed_mbps:.0f} MB/s"
+
+        # Update in place with carriage return
+        sys.stdout.write(f"\r{progress_line:<80}")
+        sys.stdout.flush()
+
+    def print_download_complete(self, model_name: str = None) -> None:
+        """
+        Print download complete notification.
+
+        Args:
+            model_name: Optional name of the downloaded model
+        """
+        if self.rich_available and self.console:
+            self.console.print()  # Newline after progress bar
+            if model_name:
+                self.console.print(
+                    f"   [green]✅ Downloaded successfully:[/green] [cyan]{model_name}[/cyan]"
+                )
+            else:
+                self.console.print("   [green]✅ Download complete[/green]")
+        else:
+            rprint()
+            msg = (
+                f"   ✅ Downloaded: {model_name}"
+                if model_name
+                else "   ✅ Download complete"
+            )
+            rprint(msg)
+
+    def print_download_error(self, error_message: str, model_name: str = None) -> None:
+        """
+        Print download error notification.
+
+        Args:
+            error_message: Error description
+            model_name: Optional name of the model that failed
+        """
+        if self.rich_available and self.console:
+            self.console.print()  # Newline after progress bar
+            if model_name:
+                self.console.print(
+                    f"   [red]❌ Download failed for {model_name}:[/red] {error_message}"
+                )
+            else:
+                self.console.print(f"   [red]❌ Download failed:[/red] {error_message}")
+        else:
+            rprint()
+            msg = (
+                f"   ❌ Download failed for {model_name}: {error_message}"
+                if model_name
+                else f"   ❌ Download failed: {error_message}"
+            )
+            rprint(msg)
+
+    def print_download_skipped(
+        self, model_name: str, reason: str = "already downloaded"
+    ) -> None:
+        """
+        Print download skipped notification.
+
+        Args:
+            model_name: Name of the model that was skipped
+            reason: Reason for skipping
+        """
+        if self.rich_available and self.console:
+            self.console.print(
+                f"[green]✅[/green] [cyan]{model_name}[/cyan] [dim]({reason})[/dim]"
+            )
+        else:
+            rprint(f"✅ {model_name} ({reason})")
+
     def print_extraction_start(
         self, image_num: int, page_num: int, mime_type: str
     ) -> None:
@@ -1727,7 +2052,7 @@ class SilentConsole(OutputHandler):
         console.print(Panel(table, border_style="blue"))
 
     # All other abstract methods as no-ops
-    def print_processing_start(self, query: str, max_steps: int):
+    def print_processing_start(self, query: str, max_steps: int, model_id: str = None):
         """No-op implementation."""
 
     def print_step_header(self, step_num: int, step_limit: int):

gaia/agents/base/tools.py

@@ -17,7 +17,10 @@ _TOOL_REGISTRY = {}
 
 
 def tool(
-    func: Callable = None, **kwargs  # pylint: disable=unused-argument
+    func: Callable = None,
+    *,
+    atomic: bool = False,
+    **kwargs,  # pylint: disable=unused-argument
 ) -> Callable:
     """
     Decorator to register a function as a tool.
@@ -28,6 +31,7 @@ def tool(
 
     Args:
         func: Function to register as a tool (when used as @tool)
+        atomic: If True, marks this tool as atomic (can execute without multi-step planning)
         **kwargs: Optional arguments (ignored, for backward compatibility)
 
     Returns:
@@ -63,12 +67,13 @@ def tool(
 
             params[name] = param_info
 
-        # Register the tool
+        # Register the tool with atomic metadata
         _TOOL_REGISTRY[tool_name] = {
             "name": tool_name,
             "description": f.__doc__ or "",
             "parameters": params,
             "function": f,
+            "atomic": atomic,
         }
 
         # Return the function unchanged

gaia/agents/blender/__init__.py

@@ -0,0 +1,7 @@
+# Copyright(C) 2025-2026 Advanced Micro Devices, Inc. All rights reserved.
+# SPDX-License-Identifier: MIT
+"""Blender Agent for 3D scene automation."""
+
+from gaia.agents.blender.agent import BlenderAgent
+
+__all__ = ["BlenderAgent"]

gaia/agents/blender/agent.py

@@ -24,9 +24,6 @@ class BlenderAgent(Agent):
     Inherits core functionality from the base Agent class.
     """
 
-    # Define Blender-specific tools that can execute directly without requiring a plan
-    SIMPLE_TOOLS = ["clear_scene", "get_scene_info"]
-
     def __init__(
         self,
         mcp: Optional[MCPClient] = None,
@@ -80,7 +77,7 @@ class BlenderAgent(Agent):
     def _get_system_prompt(self) -> str:
         """Generate the system prompt for the Blender agent."""
         # Get formatted tools from registry
-        return f"""
+        return """
 You are a specialized Blender 3D assistant that can create and modify 3D scenes.
 You will use a set of tools to accomplish tasks based on the user's request.
 
@@ -169,7 +166,7 @@ Examples of colored requests:
     def _register_tools(self):
         """Register all Blender-related tools for the agent."""
 
-        @tool
+        @tool(atomic=True)
         def clear_scene() -> Dict[str, Any]:
             """
             Remove all objects from the current Blender scene.
@@ -283,7 +280,7 @@ Examples of colored requests:
                 return {"status": "error", "error": str(e)}
 
         # @tool
-        def get_object_info(name: str) -> Dict[str, Any]:
+        def _get_object_info(name: str) -> Dict[str, Any]:
             """
             Get information about an object in the scene.
 
@@ -354,7 +351,7 @@ Examples of colored requests:
                 return {"status": "error", "error": str(e)}
 
         # @tool
-        def delete_object(name: str) -> Dict[str, Any]:
+        def _delete_object(name: str) -> Dict[str, Any]:
             """
             Delete an object from the scene.
 
@@ -382,7 +379,7 @@ Examples of colored requests:
                 self.error_history.append(str(e))
                 return {"status": "error", "error": str(e)}
 
-        @tool
+        @tool(atomic=True)
         def get_scene_info() -> Dict[str, Any]:
             """
             Get information about the current scene.
@@ -407,7 +404,7 @@ Examples of colored requests:
                 return {"status": "error", "error": str(e)}
 
         # @tool
-        def execute_blender_code(code: str) -> Dict[str, Any]:
+        def _execute_blender_code(code: str) -> Dict[str, Any]:
             """
             Execute arbitrary Python code in Blender with error handling.
 
@@ -436,7 +433,7 @@ Examples of colored requests:
                 return {"status": "error", "error": str(e)}
 
         # @tool
-        def diagnose_scene() -> Dict[str, Any]:
+        def _diagnose_scene() -> Dict[str, Any]:
             """
             Diagnose the current Blender scene for common issues.
             Returns information about objects, materials, and potential problems.

gaia/agents/blender/core/view.py

@@ -13,13 +13,13 @@ class ViewManager:
         self.mcp = mcp
 
     def adjust_for_large_scale(
-        self, clip_end: float = 100000, orbit_selection: bool = True
+        self, clip_end: float = 100000, _orbit_selection: bool = True
     ) -> Dict:
         """Adjust viewport settings to properly view large-scale objects like Earth.
 
         Args:
             clip_end: The maximum view distance to set for the 3D viewport (default: 100000)
-            orbit_selection: Whether to enable orbit around selection (default: True, but may not work in all Blender versions)
+            _orbit_selection: Whether to enable orbit around selection (default: True, but may not work in all Blender versions)
         """
 
         def generate_code():