amd-gaia 0.14.1__py3-none-any.whl

gaia/mcp/agent_mcp_server.py

@@ -0,0 +1,245 @@
+# Copyright(C) 2024-2025 Advanced Micro Devices, Inc. All rights reserved.
+# SPDX-License-Identifier: MIT
+
+"""
+Generic MCP Server for MCPAgent Subclasses
+Wraps any MCPAgent and exposes it via the MCP Python SDK
+"""
+
+import io
+import json
+import sys
+from typing import Any, Dict, Type
+
+from mcp.server.fastmcp import FastMCP
+
+from gaia.agents.base.mcp_agent import MCPAgent
+from gaia.logger import get_logger
+
+logger = get_logger(__name__)
+
+# Default MCP server configuration
+MCP_DEFAULT_PORT = 8080
+MCP_DEFAULT_HOST = "localhost"
+
+
+class AgentMCPServer:
+    """Generic MCP server that wraps any MCPAgent subclass using the MCP SDK"""
+
+    def __init__(
+        self,
+        agent_class: Type[MCPAgent],
+        name: str = None,
+        port: int = None,
+        host: str = None,
+        verbose: bool = False,
+        agent_params: Dict[str, Any] = None,
+    ):
+        """
+        Initialize MCP server for an agent.
+
+        Args:
+            agent_class: MCPAgent subclass to wrap
+            name: Display name for the server
+            port: Port to listen on (default: 8080)
+            host: Host to bind to (default: localhost)
+            verbose: Enable verbose logging
+            agent_params: Parameters to pass to agent __init__
+        """
+        # Verify agent_class is MCPAgent subclass
+        if not issubclass(agent_class, MCPAgent):
+            raise TypeError(f"{agent_class.__name__} must inherit from MCPAgent")
+
+        # Initialize agent
+        self.agent = agent_class(**(agent_params or {}))
+        self.agent_class = agent_class
+
+        # Server configuration
+        self.name = name or f"GAIA {agent_class.__name__} MCP"
+        self.port = port or MCP_DEFAULT_PORT
+        self.host = host or MCP_DEFAULT_HOST
+        self.verbose = verbose
+
+        # Create FastMCP server
+        server_info = self.agent.get_mcp_server_info()
+        self.mcp = FastMCP(name=server_info.get("name", self.name))
+
+        # Configure server settings (host, port)
+        self.mcp.settings.host = self.host
+        self.mcp.settings.port = self.port
+
+        # Register tools dynamically from agent
+        self._register_agent_tools()
+
+    def _register_agent_tools(self):
+        """Dynamically register agent tools with FastMCP"""
+        tools = self.agent.get_mcp_tool_definitions()
+
+        for tool_def in tools:
+            tool_name = tool_def["name"]
+            tool_description = tool_def.get("description", "")
+            input_schema = tool_def.get("inputSchema", {})
+
+            # Create a wrapper function for this tool
+            # We need to capture tool_name in the closure properly
+            # NOTE: Using **kwargs means FastMCP won't validate parameters,
+            # allowing us to handle both standard and VSCode's kwargs format
+            def create_tool_wrapper(name: str, description: str, verbose: bool):
+                async def tool_wrapper(**kwargs) -> Dict[str, Any]:
+                    """Dynamically generated tool wrapper"""
+                    if verbose:
+                        logger.info("=" * 80)
+                        logger.info(f"[MCP TOOL] Tool call: {name}")
+                        logger.info(f"[MCP TOOL] Raw kwargs type: {type(kwargs)}")
+                        logger.info(f"[MCP TOOL] Raw kwargs: {kwargs}")
+                        try:
+                            pretty_kwargs = json.dumps(kwargs, indent=2)
+                            logger.info(
+                                f"[MCP TOOL] Raw kwargs (pretty):\n{pretty_kwargs}"
+                            )
+                        except Exception as e:
+                            logger.warning(
+                                f"[MCP TOOL] Could not JSON format kwargs: {e}"
+                            )
+
+                    try:
+                        import time
+
+                        start_time = time.time()
+
+                        # Handle VSCode/Copilot kwargs wrapper format
+                        # VSCode sends parameters wrapped in a "kwargs" field
+                        # Can be either a dict object or stringified JSON:
+                        # - {"kwargs": {"param": "value"}}  <- dict format
+                        # - {"kwargs": "{\"param\": \"value\"}"} <- string format
+                        if "kwargs" in kwargs:
+                            kwargs_value = kwargs["kwargs"]
+
+                            if isinstance(kwargs_value, dict):
+                                # Already a dict, just unwrap it
+                                if verbose:
+                                    logger.info(
+                                        f"[MCP] Unwrapped kwargs dict: {kwargs_value}"
+                                    )
+                                kwargs = kwargs_value
+                            elif isinstance(kwargs_value, str):
+                                # Stringified JSON, try to parse it
+                                try:
+                                    parsed = json.loads(kwargs_value)
+                                    if verbose:
+                                        logger.info(
+                                            f"[MCP] Parsed stringified kwargs: {parsed}"
+                                        )
+                                    kwargs = parsed
+                                except json.JSONDecodeError as parse_error:
+                                    logger.warning(
+                                        f"[MCP] Failed to parse kwargs string: {kwargs_value}, error: {parse_error}"
+                                    )
+                                    # Keep original kwargs if parsing fails
+
+                        # Map common parameter variations to what agent expects
+                        # VSCode may send different param names than agent expects
+
+                        # Map VSCode's app_dir to Docker agent's appPath
+                        if "app_dir" in kwargs and "appPath" not in kwargs:
+                            kwargs["appPath"] = kwargs.pop("app_dir")
+                            if verbose:
+                                logger.info(f"[MCP] Mapped app_dir to appPath")
+
+                        # Map other common variations
+                        if "directory" in kwargs and "appPath" not in kwargs:
+                            kwargs["appPath"] = kwargs.pop("directory")
+                            if verbose:
+                                logger.info(f"[MCP] Mapped directory to appPath")
+
+                        if "project_path" in kwargs and "appPath" not in kwargs:
+                            kwargs["appPath"] = kwargs.pop("project_path")
+                            if verbose:
+                                logger.info(f"[MCP] Mapped project_path to appPath")
+
+                        if verbose:
+                            logger.info(f"[MCP TOOL] Final args to agent:")
+                            try:
+                                pretty_final = json.dumps(kwargs, indent=2)
+                                logger.info(f"{pretty_final}")
+                            except Exception:
+                                logger.info(f"{kwargs}")
+                            logger.info("=" * 80)
+
+                        result = self.agent.execute_mcp_tool(name, kwargs)
+
+                        elapsed = time.time() - start_time
+                        if verbose:
+                            logger.info(
+                                f"[MCP TOOL] Tool {name} completed in {elapsed:.2f}s"
+                            )
+
+                        return result
+                    except Exception as e:
+                        logger.error(f"[MCP] Error executing tool {name}: {e}")
+                        if verbose:
+                            import traceback
+
+                            logger.error(f"[MCP] Traceback: {traceback.format_exc()}")
+                        return {"error": str(e), "success": False}
+
+                # Set proper metadata
+                tool_wrapper.__name__ = name
+                tool_wrapper.__doc__ = description
+
+                return tool_wrapper
+
+            # Create the tool function
+            tool_func = create_tool_wrapper(tool_name, tool_description, self.verbose)
+
+            # Register using FastMCP's decorator API
+            # This ensures proper registration using the public API
+            self.mcp.tool()(tool_func)
+
+            if self.verbose:
+                logger.info(f"Registered tool: {tool_name}")
+
+    def start(self):
+        """Start the MCP server with Streamable HTTP transport"""
+        self._print_startup_info()
+
+        try:
+            # Run with streamable-http transport (industry standard)
+            # This automatically serves at /mcp endpoint
+            # Supports both HTTP POST and SSE streaming
+            # Host and port are configured via mcp.settings
+            self.mcp.run(transport="streamable-http")
+        except KeyboardInterrupt:
+            print("\n✅ Server stopped")
+
+    def stop(self):
+        """Stop the MCP server"""
+        # Note: With uvicorn, stopping is handled by KeyboardInterrupt
+        # This method is kept for API compatibility
+        pass
+
+    def _print_startup_info(self):
+        """Print startup banner"""
+        # Fix Windows Unicode
+        if sys.platform == "win32":
+            sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding="utf-8")
+
+        tools = self.agent.get_mcp_tool_definitions()
+
+        print("=" * 60)
+        print(f"🚀 {self.name}")
+        print("=" * 60)
+        print(f"Server: http://{self.host}:{self.port}")
+        print(f"Agent: {self.agent_class.__name__}")
+        print(f"Tools: {len(tools)}")
+        for tool in tools:
+            print(f"  - {tool['name']}: {tool.get('description', 'No description')}")
+        if self.verbose:
+            print(f"\n🔍 Verbose Mode: ENABLED")
+        print("\n📍 MCP Endpoint:")
+        print(f"  http://{self.host}:{self.port}/mcp")
+        print("\n  Supports:")
+        print("    - HTTP POST for requests")
+        print("    - SSE streaming for real-time responses")
+        print("=" * 60)
+        print("\nPress Ctrl+C to stop\n")

