@createlex/createlexgenai 1.0.0

package/python/mcp_server_stdio.py

@@ -0,0 +1,4720 @@
+import socket
+import json
+import sys
+import os
+import shutil
+from fastmcp import FastMCP
+import re
+from pathlib import Path
+import time
+from typing import Any, List, Dict, Optional
+
+_CURRENT_DIR = Path(__file__).resolve().parent
+if str(_CURRENT_DIR) not in sys.path:
+    sys.path.insert(0, str(_CURRENT_DIR))
+
+try:
+    from ui_slice_host import auto_slice_ui_mockup_host, has_pillow as host_slice_has_pillow
+except Exception as host_slice_import_error:
+    auto_slice_ui_mockup_host = None
+
+    def host_slice_has_pillow():
+        return False, str(host_slice_import_error)
+
+# THIS FILE WILL RUN OUTSIDE THE UNREAL ENGINE SCOPE,
+# DO NOT IMPORT UNREAL MODULES HERE OR EXECUTE IT IN THE UNREAL ENGINE PYTHON INTERPRETER
+
+# Global context cache for Blueprint analysis and iterative refinement
+_blueprint_context_cache = {
+    "cached_context": None,
+    "cache_timestamp": 0,
+    "cache_blueprint_path": None,
+    "cache_duration": 300,  # 5 minutes cache duration
+    "generation_history": [],  # Track generation attempts for iterative refinement
+    "last_generated_function": None,  # Store last generated function for refinement
+    "validation_results": None  # Store validation results for iteration
+}
+
+# Create a PID file to let the Unreal plugin know this process is running
+def write_pid_file():
+    try:
+        pid = os.getpid()
+        pid_dir = os.path.join(os.path.expanduser("~"), ".unrealgenai")
+        os.makedirs(pid_dir, exist_ok=True)
+        pid_path = os.path.join(pid_dir, "mcp_server.pid")
+        with open(pid_path, "w") as f:
+            f.write(f"{pid}\n8080")  # Store PID and port
+        
+        # Register to delete the PID file on exit
+        import atexit
+        def cleanup_pid_file():
+            try:
+                if os.path.exists(pid_path):
+                    os.remove(pid_path)
+            except:
+                pass
+        atexit.register(cleanup_pid_file)
+        return pid_path
+    except Exception as e:
+        print(f"Failed to write PID file: {e}", file=sys.stderr)
+        return None
+
+# Write PID file on startup
+pid_file = write_pid_file()
+if pid_file:
+    print(f"MCP Server started with PID file at: {pid_file}", file=sys.stderr)
+
+# Create an MCP server
+mcp = FastMCP("UnrealHandshake")
+
+# Context caching and validation utilities
+def get_cached_blueprint_context(force_refresh=False):
+    """Get cached Blueprint context or fetch fresh if needed"""
+    global _blueprint_context_cache
+    
+    current_time = time.time()
+    cache = _blueprint_context_cache
+    
+    # Check if cache is valid and not forced to refresh
+    if (not force_refresh and 
+        cache["cached_context"] and 
+        (current_time - cache["cache_timestamp"]) < cache["cache_duration"]):
+        print(f"Using cached context (age: {current_time - cache['cache_timestamp']:.1f}s)")
+        return cache["cached_context"]
+    
+    # Fetch fresh context
+    try:
+        context_cmd = {
+            "type": "get_blueprint_context",
+            "include_editor_state": True,
+            "include_graph_info": True,
+            "include_selected_nodes": True,
+            "include_open_editors": False
+        }
+        
+        context_response = send_to_unreal(context_cmd)
+        
+        if context_response.get("success"):
+            # Cache the context
+            cache["cached_context"] = context_response
+            cache["cache_timestamp"] = current_time
+            cache["cache_blueprint_path"] = context_response.get("active_blueprint", {}).get("path", "")
+            
+            blueprint_name = context_response.get("active_blueprint", {}).get("name", "Unknown")
+            node_count = len(context_response.get("all_nodes", {}).get("nodes", []))
+            print(f"Context refreshed - Blueprint: {blueprint_name} ({node_count} nodes)")
+            
+            return context_response
+        else:
+            return None
+            
+    except Exception as e:
+        print(f"Error fetching Blueprint context: {e}")
+        return None
+
+def validate_generated_function(implementation_result):
+    """Validate the generated function and identify issues"""
+    validation_result = {
+        "is_valid": True,
+        "issues": [],
+        "suggestions": [],
+        "needs_refinement": False
+    }
+    
+    if not implementation_result.get("success"):
+        validation_result["is_valid"] = False
+        validation_result["issues"].append("Function creation failed")
+        validation_result["needs_refinement"] = True
+    
+    errors = implementation_result.get("errors", [])
+    if errors:
+        validation_result["is_valid"] = False
+        validation_result["issues"].extend(errors)
+        validation_result["needs_refinement"] = True
+        
+        # Analyze error types and suggest fixes
+        for error in errors:
+            if "node connection failed" in error.lower():
+                validation_result["suggestions"].append("Check node pin compatibility and availability")
+            elif "failed to add" in error.lower() and "node" in error.lower():
+                validation_result["suggestions"].append("Verify node type exists in current Unreal Engine version")
+            elif "compilation" in error.lower():
+                validation_result["suggestions"].append("Check Blueprint syntax and node logic")
+    
+    # Check implementation completeness
+    created_nodes = implementation_result.get("created_nodes", [])
+    implementation_steps = implementation_result.get("implementation_steps", [])
+    
+    if len(created_nodes) < 2:
+        validation_result["suggestions"].append("Function seems too simple, consider adding more logic nodes")
+    
+    successful_steps = [step for step in implementation_steps if step.get("success")]
+    if len(successful_steps) < len(implementation_steps) * 0.8:  # Less than 80% success rate
+        validation_result["needs_refinement"] = True
+        validation_result["suggestions"].append("Multiple implementation steps failed, function needs rework")
+    
+    return validation_result
+
+def refine_function_based_on_issues(original_generation, validation_result, context):
+    """Refine function generation based on validation issues and updated context"""
+    
+    # Extract original specification
+    original_spec = original_generation.get("function_specification", {})
+    original_description = original_generation.get("function_description", "")
+    
+    # Create refined specification
+    refined_spec = original_spec.copy()
+    refined_description = original_description
+    
+    # Apply refinements based on issues
+    issues = validation_result.get("issues", [])
+    suggestions = validation_result.get("suggestions", [])
+    
+    # Analyze what currently exists in the Blueprint to avoid duplication
+    existing_functions = []
+    existing_node_types = set()
+    
+    if context and context.get("all_nodes", {}).get("nodes"):
+        for node in context["all_nodes"]["nodes"]:
+            node_class = node.get("class_name", "")
+            node_title = node.get("title", "")
+            existing_node_types.add(node_class)
+            
+            # Look for function calls that might conflict
+            if "Function" in node_class or "Call Function" in node_title:
+                existing_functions.append(node_title)
+    
+    # Check if our function might conflict with existing ones
+    proposed_name = refined_spec.get("function_name", "")
+    if any(proposed_name.lower() in func.lower() for func in existing_functions):
+        # Append iteration number to avoid conflict
+        iteration_num = original_generation.get("refinement_iteration", 0) + 1
+        refined_spec["function_name"] = f"{proposed_name}V{iteration_num}"
+        print(f"Function name conflict detected, renamed to: {refined_spec['function_name']}")
+    
+    # Use existing node patterns from the Blueprint for better compatibility
+    commonly_used_nodes = []
+    if context and context.get("all_nodes", {}).get("nodes"):
+        node_count_map = {}
+        for node in context["all_nodes"]["nodes"]:
+            node_class = node.get("class_name", "")
+            if node_class.startswith("K2Node_"):
+                simple_name = node_class.replace("K2Node_", "").replace("_", " ")
+                node_count_map[simple_name] = node_count_map.get(simple_name, 0) + 1
+        
+        # Get the top 3 most used node types
+        commonly_used_nodes = [node for node, count in sorted(node_count_map.items(), key=lambda x: x[1], reverse=True)[:3]]
+        print(f"Most commonly used nodes in Blueprint: {commonly_used_nodes}")
+    
+    # Refine node suggestions based on errors
+    if any("node connection failed" in issue.lower() for issue in issues):
+        # Simplify connections - use more basic nodes
+        refined_spec["suggested_nodes"] = [
+            node for node in refined_spec.get("suggested_nodes", []) 
+            if node in ["Branch", "Print String", "Set", "Get", "Add", "Multiply", "Greater", "Less"]
+        ]
+        
+        # Add basic execution flow nodes
+        if "Branch" not in refined_spec["suggested_nodes"]:
+            refined_spec["suggested_nodes"].insert(0, "Branch")
+        if "Print String" not in refined_spec["suggested_nodes"]:
+            refined_spec["suggested_nodes"].append("Print String")
+    
+    if any("failed to add" in issue.lower() and "node" in issue.lower() for issue in issues):
+        # Replace complex nodes with basic equivalents
+        node_replacements = {
+            "Launch Character": "Set Actor Location",
+            "Apply Damage": "Set Health",
+            "Spawn Actor from Class": "Create Object",
+            "Play Animation": "Set Animation Mode",
+            "Set Timer by Function Name": "Delay"
+        }
+        
+        new_nodes = []
+        for node in refined_spec.get("suggested_nodes", []):
+            if node in node_replacements:
+                new_nodes.append(node_replacements[node])
+            else:
+                new_nodes.append(node)
+        refined_spec["suggested_nodes"] = new_nodes
+    
+    # Prioritize commonly used nodes from the existing Blueprint
+    if commonly_used_nodes:
+        # Replace some suggested nodes with commonly used ones for better compatibility
+        final_nodes = []
+        
+        # Start with commonly used nodes that make sense
+        for common_node in commonly_used_nodes:
+            if common_node not in ["Event", "Comment"] and len(final_nodes) < 3:  # Skip event nodes and comments
+                final_nodes.append(common_node)
+        
+        # Add some of the original suggestions
+        for suggested_node in refined_spec.get("suggested_nodes", []):
+            if suggested_node not in final_nodes and len(final_nodes) < 6:
+                final_nodes.append(suggested_node)
+        
+        # Ensure we have basic nodes for functionality
+        essential_nodes = ["Branch", "Print String"]
+        for essential in essential_nodes:
+            if essential not in final_nodes and len(final_nodes) < 6:
+                final_nodes.append(essential)
+        
+        refined_spec["suggested_nodes"] = final_nodes
+        print(f"Refined node suggestions (using common Blueprint patterns): {final_nodes}")
+    
+    # Limit complexity for better success rate
+    if len(refined_spec.get("suggested_nodes", [])) > 6:
+        refined_spec["suggested_nodes"] = refined_spec["suggested_nodes"][:6]
+    
+    # Create new generation result with refinements
+    refined_generation = original_generation.copy()
+    refined_generation["function_specification"] = refined_spec
+    refined_generation["refinement_iteration"] = original_generation.get("refinement_iteration", 0) + 1
+    refined_generation["refinement_reason"] = f"Issues found: {', '.join(issues[:3])}"  # First 3 issues
+    
+    # Update implementation plan
+    refined_plan = create_implementation_plan(refined_spec, original_generation.get("context_analysis", {}))
+    refined_generation["implementation_plan"] = refined_plan
+    
+    return refined_generation
+
+# Function to send a message to Unreal Engine via socket
+# Falls back to Python Remote Execution or Web Remote Control if plugin socket unavailable
+def send_to_unreal(command):
+    # Get Unreal Engine port from environment variable, default to 9878 (Unreal Engine's socket server)
+    unreal_port = int(os.environ.get('UNREAL_PORT', '9878'))
+
+    # Try 1: Plugin socket (fastest, full feature support)
+    try:
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+            s.settimeout(5)
+            s.connect(('localhost', unreal_port))
+
+            json_str = json.dumps(command)
+            s.sendall(json_str.encode('utf-8'))
+
+            buffer_size = 8192
+            response_data = b""
+
+            while True:
+                chunk = s.recv(buffer_size)
+                if not chunk:
+                    break
+                response_data += chunk
+
+                try:
+                    json.loads(response_data.decode('utf-8'))
+                    break
+                except json.JSONDecodeError:
+                    continue
+
+            if response_data:
+                return json.loads(response_data.decode('utf-8'))
+            else:
+                return {"success": False, "error": "No response received"}
+    except ConnectionRefusedError:
+        print(f"Plugin socket unavailable (port {unreal_port}), trying fallback backends...", file=sys.stderr)
+    except Exception as e:
+        # For non-connection errors on the plugin socket, still try fallback
+        if "Connection refused" in str(e) or "No connection" in str(e) or "WinError 10061" in str(e):
+            print(f"Plugin socket unavailable, trying fallback backends...", file=sys.stderr)
+        else:
+            print(f"Error sending to Unreal via plugin: {e}", file=sys.stderr)
+            return {"success": False, "error": str(e)}
+
+    # Try 2: Generate native Python and execute via Remote Execution or Web Remote Control
+    return _send_via_fallback(command)
+
+
+def _send_via_fallback(command):
+    """Execute a command via UE's built-in Remote Execution or Web Remote Control."""
+    try:
+        from ue_native_handler import build_handler_script
+    except ImportError:
+        return {"success": False, "error": "Fallback handler not available. Install the CreatelexGenAI plugin or ensure ue_native_handler.py is in the Python path."}
+
+    script = build_handler_script(command)
+
+    # Try Web Remote Control API first (HTTP, simpler)
+    result = _try_web_remote_control(script)
+    if result is not None:
+        return result
+
+    # Try Python Remote Execution (UDP multicast)
+    result = _try_remote_execution(script)
+    if result is not None:
+        return result
+
+    return {
+        "success": False,
+        "error": "No connection to Unreal Engine. The plugin socket, Web Remote Control, and Python Remote Execution are all unavailable. Start UE with at least one enabled."
+    }
+
+
+def _try_web_remote_control(script):
+    """Try to execute a Python script via UE's Web Remote Control HTTP API."""
+    import urllib.request
+    import urllib.error
+
+    port = int(os.environ.get('WEB_REMOTE_PORT', '30010'))
+    url = f"http://127.0.0.1:{port}/remote/object/call"
+
+    payload = json.dumps({
+        "objectPath": "/Script/PythonScriptPlugin.Default__PythonScriptLibrary",
+        "functionName": "ExecutePythonCommandEx",
+        "parameters": {
+            "PythonCommand": script,
+            "ExecutionMode": "ExecuteStatement",
+            "FileExecutionScope": "Public"
+        }
+    }).encode('utf-8')
+
+    try:
+        req = urllib.request.Request(url, data=payload, headers={"Content-Type": "application/json"}, method="PUT")
+        with urllib.request.urlopen(req, timeout=30) as resp:
+            data = json.loads(resp.read().decode('utf-8'))
+            # Try to extract the printed JSON result from output
+            output = str(data.get("ReturnValue", data.get("result", "")))
+            if output:
+                try:
+                    return json.loads(output)
+                except json.JSONDecodeError:
+                    pass
+            return data
+    except urllib.error.URLError:
+        return None
+    except Exception as e:
+        print(f"Web Remote Control failed: {e}", file=sys.stderr)
+        return None
+
+
+def _try_remote_execution(script):
+    """Try to execute a Python script via UE's built-in Remote Execution protocol (UDP/TCP)."""
+    import threading
+    import queue
+
+    MULTICAST_GROUP = '239.0.0.1'
+    MULTICAST_PORT = 6766
+
+    try:
+        import uuid
+        client_id = str(uuid.uuid4())
+    except ImportError:
+        import hashlib
+        client_id = hashlib.md5(str(time.time()).encode()).hexdigest()
+
+    result_queue = queue.Queue()
+
+    # Step 1: Start a TCP server to receive UE's connection
+    tcp_server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    tcp_server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+    tcp_server.settimeout(10)
+    tcp_server.bind(('127.0.0.1', 0))
+    tcp_port = tcp_server.getsockname()[1]
+    tcp_server.listen(1)
+
+    def handle_connection():
+        try:
+            conn, addr = tcp_server.accept()
+            conn.settimeout(30)
+
+            # Send the command
+            cmd_msg = json.dumps({
+                "magic": "ue_py",
+                "version": 1,
+                "type": "command",
+                "source": client_id,
+                "command": script,
+                "unattended": False,
+                "exec_mode": "ExecuteStatement"
+            })
+            conn.sendall(cmd_msg.encode('utf-8'))
+
+            # Receive response
+            response_data = b""
+            while True:
+                try:
+                    chunk = conn.recv(8192)
+                    if not chunk:
+                        break
+                    response_data += chunk
+                    try:
+                        json.loads(response_data.decode('utf-8'))
+                        break
+                    except json.JSONDecodeError:
+                        continue
+                except socket.timeout:
+                    break
+
+            conn.close()
+
+            if response_data:
+                resp = json.loads(response_data.decode('utf-8'))
+                # Extract output from Remote Execution response
+                output_log = resp.get("output_log", [])
+                output_text = ""
+                for entry in output_log:
+                    if isinstance(entry, dict):
+                        output_text += entry.get("message", "") + "\n"
+                    else:
+                        output_text += str(entry) + "\n"
+
+                # Try to parse the output as JSON (our handler prints JSON)
+                for line in output_text.strip().split("\n"):
+                    line = line.strip()
+                    if line.startswith("{"):
+                        try:
+                            result_queue.put(json.loads(line))
+                            return
+                        except json.JSONDecodeError:
+                            pass
+
+                result_queue.put({"success": resp.get("success", False), "output": output_text.strip()})
+            else:
+                result_queue.put(None)
+        except Exception as e:
+            result_queue.put(None)
+        finally:
+            tcp_server.close()
+
+    # Start TCP handler in background thread
+    tcp_thread = threading.Thread(target=handle_connection, daemon=True)
+    tcp_thread.start()
+
+    # Step 2: Send open_connection via UDP multicast
+    try:
+        udp_sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP)
+        udp_sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        udp_sock.settimeout(2)
+
+        open_msg = json.dumps({
+            "magic": "ue_py",
+            "version": 1,
+            "type": "open_connection",
+            "source": client_id,
+            "dest": "",
+            "command_ip": "127.0.0.1",
+            "command_port": tcp_port
+        })
+
+        udp_sock.sendto(open_msg.encode('utf-8'), (MULTICAST_GROUP, MULTICAST_PORT))
+        udp_sock.close()
+    except Exception as e:
+        tcp_server.close()
+        print(f"Remote Execution UDP failed: {e}", file=sys.stderr)
+        return None
+
+    # Step 3: Wait for result
+    tcp_thread.join(timeout=15)
+
+    try:
+        result = result_queue.get_nowait()
+        return result
+    except queue.Empty:
+        return None
+
+def _ensure_dict_response(response):
+    """Normalize Unreal responses to dictionaries for cross-version compatibility."""
+    if isinstance(response, dict):
+        return response
+    if isinstance(response, str):
+        try:
+            return json.loads(response)
+        except json.JSONDecodeError as parse_err:
+            return {"success": False, "error": f"Invalid JSON response: {parse_err}", "raw": response}
+    return {"success": False, "error": "Unsupported response type from Unreal", "raw": repr(response)}
+
+
+_HOST_SLICE_IMPORT_MARKER = "__CREATELEX_HOST_SLICE_IMPORT_RESULT__"
+
+
+def _response_text_blob(response: Dict[str, Any]) -> str:
+    if not isinstance(response, dict):
+        return str(response or "")
+    fields = [
+        response.get("error"),
+        response.get("message"),
+        response.get("details"),
+        response.get("raw"),
+        response.get("output"),
+    ]
+    return " ".join(str(field) for field in fields if field)
+
+
+def _is_unreal_pillow_error(response: Dict[str, Any]) -> bool:
+    text = _response_text_blob(response).lower()
+    if "pillow" not in text:
+        return False
+    return any(
+        token in text
+        for token in [
+            "not available",
+            "install pillow",
+            "no module named",
+            "python imaging library",
+        ]
+    )
+
+
+def _extract_host_import_result(output: str) -> Optional[Dict[str, Any]]:
+    if not output:
+        return None
+    for line in output.splitlines():
+        stripped = line.strip()
+        if not stripped.startswith(_HOST_SLICE_IMPORT_MARKER):
+            continue
+        payload = stripped[len(_HOST_SLICE_IMPORT_MARKER):].strip()
+        if not payload:
+            continue
+        try:
+            parsed = json.loads(payload)
+            if isinstance(parsed, dict):
+                return parsed
+        except json.JSONDecodeError:
+            return None
+    return None
+
+
+def _build_unreal_import_script(slice_entries: List[Dict[str, str]], destination_folder: str) -> str:
+    entries_json = json.dumps(slice_entries, separators=(",", ":"), ensure_ascii=False)
+    return "\n".join(
+        [
+            "import json",
+            "import unreal",
+            f"entries = json.loads({json.dumps(entries_json)})",
+            f"destination_folder = {json.dumps(destination_folder)}",
+            f"result_marker = {json.dumps(_HOST_SLICE_IMPORT_MARKER)}",
+            "asset_tools = unreal.AssetToolsHelpers.get_asset_tools()",
+            "imported = []",
+            "failures = []",
+            "for entry in entries:",
+            "    name = str(entry.get('name') or '').strip()",
+            "    file_path = str(entry.get('file_path') or '').strip()",
+            "    if not name or not file_path:",
+            "        failures.append({'name': name, 'file_path': file_path, 'error': 'Missing name or file_path'})",
+            "        continue",
+            "    task = unreal.AssetImportTask()",
+            "    task.filename = file_path",
+            "    task.destination_path = destination_folder",
+            "    task.destination_name = name",
+            "    task.automated = True",
+            "    task.replace_existing = True",
+            "    task.save = True",
+            "    try:",
+            "        asset_tools.import_asset_tasks([task])",
+            "    except Exception as import_error:",
+            "        failures.append({'name': name, 'file_path': file_path, 'error': str(import_error)})",
+            "        continue",
+            "    imported_paths = [str(path) for path in (task.imported_object_paths or []) if path]",
+            "    asset_path = imported_paths[0] if imported_paths else ''",
+            "    if asset_path:",
+            "        imported.append({'name': name, 'asset_path': asset_path, 'imported_object_paths': imported_paths})",
+            "    else:",
+            "        failures.append({'name': name, 'file_path': file_path, 'error': 'Import succeeded with no object path'})",
+            "result = {'success': len(imported) > 0, 'imported': imported, 'failures': failures}",
+            "print(result_marker + json.dumps(result, separators=(',', ':')))",
+        ]
+    )
+
+
+def _get_manifest_component_slices(manifest: Dict[str, Any]) -> List[Dict[str, Any]]:
+    if not isinstance(manifest, dict):
+        return []
+    slices = manifest.get("slices", [])
+    if not isinstance(slices, list):
+        return []
+    return [
+        slice_info
+        for slice_info in slices
+        if isinstance(slice_info, dict) and str(slice_info.get("kind") or "").lower() != "full_mockup"
+    ]
+
+
+def _manifest_component_count(manifest: Dict[str, Any]) -> int:
+    return len(_get_manifest_component_slices(manifest))
+
+
+def _should_retry_aggressive_slice(manifest: Dict[str, Any]) -> bool:
+    # If "auto" effectively produced only a background/full-image result, force one aggressive retry.
+    return _manifest_component_count(manifest) <= 1
+
+
+def _pick_better_slice_response(
+    primary_response: Dict[str, Any],
+    aggressive_response: Dict[str, Any],
+) -> Dict[str, Any]:
+    primary_manifest = primary_response.get("manifest", {}) if isinstance(primary_response, dict) else {}
+    aggressive_manifest = aggressive_response.get("manifest", {}) if isinstance(aggressive_response, dict) else {}
+    if _manifest_component_count(aggressive_manifest) > _manifest_component_count(primary_manifest):
+        aggressive_response["auto_retry_aggressive"] = True
+        aggressive_response["retry_reason"] = (
+            "Initial auto segmentation yielded too few component slices; aggressive retry selected."
+        )
+        return aggressive_response
+    return primary_response
+
+
+def _run_host_slice_import(manifest: Dict[str, Any], destination_folder: str) -> Dict[str, Any]:
+    slices = manifest.get("slices", []) if isinstance(manifest, dict) else []
+    if not isinstance(slices, list) or not slices:
+        return {"success": False, "error": "Host slicing manifest is empty."}
+
+    slice_entries: List[Dict[str, str]] = []
+    for slice_info in slices:
+        if not isinstance(slice_info, dict):
+            continue
+        name = str(slice_info.get("name") or "").strip()
+        file_path = str(slice_info.get("file_path") or "").strip()
+        if name and file_path:
+            slice_entries.append({"name": name, "file_path": file_path})
+
+    if not slice_entries:
+        return {"success": False, "error": "Host slicing produced no valid files to import."}
+
+    script = _build_unreal_import_script(slice_entries, destination_folder)
+    import_response = _ensure_dict_response(send_to_unreal({"type": "execute_python", "script": script}))
+    if not import_response.get("success"):
+        return {
+            "success": False,
+            "error": f"Failed to import host-generated slices in Unreal: {_response_text_blob(import_response)}",
+        }
+
+    import_result = _extract_host_import_result(import_response.get("output", ""))
+    if not import_result:
+        return {
+            "success": False,
+            "error": "Unreal import script ran, but no parseable import result marker was returned.",
+            "output": import_response.get("output", ""),
+        }
+
+    imported_map = {
+        str(item.get("name")): str(item.get("asset_path"))
+        for item in import_result.get("imported", [])
+        if isinstance(item, dict) and item.get("name") and item.get("asset_path")
+    }
+
+    imported_count = 0
+    for slice_info in slices:
+        if not isinstance(slice_info, dict):
+            continue
+        asset_path = imported_map.get(str(slice_info.get("name")))
+        if asset_path:
+            slice_info["asset_path"] = asset_path
+            imported_count += 1
+
+    if imported_count <= 0:
+        return {
+            "success": False,
+            "error": "Host slices were generated but no assets were imported into Unreal.",
+            "import_result": import_result,
+        }
+
+    non_fallback_assets = [
+        slice_info.get("asset_path")
+        for slice_info in slices
+        if isinstance(slice_info, dict) and slice_info.get("asset_path") and not slice_info.get("is_fallback")
+    ]
+    any_assets = [
+        slice_info.get("asset_path")
+        for slice_info in slices
+        if isinstance(slice_info, dict) and slice_info.get("asset_path")
+    ]
+    manifest["background_asset_path"] = (
+        non_fallback_assets[0] if non_fallback_assets else (any_assets[0] if any_assets else "")
+    )
+
+    return {
+        "success": True,
+        "imported_count": imported_count,
+        "import_result": import_result,
+        "background_asset_path": manifest.get("background_asset_path", ""),
+    }
+
+
+def _run_auto_slice_with_fallback(
+    source_image_path: str,
+    destination_folder: str,
+    base_name: str,
+    max_slices: int,
+    min_component_area_ratio: float,
+    background_tolerance: int,
+    slice_mode: str,
+    include_full_image: bool,
+    enable_chroma_key: bool = True,
+    chroma_tolerance: int = 24,
+    enable_host_fallback: bool = True,
+) -> Dict[str, Any]:
+    command = {
+        "type": "auto_slice_ui_mockup",
+        "source_image_path": source_image_path,
+        "destination_folder": destination_folder,
+        "base_name": base_name,
+        "max_slices": max_slices,
+        "min_component_area_ratio": min_component_area_ratio,
+        "background_tolerance": background_tolerance,
+        "slice_mode": slice_mode,
+        "include_full_image": include_full_image,
+        "enable_chroma_key": enable_chroma_key,
+        "chroma_tolerance": chroma_tolerance,
+    }
+
+    unreal_response = _ensure_dict_response(send_to_unreal(command))
+    if unreal_response.get("success"):
+        if slice_mode == "auto":
+            initial_manifest = unreal_response.get("manifest", {})
+            if _should_retry_aggressive_slice(initial_manifest):
+                aggressive_command = dict(command)
+                aggressive_command["slice_mode"] = "aggressive"
+                aggressive_response = _ensure_dict_response(send_to_unreal(aggressive_command))
+                if aggressive_response.get("success"):
+                    return _pick_better_slice_response(unreal_response, aggressive_response)
+        return unreal_response
+    if not enable_host_fallback:
+        return unreal_response
+    if not _is_unreal_pillow_error(unreal_response):
+        return unreal_response
+
+    if auto_slice_ui_mockup_host is None:
+        return {
+            "success": False,
+            "error": (
+                "Unreal auto-slice failed because Pillow is missing, and host fallback module is unavailable. "
+                f"Original error: {_response_text_blob(unreal_response)}"
+            ),
+        }
+
+    host_has_pillow, host_pillow_error = host_slice_has_pillow()
+    if not host_has_pillow:
+        return {
+            "success": False,
+            "error": (
+                "Unreal auto-slice failed because Pillow is missing, and host fallback also lacks Pillow. "
+                f"Host import error: {host_pillow_error}"
+            ),
+        }
+
+    host_result = auto_slice_ui_mockup_host(
+        source_image_path=source_image_path,
+        destination_folder=destination_folder,
+        base_name=base_name,
+        max_slices=max_slices,
+        min_component_area_ratio=min_component_area_ratio,
+        background_tolerance=background_tolerance,
+        include_full_image=include_full_image,
+        slice_mode=slice_mode,
+        enable_chroma_key=enable_chroma_key,
+        chroma_tolerance=chroma_tolerance,
+    )
+
+    temp_dirs = set()
+    if isinstance(host_result, dict) and host_result.get("temp_dir"):
+        temp_dirs.add(str(host_result.get("temp_dir")))
+    try:
+        if not isinstance(host_result, dict) or not host_result.get("success"):
+            host_error = (
+                host_result.get("error", "Unknown host slicing error.")
+                if isinstance(host_result, dict)
+                else "Unknown host slicing error."
+            )
+            return {
+                "success": False,
+                "error": (
+                    "Unreal auto-slice failed because Pillow is missing, and host fallback failed. "
+                    f"Unreal error: {_response_text_blob(unreal_response)} Host error: {host_error}"
+                ),
+            }
+
+        if slice_mode == "auto":
+            initial_manifest = host_result.get("manifest", {}) if isinstance(host_result, dict) else {}
+            if _should_retry_aggressive_slice(initial_manifest):
+                aggressive_host_result = auto_slice_ui_mockup_host(
+                    source_image_path=source_image_path,
+                    destination_folder=destination_folder,
+                    base_name=base_name,
+                    max_slices=max_slices,
+                    min_component_area_ratio=min_component_area_ratio,
+                    background_tolerance=background_tolerance,
+                    include_full_image=include_full_image,
+                    slice_mode="aggressive",
+                    enable_chroma_key=enable_chroma_key,
+                    chroma_tolerance=chroma_tolerance,
+                )
+                if isinstance(aggressive_host_result, dict) and aggressive_host_result.get("temp_dir"):
+                    temp_dirs.add(str(aggressive_host_result.get("temp_dir")))
+                if isinstance(aggressive_host_result, dict) and aggressive_host_result.get("success"):
+                    host_result = _pick_better_slice_response(host_result, aggressive_host_result)
+
+        manifest = host_result.get("manifest")
+        if not isinstance(manifest, dict):
+            return {"success": False, "error": "Host fallback returned no valid manifest."}
+
+        import_result = _run_host_slice_import(manifest, destination_folder)
+        if not import_result.get("success"):
+            return {
+                "success": False,
+                "error": (
+                    "Host slicing succeeded but Unreal import failed during fallback. "
+                    f"{import_result.get('error', 'Unknown import error.')}"
+                ),
+                "fallback_reason": _response_text_blob(unreal_response),
+                "host_import_result": import_result.get("import_result"),
+            }
+
+        return {
+            "success": True,
+            "message": (
+                f"Generated and imported {import_result.get('imported_count', 0)} texture assets via host fallback."
+            ),
+            "slice_count": int(host_result.get("slice_count", import_result.get("imported_count", 0))),
+            "background_asset_path": import_result.get("background_asset_path", ""),
+            "segmentation_mode": host_result.get("segmentation_mode", ""),
+            "segmentation_metrics": host_result.get("segmentation_metrics", {}),
+            "manifest": manifest,
+            "host_fallback_used": True,
+            "fallback_reason": _response_text_blob(unreal_response),
+        }
+    finally:
+        for temp_dir in temp_dirs:
+            if temp_dir and os.path.isdir(temp_dir):
+                try:
+                    shutil.rmtree(temp_dir, ignore_errors=True)
+                except Exception:
+                    pass
+
+
+def _collect_widget_nodes(hierarchy_node: Optional[Dict[str, Any]], out_nodes: List[Dict[str, str]]) -> None:
+    if not isinstance(hierarchy_node, dict):
+        return
+    widget_name = str(hierarchy_node.get("name") or "").strip()
+    widget_class = str(hierarchy_node.get("class") or "").strip()
+    if widget_name:
+        out_nodes.append({"name": widget_name, "class": widget_class})
+
+    children = hierarchy_node.get("children", [])
+    if not isinstance(children, list):
+        return
+    for child in children:
+        child_obj = child
+        if isinstance(child, dict) and "Object" in child and isinstance(child.get("Object"), dict):
+            child_obj = child.get("Object")
+        _collect_widget_nodes(child_obj, out_nodes)
+
+
+def _is_panel_class_name(widget_class_name: str) -> bool:
+    class_lc = (widget_class_name or "").lower()
+    return any(
+        token in class_lc
+        for token in [
+            "panel",
+            "canvas",
+            "verticalbox",
+            "horizontalbox",
+            "overlay",
+            "grid",
+            "wrapbox",
+            "scrollbox",
+            "sizebox",
+            "border",
+            "namedslot",
+            "widgetswitcher",
+        ]
+    )
+
+
+def _is_button_like_slice_manifest_entry(slice_info: Dict[str, Any], manifest: Dict[str, Any]) -> bool:
+    if not isinstance(slice_info, dict):
+        return False
+
+    kind = str(slice_info.get("kind") or "").lower()
+    label = str(slice_info.get("label") or "").lower()
+    name = str(slice_info.get("name") or "").lower()
+    if "button" in kind or "button" in label or "button" in name:
+        return True
+
+    source_width = float(manifest.get("source_width") or 0.0)
+    source_height = float(manifest.get("source_height") or 0.0)
+    bbox = slice_info.get("bbox", [])
+    if (
+        source_width <= 0.0
+        or source_height <= 0.0
+        or not isinstance(bbox, list)
+        or len(bbox) != 4
+    ):
+        return False
+
+    try:
+        min_x, min_y, max_x, max_y = [float(value) for value in bbox]
+    except (TypeError, ValueError):
+        return False
+
+    width = max(1.0, max_x - min_x + 1.0)
+    height = max(1.0, max_y - min_y + 1.0)
+    width_ratio = width / source_width
+    height_ratio = height / source_height
+    area_ratio = (width * height) / max(1.0, source_width * source_height)
+    center_y_ratio = ((min_y + max_y) * 0.5) / source_height
+    aspect_ratio = width / max(1.0, height)
+
+    return (
+        width_ratio >= 0.15
+        and width_ratio <= 0.92
+        and height_ratio >= 0.03
+        and height_ratio <= 0.25
+        and area_ratio <= 0.20
+        and center_y_ratio >= 0.40
+        and aspect_ratio >= 1.5
+    )
+
+
+def _button_slice_priority(slice_info: Dict[str, Any], manifest: Dict[str, Any]) -> tuple:
+    kind = str(slice_info.get("kind") or "").lower()
+    explicit_priority = 0
+    if kind == "button_primary":
+        explicit_priority = 3
+    elif kind == "button_secondary":
+        explicit_priority = 2
+    elif "button" in kind:
+        explicit_priority = 1
+
+    area = 0.0
+    try:
+        area = float(slice_info.get("area") or 0.0)
+    except (TypeError, ValueError):
+        area = 0.0
+
+    is_heuristic_button = 1 if _is_button_like_slice_manifest_entry(slice_info, manifest) else 0
+    return (explicit_priority, is_heuristic_button, area)
+
+
+def _is_background_like_slice_manifest_entry(slice_info: Dict[str, Any]) -> bool:
+    if not isinstance(slice_info, dict):
+        return False
+    kind = str(slice_info.get("kind") or "").lower()
+    label = str(slice_info.get("label") or "").lower()
+    return kind in {"full_mockup", "panel_main", "header"} or any(
+        token in kind or token in label
+        for token in ["background", "panel", "header", "full"]
+    )
+
+
+def _preferred_widget_base_name(slice_info: Dict[str, Any], manifest: Dict[str, Any]) -> str:
+    kind = str(slice_info.get("kind") or "").lower()
+    label = str(slice_info.get("label") or "").lower()
+    if _is_button_like_slice_manifest_entry(slice_info, manifest):
+        if "primary" in kind or "primary" in label:
+            return "PrimaryButton"
+        if "secondary" in kind or "secondary" in label:
+            return "SecondaryButton"
+        return "ActionButton"
+    if _is_background_like_slice_manifest_entry(slice_info):
+        if "header" in kind or "header" in label:
+            return "HeaderImage"
+        if "panel" in kind or "panel" in label:
+            return "MainPanelImage"
+        return "BackgroundImage"
+    if "icon_left" in kind:
+        return "LeftIconImage"
+    if "icon_right" in kind:
+        return "RightIconImage"
+    if "icon" in kind or "icon" in label:
+        return "IconImage"
+    if "star" in kind or "star" in label:
+        return "StarImage"
+    return "SliceImage"
+
+
+def _make_unique_widget_name(base_name: str, existing_names: set) -> str:
+    candidate = base_name
+    suffix = 1
+    while candidate in existing_names:
+        suffix += 1
+        candidate = f"{base_name}_{suffix}"
+    return candidate
+
+
+def _ensure_slice_target_widgets_for_manifest(
+    user_widget_path: str,
+    manifest: Dict[str, Any],
+    max_auto_components: int = 12,
+    max_auto_buttons: int = 3,
+) -> Dict[str, Any]:
+    if not isinstance(manifest, dict):
+        return {"success": False, "error": "Invalid manifest for target widget provisioning."}
+
+    hierarchy_response = _ensure_dict_response(
+        send_to_unreal({"type": "get_widget_hierarchy", "user_widget_path": user_widget_path})
+    )
+    if not hierarchy_response.get("success"):
+        return {
+            "success": False,
+            "error": (
+                "Failed to inspect widget hierarchy before target provisioning: "
+                f"{hierarchy_response.get('error', 'Unknown error')}"
+            ),
+        }
+
+    hierarchy_root = hierarchy_response.get("hierarchy")
+    widget_nodes: List[Dict[str, str]] = []
+    _collect_widget_nodes(hierarchy_root, widget_nodes)
+
+    existing_names = {node.get("name", "") for node in widget_nodes if node.get("name")}
+    existing_image_names = [
+        node.get("name", "")
+        for node in widget_nodes
+        if "image" in (node.get("class", "").lower())
+    ]
+    existing_button_names = [
+        node.get("name", "")
+        for node in widget_nodes
+        if "button" in (node.get("class", "").lower())
+    ]
+    background_like_images = [
+        name
+        for name in existing_image_names
+        if any(token in name.lower() for token in ["background", "bg", "frame", "panel", "root"])
+    ]
+    component_image_budget = max(0, len(existing_image_names) - len(background_like_images))
+
+    root_name = ""
+    root_class = ""
+    if isinstance(hierarchy_root, dict):
+        root_name = str(hierarchy_root.get("name") or "").strip()
+        root_class = str(hierarchy_root.get("class") or "").strip()
+    parent_widget_name = root_name if (root_name and _is_panel_class_name(root_class)) else ""
+
+    slices = manifest.get("slices", [])
+    if not isinstance(slices, list) or not slices:
+        return {"success": True, "added": [], "message": "No slices in manifest."}
+
+    component_slices = [
+        slice_info
+        for slice_info in slices
+        if isinstance(slice_info, dict) and str(slice_info.get("kind") or "").lower() != "full_mockup"
+    ]
+    component_slices.sort(
+        key=lambda entry: float(entry.get("area", 0) or 0),
+        reverse=True,
+    )
+    if max_auto_components > 0:
+        component_slices = component_slices[:max_auto_components]
+
+    add_results = []
+    add_failures = []
+
+    def add_widget(widget_type: str, base_name: str) -> Optional[str]:
+        nonlocal add_results, add_failures
+        unique_name = _make_unique_widget_name(base_name, existing_names)
+        add_command = {
+            "type": "add_widget_to_user_widget",
+            "user_widget_path": user_widget_path,
+            "widget_type": widget_type,
+            "widget_name": unique_name,
+            "parent_widget_name": parent_widget_name,
+        }
+        add_response = _ensure_dict_response(send_to_unreal(add_command))
+        if add_response.get("success"):
+            actual_name = str(add_response.get("widget_name") or unique_name)
+            existing_names.add(actual_name)
+            add_results.append({"widget_type": widget_type, "widget_name": actual_name})
+            return actual_name
+        add_failures.append(
+            {
+                "widget_type": widget_type,
+                "requested_name": unique_name,
+                "error": add_response.get("error", "Unknown error"),
+            }
+        )
+        return None
+
+    if not existing_image_names:
+        background_name = "BackgroundImage"
+        add_widget("Image", background_name)
+        existing_image_names = [entry["widget_name"] for entry in add_results if entry["widget_type"] == "Image"]
+
+    created_button_count = 0
+    for slice_info in component_slices:
+        is_button_slice = _is_button_like_slice_manifest_entry(slice_info, manifest)
+        if is_button_slice:
+            if existing_button_names:
+                existing_button_names.pop(0)
+                continue
+            if created_button_count >= max_auto_buttons:
+                continue
+            base_name = _preferred_widget_base_name(slice_info, manifest)
+            created_name = add_widget("Button", base_name)
+            if created_name:
+                created_button_count += 1
+            continue
+
+        if component_image_budget > 0:
+            component_image_budget -= 1
+            continue
+        base_name = _preferred_widget_base_name(slice_info, manifest)
+        created_name = add_widget("Image", base_name)
+        if created_name:
+            component_image_budget += 0
+
+    return {
+        "success": len(add_failures) == 0,
+        "added": add_results,
+        "failures": add_failures,
+        "existing_image_count": len(existing_image_names),
+        "existing_button_count": len(
+            [
+                node.get("name", "")
+                for node in widget_nodes
+                if "button" in (node.get("class", "").lower())
+            ]
+        ),
+        "parent_widget_name": parent_widget_name,
+    }
+
+
+def _ensure_button_widgets_for_manifest(
+    user_widget_path: str,
+    manifest: Dict[str, Any],
+    max_auto_buttons: int = 2,
+) -> Dict[str, Any]:
+    if not isinstance(manifest, dict):
+        return {"success": False, "error": "Invalid manifest for button provisioning."}
+    if max_auto_buttons <= 0:
+        return {"success": True, "added": [], "message": "Button auto-provisioning disabled."}
+
+    hierarchy_response = _ensure_dict_response(
+        send_to_unreal({"type": "get_widget_hierarchy", "user_widget_path": user_widget_path})
+    )
+    if not hierarchy_response.get("success"):
+        return {
+            "success": False,
+            "error": (
+                f"Failed to inspect widget hierarchy before button provisioning: "
+                f"{hierarchy_response.get('error', 'Unknown error')}"
+            ),
+        }
+
+    hierarchy_root = hierarchy_response.get("hierarchy")
+    widget_nodes: List[Dict[str, str]] = []
+    _collect_widget_nodes(hierarchy_root, widget_nodes)
+
+    existing_names = {node.get("name", "") for node in widget_nodes if node.get("name")}
+    existing_button_names = [
+        node.get("name", "")
+        for node in widget_nodes
+        if "button" in (node.get("class", "").lower())
+    ]
+
+    slices = manifest.get("slices", [])
+    if not isinstance(slices, list) or not slices:
+        return {"success": True, "added": [], "message": "No slices in manifest."}
+
+    button_candidates = [
+        slice_info
+        for slice_info in slices
+        if isinstance(slice_info, dict)
+        and str(slice_info.get("kind") or "").lower() != "full_mockup"
+        and _is_button_like_slice_manifest_entry(slice_info, manifest)
+    ]
+    if not button_candidates:
+        return {"success": True, "added": [], "message": "No button-like slices detected."}
+
+    button_candidates.sort(
+        key=lambda entry: _button_slice_priority(entry, manifest),
+        reverse=True,
+    )
+    desired_button_count = min(max_auto_buttons, len(button_candidates))
+    if len(existing_button_names) >= desired_button_count:
+        return {
+            "success": True,
+            "added": [],
+            "message": (
+                f"Button widgets already present ({len(existing_button_names)}), no provisioning needed."
+            ),
+        }
+
+    root_name = ""
+    root_class = ""
+    if isinstance(hierarchy_root, dict):
+        root_name = str(hierarchy_root.get("name") or "").strip()
+        root_class = str(hierarchy_root.get("class") or "").strip()
+    parent_widget_name = root_name if (root_name and _is_panel_class_name(root_class)) else ""
+
+    preferred_names = ["PrimaryButton", "SecondaryButton", "TertiaryButton", "QuaternaryButton"]
+    added = []
+    provision_failures = []
+    needed = max(0, desired_button_count - len(existing_button_names))
+    for index in range(needed):
+        base_name = preferred_names[index] if index < len(preferred_names) else f"AutoButton{index + 1}"
+        candidate_name = base_name
+        suffix = 1
+        while candidate_name in existing_names:
+            suffix += 1
+            candidate_name = f"{base_name}_{suffix}"
+
+        add_command = {
+            "type": "add_widget_to_user_widget",
+            "user_widget_path": user_widget_path,
+            "widget_type": "Button",
+            "widget_name": candidate_name,
+            "parent_widget_name": parent_widget_name,
+        }
+        add_response = _ensure_dict_response(send_to_unreal(add_command))
+        if add_response.get("success"):
+            actual_name = str(add_response.get("widget_name") or candidate_name)
+            existing_names.add(actual_name)
+            added.append(actual_name)
+        else:
+            provision_failures.append(
+                {
+                    "requested_name": candidate_name,
+                    "error": add_response.get("error", "Unknown error"),
+                }
+            )
+
+    return {
+        "success": len(provision_failures) == 0,
+        "added": added,
+        "failures": provision_failures,
+        "existing_button_count": len(existing_button_names),
+        "desired_button_count": desired_button_count,
+        "parent_widget_name": parent_widget_name,
+    }
+
+
+def _coerce_numeric_list(value, expected_length: Optional[int] = None) -> List[float]:
+    if value is None:
+        return []
+
+    if isinstance(value, (list, tuple)):
+        result = []
+        for item in value:
+            try:
+                result.append(float(item))
+            except (TypeError, ValueError):
+                return []
+        return result
+
+    if isinstance(value, str):
+        stripped = value.strip()
+        if not stripped:
+            return []
+
+        try:
+            parsed = json.loads(stripped)
+            return _coerce_numeric_list(parsed, expected_length)
+        except json.JSONDecodeError:
+            pass
+
+        stripped = stripped.strip("[]()")
+        if not stripped:
+            return []
+        tokens = re.split(r"[\s,;]+", stripped)
+        result = []
+        for token in tokens:
+            if not token:
+                continue
+            try:
+                result.append(float(token))
+            except ValueError:
+                return []
+        return result
+
+    return []
+
+def _ensure_vector(value, fallback: Optional[List[float]] = None) -> List[float]:
+    vector = _coerce_numeric_list(value, expected_length=3)
+    if len(vector) == 3:
+        return vector
+    return [0.0, 0.0, 0.0] if fallback is None else fallback
+
+def _ensure_two_d(value, fallback: Optional[List[float]] = None) -> List[float]:
+    vector = _coerce_numeric_list(value, expected_length=2)
+    if len(vector) == 2:
+        return vector
+    return [0.0, 0.0] if fallback is None else fallback
+
+@mcp.tool()
+def how_to_use() -> str:
+    """Hey LLM, this grabs the how_to_use.md from knowledge_base—it's your cheat sheet for running Unreal with this MCP. Fetch it at the start of a new chat session to get the lowdown on quirks and how shit works."""
+    try:
+        current_dir = Path(__file__).parent
+        md_file_path = current_dir / "knowledge_base" / "how_to_use.md"
+        if not md_file_path.exists():
+            return "Error: how_to_use.md not found in knowledge_base subfolder."
+        with open(md_file_path, "r", encoding="utf-8") as md_file:
+            return md_file.read()
+    except Exception as e:
+        return f"Error loading how_to_use.md: {str(e)}—fix your shit."
+
+# Define basic tools for Claude to call
+@mcp.tool()
+def handshake_test(message: str) -> str:
+    """Send a handshake message to Unreal Engine"""
+    try:
+        command = {
+            "type": "handshake",
+            "message": message
+        }
+        response = send_to_unreal(command)
+        if response.get("success"):
+            return f"Handshake successful: {response['message']}"
+        else:
+            return f"Handshake failed: {response.get('error', 'Unknown error')}"
+    except Exception as e:
+        return f"Error communicating with Unreal: {str(e)}"
+
+@mcp.tool()
+def execute_python_script(script: str) -> str:
+    """
+    Execute a Python script within Unreal Engine's Python interpreter.
+    Args:
+        script: A string containing the Python code to execute in Unreal Engine.
+    Returns:
+        Message indicating success, failure, or a request for confirmation.
+    Note:
+        This tool sends the script to Unreal Engine, where it is executed via a temporary file using Unreal's internal Python execution system (similar to GEngine->Exec).
+        This method is stable but may not handle Blueprint-specific APIs as seamlessly as direct Python API calls.
+        For Blueprint manipulation, consider using dedicated tools like `add_node_to_blueprint` or ensuring the script uses stable `unreal` module functions.
+        Use this tool for Python script execution instead of `execute_unreal_command` with 'py' commands.
+    """
+    try:
+        if is_potentially_destructive(script):
+            return ("This script appears to involve potentially destructive actions (e.g., deleting or saving files) "
+                    "that were not explicitly requested. Please confirm if you want to proceed by saying 'Yes, execute it' "
+                    "or modify your request to explicitly allow such actions.")
+        
+        command = {
+            "type": "execute_python",
+            "script": script
+        }
+        response = send_to_unreal(command)
+        if response.get("success"):
+            output = response.get("output", "No output returned")
+            return f"Script executed successfully. Output: {output}"
+        else:
+            error = response.get("error", "Unknown error")
+            output = response.get("output", "")
+            if output:
+                error += f"\n\nPartial output before error: {output}"
+            return f"Failed to execute script: {response.get('error', 'Unknown error')}"
+    except Exception as e:
+        return f"Error sending script to Unreal: {str(e)}"
+
+@mcp.tool()
+def execute_unreal_command(command: str) -> str:
+    """
+    Execute an Unreal Engine command-line (CMD) command.
+    Args:
+        command: A string containing the Unreal Engine command to execute (e.g., "obj list", "stat fps").
+    Returns:
+        Message indicating success or failure, including any output or errors.
+    Note:
+        This tool executes commands directly in Unreal Engine's command system, similar to the editor's console.
+        It is intended for built-in editor commands (e.g., "stat fps", "obj list") and not for running Python scripts.
+        Do not use this tool with 'py' commands (e.g., "py script.py"); instead, use `execute_python_script` for Python execution,
+        which provides dedicated safety checks and output handling.
+        Output capture is limited; for detailed output, consider wrapping the command in a Python script with `execute_python_script`.
+    """
+    try:
+        # Check if the command is attempting to run a Python script
+        if command.strip().lower().startswith("py "):
+            return (
+                "Error: Use `execute_python_script` to run Python scripts instead of `execute_unreal_command` with 'py' commands. "
+                "For example, use `execute_python_script(script='your_code_here')` for Python execution.")
+        
+        # Check for potentially destructive commands
+        destructive_keywords = ["delete", "save", "quit", "exit", "restart"]
+        if any(keyword in command.lower() for keyword in destructive_keywords):
+            return ("This command appears to involve potentially destructive actions (e.g., deleting or saving). "
+                    "Please confirm by saying 'Yes, execute it' or explicitly request such actions.")
+        
+        command_dict = {
+            "type": "execute_unreal_command",
+            "command": command
+        }
+        response = send_to_unreal(command_dict)
+        if response.get("success"):
+            output = response.get("output", "Command executed with no detailed output returned")
+            return f"Command '{command}' executed successfully. Output: {output}"
+        else:
+            return f"Failed to execute command '{command}': {response.get('error', 'Unknown error')}"
+    except Exception as e:
+        return f"Error sending command to Unreal: {str(e)}"
+
+#
+# Basic Object Commands
+#
+
+@mcp.tool()
+def spawn_object(actor_class: str, location: Optional[List[float]] = None, rotation: Optional[List[float]] = None, scale: Optional[List[float]] = None, actor_label: Optional[str] = None) -> str:
+    """
+    Spawn an object in the Unreal Engine level
+    Args:
+        actor_class: For basic shapes, use: "Cube", "Sphere", "Cylinder", or "Cone".
+                    For other actors, use class name like "PointLight" or full path.
+        location: [X, Y, Z] coordinates
+        rotation: [Pitch, Yaw, Roll] in degrees
+        scale: [X, Y, Z] scale factors
+        actor_label: Optional custom name for the actor
+    Returns:
+        Message indicating success or failure
+    """
+    location = _ensure_vector(location, [0.0, 0.0, 0.0])
+    rotation = _ensure_vector(rotation, [0.0, 0.0, 0.0])
+    scale = _ensure_vector(scale, [1.0, 1.0, 1.0])
+
+    command = {
+        "type": "spawn",
+        "actor_class": actor_class,
+        "location": location,
+        "rotation": rotation,
+        "scale": scale,
+        "actor_label": actor_label
+    }
+    response = send_to_unreal(command)
+    if response.get("success"):
+        return f"Successfully spawned {actor_class}" + (f" with label '{actor_label}'" if actor_label else "")
+    else:
+        error = response.get('error', 'Unknown error')
+        # Add hint for Claude to understand what went wrong
+        if "not found" in error:
+            hint = "\nHint: For basic shapes, use 'Cube', 'Sphere', 'Cylinder', or 'Cone'. For other actors, try using '/Script/Engine.PointLight' format."
+            error += hint
+        return f"Failed to spawn object: {error}"
+
+@mcp.tool()
+def edit_component_property(blueprint_path: str, component_name: str, property_name: str, value: str, is_scene_actor: bool = False, actor_name: str = "") -> str:
+    """
+    Edit a property of a component in a Blueprint or scene actor.
+    Args:
+        blueprint_path: Path to the Blueprint (e.g., "/Game/FlappyBird/BP_FlappyBird") or "" for scene actors
+        component_name: Name of the component (e.g., "BirdMesh", "RootComponent")
+        property_name: Name of the property to edit (e.g., "StaticMesh", "RelativeLocation")
+        value: New value as a string (e.g., "'/Engine/BasicShapes/Sphere.Sphere'", "100,200,300")
+        is_scene_actor: If True, edit a component on a scene actor (default: False)
+        actor_name: Name of the actor in the scene (required if is_scene_actor is True, e.g., "Cube_1")
+    Returns:
+        Message indicating success or failure, with optional property suggestions if the property is not found.
+    Capabilities:
+        - Set component properties in Blueprints (e.g., StaticMesh, bSimulatePhysics).
+        - Modify scene actor components (e.g., position, rotation, scale, material).
+        - Supports scalar types (double, int, bool), objects (e.g., materials), and vectors/rotators (e.g., "100,200,300" for FVector). Note: UE 5.6 uses double for numeric operations.
+        - Examples:
+          - Set a mesh: edit_component_property("/Game/FlappyBird/BP_FlappyBird", "BirdMesh", "StaticMesh", "'/Engine/BasicShapes/Sphere.Sphere'")
+          - Move an actor: edit_component_property("", "RootComponent", "RelativeLocation", "100,200,300", True, "Cube_1")
+          - Rotate an actor: edit_component_property("", "RootComponent", "RelativeRotation", "0,90,0", True, "Cube_1")
+          - Scale an actor: edit_component_property("", "RootComponent", "RelativeScale3D", "2,2,2", True, "Cube_1")
+          - Enable physics: edit_component_property("/Game/FlappyBird/BP_FlappyBird", "BirdMesh", "bSimulatePhysics", "true")
+    """
+    command = {
+        "type": "edit_component_property",
+        "blueprint_path": blueprint_path,
+        "component_name": component_name,
+        "property_name": property_name,
+        "value": value,
+        "is_scene_actor": is_scene_actor,
+        "actor_name": actor_name
+    }
+    response = send_to_unreal(command)
+
+    # CHANGED: Improved response handling to support both string and dict responses
+    try:
+        # Handle case where response is already a dict
+        if isinstance(response, dict):
+            result = response
+        # Handle case where response is a string
+        elif isinstance(response, str):
+            import json
+            result = json.loads(response)
+        else:
+            return f"Error: Unexpected response type: {type(response)}"
+
+        if result.get("success"):
+            return result.get("message", f"Set {property_name} of {component_name} to {value}")
+        else:
+            error = result.get("error", "Unknown error")
+            if "suggestions" in result:
+                error += f"\nSuggestions: {result['suggestions']}"
+            return f"Failed: {error}"
+    except Exception as e:
+        return f"Error: {str(e)}\nRaw response: {response}"
+
+@mcp.tool()
+def create_material(material_name: str, color: List[float]) -> str:
+    """
+    Create a new material with the specified color
+    Args:
+        material_name: Name for the new material
+        color: [R, G, B] color values (0-1)
+    Returns:
+        Message indicating success or failure, and the material path if successful
+    """
+    normalized_color = _coerce_numeric_list(color)
+    if len(normalized_color) == 3:
+        color = normalized_color
+
+    command = {
+        "type": "create_material",
+        "material_name": material_name,
+        "color": color
+    }
+    response = send_to_unreal(command)
+    if response.get("success"):
+        return f"Successfully created material '{material_name}' with path: {response.get('material_path')}"
+    else:
+        return f"Failed to create material: {response.get('error', 'Unknown error')}"
+
+#
+# Blueprint Commands
+#
+
+@mcp.tool()
+def create_blueprint(blueprint_name: str, parent_class: str = "Actor", save_path: str = "/Game/Blueprints") -> str:
+    """
+    Create a new Blueprint class
+    Args:
+        blueprint_name: Name for the new Blueprint
+        parent_class: Parent class name or path (e.g., "Actor", "/Script/Engine.Actor")
+        save_path: Path to save the Blueprint asset
+    Returns:
+        Message indicating success or failure
+    """
+    command = {
+        "type": "create_blueprint",
+        "blueprint_name": blueprint_name,
+        "parent_class": parent_class,
+        "save_path": save_path
+    }
+    response = send_to_unreal(command)
+    if response.get("success"):
+        return f"Successfully created Blueprint '{blueprint_name}' with path: {response.get('blueprint_path', save_path + '/' + blueprint_name)}"
+    else:
+        return f"Failed to create Blueprint: {response.get('error', 'Unknown error')}"
+
+@mcp.tool()
+def add_component_to_blueprint(blueprint_path: str, component_class: str, component_name: str = None) -> str:
+    """
+    Add a component to a Blueprint
+    Args:
+        blueprint_path: Path to the Blueprint asset
+        component_class: Component class to add (e.g., "StaticMeshComponent", "PointLightComponent")
+        component_name: Name for the new component (optional)
+    Returns:
+        Message indicating success or failure
+    """
+    command = {
+        "type": "add_component",
+        "blueprint_path": blueprint_path,
+        "component_class": component_class,
+        "component_name": component_name
+    }
+    response = send_to_unreal(command)
+    if response.get("success"):
+        return f"Successfully added {component_class} to Blueprint at {blueprint_path}"
+    else:
+        return f"Failed to add component: {response.get('error', 'Unknown error')}"
+
+@mcp.tool()
+def add_variable_to_blueprint(blueprint_path: str, variable_name: str, variable_type: str, default_value: str = None, category: str = "Default") -> str:
+    """
+    Add a variable to a Blueprint
+    Args:
+        blueprint_path: Path to the Blueprint asset
+        variable_name: Name for the new variable
+        variable_type: Type of the variable (e.g., "double", "vector", "boolean") - Note: UE 5.6 uses double for numeric values
+        default_value: Default value for the variable (optional)
+        category: Category for organizing variables in the Blueprint editor (optional)
+    Returns:
+        Message indicating success or failure
+    """
+    # Convert default_value to string if it's a number
+    if default_value is not None and not isinstance(default_value, str):
+        default_value = str(default_value)
+
+    command = {
+        "type": "add_variable",
+        "blueprint_path": blueprint_path,
+        "variable_name": variable_name,
+        "variable_type": variable_type,
+        "default_value": default_value,
+        "category": category
+    }
+    response = send_to_unreal(command)
+    if response.get("success"):
+        return f"Successfully added {variable_type} variable '{variable_name}' to Blueprint at {blueprint_path}"
+    else:
+        return f"Failed to add variable: {response.get('error', 'Unknown error')}"
+
+@mcp.tool()
+def add_function_to_blueprint(blueprint_path: str, function_name: str, inputs: Optional[List[Dict]] = None, outputs: Optional[List[Dict]] = None) -> str:
+    """
+    Add a function to a Blueprint using UE 5.6 Kismet type system
+    Args:
+        blueprint_path: Path to the Blueprint asset
+        function_name: Name for the new function
+        inputs: List of input parameters with UE 5.6 types:
+            [{"name": "param1", "type": "double"}, {"name": "param2", "type": "string"}, ...]
+            Supported UE 5.6 types: boolean, byte, int, double, float, string, text, name,
+            vector, rotator, transform, color, object (with class name)
+        outputs: List of output parameters with same type format as inputs
+    Returns:
+        Message indicating success or failure
+    """
+    if inputs is None:
+        inputs = []
+    if outputs is None:
+        outputs = []
+
+    command = {
+        "type": "add_function",
+        "blueprint_path": blueprint_path,
+        "function_name": function_name,
+        "inputs": inputs,
+        "outputs": outputs
+    }
+    response = send_to_unreal(command)
+    if response.get("success"):
+        return f"Successfully added function '{function_name}' to Blueprint at {blueprint_path} with ID: {response.get('function_id', 'unknown')}"
+    else:
+        return f"Failed to add function: {response.get('error', 'Unknown error')}"
+
+@mcp.tool()
+def add_node_to_blueprint(blueprint_path: str, function_id: str, node_type: str, node_position: Optional[List[int]] = None, node_properties: Optional[Dict] = None) -> str:
+    """
+    Add a node to a Blueprint graph with comprehensive node discovery
+    Args:
+        blueprint_path: Path to the Blueprint asset
+        function_id: ID of the function to add the node to
+        node_type: Type of node to add. The system now supports ANY Blueprint-callable function with intelligent discovery:
+
+                  **FLEXIBLE NODE TYPES** - The system automatically finds the correct function:
+                  - Simple names: "Add", "Multiply", "SetActorRotation", "PrintString"
+                  - Library.Function format: "KismetMathLibrary.Add", "Actor.SetActorLocation"
+                  - Variations: "SetRotation", "MoveComponent", "CreateWidget"
+
+                  **COMPREHENSIVE COVERAGE** - Searches across ALL Blueprint libraries:
+                  - Math: "Add", "Multiply", "Divide", "Subtract", "MakeVector", "BreakVector"
+                  - Actor: "SetActorLocation", "SetActorRotation", "GetActorLocation", "SetActorScale3D"
+                  - Components: "SetWorldLocation", "SetRelativeLocation", "SetWorldRotation"
+                  - String: "Append", "Contains", "Split", "ToUpper", "ToLower"
+                  - Array: "Add Item", "Remove Item", "Get", "Length", "Contains"
+                  - System: "PrintString", "Delay", "Branch", "Sequence", "IsValid"
+                  - Gameplay: "GetPlayerController", "GetPlayerPawn", "SpawnActor"
+
+                  **INTELLIGENT FALLBACKS** - If exact match fails, automatically tries:
+                  - Common variations (Set/Get prefixes, library corrections)
+                  - Searches ALL loaded Blueprint-accessible classes
+                  - Returns helpful suggestions for similar functions
+
+                  **EXAMPLES THAT NOW WORK**:
+                  - "SetActorRotation" → finds Actor.SetActorRotation
+                  - "KismetMathLibrary.SetActorRotation" → corrects to Actor.SetActorRotation
+                  - "Add" → finds KismetMathLibrary.Add (with proper type suffix)
+                  - "MoveComponent" → finds appropriate component movement function
+
+        node_position: Position of the node in the graph [X, Y]. **IMPORTANT**: Space nodes at least 400 units apart horizontally and 300 units vertically to avoid overlap and ensure a clean, organized graph (e.g., [0, 0], [400, 0], [800, 0] for a chain).
+        node_properties: Properties to set on the node (optional)
+    Returns:
+        On success: The node ID (GUID) and confirmation message
+        On failure: Detailed error with suggestions for alternative node types
+    Note:
+        The enhanced discovery system searches across 30+ Blueprint libraries and ALL loaded classes.
+        It handles incorrect library prefixes, tries common variations, and provides intelligent suggestions.
+        This dramatically improves the success rate for any Blueprint-callable function.
+    """
+    if node_properties is None:
+        node_properties = {}
+
+    if isinstance(node_position, str) or node_position is None:
+        node_position = _ensure_two_d(node_position, [0.0, 0.0])
+    elif isinstance(node_position, (list, tuple)):
+        node_position = _ensure_two_d(node_position, [0.0, 0.0])
+    else:
+        node_position = [0.0, 0.0]
+
+    command = {
+        "type": "add_node",
+        "blueprint_path": blueprint_path,
+        "function_id": function_id,
+        "node_type": node_type,
+        "node_position": node_position,
+        "node_properties": node_properties
+    }
+    response = send_to_unreal(command)
+
+    if response.get("success") and response.get("node_id"):
+        return f"Successfully added {node_type} node to function {function_id} in Blueprint at {blueprint_path} with ID: {response.get('node_id')}"
+    else:
+        error_msg = response.get('error', 'Unknown error')
+
+        # Check if the response contains suggestions
+        if "SUGGESTIONS:" in error_msg:
+            return f"Node '{node_type}' not found, but here are alternatives:\n{error_msg}"
+        else:
+            return f"Failed to add node '{node_type}': {error_msg}\n\nTip: The system now searches comprehensively across all Blueprint libraries. Try simpler names like 'Add', 'SetActorLocation', or 'PrintString'."
+
+@mcp.tool()
+def get_node_suggestions(node_type: str) -> str:
+    """
+    Get suggestions for a node type in Unreal Blueprints using comprehensive discovery
+    Args:
+        node_type: The partial or full node type to get suggestions for (e.g., "Add", "Vector", "Math", "Actor")
+    Returns:
+        A string with suggestions or error message
+
+    Enhanced Discovery Features:
+        - Searches across ALL Blueprint-accessible classes (30+ libraries)
+        - Handles any node name format (simple names, Library.Function, variations)
+        - Provides intelligent scoring and ranking
+        - Includes functions from: Math, Actor, Component, String, Array, System, Gameplay, etc.
+
+    Examples that now work comprehensively:
+        - "Add" → finds all addition functions across libraries
+        - "Vector" → finds all vector-related functions
+        - "Actor" → finds all Actor class functions
+        - "SetRotation" → finds rotation-setting functions across all classes
+        - "Math" → finds all mathematical operations
+        - "Component" → finds all component-related functions
+
+    The system now searches universally across all loaded Blueprint classes,
+    so virtually any Blueprint-callable function can be discovered.
+    """
+    command = {
+        "type": "get_node_suggestions",
+        "node_type": node_type
+    }
+    response = send_to_unreal(command)
+    if response.get("success"):
+        suggestions = response.get("suggestions", [])
+        if suggestions:
+            return f"Found {len(suggestions)} suggestions for '{node_type}' using comprehensive discovery:\n" + "\n".join(suggestions)
+        else:
+            return f"No suggestions found for '{node_type}' - try broader search terms like 'Math', 'Actor', 'Vector', or 'String'"
+    else:
+        error = response.get("error", "Unknown error")
+        return f"Failed to get suggestions for '{node_type}': {error}"
+
+@mcp.tool()
+def delete_node_from_blueprint(blueprint_path: str, function_id: str, node_id: str) -> str:
+    """
+    Delete a node from a Blueprint graph
+    Args:
+        blueprint_path: Path to the Blueprint asset
+        function_id: ID of the function containing the node
+        node_id: ID of the node to delete
+    Returns:
+        Success or failure message
+    """
+    command = {
+        "type": "delete_node",
+        "blueprint_path": blueprint_path,
+        "function_id": function_id,
+        "node_id": node_id
+    }
+    response = send_to_unreal(command)
+    if response.get("success"):
+        return f"Successfully deleted node {node_id} from function {function_id} in Blueprint at {blueprint_path}"
+    else:
+        return f"Failed to delete node: {response.get('error', 'Unknown error')}"
+
+@mcp.tool()
+def get_all_nodes_in_graph(blueprint_path: str, function_id: str) -> str:
+    """
+    Get all nodes in a Blueprint graph with their positions and types
+    Args:
+        blueprint_path: Path to the Blueprint asset
+        function_id: ID of the function to get nodes from
+    Returns:
+        JSON string containing all nodes with their GUIDs, types, and positions
+    """
+    command = {
+        "type": "get_all_nodes",
+        "blueprint_path": blueprint_path,
+        "function_id": function_id
+    }
+    response = send_to_unreal(command)
+    if response.get("success"):
+        return response.get("nodes", "[]")
+    else:
+        return f"Failed to get nodes: {response.get('error', 'Unknown error')}"
+
+@mcp.tool()
+def connect_blueprint_nodes(blueprint_path: str, function_id: str, source_node_id: str, source_pin: str, target_node_id: str, target_pin: str) -> str:
+    command = {
+        "type": "connect_nodes",
+        "blueprint_path": blueprint_path,
+        "function_id": function_id,
+        "source_node_id": source_node_id,
+        "source_pin": source_pin,
+        "target_node_id": target_node_id,
+        "target_pin": target_pin
+    }
+    response = send_to_unreal(command)
+    if response.get("success"):
+        return f"Successfully connected {source_node_id}.{source_pin} to {target_node_id}.{target_pin} in Blueprint at {blueprint_path}"
+    else:
+        error = response.get("error", "Unknown error")
+        if "source_available_pins" in response and "target_available_pins" in response:
+            error += f"\nAvailable pins on source ({source_node_id}): {json.dumps(response['source_available_pins'], indent=2)}"
+            error += f"\nAvailable pins on target ({target_node_id}): {json.dumps(response['target_available_pins'], indent=2)}"
+        return f"Failed to connect nodes: {error}"
+
+@mcp.tool()
+def compile_blueprint(blueprint_path: str) -> str:
+    """
+    Compile a Blueprint
+    Args:
+        blueprint_path: Path to the Blueprint asset
+    Returns:
+        Message indicating success or failure
+    """
+    command = {
+        "type": "compile_blueprint",
+        "blueprint_path": blueprint_path
+    }
+    response = send_to_unreal(command)
+    if response.get("success"):
+        return f"Successfully compiled Blueprint at {blueprint_path}"
+    else:
+        return f"Failed to compile Blueprint: {response.get('error', 'Unknown error')}"
+
+@mcp.tool()
+def spawn_blueprint_actor(blueprint_path: str, location: Optional[List[float]] = None, rotation: Optional[List[float]] = None, scale: Optional[List[float]] = None, actor_label: Optional[str] = None) -> str:
+    """
+    Spawn a Blueprint actor in the level
+    Args:
+        blueprint_path: Path to the Blueprint asset
+        location: [X, Y, Z] coordinates
+        rotation: [Pitch, Yaw, Roll] in degrees
+        scale: [X, Y, Z] scale factors
+        actor_label: Optional custom name for the actor
+    Returns:
+        Message indicating success or failure
+    """
+    location = _ensure_vector(location, [0.0, 0.0, 0.0])
+    rotation = _ensure_vector(rotation, [0.0, 0.0, 0.0])
+    scale = _ensure_vector(scale, [1.0, 1.0, 1.0])
+
+    command = {
+        "type": "spawn_blueprint",
+        "blueprint_path": blueprint_path,
+        "location": location,
+        "rotation": rotation,
+        "scale": scale,
+        "actor_label": actor_label
+    }
+    response = send_to_unreal(command)
+    if response.get("success"):
+        return f"Successfully spawned Blueprint {blueprint_path}" + (
+            f" with label '{actor_label}'" if actor_label else "")
+    else:
+        return f"Failed to spawn Blueprint: {response.get('error', 'Unknown error')}"
+
+@mcp.tool()
+def add_component_with_events(blueprint_path: str, component_name: str, component_class: str) -> str:
+    """
+    Add a component to a Blueprint with overlap events if applicable.
+    Args:
+        blueprint_path: Path to the Blueprint (e.g., "/Game/FlappyBird/BP_FlappyBird")
+        component_name: Name of the new component (e.g., "TriggerBox")
+        component_class: Class of the component (e.g., "BoxComponent")
+    Returns:
+        Message with success, error, and event GUIDs if created
+    """
+    command = {
+        "type": "add_component_with_events",
+        "blueprint_path": blueprint_path,
+        "component_name": component_name,
+        "component_class": component_class
+    }
+    response = _ensure_dict_response(send_to_unreal(command))
+    if response.get("success"):
+        msg = response.get("message", f"Added component {component_name}")
+        begin_guid = response.get("begin_overlap_guid")
+        end_guid = response.get("end_overlap_guid")
+        if not (begin_guid or end_guid):
+            events_payload = response.get("events")
+            events_data = {}
+            if isinstance(events_payload, str):
+                try:
+                    events_data = json.loads(events_payload)
+                except json.JSONDecodeError:
+                    events_data = {}
+            elif isinstance(events_payload, dict):
+                events_data = events_payload
+            begin_guid = events_data.get("begin_guid", begin_guid)
+            end_guid = events_data.get("end_guid", end_guid)
+        if begin_guid or end_guid:
+            msg += (
+                f"\nBeginOverlap GUID: {begin_guid or 'N/A'}"
+                f"\nEndOverlap GUID: {end_guid or 'N/A'}"
+            )
+        return msg
+    error_message = response.get("error", "Unknown error")
+    raw_suffix = f"\nRaw response: {response.get('raw')}" if "raw" in response else ""
+    return f"Failed: {error_message}{raw_suffix}"
+
+@mcp.tool()
+def connect_blueprint_nodes_bulk(blueprint_path: str, function_id: str, connections: List[Dict], function_name: Optional[str] = None) -> str:
+    """
+    Connect multiple pairs of nodes in a Blueprint graph
+    Args:
+        blueprint_path: Path to the Blueprint asset
+        function_id: ID of the function containing the nodes
+        connections: Array of connection definitions, each containing:
+                    - source_node_id: ID of the source node
+                    - source_pin: Name of the source pin
+                    - target_node_id: ID of the target node
+                    - target_pin: Name of the target pin
+    Returns:
+        Message indicating success or failure, with details on which connections succeeded or failed
+    """
+    if isinstance(connections, str):
+        try:
+            connections = json.loads(connections)
+        except json.JSONDecodeError as parse_err:
+            return f"Failed to parse connections: {parse_err}"
+
+    normalized_connections: List[Dict] = []
+    raw_connections = connections
+    if isinstance(raw_connections, dict):
+        raw_connections = [raw_connections]
+
+    for entry in raw_connections or []:
+        if isinstance(entry, str):
+            try:
+                entry = json.loads(entry)
+            except json.JSONDecodeError:
+                continue
+        if not isinstance(entry, dict):
+            continue
+        normalized_connections.append({
+            "source_node_id": entry.get("source_node_id") or entry.get("source_node_guid"),
+            "source_pin": entry.get("source_pin", "exec"),
+            "target_node_id": entry.get("target_node_id") or entry.get("target_node_guid"),
+            "target_pin": entry.get("target_pin", "exec")
+        })
+
+    if not normalized_connections and isinstance(connections, list):
+        normalized_connections = connections
+
+    if not normalized_connections:
+        return "Failed: no valid connections provided"
+
+    command = {
+        "type": "connect_nodes_bulk",
+        "blueprint_path": blueprint_path,
+        "function_id": function_id,
+        "function_name": function_name or function_id,
+        "connections": normalized_connections
+    }
+    response = _ensure_dict_response(send_to_unreal(command))
+
+    # Handle the new detailed response format
+    if response.get("success"):
+        successful = response.get("successful_connections", 0)
+        total = response.get("total_connections", 0)
+        return f"Successfully connected {successful}/{total} node pairs in Blueprint at {blueprint_path}"
+    else:
+        # Extract detailed error information
+        error_message = response.get("error", "Unknown error")
+        failed_connections = []
+
+        for result in response.get("results", []):
+            if not result.get("success", False):
+                idx = result.get("connection_index", -1)
+                src = result.get("source_node", "unknown")
+                tgt = result.get("target_node", "unknown")
+                err = result.get("error", "unknown error")
+                failed_connections.append(f"Connection {idx}: {src} to {tgt} - {err}")
+
+        raw_suffix = f"\nRaw response: {response.get('raw')}" if "raw" in response else ""
+        if failed_connections:
+            detailed_errors = "\n- " + "\n- ".join(failed_connections)
+            return f"Failed to connect nodes: {error_message}{detailed_errors}{raw_suffix}"
+        else:
+            return f"Failed to connect nodes: {error_message}{raw_suffix}"
+
+@mcp.tool()
+def get_blueprint_node_guid(blueprint_path: str, graph_type: str = "EventGraph", node_name: str = None, function_id: str = None) -> str:
+    """
+    Retrieve the GUID of a pre-existing node in a Blueprint graph.
+    Args:
+        blueprint_path: Path to the Blueprint asset (e.g., "/Game/Blueprints/TestBulkBlueprint")
+        graph_type: Type of graph to query ("EventGraph" or "FunctionGraph", default: "EventGraph")
+        node_name: Name of the node to find (e.g., "BeginPlay" for EventGraph, optional if using function_id)
+        function_id: ID of the function to get the FunctionEntry node for (optional, used with graph_type="FunctionGraph")
+    Returns:
+        Message with the node's GUID or an error if not found
+    """
+    command = {
+        "type": "get_node_guid",
+        "blueprint_path": blueprint_path,
+        "graph_type": graph_type,
+        "node_name": node_name if node_name else "",
+        "function_id": function_id if function_id else ""
+    }
+    response = send_to_unreal(command)
+    if response.get("success"):
+        guid = response.get("node_guid")
+        return f"Node GUID for {node_name or 'FunctionEntry'} in {graph_type} of {blueprint_path}: {guid}"
+    else:
+        return f"Failed to get node GUID: {response.get('error', 'Unknown error')}"
+
+# Scene Control
+@mcp.tool()
+def get_all_scene_objects() -> str:
+    """
+    Retrieve all actors in the current Unreal Engine level.
+    Returns:
+        JSON string of actors with their names, classes, and locations.
+    """
+    command = {"type": "get_all_scene_objects"}
+    response = send_to_unreal(command)
+    return json.dumps(response) if response.get("success") else f"Failed: {response.get('error', 'Unknown error')}"
+
+@mcp.tool()
+def get_blueprint_context(include_editor_state: bool = True, include_graph_info: bool = True,
+                         include_selected_nodes: bool = True, include_open_editors: bool = False,
+                         specific_blueprint_path: str = None, auto_discover_nodes: bool = True) -> str:
+    """
+    Get comprehensive context about the currently active Blueprint editor in Unreal Engine.
+    This provides AI tools with complete awareness of what Blueprint is being edited,
+    what graph is active, selected nodes, compilation status, and more.
+
+    When called from "Sync with AI" button, this also discovers available Blueprint nodes
+    for the current UE version and project, solving node creation issues.
+
+    Args:
+        include_editor_state: Include detailed editor state (compilation status, Blueprint type, etc.) - default True
+        include_graph_info: Include information about all graphs in the Blueprint - default True
+        include_selected_nodes: Include information about currently selected nodes - default True
+        include_open_editors: Include list of all open Blueprint editors - default False
+        specific_blueprint_path: Focus on a specific Blueprint instead of the active one (optional)
+        auto_discover_nodes: Automatically discover available Blueprint nodes for this UE version - default True
+
+    Returns:
+        JSON string containing comprehensive Blueprint context information including:
+        - Active Blueprint name and path
+        - Current graph type (EventGraph, FunctionGraph, etc.)
+        - Selected nodes with details (class, position, pins)
+        - Compilation status and errors
+        - All available graphs
+        - Available Blueprint nodes for this UE version (if auto_discover_nodes=True)
+        - Quick summary for AI analysis
+
+    Example response structure:
+    {
+        "success": true,
+        "has_active_editor": true,
+        "active_blueprint": {"name": "MyActor", "path": "/Game/Blueprints/MyActor"},
+        "active_graph": {"name": "EventGraph", "type": "EventGraph"},
+        "available_nodes": {...},  // Discovered nodes for this UE version
+        "summary": {
+            "active_blueprint_name": "MyActor",
+            "active_blueprint_path": "/Game/Blueprints/MyActor",
+            "active_graph_name": "EventGraph",
+            "active_graph_type": "EventGraph",
+            "has_selected_nodes": true,
+            "nodes_discovered": true
+        },
+        "editor_state": {...},  // If include_editor_state = true
+        "graph_info": {...},    // If include_graph_info = true
+        "selected_nodes": {...} // If include_selected_nodes = true
+    }
+
+    This tool enables context-aware AI assistance by providing complete visibility
+    into the current Blueprint editing session AND available node inventory.
+    """
+    try:
+        command = {
+            "type": "get_blueprint_context",
+            "include_editor_state": include_editor_state,
+            "include_graph_info": include_graph_info,
+            "include_selected_nodes": include_selected_nodes,
+            "include_open_editors": include_open_editors
+        }
+        
+        if specific_blueprint_path:
+            command["specific_blueprint_path"] = specific_blueprint_path
+            
+        response = send_to_unreal(command)
+
+        if response.get("success"):
+            # If auto_discover_nodes is enabled, also discover available nodes
+            if auto_discover_nodes:
+                print("Auto-discovering available Blueprint nodes for this UE version...")
+                discovery_result = discover_available_blueprint_nodes()
+                try:
+                    discovery_data = json.loads(discovery_result)
+                    if discovery_data.get("success"):
+                        response["available_nodes"] = discovery_data.get("discovered_nodes", {})
+                        response["node_discovery"] = {
+                            "success": True,
+                            "total_nodes_found": discovery_data.get("total_nodes_found", 0),
+                            "unreal_version": discovery_data.get("unreal_version", "Unknown")
+                        }
+                        print(f"Node discovery completed: {discovery_data.get('total_nodes_found', 0)} nodes found")
+                    else:
+                        response["available_nodes"] = {}
+                        response["node_discovery"] = {
+                            "success": False,
+                            "error": "Node discovery failed"
+                        }
+                except json.JSONDecodeError as e:
+                    print(f"Failed to parse discovery result: {e}")
+                    response["available_nodes"] = {}
+                    response["node_discovery"] = {
+                        "success": False,
+                        "error": f"JSON decode error: {str(e)}"
+                    }
+                try:
+                    discovery_data = json.loads(discovery_result)
+                    if discovery_data.get("success"):
+                        # CURSOR STATUS FIX: Limit available_nodes to prevent large responses
+                        discovered_nodes = discovery_data.get("discovered_nodes", {})
+                        limited_nodes = {}
+
+                        for category, nodes in discovered_nodes.items():
+                            if isinstance(nodes, list):
+                                # Limit each category to first 10 nodes
+                                limited_nodes[category] = nodes[:10]
+                                if len(nodes) > 10:
+                                    limited_nodes[category].append(f"... and {len(nodes) - 10} more {category} nodes")
+                            else:
+                                limited_nodes[category] = nodes
+
+                        response["available_nodes"] = limited_nodes
+                        response["node_discovery"] = {
+                            "success": True,
+                            "total_nodes_found": discovery_data.get("total_nodes_found", 0),
+                            "unreal_version": discovery_data.get("unreal_version", "Unknown"),
+                            "limited": True,
+                            "note": "Node lists limited to 10 per category for Cursor compatibility"
+                        }
+                        print(f"Node discovery completed: {discovery_data.get('total_nodes_found', 0)} nodes found (limited for Cursor)")
+                    else:
+                        response["node_discovery"] = {
+                            "success": False,
+                            "error": discovery_data.get("error", "Discovery failed")
+                        }
+                        print("Node discovery failed, but Blueprint context still available")
+                except Exception as e:
+                    response["node_discovery"] = {
+                        "success": False,
+                        "error": f"Discovery parsing error: {str(e)}"
+                    }
+                    print(f"Node discovery parsing failed: {str(e)}")
+
+            # CURSOR STATUS FIX: Limit response size to prevent truncation
+            response_str = json.dumps(response, indent=2)
+            response_size = len(response_str.encode('utf-8'))
+
+            # If response is too large (>80KB), truncate the all_nodes data
+            if response_size > 80 * 1024:  # 80KB limit
+                print(f"Blueprint context response too large ({response_size} bytes), truncating node data...")
+
+                # Keep essential data but limit all_nodes
+                if "all_nodes" in response and "nodes" in response["all_nodes"]:
+                    original_nodes = response["all_nodes"]["nodes"]
+                    node_count = len(original_nodes)
+
+                    # Keep only first 3 nodes with essential data
+                    truncated_nodes = []
+                    for i, node in enumerate(original_nodes[:3]):
+                        truncated_node = {
+                            "title": node.get("title", ""),
+                            "class_name": node.get("class_name", ""),
+                            "pos_x": node.get("pos_x", 0),
+                            "pos_y": node.get("pos_y", 0),
+                            "guid": node.get("guid", ""),
+                            "is_enabled": node.get("is_enabled", True)
+                        }
+
+                        # Keep only essential pins (first 2)
+                        if "pins" in node:
+                            truncated_node["pins"] = []
+                            for pin in node["pins"][:2]:
+                                truncated_pin = {
+                                    "name": pin.get("name", ""),
+                                    "direction": pin.get("direction", ""),
+                                    "type": pin.get("type", ""),
+                                    "connected": pin.get("connected", False)
+                                }
+                                truncated_node["pins"].append(truncated_pin)
+
+                            if len(node["pins"]) > 2:
+                                truncated_node["pins"].append({
+                                    "name": f"... and {len(node['pins']) - 2} more pins",
+                                    "direction": "Info",
+                                    "type": "truncated",
+                                    "connected": False
+                                })
+
+                        truncated_nodes.append(truncated_node)
+
+                    # Add summary info
+                    if node_count > 3:
+                        truncated_nodes.append({
+                            "title": f"... and {node_count - 3} more nodes (use get_all_nodes_in_graph for full data)",
+                            "class_name": "TruncatedInfo",
+                            "pos_x": 0,
+                            "pos_y": 0,
+                            "guid": "TRUNCATED",
+                            "is_enabled": True,
+                            "pins": []
+                        })
+
+                    response["all_nodes"]["nodes"] = truncated_nodes
+                    response["all_nodes"]["total_nodes"] = node_count
+                    response["all_nodes"]["truncated"] = True
+                    response["all_nodes"]["truncation_reason"] = "Response too large for Cursor MCP - use get_all_nodes_in_graph for complete data"
+
+                # Recalculate response size
+                response_str = json.dumps(response, indent=2)
+                new_size = len(response_str.encode('utf-8'))
+                print(f"Response truncated: {response_size} -> {new_size} bytes")
+
+            # Return the (possibly truncated) context as JSON for AI analysis
+            return response_str
+        else:
+            return f"Failed to get Blueprint context: {response.get('error', 'No active Blueprint editor found')}"
+            
+    except Exception as e:
+        return f"Error getting Blueprint context: {str(e)}"
+
+def _validate_blueprint_for_functions(blueprint_context: dict) -> dict:
+    """
+    Validate if a Blueprint can have custom functions added to it.
+
+    Args:
+        blueprint_context: Blueprint context information
+
+    Returns:
+        dict: Validation result with success status and recommendations
+    """
+    blueprint_info = blueprint_context.get("blueprint_info", {})
+    blueprint_type = blueprint_info.get("type", "")
+    blueprint_name = blueprint_info.get("name", "Unknown")
+    blueprint_path = blueprint_info.get("path", "")
+
+    # Level Script Blueprints DO support custom functions - removed incorrect restriction
+
+    return {
+        "can_add_functions": True,
+        "blueprint_type": blueprint_type,
+        "blueprint_name": blueprint_name
+    }
+
+def _generate_blueprint_function_from_context(function_description: str, analysis_approach: str = "smart",
+                                           target_blueprint_path: str = None) -> str:
+    """
+    Generate a complete Blueprint function based on the current Blueprint context and a description.
+    This tool analyzes the existing Blueprint structure and creates contextually appropriate functions.
+
+    IMPORTANT: Level Script Blueprints do not support custom functions. If targeting a Level Script,
+    this tool will suggest creating a regular Blueprint class instead.
+
+    Args:
+        function_description: Natural language description of what the function should do
+                             (e.g., "Create a health system that damages the player when they take damage")
+        analysis_approach: How to analyze the context - "smart" (default), "minimal", or "comprehensive"
+        target_blueprint_path: Specific Blueprint to target (optional, uses active Blueprint if not specified)
+        
+    Returns:
+        JSON string containing the generated function details and implementation steps
+        
+    Example:
+        generate_blueprint_function_from_context(
+            "Add a jump ability that plays a sound effect and particle effect",
+            "smart"
+        )
+        
+    This tool will:
+    1. Get current Blueprint context (nodes, connections, variables, etc.)
+    2. Analyze existing patterns and architecture
+    3. Generate appropriate function with inputs/outputs
+    4. Create node sequence that integrates well with existing code
+    5. Return implementation details and reasoning
+    """
+    try:
+        # Use cached context if available, otherwise fetch fresh
+        context_response = get_cached_blueprint_context()
+        
+        # If specific Blueprint path is provided or cache is invalid, fetch fresh
+        if target_blueprint_path or not context_response:
+            context_cmd = {
+                "type": "get_blueprint_context",
+                "include_editor_state": True,
+                "include_graph_info": True,
+                "include_selected_nodes": True,
+                "include_open_editors": False
+            }
+            
+            if target_blueprint_path:
+                context_cmd["specific_blueprint_path"] = target_blueprint_path
+                
+            context_response = send_to_unreal(context_cmd)
+            
+            # Update cache with fresh context
+            if context_response.get("success"):
+                global _blueprint_context_cache
+                _blueprint_context_cache["cached_context"] = context_response
+                _blueprint_context_cache["cache_timestamp"] = time.time()
+                _blueprint_context_cache["cache_blueprint_path"] = context_response.get("active_blueprint", {}).get("path", "")
+        
+        if not context_response or not context_response.get("success"):
+            return f"Failed to get Blueprint context: {context_response.get('error', 'Unknown error') if context_response else 'No context available'}"
+        
+        # Level Script Blueprints DO support custom functions - removed incorrect validation
+
+        # Analyze the Blueprint context for function generation
+        analysis = analyze_blueprint_for_function_generation(context_response, function_description, analysis_approach)
+
+        # Generate the function specification
+        function_spec = generate_function_specification(analysis, function_description)
+
+        # Create implementation plan
+        implementation_plan = create_implementation_plan(function_spec, analysis)
+        
+        # Return comprehensive function generation result
+        result = {
+            "success": True,
+            "function_description": function_description,
+            "target_blueprint": analysis.get("blueprint_info", {}).get("name", "Unknown"),
+            "analysis_approach": analysis_approach,
+            "context_analysis": analysis,
+            "function_specification": function_spec,
+            "implementation_plan": implementation_plan,
+            "integration_suggestions": generate_integration_suggestions(analysis, function_spec)
+        }
+        
+        return json.dumps(result, indent=2)
+        
+    except Exception as e:
+        return f"Error generating Blueprint function: {str(e)}"
+
+def analyze_blueprint_for_function_generation(context, function_description, approach):
+    """Analyze Blueprint context to inform function generation"""
+    analysis = {
+        "blueprint_info": {},
+        "existing_patterns": [],
+        "available_variables": [],
+        "node_usage_patterns": [],
+        "architectural_insights": [],
+        "integration_opportunities": []
+    }
+    
+    # Extract basic Blueprint info
+    if context.get("active_blueprint"):
+        analysis["blueprint_info"] = {
+            "name": context["active_blueprint"].get("name", "Unknown"),
+            "path": context["active_blueprint"].get("path", ""),
+            "type": context.get("editor_state", {}).get("blueprint_type", "Unknown")
+        }
+    
+    # Analyze existing nodes and patterns
+    all_nodes = context.get("all_nodes", {}).get("nodes", [])
+    if all_nodes:
+        # Count node types
+        node_types = {}
+        execution_patterns = []
+        
+        for node in all_nodes:
+            node_class = node.get("class_name", "Unknown")
+            node_types[node_class] = node_types.get(node_class, 0) + 1
+            
+            # Analyze execution patterns
+            if node.get("pins"):
+                exec_outputs = [pin for pin in node["pins"] 
+                              if pin.get("type") == "exec" and pin.get("direction") == "Output"]
+                if exec_outputs and any(pin.get("connected") for pin in exec_outputs):
+                    execution_patterns.append({
+                        "node": node.get("title", "Unknown"),
+                        "class": node_class,
+                        "connects_to": [conn.get("connected_node_title") 
+                                      for pin in exec_outputs 
+                                      for conn in pin.get("connections", [])]
+                    })
+        
+        analysis["node_usage_patterns"] = [
+            {"type": node_type, "count": count} 
+            for node_type, count in node_types.items()
+        ]
+        analysis["execution_patterns"] = execution_patterns
+    
+    # Analyze architectural patterns (enhanced)
+    node_titles = [node.get("title", "") for node in all_nodes]
+    node_classes = [node.get("class_name", "") for node in all_nodes]
+    
+    # Check for common Blueprint patterns
+    if any("Event" in title for title in node_titles):
+        analysis["architectural_insights"].append("Blueprint uses event-driven architecture")
+    if any("Widget" in title or "UI" in title for title in node_titles):
+        analysis["architectural_insights"].append("Blueprint includes UI/Widget functionality")
+    if any("Component" in title or "Component" in cls for title, cls in zip(node_titles, node_classes)):
+        analysis["architectural_insights"].append("Blueprint uses component-based architecture")
+    if any("Timer" in title for title in node_titles):
+        analysis["architectural_insights"].append("Blueprint uses timer-based functionality")
+    if any("Input" in title for title in node_titles):
+        analysis["architectural_insights"].append("Blueprint handles input events")
+    if any("Animation" in title or "Anim" in title for title in node_titles):
+        analysis["architectural_insights"].append("Blueprint includes animation system")
+    if any("Collision" in title or "Overlap" in title for title in node_titles):
+        analysis["architectural_insights"].append("Blueprint handles collision/overlap events")
+    if any("AI" in title or "Pawn" in title for title in node_titles):
+        analysis["architectural_insights"].append("Blueprint includes AI/character behavior")
+    
+    # Analyze variable usage patterns from nodes
+    variable_nodes = [node for node in all_nodes if "Variable" in node.get("class_name", "") or "Get" in node.get("title", "") or "Set" in node.get("title", "")]
+    if variable_nodes:
+        analysis["architectural_insights"].append(f"Blueprint uses {len(variable_nodes)} variable operations")
+    
+    # Detect common game patterns
+    if any(word in " ".join(node_titles).lower() for word in ["health", "damage", "death"]):
+        analysis["architectural_insights"].append("Blueprint implements health/damage system")
+    if any(word in " ".join(node_titles).lower() for word in ["score", "points", "win", "lose"]):
+        analysis["architectural_insights"].append("Blueprint implements scoring/game state system")
+    if any(word in " ".join(node_titles).lower() for word in ["spawn", "enemy", "projectile"]):
+        analysis["architectural_insights"].append("Blueprint implements spawning/combat system")
+    
+    # Suggest integration opportunities based on existing nodes
+    existing_node_titles = [node.get("title", "") for node in all_nodes]
+    if "Event BeginPlay" in existing_node_titles:
+        analysis["integration_opportunities"].append("Can integrate with game initialization")
+    if any("Create" in title for title in existing_node_titles):
+        analysis["integration_opportunities"].append("Can extend object creation patterns")
+    
+    return analysis
+
+def generate_function_specification(analysis, function_description):
+    """Generate detailed function specification based on analysis"""
+    
+    # Determine function name from description (enhanced)
+    import re
+    
+    # Extract meaningful words and create a proper function name
+    words = function_description.lower().split()
+    
+    # Remove common stop words and get meaningful terms
+    stop_words = {"a", "an", "the", "to", "for", "with", "by", "from", "and", "or", "but", "in", "on", "at", "that", "this", "is", "are", "was", "were", "be", "been", "being"}
+    meaningful_words = [word for word in words if word.isalpha() and word not in stop_words]
+    
+    # Take first 2-3 meaningful words and capitalize them (without adding "Function" suffix)
+    if meaningful_words:
+        if len(meaningful_words) >= 3:
+            function_name = ''.join(word.capitalize() for word in meaningful_words[:3])
+        elif len(meaningful_words) == 2:
+            function_name = ''.join(word.capitalize() for word in meaningful_words)
+        else:
+            function_name = meaningful_words[0].capitalize()
+    else:
+        function_name = "GeneratedFunction"
+    
+    # Ensure function name starts with a verb if possible
+    action_words = {"create", "add", "remove", "delete", "update", "set", "get", "play", "stop", "start", "enable", "disable", "spawn", "destroy", "move", "rotate", "scale", "handle", "process", "check", "validate"}
+    first_word = words[0] if words else ""
+    
+    if first_word in action_words:
+        # Good, starts with action word
+        pass
+    elif any(word in action_words for word in words[:3]):
+        # Move action word to front
+        action_word = next(word for word in words[:3] if word in action_words)
+        other_words = [word for word in meaningful_words[:3] if word != action_word]
+        function_name = action_word.capitalize() + ''.join(word.capitalize() for word in other_words)
+    
+    # Clean up the function name
+    function_name = re.sub(r'[^a-zA-Z0-9]', '', function_name)
+    if not function_name or not function_name[0].isalpha():
+        function_name = "GeneratedFunction"
+    
+    spec = {
+        "function_name": function_name,
+        "description": function_description,
+        "inputs": [],
+        "outputs": [],
+        "suggested_nodes": [],
+        "complexity_estimate": "Medium"
+    }
+    
+    # Analyze description for common patterns and suggest inputs/outputs
+    desc_lower = function_description.lower()
+    
+    # Enhanced input patterns based on actual description analysis
+    words = function_description.lower().split()
+    
+    # Look for specific damage/health parameters
+    if "damage" in desc_lower:
+        if any(word in desc_lower for word in ["amount", "value", "points"]):
+            spec["inputs"].append({"name": "DamageAmount", "type": "float", "description": "Amount of damage to apply"})
+        if "player" in desc_lower or "character" in desc_lower:
+            spec["inputs"].append({"name": "DamagedActor", "type": "object", "description": "Actor receiving damage"})
+    
+    # Look for health system parameters
+    if "health" in desc_lower:
+        if "max" in desc_lower or "maximum" in desc_lower:
+            spec["inputs"].append({"name": "MaxHealth", "type": "float", "description": "Maximum health value"})
+        if "current" in desc_lower or "set" in desc_lower:
+            spec["inputs"].append({"name": "NewHealthValue", "type": "float", "description": "New health amount"})
+    
+    # Look for movement/jump parameters
+    if "jump" in desc_lower:
+        if "force" in desc_lower or "power" in desc_lower or "strength" in desc_lower:
+            spec["inputs"].append({"name": "JumpForce", "type": "vector", "description": "Jump force vector"})
+    
+    # Look for spawn parameters
+    if "spawn" in desc_lower or "create" in desc_lower:
+        if "location" in desc_lower or "position" in desc_lower:
+            spec["inputs"].append({"name": "SpawnLocation", "type": "vector", "description": "Location to spawn object"})
+        if "class" in desc_lower or "type" in desc_lower:
+            spec["inputs"].append({"name": "ActorClass", "type": "class", "description": "Class of actor to spawn"})
+    
+    # Look for UI/widget parameters
+    if any(word in desc_lower for word in ["widget", "ui", "screen", "menu"]):
+        if "show" in desc_lower or "display" in desc_lower:
+            spec["inputs"].append({"name": "WidgetClass", "type": "class", "description": "Widget class to display"})
+    
+    # Look for sound parameters
+    if "sound" in desc_lower or "audio" in desc_lower:
+        spec["inputs"].append({"name": "SoundToPlay", "type": "object", "description": "Sound asset to play"})
+        if "location" in desc_lower:
+            spec["inputs"].append({"name": "SoundLocation", "type": "vector", "description": "Location to play sound"})
+    
+    # Look for timer parameters
+    if "timer" in desc_lower:
+        if "delay" in desc_lower or "time" in desc_lower or "duration" in desc_lower:
+            spec["inputs"].append({"name": "TimerDuration", "type": "float", "description": "Timer duration in seconds"})
+    
+    # Common output patterns  
+    if any(word in desc_lower for word in ["success", "result", "completed"]):
+        spec["outputs"].append({"name": "Success", "type": "boolean", "description": "Whether operation succeeded"})
+    if any(word in desc_lower for word in ["create", "spawn", "generate"]):
+        spec["outputs"].append({"name": "CreatedObject", "type": "object", "description": "The created object reference"})
+    
+    # Suggest nodes based on description (enhanced with more patterns)
+    if "damage" in desc_lower:
+        spec["suggested_nodes"].extend(["Apply Damage", "Set Health", "Branch", "Greater", "Print String"])
+    if "sound" in desc_lower:
+        spec["suggested_nodes"].extend(["Play Sound", "Play Sound at Location", "Spawn Sound 2D"])
+    if "jump" in desc_lower:
+        spec["suggested_nodes"].extend(["Launch Character", "Set Movement Mode", "Branch", "Get Velocity"])
+    if "widget" in desc_lower or "ui" in desc_lower:
+        spec["suggested_nodes"].extend(["Create Widget", "Add to Viewport", "Set Visibility"])
+    if "timer" in desc_lower:
+        spec["suggested_nodes"].extend(["Set Timer by Function Name", "Clear Timer", "Get Timer Remaining"])
+    if "move" in desc_lower or "movement" in desc_lower:
+        spec["suggested_nodes"].extend(["Add Movement Input", "Set Actor Location", "Get Forward Vector"])
+    if "health" in desc_lower:
+        spec["suggested_nodes"].extend(["Set Health", "Get Health", "Branch", "Less Equal"])
+    if "spawn" in desc_lower or "create" in desc_lower:
+        spec["suggested_nodes"].extend(["Spawn Actor from Class", "Set Actor Location", "IsValid"])
+    if "collision" in desc_lower or "overlap" in desc_lower:
+        spec["suggested_nodes"].extend(["Set Collision Response", "OnComponentBeginOverlap", "Cast To"])
+    if "animation" in desc_lower or "anim" in desc_lower:
+        spec["suggested_nodes"].extend(["Play Animation", "Set Animation Mode", "Get Anim Instance"])
+    if "input" in desc_lower:
+        spec["suggested_nodes"].extend(["InputAction", "InputAxis", "Enable Input", "Disable Input"])
+    
+    # Add common utility nodes for most functions
+    if not spec["suggested_nodes"]:  # If no specific nodes were suggested
+        spec["suggested_nodes"].extend(["Branch", "Print String", "IsValid"])
+    
+    # Always add debug/utility nodes for complex functions
+    if len(spec["suggested_nodes"]) > 3:
+        spec["suggested_nodes"].append("Print String")  # For debugging
+    
+    # Context-aware node suggestions based on existing Blueprint patterns
+    existing_patterns = analysis.get("node_usage_patterns", [])
+    architectural_insights = analysis.get("architectural_insights", [])
+    
+    # Suggest nodes based on existing Blueprint architecture
+    if any("health" in insight.lower() for insight in architectural_insights):
+        if "health" in desc_lower and "Set Health" not in spec["suggested_nodes"]:
+            spec["suggested_nodes"].insert(0, "Set Health")
+    
+    if any("ui" in insight.lower() or "widget" in insight.lower() for insight in architectural_insights):
+        if any(word in desc_lower for word in ["show", "display", "update"]) and "Get Widget" not in spec["suggested_nodes"]:
+            spec["suggested_nodes"].append("Get Widget")
+    
+    if any("input" in insight.lower() for insight in architectural_insights):
+        if any(word in desc_lower for word in ["enable", "disable", "control"]):
+            spec["suggested_nodes"].append("Set Input Mode")
+    
+    # Add commonly used nodes from existing Blueprint
+    common_node_types = [pattern["type"] for pattern in existing_patterns if pattern["count"] > 2]
+    for node_type in common_node_types[:2]:  # Add up to 2 commonly used node types
+        if any(common in node_type for common in ["K2Node_CallFunction", "K2Node_Event"]):
+            continue  # Skip these base types
+        if node_type not in spec["suggested_nodes"]:
+            spec["suggested_nodes"].append(node_type.replace("K2Node_", "").replace("_", " "))
+    
+    # Remove duplicates while preserving order
+    seen = set()
+    spec["suggested_nodes"] = [node for node in spec["suggested_nodes"] if not (node in seen or seen.add(node))]
+    
+    # Ensure reasonable node count (between 2-8 nodes typically)
+    if len(spec["suggested_nodes"]) > 8:
+        spec["suggested_nodes"] = spec["suggested_nodes"][:8]
+    elif len(spec["suggested_nodes"]) < 2:
+        spec["suggested_nodes"].extend(["Branch", "Print String"])
+    
+    return spec
+
+def create_implementation_plan(function_spec, analysis):
+    """Create step-by-step implementation plan"""
+    plan = {
+        "steps": [],
+        "estimated_nodes": len(function_spec["suggested_nodes"]) + 2,  # +2 for entry/result
+        "integration_points": [],
+        "considerations": []
+    }
+    
+    # Step 1: Create function
+    plan["steps"].append({
+        "step": 1,
+        "action": "create_function",
+        "description": f"Create function '{function_spec['function_name']}'",
+        "details": {
+            "function_name": function_spec["function_name"],
+            "inputs": function_spec["inputs"],
+            "outputs": function_spec["outputs"]
+        }
+    })
+    
+    # Step 2: Add nodes
+    for i, node_type in enumerate(function_spec["suggested_nodes"]):
+        plan["steps"].append({
+            "step": i + 2,
+            "action": "add_node",
+            "description": f"Add {node_type} node",
+            "details": {
+                "node_type": node_type,
+                "position": [300 + i * 200, 100],
+                "purpose": f"Implements part of: {function_spec['description']}"
+            }
+        })
+    
+    # Step 3: Connect nodes
+    plan["steps"].append({
+        "step": len(function_spec["suggested_nodes"]) + 2,
+        "action": "connect_nodes",
+        "description": "Connect all nodes in execution order",
+        "details": "Sequential execution flow from function entry to result"
+    })
+    
+    # Integration suggestions
+    existing_patterns = analysis.get("execution_patterns", [])
+    if existing_patterns:
+        plan["integration_points"].append(
+            f"Can integrate with existing pattern: {existing_patterns[0].get('node', 'Unknown')}"
+        )
+    
+    # Considerations
+    blueprint_type = analysis.get("blueprint_info", {}).get("type", "")
+    if blueprint_type == "LevelScript":
+        plan["considerations"].append("Level Blueprint - consider using global events")
+    if "Widget" in str(analysis):
+        plan["considerations"].append("UI elements present - consider widget interactions")
+    
+    return plan
+
+def generate_integration_suggestions(analysis, function_spec):
+    """Generate suggestions for integrating the new function"""
+    suggestions = []
+    
+    # Based on existing nodes
+    existing_events = []
+    all_nodes = analysis.get("execution_patterns", [])
+    
+    for pattern in all_nodes:
+        if "Event" in pattern.get("node", ""):
+            existing_events.append(pattern["node"])
+    
+    if existing_events:
+        suggestions.append({
+            "type": "event_integration",
+            "description": f"Call {function_spec['function_name']} from existing event",
+            "target": existing_events[0],
+            "implementation": f"Add call to {function_spec['function_name']} after {existing_events[0]}"
+        })
+    
+    # Based on Blueprint type
+    blueprint_type = analysis.get("blueprint_info", {}).get("type", "")
+    if blueprint_type == "LevelScript":
+        suggestions.append({
+            "type": "level_limitation_warning",
+            "description": "Level Script Blueprints cannot have custom functions",
+            "implementation": "Create a regular Blueprint class (Actor, Object, etc.) for custom functions, or use events in the Level Script"
+        })
+        suggestions.append({
+            "type": "level_integration",
+            "description": "Integrate with level-specific gameplay events",
+            "implementation": "Consider calling from BeginPlay or level-specific triggers"
+        })
+
+    return suggestions
+
+def _implement_generated_blueprint_function(generation_result: str, execute_plan: bool = True) -> str:
+    """
+    Actually implement a Blueprint function that was generated by generate_blueprint_function_from_context.
+    This tool takes the output from the generator and creates the actual Blueprint function.
+    
+    Args:
+        generation_result: JSON string output from generate_blueprint_function_from_context
+        execute_plan: Whether to automatically execute the implementation plan (default: True)
+        
+    Returns:
+        JSON string with implementation results and created function details
+        
+    Example:
+        1. First generate: result = generate_blueprint_function_from_context("Add jump ability")  
+        2. Then implement: implement_generated_blueprint_function(result, True)
+        
+    This tool will:
+    1. Parse the generation result 
+    2. Create the Blueprint function with specified inputs/outputs
+    3. Add all suggested nodes in correct positions
+    4. Connect nodes according to the implementation plan
+    5. Return success/failure details with function ID for further use
+    """
+    try:
+        # Parse the generation result
+        try:
+            gen_data = json.loads(generation_result)
+        except json.JSONDecodeError:
+            return json.dumps({
+                "success": False, 
+                "error": "Invalid generation result JSON"
+            })
+        
+        if not gen_data.get("success"):
+            return json.dumps({
+                "success": False,
+                "error": "Generation result indicates failure"
+            })
+        
+        function_spec = gen_data.get("function_specification", {})
+        implementation_plan = gen_data.get("implementation_plan", {})
+        target_blueprint = gen_data.get("target_blueprint", "Unknown")
+        
+        # Get the target Blueprint path from context
+        context_cmd = {"type": "get_blueprint_context", "include_editor_state": True}
+        context_response = send_to_unreal(context_cmd)
+        
+        if not context_response.get("success"):
+            return json.dumps({
+                "success": False,
+                "error": f"Cannot get Blueprint context: {context_response.get('error')}"
+            })
+        
+        blueprint_path = context_response.get("active_blueprint", {}).get("path", "")
+        if not blueprint_path:
+            return json.dumps({
+                "success": False,
+                "error": "No active Blueprint path found"
+            })
+        
+        implementation_results = {
+            "success": True,
+            "target_blueprint": target_blueprint,
+            "blueprint_path": blueprint_path,
+            "function_name": function_spec.get("function_name", "Unknown"),
+            "implementation_steps": [],
+            "created_function_id": None,
+            "created_nodes": [],
+            "errors": []
+        }
+        
+        if not execute_plan:
+            implementation_results["message"] = "Plan parsed successfully but not executed (execute_plan=False)"
+            return json.dumps(implementation_results, indent=2)
+        
+        # Step 1: Create the function (check if it already exists first)
+        step1 = implementation_plan.get("steps", [{}])[0]
+        if step1.get("action") == "create_function":
+            details = step1.get("details", {})
+            function_name = details.get("function_name", "GeneratedFunction")
+
+            # Check if function already exists to prevent duplication
+            check_function_cmd = {
+                "type": "get_all_nodes",
+                "blueprint_path": blueprint_path
+            }
+
+            existing_check = send_to_unreal(check_function_cmd)
+            function_already_exists = False
+            existing_function_id = None
+
+            if existing_check.get("success"):
+                # Check if function with EXACT same name already exists (prevent duplicates)
+                for graph_name, graph_data in existing_check.get("graphs", {}).items():
+                    # Only match exact function names, not partial matches
+                    graph_clean_name = graph_name.replace(" ", "").lower()
+                    function_clean_name = function_name.replace(" ", "").lower()
+                    
+                    if graph_clean_name == function_clean_name:
+                        function_already_exists = True
+                        # Try to get the function entry node ID
+                        for node in graph_data.get("nodes", []):
+                            if node.get("type") == "FunctionEntry":
+                                existing_function_id = node.get("id")
+                                break
+                        break
+                
+                # If function exists, suggest a unique name instead of reusing
+                if function_already_exists:
+                    counter = 2
+                    original_name = function_name
+                    while function_already_exists:
+                        function_name = f"{original_name}{counter}"
+                        function_already_exists = False
+                        for graph_name, graph_data in existing_check.get("graphs", {}).items():
+                            graph_clean_name = graph_name.replace(" ", "").lower()
+                            function_clean_name = function_name.replace(" ", "").lower()
+                            if graph_clean_name == function_clean_name:
+                                function_already_exists = True
+                                break
+                        counter += 1
+                        if counter > 10:  # Prevent infinite loop
+                            break
+                    
+                    # Update the function name in details
+                    details["function_name"] = function_name
+                    function_already_exists = False  # Create with new name
+
+            if function_already_exists and existing_function_id:
+                # Function already exists, use it instead of creating a new one
+                implementation_results["created_function_id"] = existing_function_id
+                implementation_results["implementation_steps"].append({
+                    "step": 1,
+                    "action": "use_existing_function",
+                    "success": True,
+                    "result": f"Using existing function: {function_name}"
+                })
+                function_result = {"success": True, "function_id": existing_function_id}
+            else:
+                # Create new function
+                inputs_json = json.dumps(details.get("inputs", []))
+                outputs_json = json.dumps(details.get("outputs", []))
+
+                create_function_cmd = {
+                    "type": "add_function",
+                    "blueprint_path": blueprint_path,
+                    "function_name": function_name,
+                    "inputs": inputs_json,
+                    "outputs": outputs_json
+                }
+
+                function_result = send_to_unreal(create_function_cmd)
+            
+            if function_result.get("success") or function_result.get("function_id"):
+                function_id = function_result.get("function_id", "")
+                implementation_results["created_function_id"] = function_id
+                implementation_results["implementation_steps"].append({
+                    "step": 1,
+                    "action": "create_function", 
+                    "success": True,
+                    "result": f"Created function: {details.get('function_name')}"
+                })
+                
+                # Step 2: Add nodes to the function
+                suggested_nodes = function_spec.get("suggested_nodes", [])
+                node_positions = {}
+                
+                for i, node_type in enumerate(suggested_nodes):
+                    add_node_cmd = {
+                        "type": "add_node",
+                        "blueprint_path": blueprint_path,
+                        "function_id": function_id,
+                        "node_type": node_type,
+                        "node_position": [300 + i * 250, 100 + (i % 2) * 150],
+                        "node_properties": {}
+                    }
+                    
+                    node_result = send_to_unreal(add_node_cmd)
+                    
+                    if node_result.get("success") or node_result.get("node_id"):
+                        node_id = node_result.get("node_id", "")
+                        implementation_results["created_nodes"].append({
+                            "node_type": node_type,
+                            "node_id": node_id,
+                            "position": add_node_cmd["node_position"]
+                        })
+                        node_positions[node_type] = node_id
+                        
+                        implementation_results["implementation_steps"].append({
+                            "step": i + 2,
+                            "action": "add_node",
+                            "success": True,
+                            "result": f"Added {node_type} node"
+                        })
+                    else:
+                        implementation_results["errors"].append(f"Failed to add {node_type} node: {node_result.get('error', 'Unknown error')}")
+                
+                # Step 3: Connect nodes (basic sequential connection)
+                if len(implementation_results["created_nodes"]) > 1:
+                    connections = []
+                    
+                    # Connect function entry to first node
+                    if implementation_results["created_nodes"]:
+                        first_node = implementation_results["created_nodes"][0]
+                        connections.append({
+                            "source_node_id": "function_entry",  # Will need to get actual entry node ID
+                            "source_pin": "exec",
+                            "target_node_id": first_node["node_id"],
+                            "target_pin": "exec"
+                        })
+                    
+                    # Connect nodes sequentially
+                    for i in range(len(implementation_results["created_nodes"]) - 1):
+                        source_node = implementation_results["created_nodes"][i]
+                        target_node = implementation_results["created_nodes"][i + 1]
+                        
+                        connections.append({
+                            "source_node_id": source_node["node_id"],
+                            "source_pin": "exec",  # Default exec pin
+                            "target_node_id": target_node["node_id"],
+                            "target_pin": "exec"
+                        })
+                    
+                    # Attempt to connect nodes
+                    if connections:
+                        connect_cmd = {
+                            "type": "connect_nodes_bulk",
+                            "blueprint_path": blueprint_path,
+                            "function_id": function_id,
+                            "connections": connections
+                        }
+                        
+                        connect_result = send_to_unreal(connect_cmd)
+                        
+                        if connect_result.get("success") or connect_result.get("successful_connections", 0) > 0:
+                            implementation_results["implementation_steps"].append({
+                                "step": len(suggested_nodes) + 2,
+                                "action": "connect_nodes",
+                                "success": True,
+                                "result": f"Connected {connect_result.get('successful_connections', 0)} node pairs"
+                            })
+                        else:
+                            implementation_results["errors"].append(f"Node connection failed: {connect_result.get('error', 'Unknown error')}")
+                
+                # Compile the Blueprint
+                compile_cmd = {
+                    "type": "compile_blueprint",
+                    "blueprint_path": blueprint_path
+                }
+                
+                compile_result = send_to_unreal(compile_cmd)
+                implementation_results["implementation_steps"].append({
+                    "step": len(suggested_nodes) + 3,
+                    "action": "compile_blueprint", 
+                    "success": compile_result.get("success", False),
+                    "result": "Blueprint compilation " + ("succeeded" if compile_result.get("success") else "failed")
+                })
+                
+            else:
+                implementation_results["success"] = False
+                implementation_results["errors"].append(f"Failed to create function: {function_result.get('error', 'Unknown error')}")
+        
+        # Final assessment
+        if implementation_results["errors"]:
+            implementation_results["success"] = len(implementation_results["errors"]) < len(implementation_results["implementation_steps"])
+            implementation_results["message"] = f"Completed with {len(implementation_results['errors'])} errors"
+        else:
+            implementation_results["message"] = "Function implemented successfully"
+        
+        return json.dumps(implementation_results, indent=2)
+        
+    except Exception as e:
+        return json.dumps({
+            "success": False,
+            "error": f"Implementation failed: {str(e)}"
+        })
+
+# Node Discovery System
+@mcp.tool()
+def discover_available_blueprint_nodes(search_categories: Optional[List[str]] = None) -> str:
+    """
+    Discover what Blueprint nodes are actually available in the current Unreal Engine version and project.
+    This runs automatically when 'Sync with AI' is clicked to build a real-time inventory.
+
+    Args:
+        search_categories: List of categories to search ["math", "vector", "string", "gameplay", "system", "all"]
+                          If None, searches all categories
+
+    Returns:
+        JSON string with comprehensive node inventory including:
+        - Available node types and their exact names
+        - Library mappings (KismetMathLibrary, etc.)
+        - UE version-specific naming conventions
+        - Custom project nodes and plugins
+
+    This solves the "MakeVector not found" issue by showing what's actually available.
+    """
+    try:
+        if search_categories is None:
+            search_categories = ["math", "vector", "string", "gameplay", "system", "conversion"]
+
+        command = {
+            "type": "discover_available_blueprint_nodes",
+            "search_categories": search_categories,
+            "include_libraries": True,
+            "include_custom_nodes": True,
+            "include_plugin_nodes": True
+        }
+        response = send_to_unreal(command)
+
+        if response.get("success"):
+            # Cache the discovered nodes for this session
+            global _discovered_nodes_cache
+            _discovered_nodes_cache = response.get("discovered_nodes", {})
+
+            return json.dumps({
+                "success": True,
+                "message": "Node discovery completed successfully",
+                "unreal_version": response.get("unreal_version", "Unknown"),
+                "total_nodes_found": response.get("total_nodes_found", 0),
+                "categories_searched": search_categories,
+                "discovered_nodes": response.get("discovered_nodes", {}),
+                "library_mappings": response.get("library_mappings", {}),
+                "recommended_alternatives": response.get("recommended_alternatives", {}),
+                "discovery_timestamp": response.get("discovery_timestamp", "Unknown")
+            }, indent=2)
+        else:
+            return json.dumps({
+                "success": False,
+                "error": response.get("error", "Failed to discover nodes"),
+                "message": "Node discovery unavailable - implementing fallback discovery",
+                "fallback_attempted": True
+            }, indent=2)
+    except Exception as e:
+        return json.dumps({
+            "success": False,
+            "error": f"Error discovering nodes: {str(e)}",
+            "message": "Critical error in node discovery system"
+        }, indent=2)
+
+@mcp.tool()
+def get_node_alternatives(failed_node_name: str) -> str:
+    """
+    Get alternative node names for a failed node creation attempt.
+    Uses the discovered node cache to suggest working alternatives.
+
+    Args:
+        failed_node_name: The node name that failed to be created (e.g., "MakeVector")
+
+    Returns:
+        JSON string with alternative node names that might work
+    """
+    try:
+        command = {
+            "type": "get_node_alternatives",
+            "failed_node_name": failed_node_name,
+            "use_discovery_cache": True
+        }
+        response = send_to_unreal(command)
+
+        if response.get("success"):
+            return json.dumps(response, indent=2)
+        else:
+            # Fallback: use cached discovery data if available
+            global _discovered_nodes_cache
+            if _discovered_nodes_cache:
+                alternatives = []
+                search_term = failed_node_name.lower()
+
+                for category, nodes in _discovered_nodes_cache.items():
+                    for node_name in nodes:
+                        if search_term in node_name.lower() or "vector" in node_name.lower():
+                            alternatives.append({
+                                "node_name": node_name,
+                                "category": category,
+                                "confidence": "medium"
+                            })
+
+                return json.dumps({
+                    "success": True,
+                    "failed_node": failed_node_name,
+                    "alternatives_found": len(alternatives),
+                    "alternatives": alternatives,
+                    "source": "cached_discovery"
+                }, indent=2)
+            else:
+                return json.dumps({
+                    "success": False,
+                    "error": "No alternatives found and no discovery cache available",
+                    "suggestion": "Run discover_available_blueprint_nodes first"
+                }, indent=2)
+    except Exception as e:
+        return json.dumps({
+            "success": False,
+            "error": f"Error getting alternatives: {str(e)}"
+        }, indent=2)
+
+@mcp.tool()
+def smart_add_node_with_discovery(blueprint_path: str, function_id: str, requested_node: str,
+                                 node_position: list = [0, 0], auto_find_alternatives: bool = True) -> str:
+    """
+    Smart node addition with enhanced discovery - now largely redundant due to comprehensive built-in discovery.
+    The main add_node_to_blueprint function now handles comprehensive discovery automatically.
+
+    Args:
+        blueprint_path: Path to the Blueprint asset
+        function_id: ID of the function to add the node to
+        requested_node: The node type you want (any format accepted - "Add", "SetActorRotation", "KismetMathLibrary.MakeVector", etc.)
+        node_position: Position of the node in the graph [X, Y]
+        auto_find_alternatives: If True, tries additional alternatives (usually not needed with enhanced discovery)
+
+    Returns:
+        JSON string with creation result and any alternatives tried
+
+    Note:
+        With the enhanced discovery system, this function is mostly a wrapper around add_node_to_blueprint.
+        The main function now handles comprehensive discovery, variations, and suggestions automatically.
+        This function is maintained for backward compatibility and additional fallback options.
+    """
+    try:
+        result = {
+            "success": False,
+            "requested_node": requested_node,
+            "attempts": [],
+            "final_node_id": None,
+            "discovery_method": "enhanced_comprehensive",
+            "alternatives_tried": []
+        }
+
+        # The enhanced add_node_to_blueprint now handles comprehensive discovery automatically
+        first_attempt = add_node_to_blueprint(blueprint_path, function_id, requested_node, node_position)
+        result["attempts"].append({
+            "node_name": requested_node,
+            "result": first_attempt,
+            "success": "Successfully added" in first_attempt,
+            "method": "comprehensive_discovery"
+        })
+
+        if "Successfully added" in first_attempt:
+            result["success"] = True
+            if "with ID:" in first_attempt:
+                result["final_node_id"] = first_attempt.split("with ID:")[-1].strip()
+            result["message"] = "Node created successfully using enhanced discovery system"
+            return json.dumps(result, indent=2)
+
+        # If it still failed, check if suggestions were provided
+        if "SUGGESTIONS:" in first_attempt:
+            result["suggestions_provided"] = True
+            result["message"] = "Enhanced discovery provided suggestions for alternatives"
+        else:
+            result["suggestions_provided"] = False
+            result["message"] = "Node creation failed even with comprehensive discovery"
+
+        # Only try additional alternatives if specifically requested and no suggestions were provided
+        if auto_find_alternatives and not result["suggestions_provided"]:
+            alternatives_response = get_node_alternatives(requested_node)
+            try:
+                alternatives_data = json.loads(alternatives_response)
+                if alternatives_data.get("success") and alternatives_data.get("alternatives"):
+
+                    for alt in alternatives_data["alternatives"][:2]:  # Try top 2 alternatives as fallback
+                        alt_name = alt["node_name"]
+                        alt_attempt = add_node_to_blueprint(blueprint_path, function_id, alt_name, node_position)
+
+                        result["attempts"].append({
+                            "node_name": alt_name,
+                            "result": alt_attempt,
+                            "success": "Successfully added" in alt_attempt,
+                            "alternative_for": requested_node,
+                            "method": "fallback_alternatives"
+                        })
+                        result["alternatives_tried"].append(alt_name)
+
+                        if "Successfully added" in alt_attempt:
+                            result["success"] = True
+                            if "with ID:" in alt_attempt:
+                                result["final_node_id"] = alt_attempt.split("with ID:")[-1].strip()
+                            result["successful_alternative"] = alt_name
+                            result["message"] = f"Node created using fallback alternative: {alt_name}"
+                            break
+            except:
+                pass  # Continue with original failure
+
+        return json.dumps(result, indent=2)
+
+    except Exception as e:
+        return json.dumps({
+            "success": False,
+            "error": f"Error in smart node addition: {str(e)}",
+            "requested_node": requested_node
+        }, indent=2)
+
+# Global cache for discovered nodes
+_discovered_nodes_cache = {}
+
+@mcp.tool()
+def set_node_pin_default_value(blueprint_path: str, function_guid: str, node_guid: str, pin_name: str, value: str) -> str:
+    """
+    Set the default value of a node pin - SOLVES the automation limitation!
+    This is the key function that allows full automation without manual steps.
+
+    Args:
+        blueprint_path: Path to the Blueprint asset
+        function_guid: GUID of the function containing the node
+        node_guid: GUID of the node (returned from add_node_to_blueprint)
+        pin_name: Name of the pin to set (e.g., "X", "Y", "Z" for MakeVector)
+        value: Value to set (e.g., "0.0", "1.0")
+
+    Returns:
+        Success/failure message
+
+    Example usage for MakeVector:
+        set_node_pin_default_value(blueprint_path, func_id, makevector_node_id, "X", "0.0")
+        set_node_pin_default_value(blueprint_path, func_id, makevector_node_id, "Y", "0.0")
+        set_node_pin_default_value(blueprint_path, func_id, makevector_node_id, "Z", "1.0")
+    """
+    try:
+        command = {
+            "type": "set_node_pin_default_value",
+            "blueprint_path": blueprint_path,
+            "function_guid": function_guid,
+            "node_guid": node_guid,
+            "pin_name": pin_name,
+            "value": value
+        }
+        response = send_to_unreal(command)
+
+        if response.get("success"):
+            return f"Successfully set {pin_name} = {value} on node {node_guid}"
+        else:
+            return f"Failed to set pin value: {response.get('error', 'Unknown error')}"
+
+    except Exception as e:
+        return f"Error setting pin value: {str(e)}"
+
+@mcp.tool()
+def get_node_pin_info(blueprint_path: str, function_guid: str, node_guid: str) -> str:
+    """
+    Get information about all pins on a node.
+    Useful for discovering what pins are available and their current values.
+
+    Args:
+        blueprint_path: Path to the Blueprint asset
+        function_guid: GUID of the function containing the node
+        node_guid: GUID of the node
+
+    Returns:
+        JSON string with pin information including names, types, directions, and current values
+    """
+    try:
+        command = {
+            "type": "get_node_pin_info",
+            "blueprint_path": blueprint_path,
+            "function_guid": function_guid,
+            "node_guid": node_guid
+        }
+        response = send_to_unreal(command)
+
+        if response.get("success"):
+            return json.dumps(response, indent=2)
+        else:
+            return json.dumps({
+                "success": False,
+                "error": response.get("error", "Failed to get pin info"),
+                "node_guid": node_guid
+            }, indent=2)
+
+    except Exception as e:
+        return json.dumps({
+            "success": False,
+            "error": f"Error getting pin info: {str(e)}",
+            "node_guid": node_guid
+        }, indent=2)
+
+# Project Control
+@mcp.tool()
+def create_project_folder(folder_path: str) -> str:
+    """
+    Create a new folder in the Unreal project content directory.
+    Args:
+        folder_path: Path relative to /Game (e.g., "FlappyBird/Assets")
+    """
+    command = {"type": "create_project_folder", "folder_path": folder_path}
+    response = send_to_unreal(command)
+    return response.get("message", f"Failed: {response.get('error', 'Unknown error')}")
+
+@mcp.tool()
+def get_files_in_folder(folder_path: str) -> str:
+    """
+    List all files in a specified project folder.
+    Args:
+        folder_path: Path relative to /Game (e.g., "FlappyBird/Assets")
+    """
+    command = {"type": "get_files_in_folder", "folder_path": folder_path}
+    response = send_to_unreal(command)
+    return json.dumps(response.get("files", [])) if response.get("success") else f"Failed: {response.get('error')}"
+
+@mcp.tool()
+def create_game_mode(game_mode_path: str, pawn_blueprint_path: str, base_class: str = "GameModeBase") -> str:
+    """Create a game mode Blueprint, set its default pawn, and assign it as the current scene's default game mode.
+    Args:
+        game_mode_path: Path for new game mode (e.g., "/Game/MyGameMode")
+        pawn_blueprint_path: Path to pawn Blueprint (e.g., "/Game/Blueprints/BP_Player")
+        base_class: Base class for game mode (default: "GameModeBase")
+    """
+    try:
+        command = {
+            "type": "create_game_mode",
+            "game_mode_path": game_mode_path,
+            "pawn_blueprint_path": pawn_blueprint_path,
+            "base_class": base_class
+        }
+        response = _ensure_dict_response(send_to_unreal(command))
+        if response.get("success"):
+            return response.get(
+                "message",
+                f"Created game mode {game_mode_path} with pawn {pawn_blueprint_path}"
+            )
+        return f"Failed: {response.get('error', 'Unknown error')}"
+    except Exception as e:
+        return f"Error creating game mode: {str(e)}"
+
+@mcp.tool()
+def add_widget_to_user_widget(user_widget_path: str, widget_type: str, widget_name: str, parent_widget_name: str = "") -> str:
+    """
+    Adds a new widget (like TextBlock, Button, Image, CanvasPanel, VerticalBox) to a User Widget Blueprint.
+    Args:
+        user_widget_path: Path to the User Widget Blueprint (e.g., "/Game/UI/WBP_MainMenu").
+        widget_type: Class name of the widget to add (e.g., "TextBlock", "Button", "Image", "CanvasPanel", "VerticalBox", "HorizontalBox", "SizeBox", "Border"). Case-sensitive.
+        widget_name: A unique desired name for the new widget variable (e.g., "TitleText", "StartButton", "PlayerHealthBar"). The actual name might get adjusted for uniqueness.
+        parent_widget_name: Optional. The name of an existing Panel widget (like CanvasPanel, VerticalBox) inside the User Widget to attach this new widget to. If empty, attempts to attach to the root or the first available CanvasPanel.
+    Returns:
+        JSON string indicating success (with actual widget name) or failure with an error message.
+    """
+    command = {
+        "type": "add_widget_to_user_widget",
+        "user_widget_path": user_widget_path,
+        "widget_type": widget_type,
+        "widget_name": widget_name,
+        "parent_widget_name": parent_widget_name
+    }
+
+    # Use json.loads to parse the JSON string returned by send_to_unreal
+    response = _ensure_dict_response(send_to_unreal(command))
+    if response.get("success"):
+        actual_name = response.get("widget_name", widget_name)
+        return response.get(
+            "message",
+            f"Successfully added widget '{actual_name}' of type '{widget_type}' to '{user_widget_path}'."
+        )
+    error_message = response.get("error", "Unknown C++ error")
+    raw_suffix = f" Raw response: {response.get('raw')}" if "raw" in response else ""
+    return f"Failed to add widget: {error_message}{raw_suffix}"
+
+@mcp.tool()
+def edit_widget_property(user_widget_path: str, widget_name: str, property_name: str, value: str) -> str:
+    """
+    Edits a property of a specific widget within a User Widget Blueprint.
+    Args:
+        user_widget_path: Path to the User Widget Blueprint (e.g., "/Game/UI/WBP_MainMenu").
+        widget_name: The name of the widget inside the User Widget whose property you want to change (e.g., "TitleText", "StartButton").
+        property_name: The name of the property to edit. For layout properties controlled by the parent panel (like position, size, anchors in a CanvasPanel), prefix with "Slot." (e.g., "Text", "ColorAndOpacity", "Brush.ImageSize", "Slot.Position", "Slot.Size", "Slot.Anchors", "Slot.Alignment"). For UImage textures you can also use "Texture", "BrushFromTexture", or "Brush.ResourceObject". For UButton styles use "ButtonTexture" (all states) or "NormalTexture"/"HoveredTexture"/"PressedTexture". Case-sensitive.
+        value: The new value for the property, formatted as a string EXACTLY as Unreal expects for ImportText. Examples:
+               - Text: '"Hello World!"' (Note: String literal requires inner quotes)
+               - Float: '150.0'
+               - Integer: '10'
+               - Boolean: 'true' or 'false'
+               - LinearColor: '(R=1.0,G=0.0,B=0.0,A=1.0)'
+               - Vector2D (for Size, Position): '(X=200.0,Y=50.0)'
+               - Anchors: '(Minimum=(X=0.5,Y=0.0),Maximum=(X=0.5,Y=0.0))' (Top Center Anchor)
+               - Alignment (Vector2D): '(X=0.5,Y=0.5)' (Center Alignment)
+               - Font (FSlateFontInfo): "(FontObject=Font'/Engine/EngineFonts/Roboto.Roboto',Size=24)"
+               - Texture (Object Path): "Texture2D'/Game/Textures/MyIcon.MyIcon'" OR "/Game/Textures/MyIcon"
+               - Enum (e.g., Stretch): 'ScaleToFit'
+    Returns:
+        JSON string indicating success or failure with an error message.
+    """
+    command = {
+        "type": "edit_widget_property",
+        "user_widget_path": user_widget_path,
+        "widget_name": widget_name,
+        "property_name": property_name,
+        "value": value  # Pass the string value directly
+    }
+
+    # Use json.loads to parse the JSON string returned by send_to_unreal
+    response = _ensure_dict_response(send_to_unreal(command))
+    if response.get("success"):
+        return response.get(
+            "message",
+            f"Successfully set property '{property_name}' on widget '{widget_name}'."
+        )
+    error_message = response.get("error", "Unknown C++ error")
+    raw_suffix = f" Raw response: {response.get('raw')}" if "raw" in response else ""
+    return f"Failed to edit widget property: {error_message}{raw_suffix}"
+
+# --- NEW UI TOOLS ---
+
+@mcp.tool()
+def create_user_widget(widget_name: str, save_path: str = "/Game/UI", root_widget_type: str = "CanvasPanel") -> str:
+    """
+    Creates a new empty Widget Blueprint with a configurable root panel.
+    Args:
+        widget_name: Name for the new Widget Blueprint asset (e.g., "WBP_MainMenu", "WBP_HUD").
+        save_path: Content folder path to save the Widget Blueprint to (e.g., "/Game/UI", "/Game/Widgets"). Defaults to "/Game/UI".
+        root_widget_type: Class name of the root panel widget. Must be a panel type. Common values: "CanvasPanel" (default, free-form positioning), "VerticalBox" (vertical layout), "HorizontalBox" (horizontal layout), "Overlay" (stacked layers), "ScrollBox" (scrollable container).
+    Returns:
+        JSON with success, widget_path, and root_widget_name.
+    """
+    command = {
+        "type": "create_user_widget",
+        "widget_name": widget_name,
+        "save_path": save_path,
+        "root_widget_type": root_widget_type
+    }
+
+    response = _ensure_dict_response(send_to_unreal(command))
+    if response.get("success"):
+        widget_path = response.get("widget_path", "")
+        root_name = response.get("root_widget_name", "")
+        return response.get("message", f"Created Widget Blueprint '{widget_name}' at {widget_path} with root '{root_name}'.")
+    error_message = response.get("error", "Unknown error")
+    raw_suffix = f" Raw response: {response.get('raw')}" if "raw" in response else ""
+    return f"Failed to create widget: {error_message}{raw_suffix}"
+
+
+@mcp.tool()
+def get_widget_hierarchy(user_widget_path: str) -> str:
+    """
+    Inspects the full widget tree structure of a User Widget Blueprint. Returns a nested JSON hierarchy showing every widget, its type, slot type, and children.
+    Use this to understand the current state of a UI before making changes.
+    Args:
+        user_widget_path: Path to the User Widget Blueprint (e.g., "/Game/UI/WBP_MainMenu").
+    Returns:
+        JSON with nested hierarchy tree: each node has "name", "class", "slot_type", "is_variable", and "children" array.
+    """
+    command = {
+        "type": "get_widget_hierarchy",
+        "user_widget_path": user_widget_path
+    }
+
+    response = _ensure_dict_response(send_to_unreal(command))
+    if response.get("success"):
+        # Return the full JSON response so the AI can parse the hierarchy
+        return json.dumps(response)
+    error_message = response.get("error", "Unknown error")
+    return f"Failed to get widget hierarchy: {error_message}"
+
+
+@mcp.tool()
+def get_widget_properties(user_widget_path: str, widget_name: str, property_names: str = "") -> str:
+    """
+    Reads current property values of a specific widget within a User Widget Blueprint.
+    Args:
+        user_widget_path: Path to the User Widget Blueprint (e.g., "/Game/UI/WBP_MainMenu").
+        widget_name: Name of the widget to inspect (e.g., "TitleText", "StartButton").
+        property_names: Optional comma-separated list of specific properties to read (e.g., "Text,ColorAndOpacity,Slot.Size"). If empty, returns all properties.
+    Returns:
+        JSON with widget properties and slot properties.
+    """
+    command = {
+        "type": "get_widget_properties",
+        "user_widget_path": user_widget_path,
+        "widget_name": widget_name,
+        "property_names": property_names
+    }
+
+    response = _ensure_dict_response(send_to_unreal(command))
+    if response.get("success"):
+        return json.dumps(response)
+    error_message = response.get("error", "Unknown error")
+    return f"Failed to get widget properties: {error_message}"
+
+
+@mcp.tool()
+def remove_widget_from_user_widget(user_widget_path: str, widget_name: str, remove_children: bool = True) -> str:
+    """
+    Removes a widget from a User Widget Blueprint's hierarchy.
+    Args:
+        user_widget_path: Path to the User Widget Blueprint (e.g., "/Game/UI/WBP_MainMenu").
+        widget_name: Name of the widget to remove (e.g., "OldButton", "UnusedImage").
+        remove_children: If True (default), removes the widget and all its children. If False, reparents children to the removed widget's parent panel.
+    Returns:
+        JSON indicating success or failure.
+    """
+    command = {
+        "type": "remove_widget_from_user_widget",
+        "user_widget_path": user_widget_path,
+        "widget_name": widget_name,
+        "remove_children": remove_children
+    }
+
+    response = _ensure_dict_response(send_to_unreal(command))
+    if response.get("success"):
+        return response.get("message", f"Successfully removed widget '{widget_name}'.")
+    error_message = response.get("error", "Unknown error")
+    return f"Failed to remove widget: {error_message}"
+
+
+@mcp.tool()
+def add_widgets_bulk(user_widget_path: str, widgets: str) -> str:
+    """
+    Adds multiple widgets to a User Widget Blueprint in a single call. Much more efficient than calling add_widget_to_user_widget multiple times.
+    Args:
+        user_widget_path: Path to the User Widget Blueprint (e.g., "/Game/UI/WBP_MainMenu").
+        widgets: JSON array string where each element is an object with:
+                 - "widget_type": Class name (e.g., "TextBlock", "Button", "Image")
+                 - "widget_name": Desired unique name (e.g., "TitleText", "StartButton")
+                 - "parent_widget_name": Optional parent panel name (e.g., "RootPanel"). If omitted, attaches to root.
+                 Example: '[{"widget_type":"TextBlock","widget_name":"Title","parent_widget_name":"RootPanel"},{"widget_type":"Button","widget_name":"PlayBtn","parent_widget_name":"RootPanel"}]'
+    Returns:
+        JSON with results array (per-widget success/failure), failed_count, and total_count.
+    """
+    # Parse the widgets string to ensure it's valid JSON, then pass as list
+    try:
+        widgets_list = json.loads(widgets) if isinstance(widgets, str) else widgets
+    except json.JSONDecodeError:
+        return f"Failed to parse widgets JSON: invalid JSON format"
+
+    command = {
+        "type": "add_widgets_bulk",
+        "user_widget_path": user_widget_path,
+        "widgets": widgets_list
+    }
+
+    response = _ensure_dict_response(send_to_unreal(command))
+    if response.get("success"):
+        total = response.get("total_count", 0)
+        failed = response.get("failed_count", 0)
+        return f"Successfully added {total - failed}/{total} widgets to '{user_widget_path}'."
+    # Even partial success returns useful info
+    if "results" in response:
+        total = response.get("total_count", 0)
+        failed = response.get("failed_count", 0)
+        return f"Bulk add partially completed: {total - failed}/{total} succeeded. Details: {json.dumps(response.get('results', []))}"
+    error_message = response.get("error", "Unknown error")
+    return f"Failed bulk add: {error_message}"
+
+
+@mcp.tool()
+def edit_widget_properties_bulk(user_widget_path: str, edits: str) -> str:
+    """
+    Sets multiple properties across multiple widgets in a single call. Much more efficient than calling edit_widget_property multiple times.
+    Args:
+        user_widget_path: Path to the User Widget Blueprint (e.g., "/Game/UI/WBP_MainMenu").
+        edits: JSON array string where each element is an object with:
+               - "widget_name": Name of the target widget
+               - "property_name": Property to edit (prefix "Slot." for layout properties)
+               - "value": New value string in Unreal ImportText format
+               Example: '[{"widget_name":"Title","property_name":"Text","value":"\"Welcome!\""},{"widget_name":"Title","property_name":"Slot.Size","value":"(X=400.0,Y=60.0)"}]'
+    Returns:
+        JSON with results array (per-edit success/failure), failed_count, and total_count.
+    """
+    try:
+        edits_list = json.loads(edits) if isinstance(edits, str) else edits
+    except json.JSONDecodeError:
+        return f"Failed to parse edits JSON: invalid JSON format"
+
+    command = {
+        "type": "edit_widget_properties_bulk",
+        "user_widget_path": user_widget_path,
+        "edits": edits_list
+    }
+
+    response = _ensure_dict_response(send_to_unreal(command))
+    if response.get("success"):
+        total = response.get("total_count", 0)
+        failed = response.get("failed_count", 0)
+        return f"Successfully applied {total - failed}/{total} property edits in '{user_widget_path}'."
+    if "results" in response:
+        total = response.get("total_count", 0)
+        failed = response.get("failed_count", 0)
+        return f"Bulk edit partially completed: {total - failed}/{total} succeeded. Details: {json.dumps(response.get('results', []))}"
+    error_message = response.get("error", "Unknown error")
+    return f"Failed bulk edit: {error_message}"
+
+
+@mcp.tool()
+def list_available_widget_types(include_engine_widgets: bool = True, include_project_widgets: bool = True) -> str:
+    """
+    Lists all available widget types that can be used with add_widget_to_user_widget and add_widgets_bulk.
+    Use this to discover which widget classes are available before building a UI.
+    Args:
+        include_engine_widgets: Include built-in UMG/Engine widget types (TextBlock, Button, Image, etc.). Default: True.
+        include_project_widgets: Include project-specific (user-created) widget types. Default: True.
+    Returns:
+        JSON with categorized list of widget types. Each entry has: class_name, category (Layout/Input/Display/Utility/Other), is_panel (can contain children), is_engine.
+    """
+    command = {
+        "type": "list_available_widget_types",
+        "include_engine_widgets": include_engine_widgets,
+        "include_project_widgets": include_project_widgets
+    }
+
+    response = _ensure_dict_response(send_to_unreal(command))
+    if response.get("success"):
+        return json.dumps(response)
+    error_message = response.get("error", "Unknown error")
+    return f"Failed to list widget types: {error_message}"
+
+
+@mcp.tool()
+def bind_widget_event(user_widget_path: str, widget_name: str, event_name: str) -> str:
+    """
+    Binds a widget event (like OnClicked, OnHovered) to a Blueprint event node in the Widget Blueprint's EventGraph.
+    Automatically sets the widget as a variable (bIsVariable=true) if not already set.
+    Args:
+        user_widget_path: Path to the User Widget Blueprint (e.g., "/Game/UI/WBP_MainMenu").
+        widget_name: Name of the widget to bind the event on (e.g., "StartButton", "SettingsCheckbox").
+        event_name: Name of the multicast delegate event on the widget. Common events:
+                    - Button: "OnClicked", "OnPressed", "OnReleased", "OnHovered", "OnUnhovered"
+                    - CheckBox: "OnCheckStateChanged"
+                    - Slider: "OnValueChanged", "OnMouseCaptureBegin", "OnMouseCaptureEnd"
+                    - ComboBoxString: "OnSelectionChanged", "OnOpening"
+                    - EditableText/EditableTextBox: "OnTextChanged", "OnTextCommitted"
+    Returns:
+        JSON with success, event_node_guid, event_name, and widget_name.
+    """
+    command = {
+        "type": "bind_widget_event",
+        "user_widget_path": user_widget_path,
+        "widget_name": widget_name,
+        "event_name": event_name
+    }
+
+    response = _ensure_dict_response(send_to_unreal(command))
+    if response.get("success"):
+        event_guid = response.get("event_node_guid", "")
+        return response.get("message", f"Successfully bound event '{event_name}' on '{widget_name}' (GUID: {event_guid}).")
+    error_message = response.get("error", "Unknown error")
+    raw_suffix = f" Raw response: {response.get('raw')}" if "raw" in response else ""
+    return f"Failed to bind widget event: {error_message}{raw_suffix}"
+
+
+@mcp.tool()
+def validate_ui_spec(ui_spec: str) -> str:
+    """
+    Validate a strict JSON UI spec before generation.
+    Args:
+        ui_spec: JSON object string with schema:
+                 {
+                   "schema_version": 1,
+                   "blueprint": {
+                     "widget_name": "WBP_Menu",
+                     "save_path": "/Game/UI",
+                     "root_widget_type": "CanvasPanel",
+                     "allow_overwrite": false
+                   },
+                   "widgets": [
+                     {"widget_name":"TitleText","widget_type":"TextBlock","parent_widget_name":"$root"}
+                   ],
+                   "properties": [
+                     {"widget_name":"TitleText","property_name":"Text","value":"\"Hello\""}
+                   ]
+                 }
+    Returns:
+        Full JSON validation response with `success`, `errors`, `warnings`, and summary metadata.
+    """
+    try:
+        parsed_spec = json.loads(ui_spec) if isinstance(ui_spec, str) else ui_spec
+    except json.JSONDecodeError as parse_error:
+        return f"Failed to parse ui_spec JSON: {parse_error}"
+
+    if not isinstance(parsed_spec, dict):
+        return "ui_spec must be a JSON object"
+
+    command = {
+        "type": "validate_ui_spec",
+        "ui_spec": parsed_spec,
+    }
+    response = _ensure_dict_response(send_to_unreal(command))
+    if response.get("success") or "errors" in response or "warnings" in response:
+        return json.dumps(response)
+    error_message = response.get("error", "Unknown error")
+    raw_suffix = f" Raw response: {response.get('raw')}" if "raw" in response else ""
+    return f"Failed to validate ui_spec: {error_message}{raw_suffix}"
+
+
+@mcp.tool()
+def generate_widget_blueprint_from_spec(ui_spec: str) -> str:
+    """
+    Generate or regenerate a Widget Blueprint from a strict JSON UI spec.
+    This is the preferred code-first UI pipeline and does not require Pillow/image slicing.
+    Args:
+        ui_spec: JSON object string in the strict schema validated by `validate_ui_spec`.
+    Returns:
+        Full JSON response with `widget_path`, operation-level results, warnings, and failures.
+    """
+    try:
+        parsed_spec = json.loads(ui_spec) if isinstance(ui_spec, str) else ui_spec
+    except json.JSONDecodeError as parse_error:
+        return f"Failed to parse ui_spec JSON: {parse_error}"
+
+    if not isinstance(parsed_spec, dict):
+        return "ui_spec must be a JSON object"
+
+    command = {
+        "type": "generate_widget_blueprint_from_spec",
+        "ui_spec": parsed_spec,
+    }
+    response = _ensure_dict_response(send_to_unreal(command))
+    if response.get("success") or "widget_results" in response or "property_results" in response:
+        return json.dumps(response)
+    error_message = response.get("error", "Unknown error")
+    raw_suffix = f" Raw response: {response.get('raw')}" if "raw" in response else ""
+    return f"Failed to generate widget from spec: {error_message}{raw_suffix}"
+
+
+@mcp.tool()
+def export_widget_to_ui_spec(
+    user_widget_path: str,
+    include_properties: bool = True,
+    property_names: str = ""
+) -> str:
+    """
+    Export an existing Widget Blueprint into the strict JSON UI spec format.
+    Args:
+        user_widget_path: Path to widget blueprint (e.g., "/Game/UI/WBP_Menu").
+        include_properties: Include property operations in exported spec.
+        property_names: Optional comma-separated filter (e.g., "Text,Visibility,Slot.LayoutData,Texture").
+                        Empty exports all available properties.
+    Returns:
+        JSON response containing `ui_spec`.
+    """
+    command = {
+        "type": "export_widget_to_ui_spec",
+        "user_widget_path": user_widget_path,
+        "include_properties": include_properties,
+        "property_names": property_names,
+    }
+    response = _ensure_dict_response(send_to_unreal(command))
+    if response.get("success"):
+        return json.dumps(response)
+    error_message = response.get("error", "Unknown error")
+    raw_suffix = f" Raw response: {response.get('raw')}" if "raw" in response else ""
+    return f"Failed to export widget to ui_spec: {error_message}{raw_suffix}"
+
+
+@mcp.tool()
+def auto_slice_ui_mockup(
+    source_image_path: str,
+    destination_folder: str = "/Game/UI/AutoSlices",
+    base_name: str = "UI_Mockup",
+    max_slices: int = 16,
+    min_component_area_ratio: float = 0.0025,
+    background_tolerance: int = 28,
+    slice_mode: str = "auto",
+    include_full_image: bool = True,
+    enable_chroma_key: bool = True,
+    chroma_tolerance: int = 24,
+    enable_host_fallback: bool = True
+) -> str:
+    """
+    Auto-slice a flattened UI mockup image into multiple textures and import them into Unreal.
+    This is the first step for turning a single concept image into assignable widget art assets.
+    Args:
+        source_image_path: Absolute/local filesystem path to the mockup image file (PNG/JPG).
+        destination_folder: Unreal content folder for imported textures (must start with /Game).
+        base_name: Prefix used for generated texture asset names.
+        max_slices: Maximum number of connected-component slices to generate.
+        min_component_area_ratio: Ignore tiny components below this percentage of the full image area.
+        background_tolerance: Color-distance threshold for separating foreground from a flat/checkerboard background.
+        slice_mode: Segmentation mode: "auto" (default), "connected", or "aggressive".
+        include_full_image: Also import the original full image as a fallback background texture.
+        enable_chroma_key: If true, attempt simple corner-color chroma keying on each extracted slice.
+        chroma_tolerance: RGB tolerance used by chroma-keying (higher removes more near-matching background).
+        enable_host_fallback: If Unreal-side Pillow is missing, slice on MCP host and import results into Unreal.
+    Returns:
+        Full JSON response with a `manifest` field containing imported asset paths and slice metadata.
+    """
+    response = _run_auto_slice_with_fallback(
+        source_image_path=source_image_path,
+        destination_folder=destination_folder,
+        base_name=base_name,
+        max_slices=max_slices,
+        min_component_area_ratio=min_component_area_ratio,
+        background_tolerance=background_tolerance,
+        slice_mode=slice_mode,
+        include_full_image=include_full_image,
+        enable_chroma_key=enable_chroma_key,
+        chroma_tolerance=chroma_tolerance,
+        enable_host_fallback=enable_host_fallback,
+    )
+    if response.get("success"):
+        return json.dumps(response)
+    error_message = response.get("error", "Unknown error")
+    raw_suffix = f" Raw response: {response.get('raw')}" if "raw" in response else ""
+    return f"Failed to auto-slice UI mockup: {error_message}{raw_suffix}"
+
+
+@mcp.tool()
+def apply_ui_slices_to_widget(
+    user_widget_path: str,
+    slice_manifest: str,
+    assign_background: bool = True,
+    assign_components: bool = True,
+    max_component_assignments: int = 12,
+    apply_layout_from_slices: bool = True,
+    layout_scale: float = 1.0,
+    auto_create_buttons_if_missing: bool = True
+) -> str:
+    """
+    Apply an auto-slice manifest to a Widget Blueprint's UImage/UButton widgets.
+    The tool uses name/geometry heuristics to map generated textures, and can also place widgets
+    using slice bbox coordinates from the source image.
+    Args:
+        user_widget_path: Target widget blueprint path (e.g., "/Game/UI/WBP_RateUs").
+        slice_manifest: JSON string from `auto_slice_ui_mockup` response field `manifest`.
+        assign_background: If true, assign the best background candidate first.
+        assign_components: If true, assign remaining slices to image/button widgets heuristically.
+        max_component_assignments: Max number of non-background slice assignments.
+        apply_layout_from_slices: If true, apply CanvasPanel slot layout from slice bbox coordinates.
+        layout_scale: Uniform multiplier for bbox-based placement/sizing (useful for DPI/canvas differences).
+        auto_create_buttons_if_missing: If true, auto-add missing slice targets (Button/Image), including button widgets for button-like slices.
+    Returns:
+        JSON response with assignment/failure details.
+    """
+    try:
+        manifest_obj = json.loads(slice_manifest) if isinstance(slice_manifest, str) else slice_manifest
+    except json.JSONDecodeError:
+        return "Failed to parse slice_manifest JSON: invalid format"
+
+    provisioning_result = None
+    if auto_create_buttons_if_missing and isinstance(manifest_obj, dict):
+        provisioning_result = _ensure_slice_target_widgets_for_manifest(
+            user_widget_path=user_widget_path,
+            manifest=manifest_obj,
+            max_auto_components=max_component_assignments,
+        )
+
+    command = {
+        "type": "apply_ui_slices_to_widget",
+        "user_widget_path": user_widget_path,
+        "slice_manifest": manifest_obj,
+        "assign_background": assign_background,
+        "assign_components": assign_components,
+        "max_component_assignments": max_component_assignments,
+        "apply_layout_from_slices": apply_layout_from_slices,
+        "layout_scale": layout_scale
+    }
+
+    response = _ensure_dict_response(send_to_unreal(command))
+    if response.get("success"):
+        if isinstance(provisioning_result, dict):
+            response["button_widget_provisioning"] = provisioning_result
+            response["target_widget_provisioning"] = provisioning_result
+        return json.dumps(response)
+    error_message = response.get("error", "Unknown error")
+    raw_suffix = f" Raw response: {response.get('raw')}" if "raw" in response else ""
+    return f"Failed to apply UI slices: {error_message}{raw_suffix}"
+
+
+@mcp.tool()
+def auto_slice_and_apply_ui_mockup(
+    user_widget_path: str,
+    source_image_path: str,
+    destination_folder: str = "/Game/UI/AutoSlices",
+    base_name: str = "UI_Mockup",
+    max_slices: int = 16,
+    min_component_area_ratio: float = 0.0025,
+    background_tolerance: int = 28,
+    slice_mode: str = "auto",
+    include_full_image: bool = True,
+    enable_chroma_key: bool = True,
+    chroma_tolerance: int = 24,
+    assign_background: bool = True,
+    assign_components: bool = True,
+    max_component_assignments: int = 12,
+    apply_layout_from_slices: bool = True,
+    layout_scale: float = 1.0,
+    enable_host_fallback: bool = True,
+    auto_create_buttons_if_missing: bool = True
+) -> str:
+    """
+    Full one-shot pipeline: slice/import textures from a flattened mockup image and auto-assign them to widget images.
+    Args:
+        user_widget_path: Target widget blueprint path.
+        source_image_path: Local image path for the mockup.
+        destination_folder: Unreal content folder where generated texture assets will be imported.
+        base_name: Asset-name prefix for imported textures.
+        max_slices: Maximum number of slice components to generate.
+        min_component_area_ratio: Minimum connected-component area ratio retained as a slice.
+        background_tolerance: Color tolerance for background subtraction in flattened images.
+        slice_mode: Segmentation mode: "auto" (default), "connected", or "aggressive".
+        include_full_image: Import full image as fallback texture.
+        enable_chroma_key: If true, attempt simple corner-color chroma keying on each extracted slice.
+        chroma_tolerance: RGB tolerance used by chroma-keying (higher removes more near-matching background).
+        assign_background: Auto-assign background-like slice to background-like widget.
+        assign_components: Auto-assign remaining slices to image placeholders.
+        max_component_assignments: Maximum number of component assignments.
+        apply_layout_from_slices: Apply CanvasPanel slot layout from slice bbox coordinates.
+        layout_scale: Uniform multiplier for bbox-based placement/sizing.
+        enable_host_fallback: If Unreal-side Pillow is missing, slice on MCP host and then apply manifest.
+        auto_create_buttons_if_missing: If true, auto-add missing slice targets (Button/Image), including button widgets for button-like slices.
+    Returns:
+        Full JSON with both slice and apply results.
+    """
+    slice_response = _run_auto_slice_with_fallback(
+        source_image_path=source_image_path,
+        destination_folder=destination_folder,
+        base_name=base_name,
+        max_slices=max_slices,
+        min_component_area_ratio=min_component_area_ratio,
+        background_tolerance=background_tolerance,
+        slice_mode=slice_mode,
+        include_full_image=include_full_image,
+        enable_chroma_key=enable_chroma_key,
+        chroma_tolerance=chroma_tolerance,
+        enable_host_fallback=enable_host_fallback,
+    )
+    if not slice_response.get("success"):
+        error_message = slice_response.get("error", "Unknown error")
+        raw_suffix = f" Raw response: {slice_response.get('raw')}" if "raw" in slice_response else ""
+        return f"Failed auto-slice/apply pipeline: {error_message}{raw_suffix}"
+
+    provisioning_result = None
+    if auto_create_buttons_if_missing:
+        manifest_obj = slice_response.get("manifest")
+        if isinstance(manifest_obj, dict):
+            provisioning_result = _ensure_slice_target_widgets_for_manifest(
+                user_widget_path=user_widget_path,
+                manifest=manifest_obj,
+                max_auto_components=max_component_assignments,
+            )
+
+    apply_command = {
+        "type": "apply_ui_slices_to_widget",
+        "user_widget_path": user_widget_path,
+        "slice_manifest": slice_response.get("manifest"),
+        "assign_background": assign_background,
+        "assign_components": assign_components,
+        "max_component_assignments": max_component_assignments,
+        "apply_layout_from_slices": apply_layout_from_slices,
+        "layout_scale": layout_scale,
+    }
+    apply_response = _ensure_dict_response(send_to_unreal(apply_command))
+    combined_response = {
+        "success": bool(slice_response.get("success")) and bool(apply_response.get("success")),
+        "message": "Auto-slice and apply pipeline completed.",
+        "slice_result": slice_response,
+        "apply_result": apply_response,
+        "manifest": slice_response.get("manifest"),
+        "host_fallback_used": bool(slice_response.get("host_fallback_used")),
+    }
+    if isinstance(provisioning_result, dict):
+        combined_response["button_widget_provisioning"] = provisioning_result
+        combined_response["target_widget_provisioning"] = provisioning_result
+    if combined_response.get("success"):
+        return json.dumps(combined_response)
+
+    apply_error = apply_response.get("error", "Unknown apply error")
+    return f"Failed auto-slice/apply pipeline: {apply_error}"
+
+
+# Input
+@mcp.tool()
+def add_input_binding(action_name: str, key: str) -> str:
+    """
+    Add an input action binding to Project Settings.
+    Args:
+        action_name: Name of the action (e.g., "Flap")
+        key: Key to bind (e.g., "Space Bar")
+    """
+    command = {"type": "add_input_binding", "action_name": action_name, "key": key}
+    response = send_to_unreal(command)
+    if response.get("success"):
+        message = response.get("message", f"Added input binding {action_name} -> {key}")
+        details = response.get("details")
+        if details:
+            return f"{message} ({details})"
+        return message
+
+    error_message = response.get("error", "Unknown error")
+    details = response.get("details")
+    if details:
+        return f"Failed: {error_message} | {details}"
+    return f"Failed: {error_message}"
+
+#
+# Actor Management Tools
+#
+
+@mcp.tool()
+def find_actors_by_name(name_pattern: str, exact_match: bool = False) -> str:
+    """
+    Find actors in the scene by name pattern.
+    Args:
+        name_pattern: Name pattern to search for (supports wildcards like "*")
+        exact_match: If True, perform exact match instead of pattern matching
+    Returns:
+        JSON string with list of matching actors
+    """
+    command = {
+        "type": "find_actors_by_name",
+        "name_pattern": name_pattern,
+        "exact_match": exact_match
+    }
+    response = send_to_unreal(command)
+    if response.get("success"):
+        actors = response.get("actors", [])
+        return json.dumps({"success": True, "actors": actors, "count": len(actors)})
+    return json.dumps({"success": False, "error": response.get("error", "Unknown error")})
+
+@mcp.tool()
+def delete_actor(actor_name: str) -> str:
+    """
+    Delete an actor from the level.
+    Args:
+        actor_name: Name of the actor to delete
+    Returns:
+        Message indicating success or failure
+    """
+    command = {"type": "delete_actor", "actor_name": actor_name}
+    response = send_to_unreal(command)
+    if response.get("success"):
+        return response.get("message", f"Deleted actor: {actor_name}")
+    return f"Failed to delete actor: {response.get('error', 'Unknown error')}"
+
+@mcp.tool()
+def set_actor_transform(actor_name: str, location: Optional[List[float]] = None, rotation: Optional[List[float]] = None, scale: Optional[List[float]] = None) -> str:
+    """
+    Set actor transform (position, rotation, scale) in one call.
+    Args:
+        actor_name: Name of the actor
+        location: [X, Y, Z] coordinates (optional)
+        rotation: [Pitch, Yaw, Roll] in degrees (optional)
+        scale: [X, Y, Z] scale factors (optional)
+    Returns:
+        Message indicating success or failure
+    """
+    command = {
+        "type": "set_actor_transform",
+        "actor_name": actor_name,
+        "location": location,
+        "rotation": rotation,
+        "scale": scale
+    }
+    response = send_to_unreal(command)
+    if response.get("success"):
+        return response.get("message", f"Set transform for {actor_name}")
+    return f"Failed: {response.get('error', 'Unknown error')}"
+
+@mcp.tool()
+def get_actor_material_info(actor_name: str) -> str:
+    """
+    Get material information from an actor.
+    Args:
+        actor_name: Name of the actor
+    Returns:
+        JSON string with material information
+    """
+    command = {"type": "get_actor_material_info", "actor_name": actor_name}
+    response = send_to_unreal(command)
+    return json.dumps(response) if response else json.dumps({"success": False, "error": "No response"})
+
+#
+# Material Management Tools
+#
+
+@mcp.tool()
+def get_available_materials(folder_path: str = "/Game/Materials", recursive: bool = True) -> str:
+    """
+    Get all available materials in the project.
+    Args:
+        folder_path: Folder path to search in (default: "/Game/Materials")
+        recursive: Whether to search recursively (default: True)
+    Returns:
+        JSON string with list of materials
+    """
+    command = {
+        "type": "get_available_materials",
+        "folder_path": folder_path,
+        "recursive": recursive
+    }
+    response = send_to_unreal(command)
+    return json.dumps(response) if response else json.dumps({"success": False, "error": "No response"})
+
+@mcp.tool()
+def apply_material_to_actor(actor_name: str, material_path: str, material_slot: int = 0) -> str:
+    """
+    Apply a material to a scene actor.
+    Args:
+        actor_name: Name of the actor
+        material_path: Path to the material (e.g., "/Game/Materials/MyMaterial")
+        material_slot: Material slot index (default: 0)
+    Returns:
+        Message indicating success or failure
+    """
+    command = {
+        "type": "apply_material_to_actor",
+        "actor_name": actor_name,
+        "material_path": material_path,
+        "material_slot": material_slot
+    }
+    response = send_to_unreal(command)
+    if response.get("success"):
+        return response.get("message", f"Applied material to {actor_name}")
+    return f"Failed: {response.get('error', 'Unknown error')}"
+
+@mcp.tool()
+def apply_material_to_blueprint(blueprint_path: str, component_name: str, material_path: str, material_slot: int = 0) -> str:
+    """
+    Apply a material to a Blueprint component.
+    Args:
+        blueprint_path: Path to the Blueprint
+        component_name: Name of the component
+        material_path: Path to the material
+        material_slot: Material slot index (default: 0)
+    Returns:
+        Message indicating success or failure
+    """
+    command = {
+        "type": "apply_material_to_blueprint",
+        "blueprint_path": blueprint_path,
+        "component_name": component_name,
+        "material_path": material_path,
+        "material_slot": material_slot
+    }
+    response = send_to_unreal(command)
+    if response.get("success"):
+        return response.get("message", f"Applied material to {component_name}")
+    return f"Failed: {response.get('error', 'Unknown error')}"
+
+@mcp.tool()
+def set_mesh_material_color(material_path: str, color: List[float], property_name: str = "BaseColor") -> str:
+    """
+    Set material color properties on a mesh material.
+    Args:
+        material_path: Path to the material to modify
+        color: [R, G, B] color values (0-1)
+        property_name: Material property name (default: "BaseColor")
+    Returns:
+        Message indicating success or failure
+    """
+    normalized_color = _coerce_numeric_list(color)
+    if len(normalized_color) == 3:
+        color = normalized_color
+    
+    command = {
+        "type": "set_mesh_material_color",
+        "material_path": material_path,
+        "color": color,
+        "property_name": property_name
+    }
+    response = send_to_unreal(command)
+    if response.get("success"):
+        return response.get("message", f"Set color for {material_path}")
+    return f"Failed: {response.get('error', 'Unknown error')}"
+
+#
+# Physics Tools
+#
+
+@mcp.tool()
+def spawn_physics_blueprint_actor(blueprint_path: str, location: Optional[List[float]] = None, rotation: Optional[List[float]] = None, scale: Optional[List[float]] = None, actor_label: Optional[str] = None, simulate_physics: bool = True) -> str:
+    """
+    Spawn a Blueprint actor with physics enabled.
+    Args:
+        blueprint_path: Path to the Blueprint asset
+        location: [X, Y, Z] coordinates (optional)
+        rotation: [Pitch, Yaw, Roll] in degrees (optional)
+        scale: [X, Y, Z] scale factors (optional)
+        actor_label: Optional custom name for the actor
+        simulate_physics: Enable physics simulation (default: True)
+    Returns:
+        Message indicating success or failure
+    """
+    location = _ensure_vector(location, [0.0, 0.0, 0.0])
+    rotation = _ensure_vector(rotation, [0.0, 0.0, 0.0])
+    scale = _ensure_vector(scale, [1.0, 1.0, 1.0])
+    
+    command = {
+        "type": "spawn_physics_blueprint_actor",
+        "blueprint_path": blueprint_path,
+        "location": location,
+        "rotation": rotation,
+        "scale": scale,
+        "actor_label": actor_label,
+        "simulate_physics": simulate_physics
+    }
+    response = send_to_unreal(command)
+    if response.get("success"):
+        actor_name = response.get("actor_name", "actor")
+        return f"Successfully spawned physics-enabled {blueprint_path} as {actor_name}"
+    return f"Failed: {response.get('error', 'Unknown error')}"
+
+@mcp.tool()
+def set_physics_properties(actor_name: str, mass: Optional[float] = None, linear_damping: Optional[float] = None, angular_damping: Optional[float] = None, enable_gravity: Optional[bool] = None, simulate_physics: Optional[bool] = None, collision_enabled: Optional[bool] = None) -> str:
+    """
+    Set physics properties on an actor.
+    Args:
+        actor_name: Name of the actor
+        mass: Mass in kg (optional)
+        linear_damping: Linear damping coefficient (optional)
+        angular_damping: Angular damping coefficient (optional)
+        enable_gravity: Enable gravity (optional)
+        simulate_physics: Enable physics simulation (optional)
+        collision_enabled: Enable collision (optional)
+    Returns:
+        Message indicating success or failure
+    """
+    command = {
+        "type": "set_physics_properties",
+        "actor_name": actor_name
+    }
+    
+    # Only include provided parameters
+    if mass is not None:
+        command["mass"] = mass
+    if linear_damping is not None:
+        command["linear_damping"] = linear_damping
+    if angular_damping is not None:
+        command["angular_damping"] = angular_damping
+    if enable_gravity is not None:
+        command["enable_gravity"] = enable_gravity
+    if simulate_physics is not None:
+        command["simulate_physics"] = simulate_physics
+    if collision_enabled is not None:
+        command["collision_enabled"] = collision_enabled
+    
+    response = send_to_unreal(command)
+    if response.get("success"):
+        return response.get("message", f"Set physics properties for {actor_name}")
+    return f"Failed: {response.get('error', 'Unknown error')}"
+
+#
+# World Building Tools
+#
+
+@mcp.tool()
+def create_town(town_size: str = "medium", architectural_style: str = "modern", building_density: float = 0.7, include_advanced_features: bool = False, center_location: Optional[List[float]] = None) -> str:
+    """
+    Generate an entire town with buildings, streets, and infrastructure.
+    Args:
+        town_size: Size of the town ("small", "medium", "large", "massive")
+        architectural_style: Style of buildings ("medieval", "modern", "futuristic")
+        building_density: Density of buildings (0.0-1.0, default: 0.7)
+        include_advanced_features: Include parks, fountains, etc. (default: False)
+        center_location: [X, Y, Z] center location (optional)
+    Returns:
+        Message indicating success with town information
+    """
+    center_location = _ensure_vector(center_location, [0.0, 0.0, 0.0])
+    
+    command = {
+        "type": "create_town",
+        "town_size": town_size,
+        "architectural_style": architectural_style,
+        "building_density": building_density,
+        "include_advanced_features": include_advanced_features,
+        "center_location": center_location
+    }
+    response = send_to_unreal(command)
+    if response.get("success"):
+        count = response.get("count", 0)
+        return f"Successfully created {town_size} town with {count} buildings"
+    return f"Failed: {response.get('error', 'Unknown error')}"
+
+@mcp.tool()
+def construct_house(house_style: str = "simple", width: float = 800.0, height: float = 400.0, depth: float = 600.0, num_rooms: int = 4, location: Optional[List[float]] = None) -> str:
+    """
+    Build a multi-room house with windows, doors, and roof.
+    Args:
+        house_style: Style of house ("simple", "modern", "victorian")
+        width: Width of the house (default: 800)
+        height: Height of the house (default: 400)
+        depth: Depth of the house (default: 600)
+        num_rooms: Number of rooms (default: 4)
+        location: [X, Y, Z] location (optional)
+    Returns:
+        Message indicating success with house information
+    """
+    location = _ensure_vector(location, [0.0, 0.0, 0.0])
+    
+    command = {
+        "type": "construct_house",
+        "house_style": house_style,
+        "width": width,
+        "height": height,
+        "depth": depth,
+        "num_rooms": num_rooms,
+        "location": location
+    }
+    response = send_to_unreal(command)
+    if response.get("success"):
+        count = response.get("count", 0)
+        return f"Successfully constructed {house_style} house with {num_rooms} rooms ({count} parts)"
+    return f"Failed: {response.get('error', 'Unknown error')}"
+
+@mcp.tool()
+def construct_mansion(width: float = 1500.0, height: float = 900.0, depth: float = 1200.0, num_wings: int = 2, num_towers: int = 4, location: Optional[List[float]] = None) -> str:
+    """
+    Create a mansion complex with wings and towers.
+    Args:
+        width: Width of main building (default: 1500)
+        height: Height of main building (default: 900)
+        depth: Depth of main building (default: 1200)
+        num_wings: Number of wings (default: 2)
+        num_towers: Number of towers (default: 4)
+        location: [X, Y, Z] location (optional)
+    Returns:
+        Message indicating success with mansion information
+    """
+    location = _ensure_vector(location, [0.0, 0.0, 0.0])
+    
+    command = {
+        "type": "construct_mansion",
+        "width": width,
+        "height": height,
+        "depth": depth,
+        "num_wings": num_wings,
+        "num_towers": num_towers,
+        "location": location
+    }
+    response = send_to_unreal(command)
+    if response.get("success"):
+        count = response.get("count", 0)
+        return f"Successfully constructed mansion with {num_wings} wings and {num_towers} towers ({count} parts)"
+    return f"Failed: {response.get('error', 'Unknown error')}"
+
+@mcp.tool()
+def create_tower(tower_style: str = "medieval", height: float = 1000.0, radius: float = 200.0, location: Optional[List[float]] = None) -> str:
+    """
+    Create a tower structure.
+    Args:
+        tower_style: Style of tower ("medieval", "modern", "futuristic")
+        height: Height of the tower (default: 1000)
+        radius: Radius of the tower (default: 200)
+        location: [X, Y, Z] location (optional)
+    Returns:
+        Message indicating success
+    """
+    location = _ensure_vector(location, [0.0, 0.0, 0.0])
+    
+    command = {
+        "type": "create_tower",
+        "tower_style": tower_style,
+        "height": height,
+        "radius": radius,
+        "location": location
+    }
+    response = send_to_unreal(command)
+    if response.get("success"):
+        return f"Successfully created {tower_style} tower"
+    return f"Failed: {response.get('error', 'Unknown error')}"
+
+@mcp.tool()
+def create_arch(width: float = 400.0, height: float = 600.0, depth: float = 200.0, location: Optional[List[float]] = None) -> str:
+    """
+    Create an architectural arch.
+    Args:
+        width: Width of the arch (default: 400)
+        height: Height of the arch (default: 600)
+        depth: Depth of the arch (default: 200)
+        location: [X, Y, Z] location (optional)
+    Returns:
+        Message indicating success
+    """
+    location = _ensure_vector(location, [0.0, 0.0, 0.0])
+    
+    command = {
+        "type": "create_arch",
+        "width": width,
+        "height": height,
+        "depth": depth,
+        "location": location
+    }
+    response = send_to_unreal(command)
+    if response.get("success"):
+        count = response.get("count", 0)
+        return f"Successfully created arch ({count} parts)"
+    return f"Failed: {response.get('error', 'Unknown error')}"
+
+@mcp.tool()
+def create_staircase(num_steps: int = 10, step_width: float = 200.0, step_depth: float = 50.0, step_height: float = 20.0, location: Optional[List[float]] = None) -> str:
+    """
+    Create a staircase.
+    Args:
+        num_steps: Number of steps (default: 10)
+        step_width: Width of each step (default: 200)
+        step_depth: Depth of each step (default: 50)
+        step_height: Height of each step (default: 20)
+        location: [X, Y, Z] starting location (optional)
+    Returns:
+        Message indicating success
+    """
+    location = _ensure_vector(location, [0.0, 0.0, 0.0])
+    
+    command = {
+        "type": "create_staircase",
+        "num_steps": num_steps,
+        "step_width": step_width,
+        "step_depth": step_depth,
+        "step_height": step_height,
+        "location": location
+    }
+    response = send_to_unreal(command)
+    if response.get("success"):
+        count = response.get("count", 0)
+        return f"Successfully created staircase with {num_steps} steps"
+    return f"Failed: {response.get('error', 'Unknown error')}"
+
+@mcp.tool()
+def create_castle_fortress(size: str = "medium", num_towers: int = 4, wall_height: float = 800.0, location: Optional[List[float]] = None) -> str:
+    """
+    Build a medieval fortress with walls and towers.
+    Args:
+        size: Size of the fortress ("small", "medium", "large")
+        num_towers: Number of corner towers (default: 4)
+        wall_height: Height of walls (default: 800)
+        location: [X, Y, Z] center location (optional)
+    Returns:
+        Message indicating success with fortress information
+    """
+    location = _ensure_vector(location, [0.0, 0.0, 0.0])
+    
+    command = {
+        "type": "create_castle_fortress",
+        "size": size,
+        "num_towers": num_towers,
+        "wall_height": wall_height,
+        "location": location
+    }
+    response = send_to_unreal(command)
+    if response.get("success"):
+        count = response.get("count", 0)
+        return f"Successfully created {size} fortress with {num_towers} towers ({count} parts)"
+    return f"Failed: {response.get('error', 'Unknown error')}"
+
+@mcp.tool()
+def create_suspension_bridge(length: float = 2000.0, width: float = 400.0, height: float = 200.0, location: Optional[List[float]] = None) -> str:
+    """
+    Create a suspension bridge.
+    Args:
+        length: Length of the bridge (default: 2000)
+        width: Width of the bridge (default: 400)
+        height: Height above ground (default: 200)
+        location: [X, Y, Z] starting location (optional)
+    Returns:
+        Message indicating success
+    """
+    location = _ensure_vector(location, [0.0, 0.0, 0.0])
+    
+    command = {
+        "type": "create_suspension_bridge",
+        "length": length,
+        "width": width,
+        "height": height,
+        "location": location
+    }
+    response = send_to_unreal(command)
+    if response.get("success"):
+        count = response.get("count", 0)
+        return f"Successfully created suspension bridge ({count} parts)"
+    return f"Failed: {response.get('error', 'Unknown error')}"
+
+@mcp.tool()
+def create_aqueduct(length: float = 1500.0, height: float = 500.0, num_arches: int = 5, location: Optional[List[float]] = None) -> str:
+    """
+    Create an aqueduct structure.
+    Args:
+        length: Length of the aqueduct (default: 1500)
+        height: Height of supports (default: 500)
+        num_arches: Number of arches (default: 5)
+        location: [X, Y, Z] starting location (optional)
+    Returns:
+        Message indicating success
+    """
+    location = _ensure_vector(location, [0.0, 0.0, 0.0])
+    
+    command = {
+        "type": "create_aqueduct",
+        "length": length,
+        "height": height,
+        "num_arches": num_arches,
+        "location": location
+    }
+    response = send_to_unreal(command)
+    if response.get("success"):
+        count = response.get("count", 0)
+        return f"Successfully created aqueduct with {num_arches} arches ({count} parts)"
+    return f"Failed: {response.get('error', 'Unknown error')}"
+
+@mcp.tool()
+def create_maze(rows: int = 15, cols: int = 15, cell_size: float = 250.0, wall_height: float = 4.0, location: Optional[List[float]] = None) -> str:
+    """
+    Generate a solvable maze using recursive backtracking.
+    Args:
+        rows: Number of rows in the maze (default: 15)
+        cols: Number of columns in the maze (default: 15)
+        cell_size: Size of each cell (default: 250)
+        wall_height: Height of walls (default: 4)
+        location: [X, Y, Z] starting location (optional)
+    Returns:
+        Message indicating success with maze information
+    """
+    location = _ensure_vector(location, [0.0, 0.0, 0.0])
+    
+    command = {
+        "type": "create_maze",
+        "rows": rows,
+        "cols": cols,
+        "cell_size": cell_size,
+        "wall_height": wall_height,
+        "location": location
+    }
+    response = send_to_unreal(command)
+    if response.get("success"):
+        count = response.get("count", 0)
+        return f"Successfully created {rows}x{cols} maze with {count} walls"
+    return f"Failed: {response.get('error', 'Unknown error')}"
+
+@mcp.tool()
+def create_pyramid(base_size: float = 1000.0, height: float = 800.0, location: Optional[List[float]] = None) -> str:
+    """
+    Create a pyramid structure.
+    Args:
+        base_size: Size of the base (default: 1000)
+        height: Height of the pyramid (default: 800)
+        location: [X, Y, Z] center location (optional)
+    Returns:
+        Message indicating success
+    """
+    location = _ensure_vector(location, [0.0, 0.0, 0.0])
+    
+    command = {
+        "type": "create_pyramid",
+        "base_size": base_size,
+        "height": height,
+        "location": location
+    }
+    response = send_to_unreal(command)
+    if response.get("success"):
+        return f"Successfully created pyramid"
+    return f"Failed: {response.get('error', 'Unknown error')}"
+
+@mcp.tool()
+def create_wall(length: float = 1000.0, height: float = 400.0, thickness: float = 50.0, location: Optional[List[float]] = None, rotation: Optional[List[float]] = None) -> str:
+    """
+    Create a wall structure.
+    Args:
+        length: Length of the wall (default: 1000)
+        height: Height of the wall (default: 400)
+        thickness: Thickness of the wall (default: 50)
+        location: [X, Y, Z] center location (optional)
+        rotation: [Pitch, Yaw, Roll] rotation in degrees (optional)
+    Returns:
+        Message indicating success
+    """
+    location = _ensure_vector(location, [0.0, 0.0, 0.0])
+    rotation = _ensure_vector(rotation, [0.0, 0.0, 0.0])
+    
+    command = {
+        "type": "create_wall",
+        "length": length,
+        "height": height,
+        "thickness": thickness,
+        "location": location,
+        "rotation": rotation
+    }
+    response = send_to_unreal(command)
+    if response.get("success"):
+        return f"Successfully created wall"
+    return f"Failed: {response.get('error', 'Unknown error')}"
+
+#
+# Blueprint Enhancement
+#
+
+@mcp.tool()
+def set_static_mesh_properties(blueprint_path: str, component_name: str, static_mesh_path: Optional[str] = None, collision_enabled: Optional[bool] = None, cast_shadow: Optional[bool] = None, receive_shadow: Optional[bool] = None) -> str:
+    """
+    Set static mesh properties on a Blueprint component.
+    Args:
+        blueprint_path: Path to the Blueprint
+        component_name: Name of the StaticMeshComponent
+        static_mesh_path: Path to the static mesh to set (optional)
+        collision_enabled: Enable collision (optional)
+        cast_shadow: Cast shadows (optional)
+        receive_shadow: Receive shadows (optional)
+    Returns:
+        Message indicating success or failure
+    """
+    command = {
+        "type": "set_static_mesh_properties",
+        "blueprint_path": blueprint_path,
+        "component_name": component_name
+    }
+    
+    if static_mesh_path is not None:
+        command["static_mesh_path"] = static_mesh_path
+    if collision_enabled is not None:
+        command["collision_enabled"] = collision_enabled
+    if cast_shadow is not None:
+        command["cast_shadow"] = cast_shadow
+    if receive_shadow is not None:
+        command["receive_shadow"] = receive_shadow
+    
+    response = send_to_unreal(command)
+    if response.get("success"):
+        props_set = response.get("properties_set", [])
+        return f"Successfully set properties for {component_name}: {', '.join(props_set)}"
+    return f"Failed: {response.get('error', 'Unknown error')}"
+
+# Safety check for potentially destructive actions
+def is_potentially_destructive(script: str) -> bool:
+    """
+    Check if the script contains potentially destructive actions like deleting or saving files.
+    Returns True if such actions are detected and not explicitly requested.
+    """
+    destructive_keywords = [
+        r'unreal\.EditorAssetLibrary\.delete_asset',
+        r'unreal\.EditorLevelLibrary\.destroy_actor',
+        r'unreal\.save_package',
+        r'os\.remove',
+        r'shutil\.rmtree',
+        r'file\.write',
+        r'unreal\.EditorAssetLibrary\.save_asset'
+    ]
+    for keyword in destructive_keywords:
+        if re.search(keyword, script, re.IGNORECASE):
+            return True
+    return False
+
+if __name__ == "__main__":
+    import traceback
+    try:
+        print("Server starting...", file=sys.stderr)
+        mcp.run("stdio")
+    except Exception as e:
+        print(f"Server crashed with error: {e}", file=sys.stderr)
+        traceback.print_exc(file=sys.stderr)
+        raise
+
+# Safety check for potentially destructive actions
+def is_potentially_destructive(script: str) -> bool:
+    """
+    Check if the script contains potentially destructive actions like deleting or saving files.
+    Returns True if such actions are detected and not explicitly requested.
+    """
+    destructive_keywords = [
+        r'unreal\.EditorAssetLibrary\.delete_asset',
+        r'unreal\.EditorLevelLibrary\.destroy_actor',
+        r'unreal\.save_package',
+        r'os\.remove',
+        r'shutil\.rmtree',
+        r'file\.write',
+        r'unreal\.EditorAssetLibrary\.save_asset'
+    ]
+
+    for keyword in destructive_keywords:
+        if re.search(keyword, script, re.IGNORECASE):
+            return True
+    return False
+
+if __name__ == "__main__":
+    import traceback
+    try:
+        print("Server starting...", file=sys.stderr)
+        mcp.run("stdio")
+    except Exception as e:
+        print(f"Server crashed with error: {e}", file=sys.stderr)
+        traceback.print_exc(file=sys.stderr)
+        raise