gaia/mcp/blender_mcp_client.py

@@ -0,0 +1,138 @@
+# Copyright(C) 2024-2025 Advanced Micro Devices, Inc. All rights reserved.
+# SPDX-License-Identifier: MIT
+
+# This Blender MCP client is a simplified and modified version of the BlenderMCP project from https://github.com/BlenderMCP/blender-mcp
+
+import json
+import logging
+import re
+import socket
+
+from gaia.logger import get_logger
+
+
+class MCPError(Exception):
+    """Exception raised for MCP client errors."""
+
+    pass
+
+
+# MCP client class for tests
+class MCPClient:
+    log = get_logger(__name__)
+
+    def __init__(self, host="localhost", port=9876):
+        self.host = host
+        self.port = port
+        self.log = self.__class__.log  # Use the class-level logger for instances
+        self.log.setLevel(logging.INFO)
+
+    def _enhance_error_message(self, error_message):
+        """Enhance error messages with more helpful information."""
+        # Detect common Python errors and provide better context
+        if "name '" in error_message and "is not defined" in error_message:
+            # Extract variable name from NameError
+            match = re.search(r"name '(\w+)' is not defined", error_message)
+            if match:
+                var_name = match.group(1)
+                return f"Variable '{var_name}' is not defined. Make sure to declare it before use or check for typos."
+
+        # Handle object not found errors
+        if "Object not found:" in error_message:
+            obj_name = error_message.replace("Object not found: ", "")
+            return f"Object '{obj_name}' not found in the scene. It may have been deleted or renamed."
+
+        # Return original message if no enhancement is available
+        return error_message
+
+    def send_command(self, cmd_type, params=None):
+        if params is None:
+            params = {}
+
+        # Create command
+        command = {"type": cmd_type, "params": params}
+
+        self.log.debug(f"Sending command: {cmd_type} with params: {params}")
+
+        # Send command to server
+        try:
+            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+                sock.connect((self.host, self.port))
+                sock.sendall(json.dumps(command).encode("utf-8"))
+
+                # Receive the response
+                response = sock.recv(65536).decode("utf-8")
+
+                # Parse the JSON response
+                parsed_response = json.loads(response)
+
+                if parsed_response["status"] == "error":
+                    error_message = parsed_response.get("message", "Unknown error")
+                    enhanced_message = self._enhance_error_message(error_message)
+                    self.log.error(f"Error response: {error_message}")
+                    raise MCPError(enhanced_message)
+                else:
+                    self.log.debug(f"Response status: {parsed_response['status']}")
+
+                return parsed_response
+        except ConnectionRefusedError:
+            error_msg = "Connection refused. Is the Blender MCP server running?"
+            self.log.error(f"Connection error: {error_msg}")
+            raise MCPError(error_msg)
+        except MCPError:
+            # Re-raise MCPError without wrapping it
+            raise
+        except Exception as e:
+            error_msg = f"Error: {str(e)}"
+            self.log.error(error_msg)
+            raise MCPError(error_msg)
+
+    def execute_code(self, code):
+        self.log.debug(f"Executing code in Blender")
+        return self.send_command("execute_code", {"code": code})
+
+    def get_scene_info(self):
+        self.log.debug(f"Getting scene info")
+        return self.send_command("get_scene_info")
+
+    def create_object(
+        self,
+        type="CUBE",
+        name=None,
+        location=(0, 0, 0),
+        rotation=(0, 0, 0),
+        scale=(1, 1, 1),
+    ):
+        params = {
+            "type": type,
+            "location": location,
+            "rotation": rotation,
+            "scale": scale,
+        }
+        if name:
+            params["name"] = name
+        self.log.debug(f"Creating {type} object{' named ' + name if name else ''}")
+        return self.send_command("create_object", params)
+
+    def modify_object(
+        self, name, location=None, rotation=None, scale=None, visible=None
+    ):
+        params = {"name": name}
+        if location is not None:
+            params["location"] = location
+        if rotation is not None:
+            params["rotation"] = rotation
+        if scale is not None:
+            params["scale"] = scale
+        if visible is not None:
+            params["visible"] = visible
+        self.log.debug(f"Modifying object '{name}'")
+        return self.send_command("modify_object", params)
+
+    def delete_object(self, name):
+        self.log.debug(f"Deleting object '{name}'")
+        return self.send_command("delete_object", {"name": name})
+
+    def get_object_info(self, name):
+        self.log.debug(f"Getting info for object '{name}'")
+        return self.send_command("get_object_info", {"name": name})