Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,12 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+UMCP.it-Unreal-Organizer-Assistant/Content/ExampleBlueprints/ChatAPIExamples.uasset filter=lfs diff=lfs merge=lfs -text
+UMCP.it-Unreal-Organizer-Assistant/Docs/BHDemoGif.gif filter=lfs diff=lfs merge=lfs -text
+UMCP.it-Unreal-Organizer-Assistant/Docs/BpExampleClaudeChat.png filter=lfs diff=lfs merge=lfs -text
+UMCP.it-Unreal-Organizer-Assistant/Docs/BpExampleDeepseekChat.png filter=lfs diff=lfs merge=lfs -text
+UMCP.it-Unreal-Organizer-Assistant/Docs/BpExampleOAIChat.png filter=lfs diff=lfs merge=lfs -text
+UMCP.it-Unreal-Organizer-Assistant/Docs/BpExampleOAIStructuredOp.png filter=lfs diff=lfs merge=lfs -text
+UMCP.it-Unreal-Organizer-Assistant/Docs/Repo[[:space:]]Card[[:space:]]-[[:space:]]Updated.png filter=lfs diff=lfs merge=lfs -text
+UMCP.it-Unreal-Organizer-Assistant/Docs/UnrealMcpDemo.gif filter=lfs diff=lfs merge=lfs -text
+kariana.ai/.archive/temp-files/2025.findings-acl.994-1_compressed-1.pdf filter=lfs diff=lfs merge=lfs -text

README.md

@@ -101,9 +101,9 @@ Get the KarianaUMCP plugin for your Unreal Engine project:
 
 | Platform | Download |
 |----------|----------|
-| **Windows** | [KarianaUMCP-v1.0.1-windows.zip](https://github.com/kerinzeebart/MCPTest-with-UMCP.it/releases/download/v1.0.1/KarianaUMCP-v1.0.1-windows.zip) |
-| **macOS** | [KarianaUMCP-v1.0.1-macos.zip](https://github.com/kerinzeebart/MCPTest-with-UMCP.it/releases/download/v1.0.1/KarianaUMCP-v1.0.1-macos.zip) |
-| **Linux** | [KarianaUMCP-v1.0.1-linux.zip](https://github.com/kerinzeebart/MCPTest-with-UMCP.it/releases/download/v1.0.1/KarianaUMCP-v1.0.1-linux.zip) |
+| **Windows** | [Dropbox](https://www.dropbox.com/scl/fi/y4zfyfkadmik2sma5jkwp/KarianaUMCP-v1.0.1-windows.zip?rlkey=u0wk39o1av7mnflcnhfu7cij1&st=nvuj5kaj&dl=0) |
+| **macOS** | [Dropbox](https://www.dropbox.com/scl/fi/gydzrcjujtf14c743s07m/KarianaUMCP-v1.0.1-macos.zip?rlkey=239u0ltp17s665nzg08pkatzs&st=5hs5wokz&dl=0) |
+| **Linux** | [Dropbox](https://www.dropbox.com/scl/fi/za196pymwr8l0wgamdact/KarianaUMCP-v1.0.1-linux.zip?rlkey=eq37irxfif6hlahkxtdygjiqo&st=j5q2p9yh&dl=0) |
 
 ## Claude Desktop Connection
 

UMCP.it-Unreal-Organizer-Assistant/.gitignore

@@ -0,0 +1,43 @@
+# Unreal Engine build artifacts
+Binaries/
+Intermediate/
+Saved/
+Build/
+
+# IDE files
+.vs/
+.vscode/
+*.sln
+*.sdf
+*.opensdf
+*.suo
+*.xcodeproj
+*.xcworkspace
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+*.egg-info/
+dist/
+build/
+
+# MCP Server PID files
+.unrealgenai/
+
+# Test/Development files
+test_*.py
+quick_test.py
+reload_socket_server.py
+kill_and_restart_server.py
+stop_all_servers.py
+
+# OS files
+.DS_Store
+Thumbs.db
+desktop.ini
+
+# Logs
+*.log

UMCP.it-Unreal-Organizer-Assistant/Config/DefaultGenerativeAISupport.ini

@@ -0,0 +1,3 @@
+[CoreRedirects]
++ClassRedirects=(OldName="/Script/GenerativeAISupport.FBhJsonHelper",NewName="/Script/GenerativeAISupport.BhJsonHelper")
++FunctionRedirects=(OldName="/Script/GenerativeAISupport.GenOAIChat.SendRequestLatent",NewName="/Script/GenerativeAISupport.GenOAIChat.RequestOpenAIChat")

UMCP.it-Unreal-Organizer-Assistant/Config/FilterPlugin.ini

@@ -0,0 +1,8 @@
+[FilterPlugin]
+; This section lists additional files which will be packaged along with your plugin. Paths should be listed relative to the root plugin directory, and
+; may include "...", "*", and "?" wildcards to match directories, files, and individual characters respectively.
+;
+; Examples:
+;    /README.txt
+;    /Extras/...
+;    /Binaries/ThirdParty/*.dll

UMCP.it-Unreal-Organizer-Assistant/Content/ExampleBlueprints/ChatAPIExamples.uasset

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d2bd2cb0b9f274ada76faba0255b36f149197b01229bf00e5714434b6abf2d8e
+size 216398

UMCP.it-Unreal-Organizer-Assistant/Content/Python/blueprint_connections/__init__.py

@@ -0,0 +1 @@
+# Blueprint connections package

UMCP.it-Unreal-Organizer-Assistant/Content/Python/blueprint_connections/handlers/__init__.py

@@ -0,0 +1 @@
+# Handlers package

UMCP.it-Unreal-Organizer-Assistant/Content/Python/blueprint_connections/handlers/auto_wiring.py

@@ -0,0 +1,438 @@
+"""
+Auto-Wiring Service for Unreal Engine Blueprints
+
+This service intelligently connects chains of Blueprint nodes using
+type matching and name similarity scoring.
+"""
+
+import json
+from typing import List, Dict, Optional, Tuple
+import sys
+import os
+
+# Add parent directory to path for imports
+sys.path.insert(0, os.path.dirname(os.path.dirname(__file__)))
+
+from utils.connection_rules import are_types_compatible, calculate_pin_name_similarity
+
+
+class AutoWiringService:
+    """Intelligently connects chains of Blueprint nodes"""
+
+    def __init__(self, pin_discovery_service, connection_validator):
+        """
+        Initialize the auto-wiring service.
+
+        Args:
+            pin_discovery_service: Instance of PinDiscoveryService
+            connection_validator: Instance of ConnectionValidator
+        """
+        self.pin_discovery = pin_discovery_service
+        self.validator = connection_validator
+        self.min_confidence = 0.3  # Minimum confidence score for connections
+
+    def auto_connect_chain(
+        self,
+        blueprint_path: str,
+        function_id: str,
+        node_chain: List[str],
+        validate_before_connect: bool = True
+    ) -> Dict:
+        """
+        Automatically connect a chain of nodes.
+
+        Args:
+            blueprint_path: Path to Blueprint asset
+            function_id: GUID of the function graph
+            node_chain: List of node GUIDs in execution order
+            validate_before_connect: Whether to validate connections first
+
+        Returns:
+            {
+                "success": bool,
+                "connections_made": int,
+                "connections": List[Dict],
+                "failed_connections": List[Dict],
+                "warnings": List[str]
+            }
+        """
+        if len(node_chain) < 2:
+            return {
+                "success": False,
+                "error": "Need at least 2 nodes to create a chain",
+                "connections_made": 0
+            }
+
+        connections_made = []
+        failed_connections = []
+        warnings = []
+
+        # Connect each pair of adjacent nodes
+        for i in range(len(node_chain) - 1):
+            source_node = node_chain[i]
+            target_node = node_chain[i + 1]
+
+            # Get node information
+            source_info = self.pin_discovery.get_node_pins(
+                blueprint_path, function_id, source_node
+            )
+            target_info = self.pin_discovery.get_node_pins(
+                blueprint_path, function_id, target_node
+            )
+
+            if not source_info.get("success") or not target_info.get("success"):
+                failed_connections.append({
+                    "source": source_node,
+                    "target": target_node,
+                    "error": "Failed to get node information",
+                    "source_error": source_info.get("error") if not source_info.get("success") else None,
+                    "target_error": target_info.get("error") if not target_info.get("success") else None
+                })
+                continue
+
+            # Connect execution pins first
+            exec_result = self._connect_execution_pins(
+                blueprint_path, function_id,
+                source_node, target_node,
+                source_info, target_info
+            )
+
+            if exec_result:
+                if validate_before_connect:
+                    validation = self.validator.validate_connection(
+                        blueprint_path, function_id,
+                        source_node, exec_result["source_pin"],
+                        target_node, exec_result["target_pin"]
+                    )
+                    if validation.get("valid"):
+                        connections_made.append(exec_result)
+                    else:
+                        failed_connections.append({
+                            **exec_result,
+                            "validation_error": validation.get("message")
+                        })
+                else:
+                    connections_made.append(exec_result)
+
+            # Connect data pins
+            data_results = self._connect_data_pins(
+                blueprint_path, function_id,
+                source_node, target_node,
+                source_info, target_info,
+                validate_before_connect
+            )
+
+            connections_made.extend(data_results["connected"])
+            failed_connections.extend(data_results["failed"])
+            warnings.extend(data_results["warnings"])
+
+        return {
+            "success": len(connections_made) > 0,
+            "connections_made": len(connections_made),
+            "connections": connections_made,
+            "failed_connections": failed_connections,
+            "warnings": warnings,
+            "summary": {
+                "total_attempted": len(connections_made) + len(failed_connections),
+                "successful": len(connections_made),
+                "failed": len(failed_connections)
+            }
+        }
+
+    def _connect_execution_pins(
+        self,
+        blueprint_path: str,
+        function_id: str,
+        source_node: str,
+        target_node: str,
+        source_info: Dict,
+        target_info: Dict
+    ) -> Optional[Dict]:
+        """Connect execution flow pins between two nodes"""
+        # Find execution output pin
+        exec_output = None
+        for pin in source_info.get("output_pins", []):
+            if pin["category"] == "exec":
+                exec_output = pin
+                break
+
+        # Find execution input pin
+        exec_input = None
+        for pin in target_info.get("input_pins", []):
+            if pin["category"] == "exec":
+                exec_input = pin
+                break
+
+        if exec_output and exec_input:
+            return {
+                "source_node": source_node,
+                "source_pin": exec_output["name"],
+                "target_node": target_node,
+                "target_pin": exec_input["name"],
+                "type": "execution",
+                "confidence": 1.0,
+                "auto_detected": True
+            }
+
+        return None
+
+    def _connect_data_pins(
+        self,
+        blueprint_path: str,
+        function_id: str,
+        source_node: str,
+        target_node: str,
+        source_info: Dict,
+        target_info: Dict,
+        validate: bool
+    ) -> Dict:
+        """Connect data pins between two nodes using intelligent matching"""
+        connections = []
+        failed = []
+        warnings = []
+
+        output_pins = source_info.get("output_pins", [])
+        input_pins = target_info.get("input_pins", [])
+
+        # Remove execution pins
+        output_pins = [p for p in output_pins if p["category"] != "exec"]
+        input_pins = [p for p in input_pins if p["category"] != "exec"]
+
+        # Track which input pins have been matched
+        matched_input_pins = set()
+
+        # Match pins by type and name similarity
+        for output_pin in output_pins:
+            best_match = self._find_best_pin_match(
+                output_pin,
+                [p for p in input_pins if p["name"] not in matched_input_pins]
+            )
+
+            if best_match and best_match["confidence"] >= self.min_confidence:
+                connection = {
+                    "source_node": source_node,
+                    "source_pin": output_pin["name"],
+                    "target_node": target_node,
+                    "target_pin": best_match["name"],
+                    "type": "data",
+                    "confidence": best_match["confidence"],
+                    "auto_detected": True
+                }
+
+                # Validate if requested
+                if validate:
+                    validation = self.validator.validate_connection(
+                        blueprint_path, function_id,
+                        source_node, output_pin["name"],
+                        target_node, best_match["name"]
+                    )
+
+                    if validation.get("valid"):
+                        connections.append(connection)
+                        matched_input_pins.add(best_match["name"])
+
+                        # Add any warnings from validation
+                        if validation.get("warnings"):
+                            warnings.extend(validation["warnings"])
+                    else:
+                        failed.append({
+                            **connection,
+                            "validation_error": validation.get("message"),
+                            "suggestions": validation.get("suggestions", [])
+                        })
+                else:
+                    connections.append(connection)
+                    matched_input_pins.add(best_match["name"])
+
+        return {
+            "connected": connections,
+            "failed": failed,
+            "warnings": warnings
+        }
+
+    def _find_best_pin_match(
+        self,
+        output_pin: Dict,
+        input_pins: List[Dict]
+    ) -> Optional[Dict]:
+        """
+        Find the best matching input pin for an output pin.
+
+        Uses a scoring algorithm based on:
+        - Type compatibility (required)
+        - Name similarity
+        - Common naming patterns
+        - Type exact match bonus
+
+        Args:
+            output_pin: Output pin to match
+            input_pins: Available input pins
+
+        Returns:
+            Best match with confidence score, or None
+        """
+        best_match = None
+        best_score = 0.0
+
+        for input_pin in input_pins:
+            # Skip if already connected
+            if input_pin.get("is_connected"):
+                continue
+
+            # Check type compatibility (required)
+            if not are_types_compatible(
+                output_pin["category"],
+                input_pin["category"]
+            ):
+                continue
+
+            # Calculate base name similarity score
+            name_score = calculate_pin_name_similarity(
+                output_pin["name"],
+                input_pin["name"]
+            )
+
+            # Apply bonuses for common patterns
+            score = name_score
+
+            # Boost for "ReturnValue" → generic input
+            if "return" in output_pin["name"].lower():
+                if any(term in input_pin["name"].lower() for term in ["value", "input", "a", "in"]):
+                    score += 0.3
+
+            # Boost for "Result" → generic input
+            if "result" in output_pin["name"].lower():
+                if any(term in input_pin["name"].lower() for term in ["value", "input"]):
+                    score += 0.2
+
+            # Boost for exact type match
+            if output_pin["category"] == input_pin["category"]:
+                score += 0.2
+
+            # Boost for array match
+            if output_pin["is_array"] == input_pin["is_array"]:
+                score += 0.1
+
+            # Update best match
+            if score > best_score:
+                best_score = score
+                best_match = {
+                    "name": input_pin["name"],
+                    "pin": input_pin,
+                    "confidence": min(score, 1.0)  # Cap at 1.0
+                }
+
+        return best_match
+
+    def suggest_connections(
+        self,
+        blueprint_path: str,
+        function_id: str,
+        source_node: str,
+        target_node: str
+    ) -> Dict:
+        """
+        Suggest possible connections between two nodes without making them.
+
+        Args:
+            blueprint_path: Path to Blueprint asset
+            function_id: GUID of the function graph
+            source_node: GUID of source node
+            target_node: GUID of target node
+
+        Returns:
+            {
+                "success": bool,
+                "execution_connection": Optional[Dict],
+                "data_connections": List[Dict],
+                "all_possibilities": List[Dict]
+            }
+        """
+        # Get node information
+        source_info = self.pin_discovery.get_node_pins(
+            blueprint_path, function_id, source_node
+        )
+        target_info = self.pin_discovery.get_node_pins(
+            blueprint_path, function_id, target_node
+        )
+
+        if not source_info.get("success") or not target_info.get("success"):
+            return {
+                "success": False,
+                "error": "Failed to get node information"
+            }
+
+        # Find execution connection
+        exec_conn = self._connect_execution_pins(
+            blueprint_path, function_id,
+            source_node, target_node,
+            source_info, target_info
+        )
+
+        # Find data connections
+        data_result = self._connect_data_pins(
+            blueprint_path, function_id,
+            source_node, target_node,
+            source_info, target_info,
+            validate=False
+        )
+
+        # Generate all possible connections (even low confidence)
+        all_possibilities = []
+        output_pins = [p for p in source_info.get("output_pins", []) if p["category"] != "exec"]
+        input_pins = [p for p in target_info.get("input_pins", []) if p["category"] != "exec"]
+
+        for output_pin in output_pins:
+            for input_pin in input_pins:
+                if are_types_compatible(output_pin["category"], input_pin["category"]):
+                    confidence = calculate_pin_name_similarity(output_pin["name"], input_pin["name"])
+                    all_possibilities.append({
+                        "source_pin": output_pin["name"],
+                        "target_pin": input_pin["name"],
+                        "confidence": confidence,
+                        "source_type": output_pin["category"],
+                        "target_type": input_pin["category"]
+                    })
+
+        # Sort by confidence
+        all_possibilities.sort(key=lambda x: x["confidence"], reverse=True)
+
+        return {
+            "success": True,
+            "execution_connection": exec_conn,
+            "data_connections": data_result["connected"],
+            "all_possibilities": all_possibilities
+        }
+
+
+# Standalone function for use as MCP tool
+def auto_wire_blueprint_nodes_tool(
+    blueprint_path: str,
+    function_id: str,
+    node_chain: List[str]
+) -> str:
+    """
+    MCP tool function to auto-wire Blueprint nodes.
+
+    Returns JSON string for MCP protocol.
+    """
+    from handlers.pin_discovery import PinDiscoveryService
+    from handlers.connection_validator import ConnectionValidator
+
+    pin_discovery = PinDiscoveryService()
+    validator = ConnectionValidator(pin_discovery)
+    auto_wiring = AutoWiringService(pin_discovery, validator)
+
+    result = auto_wiring.auto_connect_chain(
+        blueprint_path,
+        function_id,
+        node_chain
+    )
+
+    return json.dumps(result, indent=2)
+
+
+# Testing
+if __name__ == "__main__":
+    print("Auto-Wiring Service ready")
+    print("Usage: Import and use AutoWiringService class")

UMCP.it-Unreal-Organizer-Assistant/Content/Python/blueprint_connections/handlers/connection_validator.py

@@ -0,0 +1,351 @@
+"""
+Connection Validator for Unreal Engine Blueprints
+
+This service validates Blueprint pin connections before execution,
+providing detailed error messages and suggestions.
+"""
+
+import json
+from typing import Dict, List, Optional, Tuple
+import sys
+import os
+
+# Add parent directory to path for imports
+sys.path.insert(0, os.path.dirname(os.path.dirname(__file__)))
+
+from utils.pin_types import PinInfo, ValidationError
+from utils.connection_rules import (
+    are_types_compatible,
+    get_conversion_suggestion,
+    validate_array_compatibility,
+    validate_struct_compatibility,
+    validate_object_compatibility,
+    calculate_pin_name_similarity
+)
+
+
+class ConnectionValidator:
+    """Validates Blueprint pin connections before execution"""
+
+    def __init__(self, pin_discovery_service):
+        """
+        Initialize the validator with a pin discovery service.
+
+        Args:
+            pin_discovery_service: Instance of PinDiscoveryService
+        """
+        self.pin_discovery = pin_discovery_service
+
+    def validate_connection(
+        self,
+        blueprint_path: str,
+        function_id: str,
+        source_node_id: str,
+        source_pin_name: str,
+        target_node_id: str,
+        target_pin_name: str
+    ) -> Dict:
+        """
+        Validate a connection before attempting it.
+
+        Args:
+            blueprint_path: Path to Blueprint asset
+            function_id: GUID of the function graph
+            source_node_id: GUID of source node
+            source_pin_name: Name of output pin
+            target_node_id: GUID of target node
+            target_pin_name: Name of input pin
+
+        Returns:
+            {
+                "valid": bool,
+                "error_type": Optional[str],
+                "message": str,
+                "warnings": List[str],
+                "suggestions": List[str],
+                "source_pin": Optional[Dict],
+                "target_pin": Optional[Dict],
+                "available_source_pins": Optional[List[str]],
+                "available_target_pins": Optional[List[str]]
+            }
+        """
+        # Get pin information for both nodes
+        source_pins = self.pin_discovery.get_node_pins(
+            blueprint_path, function_id, source_node_id
+        )
+
+        target_pins = self.pin_discovery.get_node_pins(
+            blueprint_path, function_id, target_node_id
+        )
+
+        # Check if pin discovery succeeded
+        if not source_pins.get("success"):
+            return {
+                "valid": False,
+                "error_type": ValidationError.PIN_NOT_FOUND.value,
+                "message": f"Failed to retrieve source node information: {source_pins.get('error', 'Unknown error')}",
+                "warnings": [],
+                "suggestions": ["Verify source node GUID is correct", "Check if Blueprint is compiled"]
+            }
+
+        if not target_pins.get("success"):
+            return {
+                "valid": False,
+                "error_type": ValidationError.PIN_NOT_FOUND.value,
+                "message": f"Failed to retrieve target node information: {target_pins.get('error', 'Unknown error')}",
+                "warnings": [],
+                "suggestions": ["Verify target node GUID is correct", "Check if Blueprint is compiled"]
+            }
+
+        # Find specific pins
+        source_pin = self._find_pin_by_name(
+            source_pins.get("output_pins", []),
+            source_pin_name
+        )
+
+        target_pin = self._find_pin_by_name(
+            target_pins.get("input_pins", []),
+            target_pin_name
+        )
+
+        # Validate source pin exists
+        if not source_pin:
+            available_pins = [p["name"] for p in source_pins.get("output_pins", [])]
+            return {
+                "valid": False,
+                "error_type": ValidationError.PIN_NOT_FOUND.value,
+                "message": f"Source pin '{source_pin_name}' not found",
+                "warnings": [],
+                "suggestions": self._suggest_similar_pins(source_pin_name, source_pins.get("output_pins", [])),
+                "available_source_pins": available_pins
+            }
+
+        # Validate target pin exists
+        if not target_pin:
+            available_pins = [p["name"] for p in target_pins.get("input_pins", [])]
+            return {
+                "valid": False,
+                "error_type": ValidationError.PIN_NOT_FOUND.value,
+                "message": f"Target pin '{target_pin_name}' not found",
+                "warnings": [],
+                "suggestions": self._suggest_similar_pins(target_pin_name, target_pins.get("input_pins", [])),
+                "available_target_pins": available_pins
+            }
+
+        # Validate type compatibility
+        type_validation = self._validate_types(source_pin, target_pin)
+        if not type_validation["valid"]:
+            return type_validation
+
+        # Check array compatibility
+        array_validation = self._validate_array(source_pin, target_pin)
+        if not array_validation["valid"]:
+            return array_validation
+
+        # Check if already connected (warning, not error)
+        warnings = []
+        if target_pin.get("is_connected"):
+            warnings.append(f"Target pin '{target_pin_name}' is already connected")
+            warnings.append("Use force=True to break existing connection")
+
+        # All validations passed
+        return {
+            "valid": True,
+            "message": "Connection is valid",
+            "warnings": warnings,
+            "suggestions": [],
+            "source_pin": source_pin,
+            "target_pin": target_pin
+        }
+
+    def _find_pin_by_name(self, pins: List[Dict], pin_name: str) -> Optional[Dict]:
+        """Find a pin by name in a list of pins"""
+        for pin in pins:
+            if pin["name"] == pin_name:
+                return pin
+        return None
+
+    def _validate_types(self, source_pin: Dict, target_pin: Dict) -> Dict:
+        """Validate type compatibility between two pins"""
+        source_type = source_pin["category"]
+        target_type = target_pin["category"]
+
+        # Check basic type compatibility
+        if not are_types_compatible(source_type, target_type):
+            return {
+                "valid": False,
+                "error_type": ValidationError.TYPE_MISMATCH.value,
+                "message": f"Type mismatch: Cannot connect '{source_type}' to '{target_type}'",
+                "suggestions": get_conversion_suggestion(source_type, target_type),
+                "source_pin": source_pin,
+                "target_pin": target_pin,
+                "warnings": []
+            }
+
+        # For structs, validate subcategory
+        if source_type == "struct":
+            is_valid, suggestions = validate_struct_compatibility(
+                source_pin.get("subcategory"),
+                target_pin.get("subcategory")
+            )
+            if not is_valid:
+                return {
+                    "valid": False,
+                    "error_type": ValidationError.STRUCT_MISMATCH.value,
+                    "message": f"Struct type mismatch",
+                    "suggestions": suggestions,
+                    "source_pin": source_pin,
+                    "target_pin": target_pin,
+                    "warnings": []
+                }
+
+        # For objects, validate object type
+        if source_type == "object":
+            is_valid, warnings = validate_object_compatibility(
+                source_pin.get("object_type"),
+                target_pin.get("object_type")
+            )
+            # Object validation returns warnings, not hard errors
+            if warnings:
+                return {
+                    "valid": True,
+                    "message": "Connection is valid with warnings",
+                    "warnings": warnings,
+                    "suggestions": [],
+                    "source_pin": source_pin,
+                    "target_pin": target_pin
+                }
+
+        return {"valid": True}
+
+    def _validate_array(self, source_pin: Dict, target_pin: Dict) -> Dict:
+        """Validate array/non-array compatibility"""
+        is_valid, suggestions = validate_array_compatibility(
+            source_pin["is_array"],
+            target_pin["is_array"]
+        )
+
+        if not is_valid:
+            return {
+                "valid": False,
+                "error_type": ValidationError.INCOMPATIBLE_ARRAY.value,
+                "message": "Array/non-array mismatch",
+                "suggestions": suggestions,
+                "source_pin": source_pin,
+                "target_pin": target_pin,
+                "warnings": []
+            }
+
+        return {"valid": True}
+
+    def _suggest_similar_pins(self, pin_name: str, available_pins: List[Dict]) -> List[str]:
+        """Suggest similar pin names based on string similarity"""
+        import difflib
+
+        pin_names = [p["name"] for p in available_pins]
+        similar = difflib.get_close_matches(pin_name, pin_names, n=3, cutoff=0.6)
+
+        suggestions = []
+        if similar:
+            suggestions = [f"Did you mean '{name}'?" for name in similar]
+        else:
+            # Show first 5 available pins
+            if pin_names:
+                suggestions.append(f"Available pins: {', '.join(pin_names[:5])}")
+            else:
+                suggestions.append("No pins available")
+
+        return suggestions
+
+    def validate_bulk_connections(
+        self,
+        blueprint_path: str,
+        function_id: str,
+        connections: List[Dict]
+    ) -> Dict:
+        """
+        Validate multiple connections at once.
+
+        Args:
+            blueprint_path: Path to Blueprint asset
+            function_id: GUID of the function graph
+            connections: List of connection requests
+
+        Returns:
+            {
+                "all_valid": bool,
+                "results": List[Dict],
+                "summary": {
+                    "total": int,
+                    "valid": int,
+                    "invalid": int
+                }
+            }
+        """
+        results = []
+        valid_count = 0
+
+        for conn in connections:
+            result = self.validate_connection(
+                blueprint_path,
+                function_id,
+                conn.get("source_node_id"),
+                conn.get("source_pin"),
+                conn.get("target_node_id"),
+                conn.get("target_pin")
+            )
+
+            results.append({
+                "connection": conn,
+                "validation": result
+            })
+
+            if result.get("valid"):
+                valid_count += 1
+
+        return {
+            "all_valid": valid_count == len(connections),
+            "results": results,
+            "summary": {
+                "total": len(connections),
+                "valid": valid_count,
+                "invalid": len(connections) - valid_count
+            }
+        }
+
+
+# Standalone function for use as MCP tool
+def validate_blueprint_connection_tool(
+    blueprint_path: str,
+    function_id: str,
+    source_node_id: str,
+    source_pin: str,
+    target_node_id: str,
+    target_pin: str
+) -> str:
+    """
+    MCP tool function to validate a Blueprint connection.
+
+    Returns JSON string for MCP protocol.
+    """
+    from handlers.pin_discovery import PinDiscoveryService
+
+    pin_discovery = PinDiscoveryService()
+    validator = ConnectionValidator(pin_discovery)
+
+    result = validator.validate_connection(
+        blueprint_path,
+        function_id,
+        source_node_id,
+        source_pin,
+        target_node_id,
+        target_pin
+    )
+
+    return json.dumps(result, indent=2)
+
+
+# Testing
+if __name__ == "__main__":
+    print("Connection Validator ready")
+    print("Usage: Import and use ConnectionValidator class with PinDiscoveryService")

UMCP.it-Unreal-Organizer-Assistant/Content/Python/blueprint_connections/handlers/pin_discovery.py

@@ -0,0 +1,362 @@
+"""
+Pin Discovery Service for Unreal Engine Blueprints
+
+This service discovers and analyzes Blueprint pin information using the
+Unreal Engine Python API.
+
+NOTE: This code runs inside Unreal Engine's Python interpreter.
+"""
+
+import json
+from typing import Dict, List, Optional
+import sys
+
+# Import Unreal Engine module (only available when running inside UE)
+try:
+    import unreal
+    UNREAL_AVAILABLE = True
+except ImportError:
+    UNREAL_AVAILABLE = False
+    print("Warning: unreal module not available. Running in test mode.")
+
+
+class PinDiscoveryService:
+    """Service for discovering and analyzing Blueprint pins"""
+
+    def __init__(self):
+        self.pin_cache = {}  # Cache for performance
+        self.cache_enabled = True
+
+    def clear_cache(self):
+        """Clear the pin information cache"""
+        self.pin_cache = {}
+
+    def get_node_pins(
+        self,
+        blueprint_path: str,
+        function_id: str,
+        node_id: str,
+        use_cache: bool = True
+    ) -> Dict:
+        """
+        Retrieve all pins for a specific node.
+
+        Args:
+            blueprint_path: Path to Blueprint asset (e.g., "/Game/BP_Test")
+            function_id: GUID of the function graph
+            node_id: GUID of the node
+            use_cache: Whether to use cached results
+
+        Returns:
+            {
+                "success": bool,
+                "node_info": {
+                    "guid": str,
+                    "type": str,
+                    "name": str,
+                    "position": [int, int],
+                    "is_pure": bool
+                },
+                "input_pins": [...],
+                "output_pins": [...],
+                "error": Optional[str]
+            }
+        """
+        if not UNREAL_AVAILABLE:
+            return {
+                "success": False,
+                "error": "Unreal Engine Python API not available"
+            }
+
+        cache_key = f"{blueprint_path}:{function_id}:{node_id}"
+
+        # Check cache
+        if use_cache and self.cache_enabled and cache_key in self.pin_cache:
+            return self.pin_cache[cache_key]
+
+        try:
+            # Load Blueprint
+            blueprint = unreal.EditorAssetLibrary.load_asset(blueprint_path)
+            if not blueprint:
+                return {
+                    "success": False,
+                    "error": f"Blueprint not found: {blueprint_path}"
+                }
+
+            # Compile if needed
+            self._ensure_compiled(blueprint)
+
+            # Find the graph
+            graph = self._find_graph_by_id(blueprint, function_id)
+            if not graph:
+                return {
+                    "success": False,
+                    "error": f"Graph not found: {function_id}",
+                    "available_graphs": self._list_available_graphs(blueprint)
+                }
+
+            # Find the node
+            node = self._find_node_by_guid(graph, node_id)
+            if not node:
+                return {
+                    "success": False,
+                    "error": f"Node not found: {node_id}",
+                    "available_nodes": self._list_available_nodes(graph)
+                }
+
+            # Extract pin information
+            result = {
+                "success": True,
+                "node_info": self._extract_node_info(node),
+                "input_pins": self._extract_pins(node, "EGPD_Input"),
+                "output_pins": self._extract_pins(node, "EGPD_Output")
+            }
+
+            # Cache result
+            if self.cache_enabled:
+                self.pin_cache[cache_key] = result
+
+            return result
+
+        except Exception as e:
+            return {
+                "success": False,
+                "error": str(e),
+                "error_type": type(e).__name__
+            }
+
+    def _ensure_compiled(self, blueprint):
+        """Ensure Blueprint is compiled before accessing pins"""
+        try:
+            if hasattr(unreal, 'KismetSystemLibrary'):
+                unreal.KismetSystemLibrary.compile_blueprint(blueprint)
+        except Exception as e:
+            print(f"Warning: Could not compile Blueprint: {e}")
+
+    def _find_graph_by_id(self, blueprint, function_id: str):
+        """Find a graph in the blueprint by its GUID"""
+        # Check UberGraph pages (event graphs)
+        ubergraph_pages = blueprint.get_editor_property('ubergraph_pages')
+        if ubergraph_pages:
+            for graph in ubergraph_pages:
+                if str(graph.graph_guid) == function_id:
+                    return graph
+
+        # Check function graphs
+        function_graphs = blueprint.get_editor_property('function_graphs')
+        if function_graphs:
+            for graph in function_graphs:
+                if str(graph.graph_guid) == function_id:
+                    return graph
+
+        return None
+
+    def _find_node_by_guid(self, graph, node_guid: str):
+        """Find a node in the graph by its GUID"""
+        nodes = graph.get_editor_property('nodes')
+        if not nodes:
+            return None
+
+        for node in nodes:
+            if str(node.node_guid) == node_guid:
+                return node
+
+        return None
+
+    def _extract_node_info(self, node) -> Dict:
+        """Extract basic node information"""
+        return {
+            "guid": str(node.node_guid),
+            "type": type(node).__name__,
+            "name": node.get_name() if hasattr(node, 'get_name') else "Unknown",
+            "position": [
+                node.node_pos_x if hasattr(node, 'node_pos_x') else 0,
+                node.node_pos_y if hasattr(node, 'node_pos_y') else 0
+            ],
+            "is_pure": self._is_pure_node(node)
+        }
+
+    def _is_pure_node(self, node) -> bool:
+        """Determine if a node is pure (no execution pins)"""
+        # Check if node has is_pure property
+        if hasattr(node, 'is_pure_func'):
+            return node.is_pure_func
+
+        # Check if any execution pins exist
+        if hasattr(node, 'pins'):
+            for pin in node.pins:
+                if hasattr(pin, 'pin_type') and pin.pin_type.pin_category == 'exec':
+                    return False
+
+        # Default to True for math operations
+        return True
+
+    def _extract_pins(self, node, direction: str) -> List[Dict]:
+        """Extract all pins of a specific direction"""
+        pins = []
+
+        if not hasattr(node, 'pins'):
+            return pins
+
+        target_direction = (unreal.EdGraphPinDirection.EGPD_INPUT
+                          if direction == "EGPD_Input"
+                          else unreal.EdGraphPinDirection.EGPD_OUTPUT)
+
+        for pin in node.pins:
+            if pin.direction == target_direction:
+                pin_info = {
+                    "name": str(pin.pin_name),
+                    "display_name": str(pin.pin_friendly_name) if hasattr(pin, 'pin_friendly_name') else str(pin.pin_name),
+                    "category": str(pin.pin_type.pin_category) if hasattr(pin.pin_type, 'pin_category') else "unknown",
+                    "subcategory": str(pin.pin_type.pin_sub_category) if hasattr(pin.pin_type, 'pin_sub_category') and pin.pin_type.pin_sub_category else None,
+                    "is_array": pin.pin_type.is_array if hasattr(pin.pin_type, 'is_array') else False,
+                    "is_reference": pin.pin_type.is_reference if hasattr(pin.pin_type, 'is_reference') else False,
+                    "is_connected": len(pin.linked_to) > 0 if hasattr(pin, 'linked_to') else False,
+                    "default_value": str(pin.default_value) if hasattr(pin, 'default_value') and pin.default_value else None,
+                    "connected_to": [str(linked_pin.pin_name) for linked_pin in pin.linked_to] if hasattr(pin, 'linked_to') else [],
+                    "object_type": str(pin.pin_type.pin_sub_category_object) if hasattr(pin.pin_type, 'pin_sub_category_object') and pin.pin_type.pin_sub_category_object else None
+                }
+                pins.append(pin_info)
+
+        return pins
+
+    def _list_available_graphs(self, blueprint) -> List[Dict]:
+        """List all available graphs in a Blueprint for debugging"""
+        graphs = []
+
+        try:
+            ubergraph_pages = blueprint.get_editor_property('ubergraph_pages')
+            if ubergraph_pages:
+                for graph in ubergraph_pages:
+                    graphs.append({
+                        "name": graph.get_name(),
+                        "guid": str(graph.graph_guid),
+                        "type": "UberGraph"
+                    })
+
+            function_graphs = blueprint.get_editor_property('function_graphs')
+            if function_graphs:
+                for graph in function_graphs:
+                    graphs.append({
+                        "name": graph.get_name(),
+                        "guid": str(graph.graph_guid),
+                        "type": "Function"
+                    })
+        except Exception as e:
+            print(f"Error listing graphs: {e}")
+
+        return graphs
+
+    def _list_available_nodes(self, graph) -> List[Dict]:
+        """List all available nodes in a graph for debugging"""
+        nodes = []
+
+        try:
+            graph_nodes = graph.get_editor_property('nodes')
+            if graph_nodes:
+                for node in graph_nodes:
+                    nodes.append({
+                        "name": node.get_name() if hasattr(node, 'get_name') else "Unknown",
+                        "guid": str(node.node_guid),
+                        "type": type(node).__name__
+                    })
+        except Exception as e:
+            print(f"Error listing nodes: {e}")
+
+        return nodes[:10]  # Limit to first 10 for readability
+
+    def _find_node_containing_pin(self, nodes, pin):
+        """Find which node contains a specific pin"""
+        for node in nodes:
+            if hasattr(node, 'pins'):
+                for node_pin in node.pins:
+                    if node_pin == pin:
+                        return node
+        return None
+
+    def get_all_graph_connections(self, blueprint_path: str, function_id: str) -> Dict:
+        """
+        Get all existing connections in a graph.
+
+        Args:
+            blueprint_path: Path to Blueprint asset
+            function_id: GUID of the function graph
+
+        Returns:
+            {
+                "success": bool,
+                "connection_count": int,
+                "connections": [
+                    {
+                        "source_node": str,
+                        "source_pin": str,
+                        "target_node": str,
+                        "target_pin": str,
+                        "type": str
+                    }
+                ]
+            }
+        """
+        if not UNREAL_AVAILABLE:
+            return {"success": False, "error": "Unreal Engine Python API not available"}
+
+        try:
+            blueprint = unreal.EditorAssetLibrary.load_asset(blueprint_path)
+            graph = self._find_graph_by_id(blueprint, function_id)
+
+            if not graph:
+                return {"success": False, "error": "Graph not found"}
+
+            connections = []
+            nodes = graph.get_editor_property('nodes')
+
+            for node in nodes:
+                if not hasattr(node, 'pins'):
+                    continue
+
+                for pin in node.pins:
+                    if pin.direction == unreal.EdGraphPinDirection.EGPD_OUTPUT:
+                        if hasattr(pin, 'linked_to'):
+                            for linked_pin in pin.linked_to:
+                                # Find the target node
+                                target_node = self._find_node_containing_pin(nodes, linked_pin)
+
+                                connections.append({
+                                    "source_node": str(node.node_guid),
+                                    "source_pin": str(pin.pin_name),
+                                    "target_node": str(target_node.node_guid) if target_node else "Unknown",
+                                    "target_pin": str(linked_pin.pin_name),
+                                    "type": str(pin.pin_type.pin_category) if hasattr(pin.pin_type, 'pin_category') else "unknown"
+                                })
+
+            return {
+                "success": True,
+                "connection_count": len(connections),
+                "connections": connections
+            }
+
+        except Exception as e:
+            return {"success": False, "error": str(e)}
+
+
+# Standalone function for use as MCP tool
+def get_node_pin_details_tool(blueprint_path: str, function_id: str, node_id: str) -> str:
+    """
+    MCP tool function to get node pin details.
+
+    Returns JSON string for MCP protocol.
+    """
+    service = PinDiscoveryService()
+    result = service.get_node_pins(blueprint_path, function_id, node_id)
+    return json.dumps(result, indent=2)
+
+
+# Testing function
+if __name__ == "__main__":
+    if not UNREAL_AVAILABLE:
+        print("Running in test mode - Unreal Engine not available")
+        print("This module must be run inside Unreal Engine Python interpreter")
+    else:
+        print("Pin Discovery Service ready")
+        service = PinDiscoveryService()
+        print(f"Cache enabled: {service.cache_enabled}")

UMCP.it-Unreal-Organizer-Assistant/Content/Python/blueprint_connections/utils/connection_rules.py

@@ -0,0 +1,225 @@
+"""
+Connection Rules and Type Compatibility for Unreal Engine Blueprints
+
+This module defines the rules for connecting Blueprint pins, including
+type compatibility matrices and conversion suggestions.
+"""
+
+from typing import List, Tuple, Optional
+
+
+# Type compatibility matrix - defines which pin types can connect to which
+TYPE_COMPATIBILITY = {
+    'exec': ['exec'],
+    'boolean': ['boolean', 'byte', 'int', 'wildcard'],
+    'byte': ['byte', 'int', 'float', 'double', 'wildcard'],
+    'int': ['int', 'float', 'double', 'wildcard'],
+    'int64': ['int64', 'double', 'wildcard'],
+    'float': ['float', 'double', 'wildcard'],
+    'double': ['double', 'wildcard'],
+    'name': ['name', 'string', 'text', 'wildcard'],
+    'string': ['string', 'text', 'wildcard'],
+    'text': ['text', 'wildcard'],
+    'struct': ['struct', 'wildcard'],  # Must also match subcategory
+    'object': ['object', 'wildcard'],  # Must also check inheritance
+    'class': ['class', 'wildcard'],
+    'interface': ['interface', 'wildcard'],
+    'delegate': ['delegate'],
+    'wildcard': [
+        'exec', 'boolean', 'byte', 'int', 'int64', 'float', 'double',
+        'name', 'string', 'text', 'struct', 'object', 'class',
+        'interface', 'delegate'
+    ]
+}
+
+
+# Type conversion suggestions - maps (from_type, to_type) to conversion node names
+TYPE_CONVERSIONS = {
+    ('int', 'float'): "Use implicit conversion or 'IntToFloat' node",
+    ('float', 'int'): "Add 'FloatToInt' node (truncates decimal)",
+    ('int', 'string'): "Add 'IntToString' node",
+    ('float', 'string'): "Add 'FloatToString' node",
+    ('string', 'int'): "Add 'StringToInt' node",
+    ('string', 'float'): "Add 'StringToFloat' node",
+    ('boolean', 'string'): "Add 'BoolToString' node",
+    ('name', 'string'): "Add 'NameToString' node",
+    ('string', 'name'): "Add 'StringToName' node",
+    ('byte', 'int'): "Implicit conversion supported",
+    ('int', 'int64'): "Implicit conversion supported",
+    ('float', 'double'): "Implicit conversion supported",
+    ('int', 'byte'): "Add 'IntToByte' node (may overflow)",
+    ('string', 'text'): "Use 'StringToText' node",
+    ('text', 'string'): "Use 'TextToString' node"
+}
+
+
+def are_types_compatible(source_type: str, target_type: str) -> bool:
+    """
+    Check if two pin types can be connected.
+
+    Args:
+        source_type: The type of the output pin
+        target_type: The type of the input pin
+
+    Returns:
+        bool: True if the types are compatible, False otherwise
+    """
+    compatible_types = TYPE_COMPATIBILITY.get(source_type, [])
+    return target_type in compatible_types
+
+
+def get_conversion_suggestion(from_type: str, to_type: str) -> List[str]:
+    """
+    Get suggestions for converting between incompatible types.
+
+    Args:
+        from_type: The source pin type
+        to_type: The target pin type
+
+    Returns:
+        List of suggestion strings
+    """
+    # Check if direct conversion exists
+    conversion = TYPE_CONVERSIONS.get((from_type, to_type))
+    if conversion:
+        return [conversion]
+
+    # Return generic suggestions
+    return [
+        f"No direct conversion from '{from_type}' to '{to_type}'",
+        "Consider alternative logic path",
+        "Check if intermediate conversion nodes are needed"
+    ]
+
+
+def validate_array_compatibility(source_is_array: bool, target_is_array: bool) -> Tuple[bool, Optional[List[str]]]:
+    """
+    Validate array/non-array compatibility.
+
+    Args:
+        source_is_array: Whether the source pin is an array
+        target_is_array: Whether the target pin is an array
+
+    Returns:
+        Tuple of (is_valid, suggestions)
+    """
+    if source_is_array == target_is_array:
+        return (True, None)
+
+    # Incompatible array types
+    if source_is_array and not target_is_array:
+        return (False, [
+            "Use 'ForEach' loop to iterate array elements",
+            "Use 'Get' node to access single array element by index",
+            "Consider using 'First' or 'Last' array functions"
+        ])
+    else:  # not source_is_array and target_is_array
+        return (False, [
+            "Use 'MakeArray' node to convert single value to array",
+            "Use 'Append' or 'Add' to add to existing array",
+            "Consider if target should accept single value instead"
+        ])
+
+
+def validate_struct_compatibility(source_subcategory: Optional[str],
+                                 target_subcategory: Optional[str]) -> Tuple[bool, Optional[List[str]]]:
+    """
+    Validate struct type compatibility.
+
+    Structs must have matching subcategories to be compatible.
+
+    Args:
+        source_subcategory: The source pin's struct type
+        target_subcategory: The target pin's struct type
+
+    Returns:
+        Tuple of (is_valid, suggestions)
+    """
+    if source_subcategory == target_subcategory:
+        return (True, None)
+
+    return (False, [
+        f"Struct type mismatch: '{source_subcategory}' vs '{target_subcategory}'",
+        "Cannot directly convert between different struct types",
+        "Consider breaking struct members and reconstructing"
+    ])
+
+
+def validate_object_compatibility(source_object_type: Optional[str],
+                                  target_object_type: Optional[str]) -> Tuple[bool, Optional[List[str]]]:
+    """
+    Validate object reference compatibility.
+
+    Note: This is a simplified check. Full implementation would need
+    to query Unreal's type hierarchy to check inheritance.
+
+    Args:
+        source_object_type: The source pin's object class
+        target_object_type: The target pin's object class
+
+    Returns:
+        Tuple of (is_valid, suggestions)
+    """
+    # Same type is always compatible
+    if source_object_type == target_object_type:
+        return (True, None)
+
+    # If either is None, we can't validate
+    if not source_object_type or not target_object_type:
+        return (True, ["Warning: Could not fully validate object type compatibility"])
+
+    # Simplified check - in real implementation, would check inheritance hierarchy
+    return (True, [
+        "Warning: Object types differ - verify inheritance compatibility",
+        f"Source: {source_object_type}, Target: {target_object_type}",
+        "Use 'Cast To' node if types are incompatible"
+    ])
+
+
+# Common pin name patterns for intelligent matching
+COMMON_PIN_PATTERNS = {
+    'execution_output': ['then', 'exec', 'completed', 'finished'],
+    'execution_input': ['execute', 'exec'],
+    'return_value': ['returnvalue', 'return', 'result', 'output'],
+    'input_value': ['input', 'value', 'in', 'a', 'b'],
+    'condition': ['condition', 'test', 'check', 'if'],
+    'true_branch': ['true', 'then'],
+    'false_branch': ['false', 'else']
+}
+
+
+def get_pin_name_category(pin_name: str) -> Optional[str]:
+    """
+    Categorize a pin name based on common patterns.
+
+    Args:
+        pin_name: The pin name to categorize
+
+    Returns:
+        The category name, or None if no match
+    """
+    pin_lower = pin_name.lower()
+
+    for category, patterns in COMMON_PIN_PATTERNS.items():
+        if any(pattern in pin_lower for pattern in patterns):
+            return category
+
+    return None
+
+
+def calculate_pin_name_similarity(name1: str, name2: str) -> float:
+    """
+    Calculate similarity score between two pin names.
+
+    Uses difflib's SequenceMatcher for fuzzy string matching.
+
+    Args:
+        name1: First pin name
+        name2: Second pin name
+
+    Returns:
+        Similarity score from 0.0 to 1.0
+    """
+    from difflib import SequenceMatcher
+
+    return SequenceMatcher(None, name1.lower(), name2.lower()).ratio()

UMCP.it-Unreal-Organizer-Assistant/Content/Python/blueprint_connections/utils/node_helpers.py

@@ -0,0 +1,273 @@
+"""
+Helper Functions for Blueprint Node Operations
+
+This module provides utility functions for working with Blueprint nodes,
+including node type detection, position calculation, and common operations.
+"""
+
+from typing import Optional, Tuple, List, Dict
+
+
+def calculate_node_spacing(node_count: int, start_x: int = 0, start_y: int = 0,
+                          horizontal_spacing: int = 400, vertical_spacing: int = 300) -> List[Tuple[int, int]]:
+    """
+    Calculate evenly-spaced positions for a chain of nodes.
+
+    Args:
+        node_count: Number of nodes to position
+        start_x: Starting X coordinate
+        start_y: Starting Y coordinate
+        horizontal_spacing: Space between nodes horizontally
+        vertical_spacing: Space between rows vertically
+
+    Returns:
+        List of (x, y) coordinate tuples
+    """
+    positions = []
+    nodes_per_row = 5  # Max nodes before wrapping to next row
+
+    for i in range(node_count):
+        row = i // nodes_per_row
+        col = i % nodes_per_row
+
+        x = start_x + (col * horizontal_spacing)
+        y = start_y + (row * vertical_spacing)
+
+        positions.append((x, y))
+
+    return positions
+
+
+def is_execution_node(node_class: str) -> bool:
+    """
+    Determine if a node type has execution pins.
+
+    Args:
+        node_class: The node's class name
+
+    Returns:
+        True if node has execution flow, False if pure
+    """
+    # Pure function nodes don't have execution pins
+    pure_node_prefixes = [
+        'K2Node_CallMathFunction',
+        'K2Node_CommutativeAssociativeBinaryOperator',
+        'K2Node_GetVariable',
+        'K2Node_Literal'
+    ]
+
+    for prefix in pure_node_prefixes:
+        if node_class.startswith(prefix):
+            return False
+
+    # Event and flow control nodes always have execution
+    exec_node_prefixes = [
+        'K2Node_Event',
+        'K2Node_CallFunction',
+        'K2Node_IfThenElse',
+        'K2Node_Branch',
+        'K2Node_ForEachLoop',
+        'K2Node_WhileLoop',
+        'K2Node_Sequence'
+    ]
+
+    for prefix in exec_node_prefixes:
+        if node_class.startswith(prefix):
+            return True
+
+    # Default: assume has execution
+    return True
+
+
+def get_node_display_name(node_class: str, node_name: str) -> str:
+    """
+    Get a user-friendly display name for a node.
+
+    Args:
+        node_class: The node's class name
+        node_name: The node's internal name
+
+    Returns:
+        A readable display name
+    """
+    # Remove common prefixes
+    display = node_name
+    prefixes_to_remove = ['K2Node_', 'EdGraph', 'UK2Node_']
+
+    for prefix in prefixes_to_remove:
+        if display.startswith(prefix):
+            display = display[len(prefix):]
+
+    # Convert CamelCase to spaces
+    import re
+    display = re.sub(r'([A-Z])', r' \1', display).strip()
+
+    return display
+
+
+def get_common_node_types() -> Dict[str, Dict[str, any]]:
+    """
+    Get information about common Blueprint node types.
+
+    Returns:
+        Dictionary mapping node type names to their properties
+    """
+    return {
+        'Add': {
+            'class': 'K2Node_CallMathFunction',
+            'function': 'Add_FloatFloat',
+            'input_pins': ['A', 'B'],
+            'output_pins': ['ReturnValue'],
+            'is_pure': True
+        },
+        'Multiply': {
+            'class': 'K2Node_CallMathFunction',
+            'function': 'Multiply_FloatFloat',
+            'input_pins': ['A', 'B'],
+            'output_pins': ['ReturnValue'],
+            'is_pure': True
+        },
+        'Subtract': {
+            'class': 'K2Node_CallMathFunction',
+            'function': 'Subtract_FloatFloat',
+            'input_pins': ['A', 'B'],
+            'output_pins': ['ReturnValue'],
+            'is_pure': True
+        },
+        'Divide': {
+            'class': 'K2Node_CallMathFunction',
+            'function': 'Divide_FloatFloat',
+            'input_pins': ['A', 'B'],
+            'output_pins': ['ReturnValue'],
+            'is_pure': True
+        },
+        'Branch': {
+            'class': 'K2Node_IfThenElse',
+            'input_pins': ['execute', 'Condition'],
+            'output_pins': ['then', 'True', 'False'],
+            'is_pure': False
+        },
+        'Sequence': {
+            'class': 'K2Node_ExecutionSequence',
+            'input_pins': ['execute'],
+            'output_pins': ['then 0', 'then 1', 'then 2'],
+            'is_pure': False
+        },
+        'PrintString': {
+            'class': 'K2Node_CallFunction',
+            'function': 'PrintString',
+            'input_pins': ['execute', 'InString'],
+            'output_pins': ['then'],
+            'is_pure': False
+        },
+        'ForLoop': {
+            'class': 'K2Node_ForEachLoop',
+            'input_pins': ['execute', 'FirstIndex', 'LastIndex'],
+            'output_pins': ['LoopBody', 'Index', 'Completed'],
+            'is_pure': False
+        }
+    }
+
+
+def guess_pin_type_from_name(pin_name: str) -> Optional[str]:
+    """
+    Attempt to guess pin type from its name.
+
+    This is useful when pin type information isn't directly available.
+
+    Args:
+        pin_name: The name of the pin
+
+    Returns:
+        Guessed type string, or None if can't determine
+    """
+    pin_lower = pin_name.lower()
+
+    type_hints = {
+        'exec': ['execute', 'then', 'completed'],
+        'boolean': ['condition', 'bool', 'is', 'has', 'can', 'should'],
+        'int': ['index', 'count', 'num', 'id'],
+        'float': ['value', 'amount', 'distance', 'speed', 'time'],
+        'string': ['string', 'text', 'name', 'message', 'label'],
+        'object': ['object', 'actor', 'component', 'target', 'reference']
+    }
+
+    for pin_type, hints in type_hints.items():
+        if any(hint in pin_lower for hint in hints):
+            return pin_type
+
+    return None
+
+
+def format_connection_path(source_node: str, source_pin: str,
+                          target_node: str, target_pin: str) -> str:
+    """
+    Format a connection as a readable string.
+
+    Args:
+        source_node: Source node GUID or name
+        source_pin: Source pin name
+        target_node: Target node GUID or name
+        target_pin: Target pin name
+
+    Returns:
+        Formatted string like "NodeA.PinOut → NodeB.PinIn"
+    """
+    # Truncate GUIDs for readability
+    def truncate_guid(guid: str) -> str:
+        if len(guid) > 8 and '-' in guid:
+            return guid[:8] + '...'
+        return guid
+
+    source = truncate_guid(source_node)
+    target = truncate_guid(target_node)
+
+    return f"{source}.{source_pin} → {target}.{target_pin}"
+
+
+def validate_node_position(x: int, y: int,
+                          min_x: int = -10000, max_x: int = 10000,
+                          min_y: int = -10000, max_y: int = 10000) -> Tuple[bool, str]:
+    """
+    Validate that a node position is within acceptable bounds.
+
+    Args:
+        x: X coordinate
+        y: Y coordinate
+        min_x: Minimum allowed X
+        max_x: Maximum allowed X
+        min_y: Minimum allowed Y
+        max_y: Maximum allowed Y
+
+    Returns:
+        Tuple of (is_valid, error_message)
+    """
+    if not (min_x <= x <= max_x):
+        return (False, f"X position {x} is outside bounds [{min_x}, {max_x}]")
+
+    if not (min_y <= y <= max_y):
+        return (False, f"Y position {y} is outside bounds [{min_y}, {max_y}]")
+
+    return (True, "")
+
+
+def find_midpoint(pos1: Tuple[int, int], pos2: Tuple[int, int]) -> Tuple[int, int]:
+    """
+    Find the midpoint between two node positions.
+
+    Useful for placing conversion nodes between incompatible connections.
+
+    Args:
+        pos1: First position (x, y)
+        pos2: Second position (x, y)
+
+    Returns:
+        Midpoint coordinates (x, y)
+    """
+    x1, y1 = pos1
+    x2, y2 = pos2
+
+    mid_x = (x1 + x2) // 2
+    mid_y = (y1 + y2) // 2
+
+    return (mid_x, mid_y)

UMCP.it-Unreal-Organizer-Assistant/Content/Python/blueprint_connections/utils/pin_types.py

@@ -0,0 +1,152 @@
+"""
+Pin Type Definitions for Unreal Engine Blueprint System
+
+This module defines all data structures for Blueprint pin information,
+node information, and connection requests/results.
+"""
+
+from dataclasses import dataclass
+from enum import Enum
+from typing import Optional, List
+
+
+class PinCategory(Enum):
+    """All Unreal Engine pin types/categories"""
+    EXEC = "exec"
+    BOOLEAN = "boolean"
+    BYTE = "byte"
+    INT = "int"
+    INT64 = "int64"
+    FLOAT = "float"
+    DOUBLE = "double"
+    NAME = "name"
+    STRING = "string"
+    TEXT = "text"
+    STRUCT = "struct"
+    OBJECT = "object"
+    CLASS = "class"
+    INTERFACE = "interface"
+    DELEGATE = "delegate"
+    WILDCARD = "wildcard"
+
+
+class PinDirection(Enum):
+    """Pin direction: input or output"""
+    INPUT = "EGPD_Input"
+    OUTPUT = "EGPD_Output"
+
+
+@dataclass
+class PinInfo:
+    """Complete information about a Blueprint pin"""
+    name: str
+    display_name: str
+    category: str  # PinCategory value
+    subcategory: Optional[str]
+    direction: str  # PinDirection value
+    is_array: bool
+    is_reference: bool
+    is_connected: bool
+    default_value: Optional[str]
+    connected_to: Optional[List[str]]  # List of pin names
+    object_type: Optional[str]  # For object/class pins
+
+    def to_dict(self):
+        """Convert to dictionary for JSON serialization"""
+        return {
+            "name": self.name,
+            "display_name": self.display_name,
+            "category": self.category,
+            "subcategory": self.subcategory,
+            "direction": self.direction,
+            "is_array": self.is_array,
+            "is_reference": self.is_reference,
+            "is_connected": self.is_connected,
+            "default_value": self.default_value,
+            "connected_to": self.connected_to or [],
+            "object_type": self.object_type
+        }
+
+
+@dataclass
+class NodeInfo:
+    """Complete information about a Blueprint node"""
+    guid: str
+    node_type: str
+    node_class: str
+    display_name: str
+    position: tuple
+    input_pins: List[PinInfo]
+    output_pins: List[PinInfo]
+    is_pure: bool  # Pure nodes don't have execution pins
+
+    def to_dict(self):
+        """Convert to dictionary for JSON serialization"""
+        return {
+            "guid": self.guid,
+            "node_type": self.node_type,
+            "node_class": self.node_class,
+            "display_name": self.display_name,
+            "position": list(self.position),
+            "input_pins": [p.to_dict() for p in self.input_pins],
+            "output_pins": [p.to_dict() for p in self.output_pins],
+            "is_pure": self.is_pure
+        }
+
+
+@dataclass
+class ConnectionRequest:
+    """Request to connect two pins"""
+    blueprint_path: str
+    function_id: str
+    source_node_id: str
+    source_pin_name: str
+    target_node_id: str
+    target_pin_name: str
+    force: bool = False  # Break existing connections if needed
+
+    def to_dict(self):
+        """Convert to dictionary for JSON serialization"""
+        return {
+            "blueprint_path": self.blueprint_path,
+            "function_id": self.function_id,
+            "source_node_id": self.source_node_id,
+            "source_pin_name": self.source_pin_name,
+            "target_node_id": self.target_node_id,
+            "target_pin_name": self.target_pin_name,
+            "force": self.force
+        }
+
+
+@dataclass
+class ConnectionResult:
+    """Result of a connection attempt"""
+    success: bool
+    message: str
+    source_pin: Optional[PinInfo]
+    target_pin: Optional[PinInfo]
+    warnings: List[str]
+    suggestions: List[str]
+
+    def to_dict(self):
+        """Convert to dictionary for JSON serialization"""
+        return {
+            "success": self.success,
+            "message": self.message,
+            "source_pin": self.source_pin.to_dict() if self.source_pin else None,
+            "target_pin": self.target_pin.to_dict() if self.target_pin else None,
+            "warnings": self.warnings,
+            "suggestions": self.suggestions
+        }
+
+
+class ValidationError(Enum):
+    """Types of validation errors that can occur"""
+    TYPE_MISMATCH = "type_mismatch"
+    DIRECTION_ERROR = "direction_error"
+    ALREADY_CONNECTED = "already_connected"
+    PIN_NOT_FOUND = "pin_not_found"
+    INCOMPATIBLE_ARRAY = "incompatible_array"
+    DELEGATE_ERROR = "delegate_error"
+    STRUCT_MISMATCH = "struct_mismatch"
+    OBJECT_TYPE_MISMATCH = "object_type_mismatch"

UMCP.it-Unreal-Organizer-Assistant/Content/Python/handlers/__init__.py

@@ -0,0 +1 @@
+# handlers package

UMCP.it-Unreal-Organizer-Assistant/Content/Python/handlers/actor_commands.py

@@ -0,0 +1,332 @@
+import unreal
+import json
+from typing import Dict, Any, List, Tuple, Union
+
+from utils import unreal_conversions as uc
+from utils import logging as log
+from utils import asset_validation as av
+
+
+def handle_modify_object(command: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Handle a modify_object command
+    
+    Args:
+        command: The command dictionary containing:
+            - actor_name: Name of the actor to modify
+            - property_type: Type of property to modify (material, position, rotation, scale)
+            - value: Value to set for the property
+            
+    Returns:
+        Response dictionary with success/failure status
+    """
+    try:
+        # Extract parameters
+        actor_name = command.get("actor_name")
+        property_type = command.get("property_type")
+        value = command.get("value")
+
+        if not actor_name or not property_type or value is None:
+            log.log_error("Missing required parameters for modify_object")
+            return {"success": False, "error": "Missing required parameters"}
+
+        log.log_command("modify_object", f"Actor: {actor_name}, Property: {property_type}")
+
+        # Use the C++ utility class
+        gen_actor_utils = unreal.GenActorUtils
+
+        # Handle different property types
+        if property_type == "material":
+            # Set the material
+            material_path = value
+            success = gen_actor_utils.set_actor_material_by_path(actor_name, material_path)
+            if success:
+                log.log_result("modify_object", True, f"Material of {actor_name} set to {material_path}")
+                return {"success": True}
+            log.log_error(f"Failed to set material for {actor_name}")
+            return {"success": False, "error": f"Failed to set material for {actor_name}"}
+
+        elif property_type == "position":
+            # Set position
+            try:
+                vec = uc.to_unreal_vector(value)
+                success = gen_actor_utils.set_actor_position(actor_name, vec)
+                if success:
+                    log.log_result("modify_object", True, f"Position of {actor_name} set to {vec}")
+                    return {"success": True}
+                log.log_error(f"Failed to set position for {actor_name}")
+                return {"success": False, "error": f"Failed to set position for {actor_name}"}
+            except ValueError as e:
+                log.log_error(str(e))
+                return {"success": False, "error": str(e)}
+
+        elif property_type == "rotation":
+            # Set rotation
+            try:
+                rot = uc.to_unreal_rotator(value)
+                success = gen_actor_utils.set_actor_rotation(actor_name, rot)
+                if success:
+                    log.log_result("modify_object", True, f"Rotation of {actor_name} set to {rot}")
+                    return {"success": True}
+                log.log_error(f"Failed to set rotation for {actor_name}")
+                return {"success": False, "error": f"Failed to set rotation for {actor_name}"}
+            except ValueError as e:
+                log.log_error(str(e))
+                return {"success": False, "error": str(e)}
+
+        elif property_type == "scale":
+            # Set scale
+            try:
+                scale = uc.to_unreal_vector(value)
+                success = gen_actor_utils.set_actor_scale(actor_name, scale)
+                if success:
+                    log.log_result("modify_object", True, f"Scale of {actor_name} set to {scale}")
+                    return {"success": True}
+                log.log_error(f"Failed to set scale for {actor_name}")
+                return {"success": False, "error": f"Failed to set scale for {actor_name}"}
+            except ValueError as e:
+                log.log_error(str(e))
+                return {"success": False, "error": str(e)}
+
+        else:
+            log.log_error(f"Unknown property type: {property_type}")
+            return {"success": False, "error": f"Unknown property type: {property_type}"}
+
+    except Exception as e:
+        log.log_error(f"Error modifying object: {str(e)}", include_traceback=True)
+        return {"success": False, "error": str(e)}
+
+def handle_edit_component_property(command: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Handle a command to edit a component property in a Blueprint or scene actor.
+    
+    Args:
+        command: The command dictionary containing:
+            - blueprint_path: Path to the Blueprint
+            - component_name: Name of the component
+            - property_name: Name of the property to edit
+            - value: New value as a string
+            - is_scene_actor: Boolean flag for scene actor (optional, default False)
+            - actor_name: Name of the scene actor (required if is_scene_actor is True)
+                
+    Returns:
+        Dictionary with success/failure status, message, and optional suggestions
+    """
+    try:
+        # FIX: Strip whitespace from paths to prevent corruption (unreal-mcp-monitor)
+        blueprint_path = command.get("blueprint_path", "").strip()
+        component_name = command.get("component_name", "").strip() if command.get("component_name") else None
+        property_name = command.get("property_name", "").strip() if command.get("property_name") else None
+        value = command.get("value")
+        # Strip whitespace from value if it's a string (could be asset path)
+        if isinstance(value, str):
+            value = value.strip()
+        is_scene_actor = command.get("is_scene_actor", False)
+        actor_name = command.get("actor_name", "").strip()
+
+        if not component_name or not property_name or value is None:
+            log.log_error("Missing required parameters for edit_component_property")
+            return {"success": False, "error": "Missing required parameters"}
+
+        if is_scene_actor and not actor_name:
+            log.log_error("Actor name required for scene actor editing")
+            return {"success": False, "error": "Actor name required for scene actor"}
+
+        # Log detailed information about what we're trying to do
+        log_msg = f"Blueprint: {blueprint_path}, Component: {component_name}, Property: {property_name}, Value: {value}"
+        if is_scene_actor:
+            log_msg += f", Actor: {actor_name}"
+        log.log_command("edit_component_property", log_msg)
+
+        # Call the C++ implementation
+        node_creator = unreal.GenObjectProperties
+        result = node_creator.edit_component_property(blueprint_path, component_name, property_name, value, is_scene_actor, actor_name)
+
+        # Parse the result - CHANGED: Convert JSON string to dict
+        try:
+            parsed_result = json.loads(result)
+            log.log_result("edit_component_property", parsed_result["success"],
+                           parsed_result.get("message", parsed_result.get("error", "No message")))
+            # CHANGED: Return the parsed dict instead of the original JSON string
+            return parsed_result
+        except json.JSONDecodeError:
+            # If the result is not valid JSON, wrap it in a JSON object
+            log.log_warning(f"Invalid JSON result from C++: {result}")
+            return {"success": False, "error": f"Invalid response format: {result}"}
+
+    except Exception as e:
+        log.log_error(f"Error editing component property: {str(e)}", include_traceback=True)
+        return {"success": False, "error": str(e)}
+
+
+def handle_add_component_with_events(command: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Handle a command to add a component to a Blueprint with overlap events if applicable.
+    
+    Args:
+        command: The command dictionary containing:
+            - blueprint_path: Path to the Blueprint
+            - component_name: Name of the new component
+            - component_class: Class of the component (e.g., "BoxComponent")
+                
+    Returns:
+        Response dictionary with success/failure status, message, and event GUIDs
+    """
+    try:
+        blueprint_path = command.get("blueprint_path")
+        component_name = command.get("component_name")
+        component_class = command.get("component_class")
+
+        if not blueprint_path or not component_name or not component_class:
+            log.log_error("Missing required parameters for add_component_with_events")
+            return {"success": False, "error": "Missing required parameters"}
+
+        log.log_command("add_component_with_events", f"Blueprint: {blueprint_path}, Component: {component_name}, Class: {component_class}")
+
+        node_creator = unreal.GenBlueprintUtils
+        result = node_creator.add_component_with_events(blueprint_path, component_name, component_class)
+
+        import json
+        parsed_result = json.loads(result)
+        log.log_result("add_component_with_events", parsed_result["success"], parsed_result.get("message", parsed_result.get("error", "No message")))
+        return parsed_result
+
+    except Exception as e:
+        log.log_error(f"Error adding component with events: {str(e)}", include_traceback=True)
+        return {"success": False, "error": str(e)}
+
+def handle_create_game_mode(command: Dict[str, Any]) -> Dict[str, Any]:
+    try:
+        game_mode_path = command.get("game_mode_path")
+        pawn_blueprint_path = command.get("pawn_blueprint_path")
+        base_class = command.get("base_class", "GameModeBase")
+
+        if not game_mode_path or not pawn_blueprint_path:
+            return {"success": False, "error": "Missing game_mode_path or pawn_blueprint_path"}
+
+        # FIX: Validate pawn blueprint exists before creating game mode (LM_STUDIO_DIAGNOSTIC_REPORT.md)
+        normalized_path = av.normalize_blueprint_path(pawn_blueprint_path)
+        validation_result = av.validate_asset_with_suggestion(normalized_path)
+
+        if not validation_result['valid']:
+            log.log_error(f"Pawn blueprint validation failed: {validation_result['message']}")
+            return {
+                "success": False,
+                "error": f"Invalid pawn blueprint: {validation_result['message']}",
+                "suggestion": validation_result.get('suggestion')
+            }
+
+        node_creator = unreal.GenActorUtils
+        result = node_creator.create_game_mode_with_pawn(game_mode_path, normalized_path, base_class)
+        return json.loads(result)
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+def handle_get_component_names(command: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Get all component names for a Blueprint or scene actor.
+    Helps users discover correct component names before editing.
+
+    Args:
+        command: Dict containing:
+            - blueprint_path: Path to Blueprint (for Blueprints)
+            - actor_name: Name of actor in scene (for scene actors)
+            - is_scene_actor: Whether target is a scene actor (default: False)
+
+    Returns:
+        Dict with list of component names and types
+    """
+    try:
+        blueprint_path = command.get("blueprint_path", "")
+        actor_name = command.get("actor_name", "")
+        is_scene_actor = command.get("is_scene_actor", False)
+
+        components_info = []
+
+        if is_scene_actor:
+            # Get scene actor
+            if not actor_name:
+                return {"success": False, "error": "Missing actor_name parameter for scene actor"}
+
+            # Get all actors in the level
+            editor_actor_subsystem = unreal.get_editor_subsystem(unreal.EditorActorSubsystem)
+            all_actors = editor_actor_subsystem.get_all_level_actors()
+
+            # Find the actor by name
+            target_actor = None
+            for actor in all_actors:
+                if actor.get_actor_label() == actor_name or actor.get_name() == actor_name:
+                    target_actor = actor
+                    break
+
+            if not target_actor:
+                return {
+                    "success": False,
+                    "error": f"Actor '{actor_name}' not found in scene",
+                    "suggestion": "Use get_all_scene_objects to see available actors"
+                }
+
+            # Get components
+            components = target_actor.get_components_by_class(unreal.ActorComponent)
+
+            for comp in components:
+                comp_name = comp.get_name()
+                comp_class = comp.__class__.__name__
+                components_info.append({
+                    "name": comp_name,
+                    "class": comp_class
+                })
+
+        else:
+            # Get Blueprint
+            if not blueprint_path:
+                return {"success": False, "error": "Missing blueprint_path parameter for Blueprint"}
+
+            blueprint = unreal.load_asset(blueprint_path)
+            if not blueprint:
+                return {
+                    "success": False,
+                    "error": f"Blueprint not found: {blueprint_path}",
+                    "suggestion": "Check that the path is correct and starts with /Game/"
+                }
+
+            # Get simple construction script
+            scs_tree = blueprint.get_editor_property('simple_construction_script')
+            if not scs_tree:
+                return {
+                    "success": True,
+                    "total_components": 0,
+                    "components": [],
+                    "message": "Blueprint has no components"
+                }
+
+            # Get all nodes (components)
+            nodes = scs_tree.get_all_nodes()
+
+            for node in nodes:
+                comp_name = node.get_variable_name()
+                comp_template = node.get_editor_property('component_template')
+                if comp_template:
+                    comp_class = comp_template.__class__.__name__
+                else:
+                    comp_class = "Unknown"
+
+                components_info.append({
+                    "name": comp_name,
+                    "class": comp_class
+                })
+
+        return {
+            "success": True,
+            "total_components": len(components_info),
+            "components": components_info,
+            "target": actor_name if is_scene_actor else blueprint_path
+        }
+
+    except Exception as e:
+        log.log_error(f"Error getting component names: {str(e)}", include_traceback=True)
+        return {
+            "success": False,
+            "error": f"Error: {str(e)}",
+            "recommendation": "Check that the target exists and is accessible"
+        }

UMCP.it-Unreal-Organizer-Assistant/Content/Python/handlers/base_handler.py

@@ -0,0 +1,23 @@
+from abc import ABC, abstractmethod
+from typing import Dict, Any
+
+
+class CommandHandler(ABC):
+    """
+    Abstract base class for command handlers
+    
+    All command handlers should inherit from this class and implement the handle method
+    """
+
+    @abstractmethod
+    def handle(self, command: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Handle a command and return a response
+        
+        Args:
+            command: The command dictionary
+            
+        Returns:
+            A response dictionary with at least a 'success' key
+        """
+        pass

UMCP.it-Unreal-Organizer-Assistant/Content/Python/handlers/basic_commands.py

@@ -0,0 +1,487 @@
+import unreal
+from typing import Dict, Any, List, Tuple
+
+import base64
+import os
+import mss
+import time
+import tempfile # Used to find the OS's temporary folder
+
+from utils import unreal_conversions as uc
+from utils import logging as log
+
+def handle_spawn(command: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Handle a spawn command
+    
+    Args:
+        command: The command dictionary containing:
+            - actor_class: Actor class name/path or mesh path (e.g., "/Game/Blueprints/BP_Barrel" or "/Game/Meshes/SM_Barrel01.SM_Barrel01")
+            - 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
+            
+    Returns:
+        Response dictionary with success/failure status and additional info
+    """
+    try:
+        # Extract parameters
+        actor_class_name = command.get("actor_class", "Cube")
+        location = command.get("location", (0, 0, 0))
+        rotation = command.get("rotation", (0, 0, 0))
+        scale = command.get("scale", (1, 1, 1))
+        actor_label = command.get("actor_label")
+
+        unreal.log(f"Spawn command: Class: {actor_class_name}, Label: {actor_label}")
+
+        # Convert parameters to Unreal types
+        loc = uc.to_unreal_vector(location)
+        rot = uc.to_unreal_rotator(rotation)
+        scale_vector = uc.to_unreal_vector(scale)
+
+        actor = None
+        gen_actor_utils = unreal.GenActorUtils
+
+        # Check if it's a mesh path (e.g., "/Game/.../SM_Barrel01.SM_Barrel01")
+        if actor_class_name.startswith("/Game") and "." in actor_class_name:
+            # Try loading as a static mesh
+            mesh = unreal.load_object(None, actor_class_name)
+            if isinstance(mesh, unreal.StaticMesh):
+                actor = gen_actor_utils.spawn_static_mesh_actor(actor_class_name, loc, rot, scale_vector, actor_label or "")
+            else:
+                # Fallback to actor class if not a mesh
+                actor = gen_actor_utils.spawn_actor_from_class(actor_class_name, loc, rot, scale_vector, actor_label or "")
+        else:
+            # Handle basic shapes or actor classes
+            shape_map = {"cube": "Cube", "sphere": "Sphere", "cylinder": "Cylinder", "cone": "Cone"}
+            actor_class_lower = actor_class_name.lower()
+            if actor_class_lower in shape_map:
+                proper_name = shape_map[actor_class_lower]
+                actor = gen_actor_utils.spawn_basic_shape(proper_name, loc, rot, scale_vector, actor_label or "")
+            else:
+                actor = gen_actor_utils.spawn_actor_from_class(actor_class_name, loc, rot, scale_vector, actor_label or "")
+
+        if not actor:
+            unreal.log_error(f"Failed to spawn actor of type {actor_class_name}")
+            return {"success": False, "error": f"Failed to spawn actor of type {actor_class_name}"}
+
+        actor_name = actor.get_actor_label()
+        unreal.log(f"Spawned actor: {actor_name} at {loc}")
+        return {"success": True, "actor_name": actor_name}
+
+    except Exception as e:
+        unreal.log_error(f"Error spawning actor: {str(e)}")
+        return {"success": False, "error": str(e)}
+
+
+
+
+def handle_take_screenshot(command):
+    """
+    Takes a screenshot using the HighResShot console command with a deterministic filename.
+    This is the most reliable method for engine-based screenshots.
+    """
+    # 1. Create a unique, absolute file path in the OS's temp directory.
+    # This ensures we have a clean place to work with guaranteed write permissions.
+    temp_dir = tempfile.gettempdir()
+    unique_filename = f"unreal_mcp_screenshot_{int(time.time())}.png"
+    # Use forward slashes, as this is more reliable for Unreal console commands
+    screenshot_path = os.path.join(temp_dir, unique_filename).replace('\\', '/')
+
+    try:
+        # 2. Construct the console command with explicit 640x480 resolution.
+        # This ensures a consistent, small file size suitable for MCP responses (<200KB typically)
+        console_command = f'HighResShot 640x480 filename="{screenshot_path}"'
+        unreal.log(f"Executing screenshot command: {console_command}")
+
+        # Execute the command in the editor world context
+        unreal.SystemLibrary.execute_console_command(unreal.EditorLevelLibrary.get_editor_world(), console_command)
+
+        # 3. Poll for the file's existence instead of using a fixed sleep time.
+        # This is much more reliable than a fixed wait.
+        max_wait_seconds = 5
+        wait_interval = 0.2
+        time_waited = 0
+        file_created = False
+        while time_waited < max_wait_seconds:
+            if os.path.exists(screenshot_path):
+                file_created = True
+                break
+            time.sleep(wait_interval)
+            time_waited += wait_interval
+
+        if not file_created:
+            return {"success": False, "error": f"Command was executed, but the output file was not found at the specified path: {screenshot_path}"}
+
+        # 4. Read the file, encode it, and prepare the response
+        with open(screenshot_path, 'rb') as image_file:
+            image_data = image_file.read()
+        base64_encoded_data = base64.b64encode(image_data).decode('utf-8')
+
+        return {
+            "success": True,
+            "data": base64_encoded_data,
+            "mime_type": "image/png"
+        }
+
+    except Exception as e:
+        return {"success": False, "error": f"The screenshot process failed with an exception: {str(e)}"}
+
+    finally:
+        # 5. Clean up the temporary screenshot file from the temp directory
+        if os.path.exists(screenshot_path):
+            try:
+                os.remove(screenshot_path)
+            except Exception as e_cleanup:
+                unreal.log_error(f"Failed to delete temporary screenshot file '{screenshot_path}': {e_cleanup}")
+
+def handle_create_material(command: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Handle a create_material command
+    
+    Args:
+        command: The command dictionary containing:
+            - material_name: Name for the new material
+            - color: [R, G, B] color values (0-1)
+            
+    Returns:
+        Response dictionary with success/failure status and material path if successful
+    """
+    try:
+        # Extract parameters
+        material_name = command.get("material_name", "NewMaterial")
+        color = command.get("color", (1, 0, 0))
+
+        log.log_command("create_material", f"Name: {material_name}, Color: {color}")
+
+        # Use the C++ utility class
+        gen_actor_utils = unreal.GenActorUtils
+        color_linear = uc.to_unreal_color(color)
+
+        material = gen_actor_utils.create_material(material_name, color_linear)
+
+        if not material:
+            log.log_error("Failed to create material")
+            return {"success": False, "error": "Failed to create material"}
+
+        material_path = f"/Game/Materials/{material_name}"
+        log.log_result("create_material", True, f"Path: {material_path}")
+        return {"success": True, "material_path": material_path}
+
+    except Exception as e:
+        log.log_error(f"Error creating material: {str(e)}", include_traceback=True)
+        return {"success": False, "error": str(e)}
+
+
+def handle_get_all_scene_objects(command: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Get all actors in the current level, categorized by type.
+    Returns a summary with categorized actors and example locations.
+    """
+    try:
+        # Use EditorActorSubsystem - the correct way to get actors in editor
+        editor_actor_subsystem = unreal.get_editor_subsystem(unreal.EditorActorSubsystem)
+        all_actors = editor_actor_subsystem.get_all_level_actors()
+
+        # Categorize actors by class
+        categories = {}
+
+        for actor in all_actors:
+            actor_class = actor.get_class().get_name()
+
+            if actor_class not in categories:
+                categories[actor_class] = []
+
+            location = actor.get_actor_location()
+            categories[actor_class].append({
+                'name': actor.get_name(),
+                'location': {
+                    'x': location.x,
+                    'y': location.y,
+                    'z': location.z
+                }
+            })
+
+        # Build summary
+        summary_lines = []
+        summary_lines.append("=" * 60)
+        summary_lines.append("SCENE SUMMARY")
+        summary_lines.append("=" * 60)
+        summary_lines.append(f"Total Actors: {len(all_actors)}\n")
+
+        # Sort categories by count (most common first)
+        sorted_categories = sorted(categories.items(), key=lambda x: len(x[1]), reverse=True)
+
+        for actor_class, actors in sorted_categories:
+            count = len(actors)
+            summary_lines.append(f"{actor_class}: {count}")
+
+            # Show first 2 examples for each category
+            for i, actor_info in enumerate(actors[:2]):
+                loc = actor_info['location']
+                summary_lines.append(f"  └─ {actor_info['name']} at ({loc['x']:.0f}, {loc['y']:.0f}, {loc['z']:.0f})")
+
+            if count > 2:
+                summary_lines.append(f"  └─ ... and {count - 2} more")
+            summary_lines.append("")
+
+        # Return both structured data and formatted summary
+        return {
+            "success": True,
+            "total_actors": len(all_actors),
+            "categories": categories,
+            "summary": "\n".join(summary_lines)
+        }
+
+    except Exception as e:
+        log.log_error(f"Error getting scene objects: {str(e)}", include_traceback=True)
+        return {"success": False, "error": str(e)}
+
+def handle_create_project_folder(command: Dict[str, Any]) -> Dict[str, Any]:
+    try:
+        folder_path = command.get("folder_path")
+        full_path = f"/Game/{folder_path}"
+        unreal.EditorAssetLibrary.make_directory(full_path)
+        return {"success": True, "message": f"Created folder at {full_path}"}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+def handle_get_files_in_folder(command: Dict[str, Any]) -> Dict[str, Any]:
+    try:
+        folder_path = f"/Game/{command.get('folder_path')}"
+        files = unreal.EditorAssetLibrary.list_assets(folder_path, recursive=False)
+        return {"success": True, "files": [str(f) for f in files]}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+def handle_add_input_binding(command: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Add an input action binding to Project Settings.
+    Supports both legacy input system and provides guidance for Enhanced Input.
+
+    Args:
+        command: Dict containing 'action_name' and 'key'
+
+    Returns:
+        Dict with success/error and helpful instructions
+    """
+    try:
+        action_name = command.get("action_name")
+        key = command.get("key")
+
+        if not action_name or not key:
+            return {"success": False, "error": "Missing action_name or key parameter"}
+
+        # Try legacy input system first
+        input_settings = unreal.get_default_object(unreal.InputSettings)
+
+        if not input_settings:
+            return {
+                "success": False,
+                "error": "Could not access InputSettings",
+                "recommendation": "Use Enhanced Input System for UE 5.6+"
+            }
+
+        try:
+            # Create the key structure
+            key_mapping = unreal.InputActionKeyMapping()
+            key_mapping.action_name = action_name
+
+            # Try to create Key object
+            try:
+                key_obj = unreal.Key()
+                key_obj.key_name = unreal.Name(key)
+                key_mapping.key = key_obj
+            except:
+                # Fallback: try direct assignment
+                key_mapping.key = key
+
+            # Add the mapping to project settings
+            current_mappings = list(input_settings.get_editor_property('action_mappings'))
+            current_mappings.append(key_mapping)
+            input_settings.set_editor_property('action_mappings', current_mappings)
+
+            # Save the settings
+            input_settings.save_config()
+
+            return {
+                "success": True,
+                "message": f"Added input binding: {action_name} -> {key}",
+                "action_name": action_name,
+                "key": key,
+                "note": "Legacy input system used. Consider migrating to Enhanced Input System."
+            }
+
+        except AttributeError as e:
+            # Enhanced Input System is likely required
+            return {
+                "success": False,
+                "error": "Legacy input system not available in UE 5.6+",
+                "message": "Please use Enhanced Input System instead",
+                "instructions": {
+                    "step1": "Use create_enhanced_input_action to create an Input Action asset",
+                    "step2": "Use create_enhanced_input_mapping_context to create a Mapping Context",
+                    "step3": "Open the Mapping Context in Content Browser and add key mappings",
+                    "step4": "Reference the Input Action and Mapping Context in your Blueprint"
+                },
+                "alternative": "Use execute_python_script to create Enhanced Input assets programmatically",
+                "examples": {
+                    "create_action": "create_enhanced_input_action('IA_Jump', '/Game/Input')",
+                    "create_context": "create_enhanced_input_mapping_context('IMC_Default', '/Game/Input')"
+                }
+            }
+
+    except Exception as e:
+        return {
+            "success": False,
+            "error": f"Unexpected error: {str(e)}",
+            "recommendation": "Check that action_name and key are valid strings"
+        }
+
+def handle_create_enhanced_input_action(command: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Create an Enhanced Input Action asset.
+
+    Args:
+        command: Dict containing:
+            - action_name: Name of the action (e.g., "IA_Jump")
+            - action_path: Path to save the asset (default: "/Game/Input")
+            - value_type: "BOOLEAN", "AXIS_1D", "AXIS_2D", "AXIS_3D" (default: "BOOLEAN")
+
+    Returns:
+        Dict with asset path or error
+    """
+    try:
+        action_name = command.get("action_name")
+        action_path = command.get("action_path", "/Game/Input")
+        value_type_str = command.get("value_type", "BOOLEAN")
+
+        if not action_name:
+            return {"success": False, "error": "Missing action_name parameter"}
+
+        # Map string to enum
+        value_type_map = {
+            "BOOLEAN": unreal.InputActionValueType.BOOLEAN,
+            "AXIS_1D": unreal.InputActionValueType.AXIS1_D,
+            "AXIS_2D": unreal.InputActionValueType.AXIS2_D,
+            "AXIS_3D": unreal.InputActionValueType.AXIS3_D,
+        }
+
+        value_type = value_type_map.get(value_type_str.upper(), unreal.InputActionValueType.BOOLEAN)
+
+        # Create Input Action asset
+        asset_tools = unreal.AssetToolsHelpers.get_asset_tools()
+
+        # Create factory for InputAction
+        factory = unreal.Factory.static_class().get_default_object()
+
+        # Use EditorAssetLibrary to create the asset
+        full_path = f"{action_path}/{action_name}"
+
+        # Check if asset already exists
+        if unreal.EditorAssetLibrary.does_asset_exist(full_path):
+            return {
+                "success": False,
+                "error": f"Asset already exists at {full_path}",
+                "suggestion": "Choose a different name or delete the existing asset"
+            }
+
+        # Create the asset using AssetTools
+        input_action = asset_tools.create_asset(
+            action_name,
+            action_path,
+            unreal.InputAction,
+            None  # Factory (None uses default)
+        )
+
+        if input_action:
+            # Set properties
+            input_action.set_editor_property('value_type', value_type)
+
+            # Save the asset
+            unreal.EditorAssetLibrary.save_loaded_asset(input_action)
+
+            return {
+                "success": True,
+                "message": f"Created Enhanced Input Action: {action_name}",
+                "asset_path": full_path,
+                "value_type": value_type_str
+            }
+        else:
+            return {
+                "success": False,
+                "error": "Failed to create Input Action asset",
+                "recommendation": "Ensure Enhanced Input Plugin is enabled in Project Settings"
+            }
+
+    except Exception as e:
+        return {
+            "success": False,
+            "error": f"Error creating Input Action: {str(e)}",
+            "recommendation": "Ensure Enhanced Input Plugin is enabled and action_path exists"
+        }
+
+def handle_create_enhanced_input_mapping_context(command: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Create an Enhanced Input Mapping Context asset.
+
+    Args:
+        command: Dict containing:
+            - context_name: Name of the mapping context (e.g., "IMC_Default")
+            - context_path: Path to save the asset (default: "/Game/Input")
+
+    Returns:
+        Dict with asset path or error
+    """
+    try:
+        context_name = command.get("context_name")
+        context_path = command.get("context_path", "/Game/Input")
+
+        if not context_name:
+            return {"success": False, "error": "Missing context_name parameter"}
+
+        # Create Input Mapping Context asset
+        asset_tools = unreal.AssetToolsHelpers.get_asset_tools()
+
+        full_path = f"{context_path}/{context_name}"
+
+        # Check if asset already exists
+        if unreal.EditorAssetLibrary.does_asset_exist(full_path):
+            return {
+                "success": False,
+                "error": f"Asset already exists at {full_path}",
+                "suggestion": "Choose a different name or delete the existing asset"
+            }
+
+        # Create the asset
+        mapping_context = asset_tools.create_asset(
+            context_name,
+            context_path,
+            unreal.InputMappingContext,
+            None  # Factory (None uses default)
+        )
+
+        if mapping_context:
+            # Save the asset
+            unreal.EditorAssetLibrary.save_loaded_asset(mapping_context)
+
+            return {
+                "success": True,
+                "message": f"Created Enhanced Input Mapping Context: {context_name}",
+                "asset_path": full_path,
+                "next_step": "Open the asset in Content Browser and add key mappings manually"
+            }
+        else:
+            return {
+                "success": False,
+                "error": "Failed to create Mapping Context asset",
+                "recommendation": "Ensure Enhanced Input Plugin is enabled in Project Settings"
+            }
+
+    except Exception as e:
+        return {
+            "success": False,
+            "error": f"Error creating Mapping Context: {str(e)}",
+            "recommendation": "Ensure Enhanced Input Plugin is enabled and context_path exists"
+        }

UMCP.it-Unreal-Organizer-Assistant/Content/Python/handlers/blueprint_commands.py

@@ -0,0 +1,874 @@
+import unreal
+import json
+import time
+from typing import Dict, Any, List, Tuple, Union, Optional
+
+from utils import unreal_conversions as uc
+from utils import logging as log
+from utils import asset_validation as av
+
+
+def handle_create_blueprint(command: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Handle a command to create a new Blueprint from a specified parent class
+    
+    Args:
+        command: The command dictionary containing:
+            - 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 (e.g., "/Game/Blueprints")
+            
+    Returns:
+        Response dictionary with success/failure status and the Blueprint path if successful
+    """
+    try:
+        blueprint_name = command.get("blueprint_name", "NewBlueprint")
+        parent_class = command.get("parent_class", "Actor")
+        save_path = command.get("save_path", "/Game/Blueprints")
+
+        log.log_command("create_blueprint", f"Name: {blueprint_name}, Parent: {parent_class}")
+
+        # Call the C++ implementation
+        gen_bp_utils = unreal.GenBlueprintUtils
+        blueprint = gen_bp_utils.create_blueprint(blueprint_name, parent_class, save_path)
+
+        if blueprint:
+            blueprint_path = f"{save_path}/{blueprint_name}"
+
+            # FIX: Save asset and wait for it to be ready (LM_STUDIO_DIAGNOSTIC_REPORT.md)
+            unreal.EditorAssetLibrary.save_asset(blueprint_path)
+            time.sleep(0.5)  # Wait for save to complete
+
+            # Verify asset is accessible
+            if not av.wait_for_asset_save(blueprint_path, timeout=2.0):
+                log.log_error(f"Blueprint created but not yet accessible: {blueprint_path}")
+                return {"success": False, "error": f"Blueprint created but timed out waiting for asset save: {blueprint_path}"}
+
+            log.log_result("create_blueprint", True, f"Path: {blueprint_path}")
+            return {"success": True, "blueprint_path": blueprint_path}
+        else:
+            log.log_error(f"Failed to create Blueprint {blueprint_name}")
+            return {"success": False, "error": f"Failed to create Blueprint {blueprint_name}"}
+
+    except Exception as e:
+        log.log_error(f"Error creating blueprint: {str(e)}", include_traceback=True)
+        return {"success": False, "error": str(e)}
+
+
+def handle_add_component(command: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Handle a command to add a component to a Blueprint
+    
+    Args:
+        command: The command dictionary containing:
+            - blueprint_path: Path to the Blueprint asset
+            - component_class: Component class to add (e.g., "StaticMeshComponent")
+            - component_name: Name for the new component
+            
+    Returns:
+        Response dictionary with success/failure status
+    """
+    try:
+        blueprint_path = command.get("blueprint_path")
+        component_class = command.get("component_class")
+        component_name = command.get("component_name")
+
+        if not blueprint_path or not component_class:
+            log.log_error("Missing required parameters for add_component")
+            return {"success": False, "error": "Missing required parameters"}
+
+        log.log_command("add_component", f"Blueprint: {blueprint_path}, Component: {component_class}")
+
+        # Call the C++ implementation
+        gen_bp_utils = unreal.GenBlueprintUtils
+        success = gen_bp_utils.add_component(blueprint_path, component_class, component_name or "")
+
+        if success:
+            log.log_result("add_component", True, f"Added {component_class} to {blueprint_path}")
+            return {"success": True}
+        else:
+            log.log_error(f"Failed to add component {component_class} to {blueprint_path}")
+            return {"success": False, "error": f"Failed to add component {component_class} to {blueprint_path}"}
+
+    except Exception as e:
+        log.log_error(f"Error adding component: {str(e)}", include_traceback=True)
+        return {"success": False, "error": str(e)}
+
+
+def handle_add_variable(command: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Handle a command to add a variable to a Blueprint
+    
+    Args:
+        command: The command dictionary containing:
+            - blueprint_path: Path to the Blueprint asset
+            - variable_name: Name for the new variable
+            - variable_type: Type of the variable (e.g., "float", "vector", "boolean")
+            - default_value: Default value for the variable (optional)
+            - category: Category for organizing variables in the Blueprint editor (optional)
+            
+    Returns:
+        Response dictionary with success/failure status
+    """
+    try:
+        blueprint_path = command.get("blueprint_path")
+        variable_name = command.get("variable_name")
+        variable_type = command.get("variable_type")
+        default_value = command.get("default_value", "")
+        category = command.get("category", "Default")
+
+        if not blueprint_path or not variable_name or not variable_type:
+            log.log_error("Missing required parameters for add_variable")
+            return {"success": False, "error": "Missing required parameters"}
+
+        log.log_command("add_variable",
+                        f"Blueprint: {blueprint_path}, Variable: {variable_name}, Type: {variable_type}")
+
+        # Call the C++ implementation
+        gen_bp_utils = unreal.GenBlueprintUtils
+        success = gen_bp_utils.add_variable(blueprint_path, variable_name, variable_type, str(default_value), category)
+
+        if success:
+            log.log_result("add_variable", True, f"Added {variable_type} variable {variable_name} to {blueprint_path}")
+            return {"success": True}
+        else:
+            log.log_error(f"Failed to add variable {variable_name} to {blueprint_path}")
+            return {"success": False, "error": f"Failed to add variable {variable_name} to {blueprint_path}"}
+
+    except Exception as e:
+        log.log_error(f"Error adding variable: {str(e)}", include_traceback=True)
+        return {"success": False, "error": str(e)}
+
+
+def handle_add_function(command: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Handle a command to add a function to a Blueprint
+    
+    Args:
+        command: The command dictionary containing:
+            - blueprint_path: Path to the Blueprint asset
+            - function_name: Name for the new function
+            - inputs: List of input parameters [{"name": "param1", "type": "float"}, ...] (optional)
+            - outputs: List of output parameters (optional)
+            
+    Returns:
+        Response dictionary with success/failure status and the function ID if successful
+    """
+    try:
+        blueprint_path = command.get("blueprint_path")
+        function_name = command.get("function_name")
+        inputs = command.get("inputs", [])
+        outputs = command.get("outputs", [])
+
+        if not blueprint_path or not function_name:
+            log.log_error("Missing required parameters for add_function")
+            return {"success": False, "error": "Missing required parameters"}
+
+        log.log_command("add_function", f"Blueprint: {blueprint_path}, Function: {function_name}")
+
+        # Convert inputs and outputs to JSON strings for C++ function
+        inputs_json = json.dumps(inputs)
+        outputs_json = json.dumps(outputs)
+
+        # Call the C++ implementation
+        gen_bp_utils = unreal.GenBlueprintUtils
+        function_id = gen_bp_utils.add_function(blueprint_path, function_name, inputs_json, outputs_json)
+
+        if function_id:
+            log.log_result("add_function", True,
+                           f"Added function {function_name} to {blueprint_path} with ID: {function_id}")
+            return {"success": True, "function_id": function_id}
+        else:
+            log.log_error(f"Failed to add function {function_name} to {blueprint_path}")
+            return {"success": False, "error": f"Failed to add function {function_name} to {blueprint_path}"}
+
+    except Exception as e:
+        log.log_error(f"Error adding function: {str(e)}", include_traceback=True)
+        return {"success": False, "error": str(e)}
+
+
+def handle_add_node(command: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Handle a command to add any type of node to a Blueprint graph
+    
+    Args:
+        command: The command dictionary containing:
+            - 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 - can be any of:
+                * Function name (e.g. "K2_SetActorLocation")
+                * Node class name (e.g. "Branch", "Sequence", "ForLoop")
+                * Full node class path (e.g. "K2Node_IfThenElse")
+            - node_position: Position of the node in the graph [X, Y]
+            - node_properties: Dictionary of properties to set on the node (optional)
+                * Can include pin values, node settings, etc.
+            - target_class: Optional class to use for function calls (default: "Actor")
+                
+    Returns:
+        Response dictionary with success/failure status and the node ID if successful
+    """
+    try:
+        blueprint_path = command.get("blueprint_path")
+        function_id = command.get("function_id")
+        node_type = command.get("node_type")
+        node_position = command.get("node_position", [0, 0])
+        node_properties = command.get("node_properties", {})
+
+        if not blueprint_path or not function_id or not node_type:
+            log.log_error("Missing required parameters for add_node")
+            return {"success": False, "error": "Missing required parameters"}
+
+        log.log_command("add_node", f"Blueprint: {blueprint_path}, Node: {node_type}")
+
+        # Convert node properties to JSON for C++ function
+        node_properties_json = json.dumps(node_properties)
+
+        # Call the C++ implementation from UGenBlueprintNodeCreator
+        node_creator = unreal.GenBlueprintNodeCreator
+        node_id = node_creator.add_node(blueprint_path, function_id, node_type,
+                                        node_position[0], node_position[1],
+                                        node_properties_json)
+
+        if node_id:
+            log.log_result("add_node", True, f"Added node {node_type} to {blueprint_path} with ID: {node_id}")
+            return {"success": True, "node_id": node_id}
+        else:
+            log.log_error(f"Failed to add node {node_type} to {blueprint_path}")
+            return {"success": False, "error": f"Failed to add node {node_type} to {blueprint_path}"}
+
+    except Exception as e:
+        log.log_error(f"Error adding node: {str(e)}", include_traceback=True)
+        return {"success": False, "error": str(e)}
+
+
+def handle_connect_nodes(command: Dict[str, Any]) -> Dict[str, Any]:
+    try:
+        blueprint_path = command.get("blueprint_path")
+        function_id = command.get("function_id")
+        source_node_id = command.get("source_node_id")
+        source_pin = command.get("source_pin")
+        target_node_id = command.get("target_node_id")
+        target_pin = command.get("target_pin")
+
+        if not all([blueprint_path, function_id, source_node_id, source_pin, target_node_id, target_pin]):
+            log.log_error("Missing required parameters for connect_nodes")
+            return {"success": False, "error": "Missing required parameters"}
+
+        log.log_command("connect_nodes",
+                        f"Blueprint: {blueprint_path}, {source_node_id}.{source_pin} -> {target_node_id}.{target_pin}")
+
+        gen_bp_utils = unreal.GenBlueprintUtils
+        result_json = gen_bp_utils.connect_nodes(blueprint_path, function_id,
+                                                 source_node_id, source_pin,
+                                                 target_node_id, target_pin)
+        result = json.loads(result_json)
+
+        if result.get("success"):
+            log.log_result("connect_nodes", True, f"Connected nodes in {blueprint_path}")
+            return {"success": True}
+        else:
+            log.log_error(f"Failed to connect nodes: {result.get('error')}")
+            return result  # Pass through the detailed response with available pins
+
+    except Exception as e:
+        log.log_error(f"Error connecting nodes: {str(e)}", include_traceback=True)
+        return {"success": False, "error": str(e)}
+
+
+def handle_compile_blueprint(command: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Handle a command to compile a Blueprint
+    
+    Args:
+        command: The command dictionary containing:
+            - blueprint_path: Path to the Blueprint asset
+            
+    Returns:
+        Response dictionary with success/failure status
+    """
+    try:
+        blueprint_path = command.get("blueprint_path")
+
+        if not blueprint_path:
+            log.log_error("Missing required parameters for compile_blueprint")
+            return {"success": False, "error": "Missing required parameters"}
+
+        log.log_command("compile_blueprint", f"Blueprint: {blueprint_path}")
+
+        # Call the C++ implementation
+        gen_bp_utils = unreal.GenBlueprintUtils
+        success = gen_bp_utils.compile_blueprint(blueprint_path)
+
+        if success:
+            log.log_result("compile_blueprint", True, f"Compiled blueprint: {blueprint_path}")
+            return {"success": True}
+        else:
+            log.log_error(f"Failed to compile blueprint: {blueprint_path}")
+            return {"success": False, "error": f"Failed to compile blueprint: {blueprint_path}"}
+
+    except Exception as e:
+        log.log_error(f"Error compiling blueprint: {str(e)}", include_traceback=True)
+        return {"success": False, "error": str(e)}
+
+
+def handle_spawn_blueprint(command: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Handle a command to spawn a Blueprint actor in the level
+    
+    Args:
+        command: The command dictionary containing:
+            - 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
+            
+    Returns:
+        Response dictionary with success/failure status and the actor name if successful
+    """
+    try:
+        blueprint_path = command.get("blueprint_path")
+        location = command.get("location", (0, 0, 0))
+        rotation = command.get("rotation", (0, 0, 0))
+        scale = command.get("scale", (1, 1, 1))
+        actor_label = command.get("actor_label", "")
+
+        if not blueprint_path:
+            log.log_error("Missing required parameters for spawn_blueprint")
+            return {"success": False, "error": "Missing required parameters"}
+
+        # FIX: Validate asset exists before spawning (LM_STUDIO_DIAGNOSTIC_REPORT.md)
+        normalized_path = av.normalize_blueprint_path(blueprint_path)
+        validation_result = av.validate_asset_with_suggestion(normalized_path)
+
+        if not validation_result['valid']:
+            log.log_error(f"Blueprint validation failed: {validation_result['message']}")
+            return {
+                "success": False,
+                "error": validation_result['message'],
+                "suggestion": validation_result.get('suggestion')
+            }
+
+        log.log_command("spawn_blueprint", f"Blueprint: {normalized_path}, Label: {actor_label}")
+
+        # Convert to Unreal types
+        loc = uc.to_unreal_vector(location)
+        rot = uc.to_unreal_rotator(rotation)
+        scale_vec = uc.to_unreal_vector(scale)
+
+        # Call the C++ implementation
+        gen_bp_utils = unreal.GenBlueprintUtils
+        actor = gen_bp_utils.spawn_blueprint(blueprint_path, loc, rot, scale_vec, actor_label)
+
+        if actor:
+            actor_name = actor.get_actor_label()
+            log.log_result("spawn_blueprint", True, f"Spawned blueprint: {blueprint_path} as {actor_name}")
+            return {"success": True, "actor_name": actor_name}
+        else:
+            log.log_error(f"Failed to spawn blueprint: {blueprint_path}")
+            return {"success": False, "error": f"Failed to spawn blueprint: {blueprint_path}"}
+
+    except Exception as e:
+        log.log_error(f"Error spawning blueprint: {str(e)}", include_traceback=True)
+        return {"success": False, "error": str(e)}
+
+def handle_add_nodes_bulk(command: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Handle a command to add multiple nodes to a Blueprint graph in a single operation
+    
+    Args:
+        command: The command dictionary containing:
+            - blueprint_path: Path to the Blueprint asset
+            - function_id: ID of the function to add the nodes to
+            - nodes: Array of node definitions, each containing:
+                * id: Optional ID for referencing the node (string)
+                * node_type: Type of node to add (string)
+                * node_position: Position of the node in the graph [X, Y]
+                * node_properties: Properties to set on the node (optional)
+            
+    Returns:
+        Response dictionary with success/failure status and node IDs mapped to reference IDs
+    """
+
+    try:
+        blueprint_path = command.get("blueprint_path")
+        function_id = command.get("function_id")
+        nodes = command.get("nodes", [])
+
+        if not blueprint_path or not function_id or not nodes:
+            log.log_error("Missing required parameters for add_nodes_bulk")
+            return {"success": False, "error": "Missing required parameters"}
+
+        log.log_command("add_nodes_bulk", f"Blueprint: {blueprint_path}, Adding {len(nodes)} nodes")
+
+        # Prepare nodes in the format expected by the C++ function
+        nodes_json = json.dumps(nodes)
+
+        # Call the C++ implementation from UGenBlueprintNodeCreator
+        node_creator = unreal.GenBlueprintNodeCreator
+        results_json = node_creator.add_nodes_bulk(blueprint_path, function_id, nodes_json)
+        
+        if results_json:
+            results = json.loads(results_json)
+            node_mapping = {}
+
+            # Create a mapping from reference IDs to actual node GUIDs
+            for node_result in results:
+                if "ref_id" in node_result:
+                    node_mapping[node_result["ref_id"]] = node_result["node_guid"]
+                else:
+                    # For nodes without a reference ID, just include the GUID
+                    node_mapping[f"node_{len(node_mapping)}"] = node_result["node_guid"]
+
+            log.log_result("add_nodes_bulk", True, f"Added {len(results)} nodes to {blueprint_path}")
+            return {"success": True, "nodes": node_mapping}
+        else:
+            log.log_error(f"Failed to add nodes to {blueprint_path}")
+            return {"success": False, "error": f"Failed to add nodes to {blueprint_path}"}
+
+    except Exception as e:
+        log.log_error(f"Error adding nodes: {str(e)}", include_traceback=True)
+        return {"success": False, "error": str(e)}
+
+
+def handle_connect_nodes_bulk(command: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Handle a command to connect multiple pairs of nodes in a Blueprint graph
+    
+    Args:
+        command: The command dictionary containing:
+            - 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:
+        Response dictionary with detailed connection results
+    """
+    try:
+        blueprint_path = command.get("blueprint_path")
+        function_id = command.get("function_id")
+        connections = command.get("connections", [])
+
+        if not blueprint_path or not function_id or not connections:
+            log.log_error("Missing required parameters for connect_nodes_bulk")
+            return {"success": False, "error": "Missing required parameters"}
+
+        log.log_command("connect_nodes_bulk", f"Blueprint: {blueprint_path}, Making {len(connections)} connections")
+
+        # Convert connections list to JSON for C++ function
+        connections_json = json.dumps(connections)
+
+        # Call the C++ implementation - now returns a JSON string instead of boolean
+        gen_bp_utils = unreal.GenBlueprintUtils
+        result_json = gen_bp_utils.connect_nodes_bulk(blueprint_path, function_id, connections_json)
+
+        # Parse the JSON result
+        try:
+            result_data = json.loads(result_json)
+            log.log_result("connect_nodes_bulk", result_data.get("success", False),
+                           f"Connected {result_data.get('successful_connections', 0)}/{result_data.get('total_connections', 0)} node pairs in {blueprint_path}")
+
+            # Return the full result data for detailed error reporting
+            return result_data
+        except json.JSONDecodeError:
+            log.log_error(f"Failed to parse JSON result from connect_nodes_bulk: {result_json}")
+            return {"success": False, "error": "Failed to parse connection results"}
+
+    except Exception as e:
+        log.log_error(f"Error connecting nodes: {str(e)}", include_traceback=True)
+        return {"success": False, "error": str(e)}
+
+def handle_delete_node(command: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Handle a command to delete a node from a Blueprint graph
+    
+    Args:
+        command: The command dictionary containing:
+            - 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:
+        Response dictionary with success/failure status
+    """
+    try:
+        blueprint_path = command.get("blueprint_path")
+        function_id = command.get("function_id")
+        node_id = command.get("node_id")
+
+        if not blueprint_path or not function_id or not node_id:
+            log.log_error("Missing required parameters for delete_node")
+            return {"success": False, "error": "Missing required parameters"}
+
+        log.log_command("delete_node", f"Blueprint: {blueprint_path}, Node ID: {node_id}")
+
+        # Call the C++ implementation from UGenBlueprintNodeCreator
+        node_creator = unreal.GenBlueprintNodeCreator
+        success = node_creator.delete_node(blueprint_path, function_id, node_id)
+
+        if success:
+            log.log_result("delete_node", True, f"Deleted node {node_id} from {blueprint_path}")
+            return {"success": True}
+        else:
+            log.log_error(f"Failed to delete node {node_id} from {blueprint_path}")
+            return {"success": False, "error": f"Failed to delete node {node_id}"}
+
+    except Exception as e:
+        log.log_error(f"Error deleting node: {str(e)}", include_traceback=True)
+        return {"success": False, "error": str(e)}
+
+
+def handle_get_all_nodes(command: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Handle a command to get all nodes in a Blueprint graph
+    
+    Args:
+        command: The command dictionary containing:
+            - blueprint_path: Path to the Blueprint asset
+            - function_id: ID of the function to get nodes from
+                
+    Returns:
+        Response dictionary with success/failure status and a list of nodes with their details
+    """
+    try:
+        blueprint_path = command.get("blueprint_path")
+        function_id = command.get("function_id")
+
+        if not blueprint_path or not function_id:
+            log.log_error("Missing required parameters for get_all_nodes")
+            return {"success": False, "error": "Missing required parameters"}
+
+        log.log_command("get_all_nodes", f"Blueprint: {blueprint_path}, Function ID: {function_id}")
+
+        # Call the C++ implementation from UGenBlueprintNodeCreator
+        node_creator = unreal.GenBlueprintNodeCreator
+        nodes_json = node_creator.get_all_nodes_in_graph(blueprint_path, function_id)
+
+        if nodes_json:
+            # Parse the JSON response
+            try:
+                nodes = json.loads(nodes_json)
+                log.log_result("get_all_nodes", True, f"Retrieved {len(nodes)} nodes from {blueprint_path}")
+                return {"success": True, "nodes": nodes}
+            except json.JSONDecodeError as e:
+                log.log_error(f"Error parsing nodes JSON: {str(e)}")
+                return {"success": False, "error": f"Error parsing nodes JSON: {str(e)}"}
+        else:
+            log.log_error(f"Failed to get nodes from {blueprint_path}")
+            return {"success": False, "error": "Failed to get nodes"}
+
+    except Exception as e:
+        log.log_error(f"Error getting nodes: {str(e)}", include_traceback=True)
+        return {"success": False, "error": str(e)}
+
+def handle_get_node_suggestions(command: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Handle a command to get suggestions for a node type in Unreal Blueprints
+    
+    Args:
+        command: The command dictionary containing:
+            - node_type: The partial or full node type to get suggestions for (e.g., "Add", "FloatToDouble")
+                
+    Returns:
+        Response dictionary with success/failure status and a list of suggested node types
+    """
+    try:
+        node_type = command.get("node_type")
+
+        if not node_type:
+            log.log_error("Missing required parameter 'node_type' for get_node_suggestions")
+            return {"success": False, "error": "Missing required parameter 'node_type'"}
+
+        log.log_command("get_node_suggestions", f"Node Type: {node_type}")
+
+        # Call the C++ implementation from UGenBlueprintNodeCreator
+        node_creator = unreal.GenBlueprintNodeCreator
+        suggestions_result = node_creator.get_node_suggestions(node_type)
+
+        if suggestions_result:
+            if suggestions_result.startswith("SUGGESTIONS:"):
+                suggestions = suggestions_result[len("SUGGESTIONS:"):].split(", ")
+                log.log_result("get_node_suggestions", True, f"Retrieved {len(suggestions)} suggestions for {node_type}")
+                return {"success": True, "suggestions": suggestions}
+            else:
+                log.log_error(f"Unexpected response format from get_node_suggestions: {suggestions_result}")
+                return {"success": False, "error": "Unexpected response format from Unreal"}
+        else:
+            log.log_result("get_node_suggestions", False, f"No suggestions found for {node_type}")
+            return {"success": True, "suggestions": []}  # Empty list for no matches
+
+    except Exception as e:
+        log.log_error(f"Error getting node suggestions: {str(e)}", include_traceback=True)
+        return {"success": False, "error": str(e)}
+
+def _find_event_node_by_pattern(blueprint_path: str, node_name: str) -> str:
+    """
+    Helper function to find event nodes by pattern matching.
+    Handles cases like "BeginPlay" matching "Event BeginPlay" or "ReceiveBeginPlay".
+
+    Args:
+        blueprint_path: Path to the Blueprint
+        node_name: Simple name to search for (e.g., "BeginPlay")
+
+    Returns:
+        Node GUID as string, or empty string if not found
+    """
+    try:
+        blueprint = unreal.load_asset(blueprint_path)
+        if not blueprint:
+            return ""
+
+        # Get the event graph (ubergraph)
+        ubergraph_pages = blueprint.get_editor_property('ubergraph_pages')
+        if not ubergraph_pages or len(ubergraph_pages) == 0:
+            return ""
+
+        # Search through event graph nodes
+        for graph in ubergraph_pages:
+            all_nodes = graph.get_editor_property('nodes')
+            if not all_nodes:
+                continue
+
+            # Normalize search term (lowercase, no spaces)
+            search_term = node_name.lower().replace(" ", "").replace("event", "").replace("receive", "")
+
+            for node in all_nodes:
+                # Get node class name (e.g., "K2Node_Event")
+                node_class = node.__class__.__name__
+
+                # For event nodes, check if it's an event node type
+                if "Event" in node_class or "K2Node" in node_class:
+                    # Try to get the event name from the node
+                    try:
+                        # Different event nodes store their name differently
+                        event_name = ""
+                        if hasattr(node, 'get_editor_property'):
+                            # Try EventReference.MemberName for event nodes
+                            try:
+                                event_ref = node.get_editor_property('event_reference')
+                                if event_ref:
+                                    event_name = str(event_ref.get_editor_property('member_name'))
+                            except:
+                                pass
+
+                            # Try CustomFunctionName
+                            if not event_name:
+                                try:
+                                    event_name = str(node.get_editor_property('custom_function_name'))
+                                except:
+                                    pass
+
+                        # Normalize event name for comparison
+                        if event_name:
+                            normalized_event = event_name.lower().replace(" ", "").replace("event", "").replace("receive", "")
+
+                            # Check if search term matches
+                            if search_term in normalized_event or normalized_event in search_term:
+                                node_guid = str(node.get_editor_property('node_guid'))
+                                log.log_result("_find_event_node_by_pattern", True,
+                                             f"Found event node '{event_name}' matching '{node_name}' with GUID {node_guid}")
+                                return node_guid
+                    except Exception as e:
+                        # Skip nodes that don't have the expected properties
+                        continue
+
+        return ""
+
+    except Exception as e:
+        log.log_warning(f"Error in pattern-based event node search: {str(e)}")
+        return ""
+
+def handle_get_node_guid(command: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Handle a command to retrieve the GUID of a pre-existing node in a Blueprint graph.
+    
+    Args:
+        command: The command dictionary containing:
+            - blueprint_path: Path to the Blueprint asset
+            - graph_type: "EventGraph" or "FunctionGraph"
+            - node_name: Name of the node (e.g., "BeginPlay") for EventGraph
+            - function_id: ID of the function for FunctionGraph to get FunctionEntry
+            
+    Returns:
+        Response dictionary with the node's GUID or an error
+    """
+    try:
+        blueprint_path = command.get("blueprint_path")
+        graph_type = command.get("graph_type", "EventGraph")
+        node_name = command.get("node_name", "")
+        function_id = command.get("function_id", "")
+
+        if not blueprint_path:
+            log.log_error("Missing blueprint_path for get_node_guid")
+            return {"success": False, "error": "Missing blueprint_path"}
+
+        if graph_type not in ["EventGraph", "FunctionGraph"]:
+            log.log_error(f"Invalid graph_type: {graph_type}")
+            return {"success": False, "error": f"Invalid graph_type: {graph_type}"}
+
+        log.log_command("get_node_guid", f"Blueprint: {blueprint_path}, Graph: {graph_type}, Node: {node_name or function_id}")
+
+        # Call the C++ implementation
+        gen_bp_utils = unreal.GenBlueprintUtils
+        node_guid = gen_bp_utils.get_node_guid(blueprint_path, graph_type, node_name, function_id)
+
+        # FIX: Fallback to Python-based event node search if C++ fails (unreal-mcp-monitor)
+        if not node_guid and graph_type == "EventGraph" and node_name:
+            log.log_warning(f"C++ search failed for '{node_name}', trying Python fallback with pattern matching")
+            node_guid = _find_event_node_by_pattern(blueprint_path, node_name)
+
+        if node_guid:
+            log.log_result("get_node_guid", True, f"Found node GUID: {node_guid}")
+            return {"success": True, "node_guid": node_guid}
+        else:
+            log.log_error(f"Failed to find node: {node_name or 'FunctionEntry'}")
+            # Provide helpful suggestions for event nodes
+            if graph_type == "EventGraph":
+                suggestion = "Try: 'Event BeginPlay', 'ReceiveBeginPlay', or use get_all_nodes_in_graph to see all available event nodes"
+            else:
+                suggestion = "Use get_all_nodes_in_graph to see available nodes"
+            return {"success": False, "error": f"Node not found: {node_name or 'FunctionEntry'}", "suggestion": suggestion}
+
+    except Exception as e:
+        log.log_error(f"Error getting node GUID: {str(e)}", include_traceback=True)
+        return {"success": False, "error": str(e)}
+
+def handle_get_node_pin_names(command: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Get all pin names for a specific node.
+    Helps with node connections.
+
+    Args:
+        command: Dict containing:
+            - blueprint_path: Path to Blueprint
+            - function_id: Function graph ID
+            - node_id: Node GUID
+
+    Returns:
+        Dict with input and output pin names
+    """
+    try:
+        blueprint_path = command.get("blueprint_path")
+        function_id = command.get("function_id")
+        node_id = command.get("node_id")
+
+        if not all([blueprint_path, function_id, node_id]):
+            return {"success": False, "error": "Missing required parameters: blueprint_path, function_id, node_id"}
+
+        log.log_command("get_node_pin_names", f"Blueprint: {blueprint_path}, Function: {function_id}, Node: {node_id}")
+
+        # Load the Blueprint
+        blueprint = unreal.load_asset(blueprint_path)
+        if not blueprint:
+            return {
+                "success": False,
+                "error": f"Blueprint not found: {blueprint_path}",
+                "suggestion": "Check that the path is correct and starts with /Game/"
+            }
+
+        # FIX: Use alternative API methods with fallbacks (unreal-mcp-monitor)
+        # Try multiple methods to access blueprint data
+        generated_class = None
+        try:
+            # Method 1: get_editor_property
+            generated_class = blueprint.get_editor_property('generated_class')
+        except:
+            try:
+                # Method 2: Direct attribute access
+                generated_class = blueprint.generated_class()
+            except:
+                # Method 3: Skip if not needed (generated_class not used below)
+                pass
+
+        # Get all graphs
+        function_graphs = unreal.EditorAssetLibrary.find_asset_data(blueprint_path).get_tag_value('UbergraphPages')
+
+        # Find the target graph by function ID
+        target_graph = None
+        for graph in blueprint.get_editor_property('function_graphs') or []:
+            graph_guid = str(graph.get_editor_property('graph_guid'))
+            if graph_guid == function_id:
+                target_graph = graph
+                break
+
+        # Also check ubergraph
+        if not target_graph:
+            ubergraph = blueprint.get_editor_property('ubergraph_pages')
+            if ubergraph and len(ubergraph) > 0:
+                for graph in ubergraph:
+                    graph_guid = str(graph.get_editor_property('graph_guid'))
+                    if graph_guid == function_id:
+                        target_graph = graph
+                        break
+
+        if not target_graph:
+            return {
+                "success": False,
+                "error": f"Function graph not found for ID: {function_id}",
+                "suggestion": "Use get_all_nodes_in_graph to see available functions"
+            }
+
+        # Find the node by GUID
+        all_nodes = target_graph.get_editor_property('nodes')
+        target_node = None
+
+        for node in all_nodes:
+            node_guid_str = str(node.get_editor_property('node_guid'))
+            if node_guid_str == node_id:
+                target_node = node
+                break
+
+        if not target_node:
+            return {
+                "success": False,
+                "error": f"Node not found with GUID: {node_id}",
+                "suggestion": "Use get_all_nodes_in_graph to see available nodes"
+            }
+
+        # Get pins
+        pins = target_node.get_editor_property('pins')
+        input_pins = []
+        output_pins = []
+
+        for pin in pins:
+            pin_name = str(pin.get_editor_property('pin_name'))
+            pin_category = str(pin.get_editor_property('pin_type').get_editor_property('pin_category'))
+            pin_is_array = pin.get_editor_property('pin_type').get_editor_property('container_type') == unreal.EPinContainerType.ARRAY
+
+            pin_info = {
+                "name": pin_name,
+                "type": pin_category,
+                "is_array": pin_is_array
+            }
+
+            pin_direction = pin.get_editor_property('direction')
+            if pin_direction == unreal.EdGraphPinDirection.EGPD_INPUT:
+                input_pins.append(pin_info)
+            else:
+                output_pins.append(pin_info)
+
+        node_type = target_node.__class__.__name__
+
+        log.log_result("get_node_pin_names", True, f"Found {len(input_pins)} input pins and {len(output_pins)} output pins")
+
+        return {
+            "success": True,
+            "node_type": node_type,
+            "node_id": node_id,
+            "input_pins": input_pins,
+            "output_pins": output_pins,
+            "total_input_pins": len(input_pins),
+            "total_output_pins": len(output_pins)
+        }
+
+    except Exception as e:
+        log.log_error(f"Error getting node pin names: {str(e)}", include_traceback=True)
+        return {
+            "success": False,
+            "error": f"Error: {str(e)}",
+            "recommendation": "Ensure the Blueprint, function, and node exist and are accessible"
+        }

UMCP.it-Unreal-Organizer-Assistant/Content/Python/handlers/blueprint_connection_commands.py

@@ -0,0 +1,338 @@
+"""
+Blueprint Node Connection Command Handlers for UMCP Plugin
+
+This module provides handlers for Blueprint node connection operations,
+integrating the Blueprint connection system with the UMCP socket server.
+
+Handlers:
+- get_node_pins: Discover pin information for a Blueprint node
+- validate_connection: Validate a connection before making it
+- auto_connect_chain: Intelligently auto-wire a chain of nodes
+- suggest_connections: Get ranked connection suggestions
+- get_graph_connections: List all connections in a function graph
+"""
+
+import sys
+import os
+from typing import Dict, Any
+from utils import logging as log
+
+# Add blueprint_connections to path (dynamically find it relative to this file)
+BLUEPRINT_CONN_PATH = os.path.join(os.path.dirname(os.path.dirname(__file__)), "blueprint_connections")
+if BLUEPRINT_CONN_PATH not in sys.path:
+    sys.path.insert(0, BLUEPRINT_CONN_PATH)
+
+# Import Blueprint connection modules
+try:
+    from handlers.pin_discovery import PinDiscoveryService
+    from handlers.connection_validator import ConnectionValidator
+    from handlers.auto_wiring import AutoWiringService
+
+    log.log_info("Blueprint connection modules loaded successfully")
+except Exception as e:
+    log.log_error(f"Failed to load Blueprint connection modules: {e}", include_traceback=True)
+    # Define placeholder classes so the module still loads
+    class PinDiscoveryService:
+        pass
+    class ConnectionValidator:
+        pass
+    class AutoWiringService:
+        pass
+
+
+def handle_get_node_pins(command: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Get all pins for a Blueprint node
+
+    Args:
+        command: {
+            "type": "get_node_pins",
+            "blueprint_path": "/Game/Blueprints/BP_Test",
+            "function_id": "FUNCTION_GUID",
+            "node_id": "NODE_GUID",
+            "use_cache": true  # optional, defaults to true
+        }
+
+    Returns:
+        {
+            "success": true,
+            "node_info": {...},
+            "input_pins": [{...}],
+            "output_pins": [{...}]
+        }
+    """
+    try:
+        blueprint_path = command.get("blueprint_path")
+        function_id = command.get("function_id")
+        node_id = command.get("node_id")
+        use_cache = command.get("use_cache", True)
+
+        if not all([blueprint_path, function_id, node_id]):
+            return {
+                "success": False,
+                "error": "Missing required parameters: blueprint_path, function_id, node_id"
+            }
+
+        # Initialize service - NO PARAMETERS
+        service = PinDiscoveryService()
+
+        # Get node pins - pass all parameters to method, not constructor
+        result = service.get_node_pins(
+            blueprint_path=blueprint_path,
+            function_id=function_id,
+            node_id=node_id,
+            use_cache=use_cache
+        )
+
+        return result
+
+    except Exception as e:
+        log.log_error(f"Error in get_node_pins: {e}", include_traceback=True)
+        return {"success": False, "error": str(e)}
+
+
+def handle_validate_connection(command: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Validate a Blueprint node connection before making it
+
+    Args:
+        command: {
+            "type": "validate_connection",
+            "blueprint_path": "/Game/Blueprints/BP_Test",
+            "function_id": "FUNCTION_GUID",
+            "source_node_id": "SOURCE_GUID",
+            "source_pin_name": "ReturnValue",
+            "target_node_id": "TARGET_GUID",
+            "target_pin_name": "A"
+        }
+
+    Returns:
+        {
+            "success": true,
+            "valid": true/false,
+            "error_type": "TYPE_MISMATCH" (if invalid),
+            "suggestions": ["..."],
+            "warnings": ["..."]
+        }
+    """
+    try:
+        blueprint_path = command.get("blueprint_path")
+        function_id = command.get("function_id")
+        source_node_id = command.get("source_node_id")
+        source_pin_name = command.get("source_pin_name")
+        target_node_id = command.get("target_node_id")
+        target_pin_name = command.get("target_pin_name")
+
+        if not all([blueprint_path, function_id, source_node_id, source_pin_name,
+                   target_node_id, target_pin_name]):
+            return {
+                "success": False,
+                "error": "Missing required parameters"
+            }
+
+        # Initialize service chain - CORRECT ORDER
+        pin_discovery = PinDiscoveryService()
+        validator = ConnectionValidator(pin_discovery)
+
+        # Validate connection - pass blueprint_path and function_id to METHOD
+        result = validator.validate_connection(
+            blueprint_path=blueprint_path,
+            function_id=function_id,
+            source_node_id=source_node_id,
+            source_pin_name=source_pin_name,
+            target_node_id=target_node_id,
+            target_pin_name=target_pin_name
+        )
+
+        # Add success flag
+        result["success"] = True
+        return result
+
+    except Exception as e:
+        log.log_error(f"Error in validate_connection: {e}", include_traceback=True)
+        return {"success": False, "error": str(e)}
+
+
+def handle_auto_connect_chain(command: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Automatically wire a chain of Blueprint nodes
+
+    Args:
+        command: {
+            "type": "auto_connect_chain",
+            "blueprint_path": "/Game/Blueprints/BP_Test",
+            "function_id": "FUNCTION_GUID",
+            "node_chain": ["NODE_GUID_1", "NODE_GUID_2", "NODE_GUID_3"],
+            "validate_before_connect": true  # optional, defaults to true
+        }
+
+    Returns:
+        {
+            "success": true,
+            "connections_made": 5,
+            "connections": [
+                {
+                    "source_node_id": "...",
+                    "source_pin": "...",
+                    "target_node_id": "...",
+                    "target_pin": "...",
+                    "connection_type": "execution/data",
+                    "confidence": 1.0
+                }
+            ],
+            "failed_connections": [...],
+            "warnings": [...]
+        }
+    """
+    try:
+        blueprint_path = command.get("blueprint_path")
+        function_id = command.get("function_id")
+        node_chain = command.get("node_chain", [])
+        validate_before_connect = command.get("validate_before_connect", True)
+
+        if not all([blueprint_path, function_id, node_chain]):
+            return {
+                "success": False,
+                "error": "Missing required parameters: blueprint_path, function_id, node_chain"
+            }
+
+        if len(node_chain) < 2:
+            return {
+                "success": False,
+                "error": "node_chain must contain at least 2 nodes"
+            }
+
+        # Initialize service chain - CORRECT ORDER
+        pin_discovery = PinDiscoveryService()
+        validator = ConnectionValidator(pin_discovery)
+        service = AutoWiringService(pin_discovery, validator)
+
+        # Auto-wire the chain - pass blueprint_path and function_id to METHOD
+        result = service.auto_connect_chain(
+            blueprint_path=blueprint_path,
+            function_id=function_id,
+            node_chain=node_chain,
+            validate_before_connect=validate_before_connect
+        )
+
+        # Add success flag
+        result["success"] = True
+        return result
+
+    except Exception as e:
+        log.log_error(f"Error in auto_connect_chain: {e}", include_traceback=True)
+        return {"success": False, "error": str(e)}
+
+
+def handle_suggest_connections(command: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Get ranked connection suggestions between two nodes
+
+    Args:
+        command: {
+            "type": "suggest_connections",
+            "blueprint_path": "/Game/Blueprints/BP_Test",
+            "function_id": "FUNCTION_GUID",
+            "source_node_id": "SOURCE_GUID",
+            "target_node_id": "TARGET_GUID"
+        }
+
+    Returns:
+        {
+            "success": true,
+            "execution_connection": {...},
+            "data_connections": [{...}],
+            "all_possibilities": [{...}]
+        }
+    """
+    try:
+        blueprint_path = command.get("blueprint_path")
+        function_id = command.get("function_id")
+        source_node_id = command.get("source_node_id")
+        target_node_id = command.get("target_node_id")
+
+        if not all([blueprint_path, function_id, source_node_id, target_node_id]):
+            return {
+                "success": False,
+                "error": "Missing required parameters: blueprint_path, function_id, source_node_id, target_node_id"
+            }
+
+        # Initialize service chain - CORRECT ORDER
+        pin_discovery = PinDiscoveryService()
+        validator = ConnectionValidator(pin_discovery)
+        service = AutoWiringService(pin_discovery, validator)
+
+        # Get suggestions - pass blueprint_path and function_id to METHOD
+        result = service.suggest_connections(
+            blueprint_path=blueprint_path,
+            function_id=function_id,
+            source_node_id=source_node_id,
+            target_node_id=target_node_id
+        )
+
+        # Add success flag
+        result["success"] = True
+        return result
+
+    except Exception as e:
+        log.log_error(f"Error in suggest_connections: {e}", include_traceback=True)
+        return {"success": False, "error": str(e)}
+
+
+def handle_get_graph_connections(command: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Get all connections in a Blueprint function graph
+
+    Args:
+        command: {
+            "type": "get_graph_connections",
+            "blueprint_path": "/Game/Blueprints/BP_Test",
+            "function_id": "FUNCTION_GUID"
+        }
+
+    Returns:
+        {
+            "success": true,
+            "connections": [
+                {
+                    "source_node_guid": "...",
+                    "source_pin_name": "...",
+                    "target_node_guid": "...",
+                    "target_pin_name": "..."
+                }
+            ],
+            "total_connections": 10
+        }
+    """
+    try:
+        blueprint_path = command.get("blueprint_path")
+        function_id = command.get("function_id")
+
+        if not all([blueprint_path, function_id]):
+            return {
+                "success": False,
+                "error": "Missing required parameters: blueprint_path, function_id"
+            }
+
+        # Initialize service - NO PARAMETERS
+        service = PinDiscoveryService()
+
+        # Get all connections - pass blueprint_path and function_id to METHOD
+        result = service.get_all_graph_connections(
+            blueprint_path=blueprint_path,
+            function_id=function_id
+        )
+
+        # Add success flag if not already present
+        if "success" not in result:
+            result["success"] = True
+
+        # Rename field for consistency with tool documentation
+        if "connection_count" in result:
+            result["total_connections"] = result.pop("connection_count")
+
+        return result
+
+    except Exception as e:
+        log.log_error(f"Error in get_graph_connections: {e}", include_traceback=True)
+        return {"success": False, "error": str(e)}

UMCP.it-Unreal-Organizer-Assistant/Content/Python/handlers/organization_commands.py

@@ -0,0 +1,646 @@
+"""
+Asset and World Organization Commands for Unreal Engine MCP
+
+This module provides comprehensive organization capabilities for Unreal Engine projects:
+- Content Browser folder structure management
+- Asset organization by type
+- World Outliner actor organization
+- Asset tagging system
+- Asset search by tags
+- Organization reporting
+
+All functions have been tested in Unreal Engine 5.6.1 and are production-ready.
+"""
+
+import json
+import unreal
+from typing import Dict, Any, List, Optional
+from utils import logging as log
+
+
+def handle_create_folder_structure(command: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Create a folder structure in the Content Browser.
+
+    Args:
+        command: Dictionary containing:
+            - base_path: Base path for folder creation (default: "/Game")
+            - folder_structure: Dictionary or list defining folder hierarchy
+
+    Returns:
+        Dictionary with created folders and status
+    """
+    try:
+        base_path = command.get("base_path", "/Game")
+        folder_structure = command.get("folder_structure", None)
+
+        created_folders = []
+        failed_folders = []
+
+        # Default folder structure if none provided
+        if folder_structure is None:
+            folder_structure = {
+                "Blueprints": ["Characters", "Weapons", "Items"],
+                "Materials": [],
+                "Meshes": ["Static", "Skeletal"],
+                "Textures": [],
+                "Audio": ["Music", "SFX"],
+                "Input": ["Actions", "Contexts"],
+                "UI": ["Widgets", "Textures"]
+            }
+
+        # Convert list to dict if needed
+        if isinstance(folder_structure, list):
+            folder_structure = {folder: [] for folder in folder_structure}
+
+        # Create base path if it doesn't exist
+        if not unreal.EditorAssetLibrary.does_directory_exist(base_path):
+            unreal.EditorAssetLibrary.make_directory(base_path)
+            created_folders.append(base_path)
+
+        # Create folder structure
+        for parent_folder, subfolders in folder_structure.items():
+            parent_path = f"{base_path}/{parent_folder}"
+
+            # Create parent folder
+            if not unreal.EditorAssetLibrary.does_directory_exist(parent_path):
+                success = unreal.EditorAssetLibrary.make_directory(parent_path)
+                if success:
+                    created_folders.append(parent_path)
+                else:
+                    failed_folders.append(parent_path)
+
+            # Create subfolders
+            for subfolder in subfolders:
+                subfolder_path = f"{parent_path}/{subfolder}"
+                if not unreal.EditorAssetLibrary.does_directory_exist(subfolder_path):
+                    success = unreal.EditorAssetLibrary.make_directory(subfolder_path)
+                    if success:
+                        created_folders.append(subfolder_path)
+                    else:
+                        failed_folders.append(subfolder_path)
+
+        return {
+            'success': True,
+            'message': f'Created {len(created_folders)} folders',
+            'created_folders': created_folders,
+            'failed_folders': failed_folders,
+            'total_created': len(created_folders),
+            'total_failed': len(failed_folders)
+        }
+
+    except Exception as e:
+        log.log_error(f"Error creating folder structure: {str(e)}")
+        return {
+            'success': False,
+            'error': str(e)
+        }
+
+
+def handle_organize_assets_by_type(command: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Organize assets from source folder into target folders by type.
+
+    Args:
+        command: Dictionary containing:
+            - source_folder: Folder to scan for assets
+            - target_base: Base path for organized folders (optional)
+            - organization_rules: Custom rules for organization (optional)
+            - dry_run: If True, don't move assets, just report (optional)
+
+    Returns:
+        Dictionary with organization results
+    """
+    try:
+        source_folder = command.get("source_folder")
+        target_base = command.get("target_base", None)
+        organization_rules = command.get("organization_rules", None)
+        dry_run = command.get("dry_run", False)
+
+        if not source_folder:
+            return {
+                'success': False,
+                'error': 'source_folder is required'
+            }
+
+        # Default target base
+        if target_base is None:
+            target_base = f"{source_folder}_Organized"
+
+        # Default organization rules
+        if organization_rules is None:
+            organization_rules = {
+                "Blueprint": f"{target_base}/Blueprints",
+                "InputAction": f"{target_base}/Input/Actions",
+                "InputMappingContext": f"{target_base}/Input/Contexts",
+                "Material": f"{target_base}/Materials",
+                "MaterialInstance": f"{target_base}/Materials/Instances",
+                "StaticMesh": f"{target_base}/Meshes/Static",
+                "SkeletalMesh": f"{target_base}/Meshes/Skeletal",
+                "Texture2D": f"{target_base}/Textures",
+                "SoundWave": f"{target_base}/Audio/SFX",
+                "AnimSequence": f"{target_base}/Animations",
+                "WidgetBlueprint": f"{target_base}/UI/Widgets",
+            }
+
+        # Create necessary folders
+        for folder_path in set(organization_rules.values()):
+            if not unreal.EditorAssetLibrary.does_directory_exist(folder_path):
+                unreal.EditorAssetLibrary.make_directory(folder_path)
+
+        # Get all assets in source folder
+        assets = unreal.EditorAssetLibrary.list_assets(source_folder, recursive=True)
+
+        moved_assets = []
+        skipped_assets = []
+        failed_assets = []
+
+        for asset_path in assets:
+            asset = unreal.load_asset(asset_path)
+            if not asset:
+                continue
+
+            asset_name = asset.get_name()
+            asset_class = asset.get_class().get_name()
+
+            # Find target folder for this asset type
+            target_folder = organization_rules.get(asset_class)
+            if not target_folder:
+                skipped_assets.append({
+                    'name': asset_name,
+                    'class': asset_class,
+                    'reason': 'No rule for this asset type'
+                })
+                continue
+
+            # Build new path
+            new_path = f"{target_folder}/{asset_name}"
+
+            # Skip if already in correct location
+            if asset_path.startswith(target_folder):
+                skipped_assets.append({
+                    'name': asset_name,
+                    'class': asset_class,
+                    'reason': 'Already in correct location'
+                })
+                continue
+
+            # Move asset (or simulate if dry run)
+            if dry_run:
+                moved_assets.append({
+                    'name': asset_name,
+                    'class': asset_class,
+                    'from': asset_path,
+                    'to': new_path,
+                    'moved': False,
+                    'dry_run': True
+                })
+            else:
+                success = unreal.EditorAssetLibrary.rename_asset(asset_path, new_path)
+                if success:
+                    moved_assets.append({
+                        'name': asset_name,
+                        'class': asset_class,
+                        'from': asset_path,
+                        'to': new_path,
+                        'moved': True
+                    })
+                else:
+                    failed_assets.append({
+                        'name': asset_name,
+                        'class': asset_class,
+                        'path': asset_path,
+                        'target': new_path
+                    })
+
+        return {
+            'success': True,
+            'dry_run': dry_run,
+            'source_folder': source_folder,
+            'target_base': target_base,
+            'total_assets_scanned': len(assets),
+            'moved_count': len(moved_assets),
+            'skipped_count': len(skipped_assets),
+            'failed_count': len(failed_assets),
+            'moved_assets': moved_assets[:10] if len(moved_assets) > 10 else moved_assets,
+            'skipped_assets': skipped_assets[:5] if len(skipped_assets) > 5 else skipped_assets,
+            'failed_assets': failed_assets,
+            'truncated': len(moved_assets) > 10
+        }
+
+    except Exception as e:
+        log.log_error(f"Error organizing assets: {str(e)}")
+        return {
+            'success': False,
+            'error': str(e)
+        }
+
+
+def handle_organize_world_outliner(command: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Organize actors in the World Outliner into folder hierarchy.
+
+    Args:
+        command: Dictionary containing:
+            - organization_rules: Dictionary mapping actor classes to folder paths (optional)
+            - target_actors: List of specific actor names to organize (optional)
+
+    Returns:
+        Dictionary with organization results
+    """
+    try:
+        organization_rules = command.get("organization_rules", None)
+        target_actors = command.get("target_actors", None)
+
+        # Default organization rules
+        if organization_rules is None:
+            organization_rules = {
+                # Lighting
+                "DirectionalLight": "/Environment/Lighting/Directional",
+                "PointLight": "/Environment/Lighting/Point",
+                "SpotLight": "/Environment/Lighting/Spot",
+                "SkyLight": "/Environment/Lighting/Sky",
+                "RectLight": "/Environment/Lighting/Rect",
+
+                # Environment
+                "Landscape": "/Environment/Terrain",
+                "StaticMeshActor": "/Props/Static",
+                "Foliage": "/Environment/Foliage",
+
+                # Gameplay
+                "PlayerStart": "/Gameplay/Spawn",
+                "TriggerBox": "/Gameplay/Triggers/Box",
+                "TriggerSphere": "/Gameplay/Triggers/Sphere",
+                "TriggerVolume": "/Gameplay/Triggers/Volume",
+                "NavMeshBoundsVolume": "/Gameplay/Navigation",
+
+                # Cinematics
+                "Camera": "/Cinematics/Cameras",
+                "CineCameraActor": "/Cinematics/Cameras/Cine",
+
+                # Audio
+                "AmbientSound": "/Audio/Ambient",
+
+                # Effects
+                "ParticleSystem": "/Effects/Particles",
+                "Niagara": "/Effects/Niagara",
+            }
+
+        # Get all actors in level
+        all_actors = unreal.EditorLevelLibrary.get_all_level_actors()
+
+        # Filter to target actors if specified
+        if target_actors:
+            all_actors = [a for a in all_actors if a and a.get_name() in target_actors]
+
+        organized_actors = []
+        skipped_actors = []
+
+        for actor in all_actors:
+            if not actor:
+                continue
+
+            actor_name = actor.get_name()
+            actor_class = actor.get_class().get_name()
+
+            # Find matching folder path
+            folder_path = None
+            for class_pattern, path in organization_rules.items():
+                if class_pattern in actor_class:
+                    folder_path = path
+                    break
+
+            if folder_path:
+                # Set folder path for actor
+                actor.set_folder_path(folder_path)
+                organized_actors.append({
+                    'name': actor_name,
+                    'class': actor_class,
+                    'folder': folder_path
+                })
+            else:
+                skipped_actors.append({
+                    'name': actor_name,
+                    'class': actor_class,
+                    'reason': 'No matching organization rule'
+                })
+
+        # Generate folder summary
+        folder_counts = {}
+        for item in organized_actors:
+            folder = item['folder']
+            folder_counts[folder] = folder_counts.get(folder, 0) + 1
+
+        return {
+            'success': True,
+            'total_actors': len(all_actors),
+            'organized_count': len(organized_actors),
+            'skipped_count': len(skipped_actors),
+            'folder_summary': folder_counts,
+            'organized_actors': organized_actors[:10] if len(organized_actors) > 10 else organized_actors,
+            'skipped_actors': skipped_actors[:5] if len(skipped_actors) > 5 else skipped_actors,
+            'truncated': len(organized_actors) > 10
+        }
+
+    except Exception as e:
+        log.log_error(f"Error organizing world outliner: {str(e)}")
+        return {
+            'success': False,
+            'error': str(e)
+        }
+
+
+def handle_tag_assets(command: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Add metadata tags to assets for organization and search.
+
+    Args:
+        command: Dictionary containing:
+            - asset_paths: List of asset paths to tag
+            - tags: List of tag strings to apply
+            - auto_tag: If True, automatically generate tags (optional)
+
+    Returns:
+        Dictionary with tagging results
+    """
+    try:
+        asset_paths = command.get("asset_paths", [])
+        tags = command.get("tags", [])
+        auto_tag = command.get("auto_tag", False)
+
+        if not asset_paths:
+            return {
+                'success': False,
+                'error': 'asset_paths is required'
+            }
+
+        tagged_assets = []
+        failed_assets = []
+
+        for asset_path in asset_paths:
+            asset = unreal.load_asset(asset_path)
+            if not asset:
+                failed_assets.append({
+                    'path': asset_path,
+                    'reason': 'Asset not found'
+                })
+                continue
+
+            asset_name = asset.get_name()
+            asset_class = asset.get_class().get_name()
+
+            # Generate auto tags if requested
+            applied_tags = list(tags)
+            if auto_tag:
+                auto_tags = []
+
+                # Tag based on name patterns
+                name_upper = asset_name.upper()
+                if "FPS" in name_upper:
+                    auto_tags.append("FPS")
+                if "JUMP" in name_upper:
+                    auto_tags.extend(["Movement", "Character"])
+                if "FIRE" in name_upper or "SHOOT" in name_upper:
+                    auto_tags.extend(["Combat", "Weapon"])
+                if "MOVE" in name_upper or "WALK" in name_upper or "RUN" in name_upper:
+                    auto_tags.append("Movement")
+                if "LOOK" in name_upper or "AIM" in name_upper:
+                    auto_tags.append("Camera")
+                if "RELOAD" in name_upper:
+                    auto_tags.extend(["Combat", "Weapon"])
+                if "CROUCH" in name_upper:
+                    auto_tags.extend(["Movement", "Character"])
+
+                # Tag based on class
+                if "Input" in asset_class:
+                    auto_tags.append("Input")
+                if "Blueprint" in asset_class:
+                    auto_tags.append("Blueprint")
+                if "Material" in asset_class:
+                    auto_tags.append("Material")
+
+                applied_tags.extend(auto_tags)
+
+            # Remove duplicates
+            applied_tags = list(set(applied_tags))
+
+            # Apply tags as metadata
+            for tag in applied_tags:
+                unreal.EditorAssetLibrary.set_metadata_tag(asset, tag, "true")
+
+            tagged_assets.append({
+                'name': asset_name,
+                'class': asset_class,
+                'path': asset_path,
+                'tags': applied_tags
+            })
+
+        return {
+            'success': True,
+            'tagged_count': len(tagged_assets),
+            'failed_count': len(failed_assets),
+            'auto_tag': auto_tag,
+            'tagged_assets': tagged_assets,
+            'failed_assets': failed_assets
+        }
+
+    except Exception as e:
+        log.log_error(f"Error tagging assets: {str(e)}")
+        return {
+            'success': False,
+            'error': str(e)
+        }
+
+
+def handle_search_assets_by_tag(command: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Search for assets with specific metadata tags.
+
+    Args:
+        command: Dictionary containing:
+            - folder_path: Folder to search in
+            - tags: List of tags to search for
+            - match_all: If True, asset must have ALL tags (optional)
+
+    Returns:
+        Dictionary with search results
+    """
+    try:
+        folder_path = command.get("folder_path")
+        tags = command.get("tags", [])
+        match_all = command.get("match_all", False)
+
+        if not folder_path:
+            return {
+                'success': False,
+                'error': 'folder_path is required'
+            }
+
+        if not tags:
+            return {
+                'success': False,
+                'error': 'tags list is required'
+            }
+
+        # Get all assets in folder
+        assets = unreal.EditorAssetLibrary.list_assets(folder_path, recursive=True)
+
+        matching_assets = []
+
+        for asset_path in assets:
+            asset = unreal.load_asset(asset_path)
+            if not asset:
+                continue
+
+            asset_name = asset.get_name()
+            asset_class = asset.get_class().get_name()
+
+            # Check tags
+            asset_tags = []
+            for tag in tags:
+                has_tag = unreal.EditorAssetLibrary.get_metadata_tag(asset, tag)
+                if has_tag:
+                    asset_tags.append(tag)
+
+            # Determine if this asset matches
+            if match_all:
+                matches = len(asset_tags) == len(tags)
+            else:
+                matches = len(asset_tags) > 0
+
+            if matches:
+                matching_assets.append({
+                    'name': asset_name,
+                    'class': asset_class,
+                    'path': asset_path,
+                    'matched_tags': asset_tags
+                })
+
+        return {
+            'success': True,
+            'search_folder': folder_path,
+            'search_tags': tags,
+            'match_all': match_all,
+            'total_assets_scanned': len(assets),
+            'matching_count': len(matching_assets),
+            'matching_assets': matching_assets
+        }
+
+    except Exception as e:
+        log.log_error(f"Error searching assets by tag: {str(e)}")
+        return {
+            'success': False,
+            'error': str(e)
+        }
+
+
+def handle_generate_organization_report(command: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Generate a comprehensive organization report.
+
+    Args:
+        command: Dictionary containing:
+            - content_browser_paths: List of paths to analyze (optional)
+            - include_world_outliner: Include World Outliner stats (optional)
+
+    Returns:
+        Dictionary with comprehensive organization report
+    """
+    try:
+        content_browser_paths = command.get("content_browser_paths", None)
+        include_world_outliner = command.get("include_world_outliner", True)
+
+        # Default paths
+        if content_browser_paths is None:
+            content_browser_paths = ["/Game"]
+
+        report = {
+            'content_browser': {},
+            'world_outliner': {},
+            'summary': {}
+        }
+
+        # Analyze Content Browser
+        total_assets = 0
+        assets_by_type = {}
+        assets_by_folder = {}
+
+        for base_path in content_browser_paths:
+            # Get all assets recursively
+            assets = unreal.EditorAssetLibrary.list_assets(base_path, recursive=True)
+            total_assets += len(assets)
+
+            for asset_path in assets:
+                asset = unreal.load_asset(asset_path)
+                if not asset:
+                    continue
+
+                asset_class = asset.get_class().get_name()
+
+                # Count by type
+                assets_by_type[asset_class] = assets_by_type.get(asset_class, 0) + 1
+
+                # Count by folder (immediate parent folder)
+                folder = '/'.join(asset_path.split('/')[:-1])
+                assets_by_folder[folder] = assets_by_folder.get(folder, 0) + 1
+
+        report['content_browser'] = {
+            'total_assets': total_assets,
+            'assets_by_type': dict(sorted(assets_by_type.items(), key=lambda x: x[1], reverse=True)),
+            'top_folders': dict(sorted(assets_by_folder.items(), key=lambda x: x[1], reverse=True)[:20])
+        }
+
+        # Analyze World Outliner
+        if include_world_outliner:
+            all_actors = unreal.EditorLevelLibrary.get_all_level_actors()
+            actors_by_class = {}
+            actors_by_folder = {}
+            organized_actors = 0
+            unorganized_actors = 0
+
+            for actor in all_actors:
+                if not actor:
+                    continue
+
+                actor_class = actor.get_class().get_name()
+                folder = str(actor.get_folder_path())
+
+                # Count by class
+                actors_by_class[actor_class] = actors_by_class.get(actor_class, 0) + 1
+
+                # Count by folder
+                if folder and folder != "None":
+                    actors_by_folder[folder] = actors_by_folder.get(folder, 0) + 1
+                    organized_actors += 1
+                else:
+                    unorganized_actors += 1
+
+            report['world_outliner'] = {
+                'total_actors': len(all_actors),
+                'organized_actors': organized_actors,
+                'unorganized_actors': unorganized_actors,
+                'organization_percentage': round((organized_actors / len(all_actors) * 100), 2) if len(all_actors) > 0 else 0,
+                'actors_by_class': dict(sorted(actors_by_class.items(), key=lambda x: x[1], reverse=True)[:15]),
+                'actors_by_folder': dict(sorted(actors_by_folder.items(), key=lambda x: x[1], reverse=True)[:15])
+            }
+
+        # Generate summary
+        report['summary'] = {
+            'content_browser_total_assets': total_assets,
+            'content_browser_asset_types': len(assets_by_type),
+            'content_browser_folders': len(assets_by_folder),
+            'world_outliner_total_actors': report['world_outliner'].get('total_actors', 0),
+            'world_outliner_organized_percentage': report['world_outliner'].get('organization_percentage', 0)
+        }
+
+        return {
+            'success': True,
+            'report': report
+        }
+
+    except Exception as e:
+        log.log_error(f"Error generating organization report: {str(e)}")
+        return {
+            'success': False,
+            'error': str(e)
+        }

UMCP.it-Unreal-Organizer-Assistant/Content/Python/handlers/physics_commands.py

@@ -0,0 +1,262 @@
+"""
+Physics and Selection Command Handlers - Simplified Version
+
+Based on proven working code that avoids collision enum mismatches.
+Only modifies mobility and physics simulation.
+
+Date: October 8, 2025
+Status: Production Ready
+"""
+
+import json
+import unreal
+from typing import Dict, Any
+
+
+def handle_get_selected_actors(command: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Get all currently selected actors in the Unreal Editor viewport.
+
+    Returns actor names, classes, locations, and physics status.
+
+    Args:
+        command: Command dictionary (no parameters needed)
+
+    Returns:
+        JSON dict with list of selected actors and their details
+    """
+    try:
+        # Get selected actors
+        selected_actors = unreal.EditorLevelLibrary.get_selected_level_actors()
+
+        if not selected_actors:
+            return {
+                'success': True,
+                'selected_count': 0,
+                'message': 'No actors selected',
+                'actors': []
+            }
+
+        # Build actor info list
+        actors_info = []
+        for actor in selected_actors:
+            if not actor:
+                continue
+
+            actor_name = actor.get_name()
+            actor_class = actor.get_class().get_name()
+            location = actor.get_actor_location()
+
+            # Check for mesh component
+            mesh_component = actor.get_component_by_class(unreal.StaticMeshComponent)
+            if not mesh_component:
+                mesh_component = actor.get_component_by_class(unreal.SkeletalMeshComponent)
+
+            has_mesh = mesh_component is not None
+            physics_enabled = False
+            if mesh_component:
+                physics_enabled = mesh_component.body_instance.simulate_physics
+
+            actors_info.append({
+                'name': actor_name,
+                'class': actor_class,
+                'location': {
+                    'x': round(location.x, 2),
+                    'y': round(location.y, 2),
+                    'z': round(location.z, 2)
+                },
+                'has_mesh': has_mesh,
+                'physics_enabled': physics_enabled
+            })
+
+        return {
+            'success': True,
+            'selected_count': len(actors_info),
+            'actors': actors_info
+        }
+
+    except Exception as e:
+        return {
+            'success': False,
+            'error': str(e)
+        }
+
+
+def handle_enable_physics_on_selected(command: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Enable physics simulation on all currently selected actors.
+
+    Uses the proven working approach:
+    1. Set mobility to Movable
+    2. Enable physics simulation
+    3. Does NOT modify collision (avoids enum mismatches)
+
+    Args:
+        command: Command dictionary (no parameters needed)
+
+    Returns:
+        JSON dict with results for each processed actor
+    """
+    try:
+        # Get selected actors
+        selected_actors = unreal.EditorLevelLibrary.get_selected_level_actors()
+
+        if not selected_actors:
+            return {
+                'success': False,
+                'error': 'No actors selected',
+                'message': 'Please select actors in the viewport first'
+            }
+
+        processed_actors = []
+        skipped_actors = []
+
+        for actor in selected_actors:
+            if not actor:
+                continue
+
+            actor_name = actor.get_name()
+            actor_class = actor.get_class().get_name()
+
+            # Try StaticMeshComponent first, then SkeletalMeshComponent
+            mesh_component = actor.get_component_by_class(unreal.StaticMeshComponent)
+            if not mesh_component:
+                mesh_component = actor.get_component_by_class(unreal.SkeletalMeshComponent)
+
+            if not mesh_component:
+                skipped_actors.append({
+                    'name': actor_name,
+                    'class': actor_class,
+                    'reason': 'No StaticMeshComponent or SkeletalMeshComponent found'
+                })
+                continue
+
+            # Store before state
+            component_name = mesh_component.get_name()
+            before_mobility = str(mesh_component.mobility)
+            before_physics = mesh_component.body_instance.simulate_physics
+
+            # Step 1: Set mobility to Movable (required for physics)
+            mesh_component.set_mobility(unreal.ComponentMobility.MOVABLE)
+
+            # Step 2: Enable physics simulation
+            mesh_component.set_simulate_physics(True)
+
+            # Verify it worked
+            after_physics = mesh_component.body_instance.simulate_physics
+
+            processed_actors.append({
+                'name': actor_name,
+                'class': actor_class,
+                'component': component_name,
+                'before': {
+                    'mobility': before_mobility,
+                    'physics': before_physics
+                },
+                'after': {
+                    'mobility': 'MOVABLE',
+                    'physics': after_physics
+                }
+            })
+
+        return {
+            'success': True,
+            'processed_count': len(processed_actors),
+            'skipped_count': len(skipped_actors),
+            'processed_actors': processed_actors,
+            'skipped_actors': skipped_actors,
+            'message': f'Enabled physics on {len(processed_actors)} actor(s)'
+        }
+
+    except Exception as e:
+        return {
+            'success': False,
+            'error': str(e)
+        }
+
+
+def handle_enable_physics_on_actor(command: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Enable physics simulation on a specific actor by name.
+
+    No selection required - targets actor by name directly.
+
+    Args:
+        command: Command dictionary with parameters:
+            - actor_name (str): Name of the actor (e.g., "SM_Table_01_60")
+
+    Returns:
+        JSON dict with results
+    """
+    try:
+        actor_name = command.get('actor_name')
+        if not actor_name:
+            return {
+                'success': False,
+                'error': 'actor_name parameter required'
+            }
+
+        # Get all actors and find the target
+        all_actors = unreal.EditorLevelLibrary.get_all_level_actors()
+
+        target_actor = None
+        for actor in all_actors:
+            if actor and actor.get_name() == actor_name:
+                target_actor = actor
+                break
+
+        if not target_actor:
+            return {
+                'success': False,
+                'error': f'Actor not found: {actor_name}',
+                'message': 'Check actor name and try again'
+            }
+
+        actor_class = target_actor.get_class().get_name()
+
+        # Try StaticMeshComponent first, then SkeletalMeshComponent
+        mesh_component = target_actor.get_component_by_class(unreal.StaticMeshComponent)
+        if not mesh_component:
+            mesh_component = target_actor.get_component_by_class(unreal.SkeletalMeshComponent)
+
+        if not mesh_component:
+            return {
+                'success': False,
+                'error': 'No mesh component found',
+                'actor_name': actor_name,
+                'actor_class': actor_class
+            }
+
+        # Store before state
+        component_name = mesh_component.get_name()
+        before_mobility = str(mesh_component.mobility)
+        before_physics = mesh_component.body_instance.simulate_physics
+
+        # Enable physics
+        mesh_component.set_mobility(unreal.ComponentMobility.MOVABLE)
+        mesh_component.set_simulate_physics(True)
+
+        # Verify it worked
+        after_physics = mesh_component.body_instance.simulate_physics
+
+        return {
+            'success': True,
+            'actor_name': actor_name,
+            'actor_class': actor_class,
+            'component': component_name,
+            'before': {
+                'mobility': before_mobility,
+                'physics': before_physics
+            },
+            'after': {
+                'mobility': 'MOVABLE',
+                'physics': after_physics
+            },
+            'message': f'Enabled physics on {actor_name}'
+        }
+
+    except Exception as e:
+        return {
+            'success': False,
+            'error': str(e)
+        }

UMCP.it-Unreal-Organizer-Assistant/Content/Python/handlers/physics_commands_backup.py

@@ -0,0 +1,303 @@
+"""
+Physics and Selection Command Handlers
+
+Handles physics simulation and actor selection commands for the Unreal MCP plugin.
+Commands include getting selected actors, enabling physics on selected/named actors.
+
+Date: October 8, 2025
+Status: Production Ready
+"""
+
+import json
+import unreal
+from typing import Dict, Any
+
+
+def handle_get_selected_actors(command: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Get all currently selected actors in the Unreal Editor viewport.
+
+    Returns actor names, classes, locations, and physics status.
+
+    Args:
+        command: Command dictionary (no parameters needed)
+
+    Returns:
+        JSON dict with list of selected actors and their details
+    """
+    try:
+        # Get selected actors
+        selected_actors = unreal.EditorLevelLibrary.get_selected_level_actors()
+
+        if not selected_actors:
+            return {
+                'success': True,
+                'selected_count': 0,
+                'message': 'No actors selected',
+                'actors': []
+            }
+
+        # Build actor info list
+        actors_info = []
+        for actor in selected_actors:
+            if not actor:
+                continue
+
+            actor_name = actor.get_name()
+            actor_class = actor.get_class().get_name()
+            location = actor.get_actor_location()
+
+            # Check if it has a static mesh component
+            components = actor.get_components_by_class(unreal.StaticMeshComponent)
+            has_static_mesh = len(components) > 0
+
+            # Check if physics is enabled (if it has static mesh)
+            physics_enabled = False
+            if components:
+                physics_enabled = components[0].body_instance.simulate_physics
+
+            actors_info.append({
+                'name': actor_name,
+                'class': actor_class,
+                'location': {
+                    'x': location.x,
+                    'y': location.y,
+                    'z': location.z
+                },
+                'has_static_mesh': has_static_mesh,
+                'physics_enabled': physics_enabled
+            })
+
+        return {
+            'success': True,
+            'selected_count': len(actors_info),
+            'actors': actors_info
+        }
+
+    except Exception as e:
+        return {
+            'success': False,
+            'error': str(e)
+        }
+
+
+def handle_enable_physics_on_selected(command: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Enable physics simulation on all currently selected actors.
+
+    This function:
+    1. Sets mobility to Movable
+    2. Enables physics simulation
+    3. Sets collision to QUERY_AND_PHYSICS
+    4. Optionally overrides mass
+
+    Args:
+        command: Command dictionary with optional parameters:
+            - enable_collision (bool): Enable collision (default: True)
+            - mass_override (float): Override mass in kg (default: None)
+
+    Returns:
+        JSON dict with results for each actor
+    """
+    try:
+        enable_collision = command.get('enable_collision', True)
+        mass_override = command.get('mass_override', None)
+
+        # Get selected actors
+        selected_actors = unreal.EditorLevelLibrary.get_selected_level_actors()
+
+        if not selected_actors:
+            return {
+                'success': False,
+                'error': 'No actors selected',
+                'message': 'Please select actors in the viewport first'
+            }
+
+        processed_actors = []
+        skipped_actors = []
+
+        for actor in selected_actors:
+            if not actor:
+                continue
+
+            actor_name = actor.get_name()
+            actor_class = actor.get_class().get_name()
+
+            # Get static mesh components
+            components = actor.get_components_by_class(unreal.StaticMeshComponent)
+
+            if not components:
+                skipped_actors.append({
+                    'name': actor_name,
+                    'class': actor_class,
+                    'reason': 'No StaticMeshComponent found'
+                })
+                continue
+
+            # Process each component (usually just one)
+            components_processed = []
+            for component in components:
+                component_name = component.get_name()
+
+                # Store before state
+                before_mobility = str(component.mobility)
+                before_physics = component.body_instance.simulate_physics
+
+                # Step 1: Set mobility to Movable
+                component.set_mobility(unreal.ComponentMobility.MOVABLE)
+
+                # Step 2: Enable physics simulation
+                component.set_simulate_physics(True)
+
+                # Step 3: Enable collision if requested
+                if enable_collision:
+                    component.set_collision_enabled(unreal.CollisionEnabled.QUERY_AND_PHYSICS)
+
+                # Step 4: Override mass if specified
+                if mass_override is not None:
+                    component.set_mass_override_in_kg(name='', mass_in_kg=mass_override, override=True)
+
+                # Get final mass
+                final_mass = component.get_mass()
+
+                components_processed.append({
+                    'component_name': component_name,
+                    'before': {
+                        'mobility': before_mobility,
+                        'physics': before_physics
+                    },
+                    'after': {
+                        'mobility': 'MOVABLE',
+                        'physics': True,
+                        'mass_kg': round(final_mass, 2)
+                    }
+                })
+
+            processed_actors.append({
+                'name': actor_name,
+                'class': actor_class,
+                'components': components_processed
+            })
+
+        return {
+            'success': True,
+            'processed_count': len(processed_actors),
+            'skipped_count': len(skipped_actors),
+            'processed_actors': processed_actors,
+            'skipped_actors': skipped_actors,
+            'message': f'Enabled physics on {len(processed_actors)} actor(s)'
+        }
+
+    except Exception as e:
+        return {
+            'success': False,
+            'error': str(e)
+        }
+
+
+def handle_enable_physics_on_actor(command: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Enable physics simulation on a specific actor by name.
+
+    Args:
+        command: Command dictionary with parameters:
+            - actor_name (str): Name of the actor (e.g., "SM_Stairs_632", "Cube_1")
+            - enable_collision (bool): Enable collision (default: True)
+            - mass_override (float): Override mass in kg (default: None)
+
+    Returns:
+        JSON dict with results
+    """
+    try:
+        actor_name = command.get('actor_name')
+        enable_collision = command.get('enable_collision', True)
+        mass_override = command.get('mass_override', None)
+
+        if not actor_name:
+            return {
+                'success': False,
+                'error': 'actor_name parameter is required'
+            }
+
+        # Get all actors
+        all_actors = unreal.EditorLevelLibrary.get_all_level_actors()
+
+        # Find actor by name
+        target_actor = None
+        for actor in all_actors:
+            if actor and actor.get_name() == actor_name:
+                target_actor = actor
+                break
+
+        if not target_actor:
+            return {
+                'success': False,
+                'error': f'Actor not found: {actor_name}',
+                'message': 'Check actor name and try again'
+            }
+
+        actor_class = target_actor.get_class().get_name()
+
+        # Get static mesh components
+        components = target_actor.get_components_by_class(unreal.StaticMeshComponent)
+
+        if not components:
+            return {
+                'success': False,
+                'error': 'No StaticMeshComponent found',
+                'actor_name': actor_name,
+                'actor_class': actor_class
+            }
+
+        # Process components
+        components_processed = []
+        for component in components:
+            component_name = component.get_name()
+
+            # Store before state
+            before_mobility = str(component.mobility)
+            before_physics = component.body_instance.simulate_physics
+
+            # Step 1: Set mobility to Movable
+            component.set_mobility(unreal.ComponentMobility.MOVABLE)
+
+            # Step 2: Enable physics simulation
+            component.set_simulate_physics(True)
+
+            # Step 3: Enable collision if requested
+            if enable_collision:
+                component.set_collision_enabled(unreal.CollisionEnabled.QUERY_AND_PHYSICS)
+
+            # Step 4: Override mass if specified
+            if mass_override is not None:
+                component.set_mass_override_in_kg(name='', mass_in_kg=mass_override, override=True)
+
+            # Get final mass
+            final_mass = component.get_mass()
+
+            components_processed.append({
+                'component_name': component_name,
+                'before': {
+                    'mobility': before_mobility,
+                    'physics': before_physics
+                },
+                'after': {
+                    'mobility': 'MOVABLE',
+                    'physics': True,
+                    'mass_kg': round(final_mass, 2)
+                }
+            })
+
+        return {
+            'success': True,
+            'actor_name': actor_name,
+            'actor_class': actor_class,
+            'components': components_processed,
+            'message': f'Enabled physics on {actor_name}'
+        }
+
+    except Exception as e:
+        return {
+            'success': False,
+            'error': str(e)
+        }

UMCP.it-Unreal-Organizer-Assistant/Content/Python/handlers/physics_commands_simple.py

@@ -0,0 +1,262 @@
+"""
+Physics and Selection Command Handlers - Simplified Version
+
+Based on proven working code that avoids collision enum mismatches.
+Only modifies mobility and physics simulation.
+
+Date: October 8, 2025
+Status: Production Ready
+"""
+
+import json
+import unreal
+from typing import Dict, Any
+
+
+def handle_get_selected_actors(command: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Get all currently selected actors in the Unreal Editor viewport.
+
+    Returns actor names, classes, locations, and physics status.
+
+    Args:
+        command: Command dictionary (no parameters needed)
+
+    Returns:
+        JSON dict with list of selected actors and their details
+    """
+    try:
+        # Get selected actors
+        selected_actors = unreal.EditorLevelLibrary.get_selected_level_actors()
+
+        if not selected_actors:
+            return {
+                'success': True,
+                'selected_count': 0,
+                'message': 'No actors selected',
+                'actors': []
+            }
+
+        # Build actor info list
+        actors_info = []
+        for actor in selected_actors:
+            if not actor:
+                continue
+
+            actor_name = actor.get_name()
+            actor_class = actor.get_class().get_name()
+            location = actor.get_actor_location()
+
+            # Check for mesh component
+            mesh_component = actor.get_component_by_class(unreal.StaticMeshComponent)
+            if not mesh_component:
+                mesh_component = actor.get_component_by_class(unreal.SkeletalMeshComponent)
+
+            has_mesh = mesh_component is not None
+            physics_enabled = False
+            if mesh_component:
+                physics_enabled = mesh_component.body_instance.simulate_physics
+
+            actors_info.append({
+                'name': actor_name,
+                'class': actor_class,
+                'location': {
+                    'x': round(location.x, 2),
+                    'y': round(location.y, 2),
+                    'z': round(location.z, 2)
+                },
+                'has_mesh': has_mesh,
+                'physics_enabled': physics_enabled
+            })
+
+        return {
+            'success': True,
+            'selected_count': len(actors_info),
+            'actors': actors_info
+        }
+
+    except Exception as e:
+        return {
+            'success': False,
+            'error': str(e)
+        }
+
+
+def handle_enable_physics_on_selected(command: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Enable physics simulation on all currently selected actors.
+
+    Uses the proven working approach:
+    1. Set mobility to Movable
+    2. Enable physics simulation
+    3. Does NOT modify collision (avoids enum mismatches)
+
+    Args:
+        command: Command dictionary (no parameters needed)
+
+    Returns:
+        JSON dict with results for each processed actor
+    """
+    try:
+        # Get selected actors
+        selected_actors = unreal.EditorLevelLibrary.get_selected_level_actors()
+
+        if not selected_actors:
+            return {
+                'success': False,
+                'error': 'No actors selected',
+                'message': 'Please select actors in the viewport first'
+            }
+
+        processed_actors = []
+        skipped_actors = []
+
+        for actor in selected_actors:
+            if not actor:
+                continue
+
+            actor_name = actor.get_name()
+            actor_class = actor.get_class().get_name()
+
+            # Try StaticMeshComponent first, then SkeletalMeshComponent
+            mesh_component = actor.get_component_by_class(unreal.StaticMeshComponent)
+            if not mesh_component:
+                mesh_component = actor.get_component_by_class(unreal.SkeletalMeshComponent)
+
+            if not mesh_component:
+                skipped_actors.append({
+                    'name': actor_name,
+                    'class': actor_class,
+                    'reason': 'No StaticMeshComponent or SkeletalMeshComponent found'
+                })
+                continue
+
+            # Store before state
+            component_name = mesh_component.get_name()
+            before_mobility = str(mesh_component.mobility)
+            before_physics = mesh_component.body_instance.simulate_physics
+
+            # Step 1: Set mobility to Movable (required for physics)
+            mesh_component.set_mobility(unreal.ComponentMobility.MOVABLE)
+
+            # Step 2: Enable physics simulation
+            mesh_component.set_simulate_physics(True)
+
+            # Verify it worked
+            after_physics = mesh_component.body_instance.simulate_physics
+
+            processed_actors.append({
+                'name': actor_name,
+                'class': actor_class,
+                'component': component_name,
+                'before': {
+                    'mobility': before_mobility,
+                    'physics': before_physics
+                },
+                'after': {
+                    'mobility': 'MOVABLE',
+                    'physics': after_physics
+                }
+            })
+
+        return {
+            'success': True,
+            'processed_count': len(processed_actors),
+            'skipped_count': len(skipped_actors),
+            'processed_actors': processed_actors,
+            'skipped_actors': skipped_actors,
+            'message': f'Enabled physics on {len(processed_actors)} actor(s)'
+        }
+
+    except Exception as e:
+        return {
+            'success': False,
+            'error': str(e)
+        }
+
+
+def handle_enable_physics_on_actor(command: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Enable physics simulation on a specific actor by name.
+
+    No selection required - targets actor by name directly.
+
+    Args:
+        command: Command dictionary with parameters:
+            - actor_name (str): Name of the actor (e.g., "SM_Table_01_60")
+
+    Returns:
+        JSON dict with results
+    """
+    try:
+        actor_name = command.get('actor_name')
+        if not actor_name:
+            return {
+                'success': False,
+                'error': 'actor_name parameter required'
+            }
+
+        # Get all actors and find the target
+        all_actors = unreal.EditorLevelLibrary.get_all_level_actors()
+
+        target_actor = None
+        for actor in all_actors:
+            if actor and actor.get_name() == actor_name:
+                target_actor = actor
+                break
+
+        if not target_actor:
+            return {
+                'success': False,
+                'error': f'Actor not found: {actor_name}',
+                'message': 'Check actor name and try again'
+            }
+
+        actor_class = target_actor.get_class().get_name()
+
+        # Try StaticMeshComponent first, then SkeletalMeshComponent
+        mesh_component = target_actor.get_component_by_class(unreal.StaticMeshComponent)
+        if not mesh_component:
+            mesh_component = target_actor.get_component_by_class(unreal.SkeletalMeshComponent)
+
+        if not mesh_component:
+            return {
+                'success': False,
+                'error': 'No mesh component found',
+                'actor_name': actor_name,
+                'actor_class': actor_class
+            }
+
+        # Store before state
+        component_name = mesh_component.get_name()
+        before_mobility = str(mesh_component.mobility)
+        before_physics = mesh_component.body_instance.simulate_physics
+
+        # Enable physics
+        mesh_component.set_mobility(unreal.ComponentMobility.MOVABLE)
+        mesh_component.set_simulate_physics(True)
+
+        # Verify it worked
+        after_physics = mesh_component.body_instance.simulate_physics
+
+        return {
+            'success': True,
+            'actor_name': actor_name,
+            'actor_class': actor_class,
+            'component': component_name,
+            'before': {
+                'mobility': before_mobility,
+                'physics': before_physics
+            },
+            'after': {
+                'mobility': 'MOVABLE',
+                'physics': after_physics
+            },
+            'message': f'Enabled physics on {actor_name}'
+        }
+
+    except Exception as e:
+        return {
+            'success': False,
+            'error': str(e)
+        }

UMCP.it-Unreal-Organizer-Assistant/Content/Python/handlers/python_commands.py

@@ -0,0 +1,278 @@
+import textwrap
+
+import unreal
+import sys
+from typing import Dict, Any
+import os
+import uuid
+import time
+import traceback
+
+# Assuming a logging module similar to your example
+from utils import logging as log
+
+
+def execute_script(script_file, output_file, error_file, status_file):
+    """Execute a Python script with output and error redirection."""
+    with open(output_file, 'w') as output_file_handle, open(error_file, 'w') as error_file_handle:
+        original_stdout = sys.stdout
+        original_stderr = sys.stderr
+        sys.stdout = output_file_handle
+        sys.stderr = error_file_handle
+
+        success = True
+        try:
+            with open(script_file, 'r') as f:
+                exec(f.read())
+        except Exception as e:
+            traceback.print_exc()
+            success = False
+        finally:
+            sys.stdout = original_stdout
+            sys.stderr = original_stderr
+
+        with open(status_file, 'w') as f:
+            f.write('1' if success else '0')
+
+
+def get_log_line_count():
+    """
+    Get the current line count of the Unreal log file
+    """
+    try:
+        log_path = os.path.join(unreal.Paths.project_log_dir(), "Unreal.log")
+        if os.path.exists(log_path):
+            with open(log_path, 'r', encoding='utf-8', errors='ignore') as f:
+                return sum(1 for _ in f)
+        return 0
+    except Exception as e:
+        log.log_error(f"Error getting log line count: {str(e)}")
+        return 0
+
+
+def get_recent_unreal_logs(start_line=None):
+    """
+    Retrieve recent Unreal Engine log entries to provide context for errors
+    
+    Args:
+        start_line: Optional line number to start from (to only get new logs)
+        
+    Returns:
+        String containing log entries or None if logs couldn't be accessed
+    """
+    try:
+        log_path = os.path.join(unreal.Paths.project_log_dir(), "Unreal.log")
+        if os.path.exists(log_path):
+            with open(log_path, 'r', encoding='utf-8', errors='ignore') as f:
+                if start_line is None:
+                    # Legacy behavior - get last 20 lines
+                    lines = f.readlines()
+                    return "".join(lines[-20:])
+                else:
+                    # Skip to the starting line
+                    for i, _ in enumerate(f):
+                        if i >= start_line - 1:
+                            break
+                    
+                    # Get all new lines
+                    new_lines = f.readlines()
+                    return "".join(new_lines) if new_lines else "No new log entries generated"
+        return None
+    except Exception as e:
+        log.log_error(f"Error getting recent logs: {str(e)}")
+        return None
+
+
+def handle_execute_python(command: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Handle a command to execute a Python script in Unreal Engine
+    
+    Args:
+        command: The command dictionary containing:
+            - script: The Python code to execute as a string
+            - force: Optional boolean to bypass safety checks (default: False)
+            
+    Returns:
+        Response dictionary with success/failure status and output if successful
+    """
+    try:
+        script = command.get("script")
+        force = command.get("force", False)
+
+        if not script:
+            log.log_error("Missing required parameter for execute_python: script")
+            return {"success": False, "error": "Missing required parameter: script"}
+
+        log.log_command("execute_python", f"Script: {script[:50]}...")
+
+        # Get log line count before execution
+        log_start_line = get_log_line_count()
+
+        destructive_keywords = [
+            "unreal.EditorAssetLibrary.delete_asset",
+            "unreal.EditorLevelLibrary.destroy_actor",
+            "unreal.save_package",
+            "os.remove",
+            "shutil.rmtree",
+            "file.write",
+            "unreal.EditorAssetLibrary.save_asset"
+        ]
+        is_destructive = any(keyword in script for keyword in destructive_keywords)
+
+        if is_destructive and not force:
+            log.log_warning("Potentially destructive script detected")
+            return {
+                "success": False,
+                "error": ("This script may involve destructive actions (e.g., deleting or saving files) "
+                          "not explicitly requested. Please confirm with 'Yes, execute it' or set force=True.")
+            }
+
+        temp_dir = os.path.join(unreal.Paths.project_saved_dir(), "Temp", "PythonExec")
+        if not os.path.exists(temp_dir):
+            os.makedirs(temp_dir)
+
+        script_file = os.path.join(temp_dir, f"script_{uuid.uuid4().hex}.py")
+        output_file = os.path.join(temp_dir, "output.txt")
+        error_file = os.path.join(temp_dir, "error.txt")
+        status_file = os.path.join(temp_dir, "status.txt")
+
+        # Normalize user script indentation and write to file
+        dedented_script = textwrap.dedent(script).strip()
+        with open(script_file, 'w') as f:
+            f.write(dedented_script)
+
+        # Execute using the wrapper
+        execute_script(script_file, output_file, error_file, status_file)
+        time.sleep(0.5)  # Allow execution to complete
+
+        output = ""
+        error = ""
+        success = False
+
+        if os.path.exists(output_file):
+            with open(output_file, 'r') as f:
+                output = f.read()
+        if os.path.exists(error_file):
+            with open(error_file, 'r') as f:
+                error = f.read()
+        if os.path.exists(status_file):
+            with open(status_file, 'r') as f:
+                success = f.read().strip() == "1"
+
+        for file in [script_file, output_file, error_file, status_file]:
+            if os.path.exists(file):
+                os.remove(file)
+
+        # Enhanced error handling for common Unreal API issues
+        if not success and error:
+            if "set_world_location() required argument 'sweep'" in error:
+                error += "\n\nHINT: The set_world_location() method requires a 'sweep' parameter. Try: set_world_location(location, sweep=False)"
+            elif "set_world_location() required argument 'teleport'" in error:
+                error += "\n\nHINT: The set_world_location() method requires 'teleport' parameter. Try: set_world_location(location, sweep=False, teleport=False)"
+            elif "set_actor_location() required argument 'teleport'" in error:
+                error += "\n\nHINT: The set_actor_location() method requires a 'teleport' parameter. Try: set_actor_location(location, sweep=False, teleport=False)"
+
+            # Get only new log entries
+            recent_logs = get_recent_unreal_logs(log_start_line)
+            if recent_logs:
+                error += "\n\nNew Unreal logs during execution:\n" + recent_logs
+
+        if success:
+            # Get only new log entries for successful execution as well
+            recent_logs = get_recent_unreal_logs(log_start_line)
+            if recent_logs:
+                output += "\n\nNew Unreal logs during execution:\n" + recent_logs
+                
+            log.log_result("execute_python", True, f"Script executed with output: {output}")
+            return {"success": True, "output": output}
+        else:
+            log.log_error(f"Script execution failed with error: {error}")
+            return {"success": False, "error": error if error else "Execution failed without specific error", "output": output}
+
+    except Exception as e:
+        log.log_error(f"Error handling execute_python: {str(e)}", include_traceback=True)
+        return {"success": False, "error": str(e)}
+    finally:
+        for file in [script_file, output_file, error_file, status_file]:
+            if os.path.exists(file):
+                try:
+                    os.remove(file)
+                except:
+                    pass
+
+
+def handle_execute_unreal_command(command: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Handle a command to execute an Unreal Engine console command
+    
+    Args:
+        command: The command dictionary containing:
+            - command: The Unreal Engine console command to execute
+            - force: Optional boolean to bypass safety checks (default: False)
+            
+    Returns:
+        Response dictionary with success/failure status and output if successful
+    """
+    script_file = None
+    output_file = None
+    error_file = None
+    
+    try:
+        cmd = command.get("command")
+        force = command.get("force", False)
+
+        if not cmd:
+            log.log_error("Missing required parameter for execute_unreal_command: command")
+            return {"success": False, "error": "Missing required parameter: command"}
+
+        if cmd.strip().lower().startswith("py "):
+            log.log_error("Attempted to run a Python script with execute_unreal_command")
+            return {
+                "success": False,
+                "error": ("Use 'execute_python' command to run Python scripts instead of 'execute_unreal_command' with 'py'. "
+                          "For example, send {'type': 'execute_python', 'script': 'your_code_here'}.")
+            }
+
+        log.log_command("execute_unreal_command", f"Command: {cmd}")
+
+        # Get log line count before execution
+        log_start_line = get_log_line_count()
+
+        destructive_keywords = ["delete", "save", "quit", "exit", "restart"]
+        is_destructive = any(keyword in cmd.lower() for keyword in destructive_keywords)
+
+        if is_destructive and not force:
+            log.log_warning("Potentially destructive command detected")
+            return {
+                "success": False,
+                "error": ("This command may involve destructive actions (e.g., deleting or saving). "
+                          "Please confirm with 'Yes, execute it' or set force=True.")
+            }
+
+        # Execute the command
+        world = unreal.EditorLevelLibrary.get_editor_world()
+        unreal.SystemLibrary.execute_console_command(world, cmd)
+        
+        # Add a short delay to allow logs to be captured
+        time.sleep(1.0)  # Slightly longer delay to ensure logs are written
+        
+        # Get new log entries generated during command execution
+        recent_logs = get_recent_unreal_logs(log_start_line)
+        
+        output = f"Command '{cmd}' executed successfully"
+        if recent_logs:
+            output += "\n\nRelated Unreal logs:\n" + recent_logs
+            
+        log.log_result("execute_unreal_command", True, f"Command '{cmd}' executed")
+        return {"success": True, "output": output}
+        
+    except Exception as e:
+        # Get new log entries to provide context for the error
+        recent_logs = get_recent_unreal_logs(log_start_line) if 'log_start_line' in locals() else None
+        error_msg = f"Error executing command: {str(e)}"
+        
+        if recent_logs:
+            error_msg += "\n\nUnreal logs around the time of error:\n" + recent_logs
+            
+        log.log_error(f"Error handling execute_unreal_command: {str(e)}", include_traceback=True)
+        return {"success": False, "error": error_msg}

UMCP.it-Unreal-Organizer-Assistant/Content/Python/handlers/ui_commands.py

@@ -0,0 +1,181 @@
+import unreal
+from typing import Dict, Any, Union
+from utils import logging as log
+import json # Import json for parsing C++ response
+import re # For parsing property values
+
+# Lazy load the C++ utils class to avoid issues during Unreal init
+_widget_gen_utils = None
+def get_widget_gen_utils():
+    global _widget_gen_utils
+    if _widget_gen_utils is None:
+        try:
+            # Attempt to load the class generated from C++
+            # Make sure your C++ class is compiled and accessible to Python
+            _widget_gen_utils = unreal.GenWidgetUtils()
+        except Exception as e:
+            log.log_error(f"Failed to get unreal.WidgetGenUtils: {e}. Ensure C++ module is compiled and loaded.")
+            raise  # Re-raise to signal failure
+    return _widget_gen_utils
+
+def handle_add_widget_to_user_widget(command: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Handles adding a widget component to a User Widget Blueprint.
+    """
+    try:
+        widget_gen_utils = get_widget_gen_utils()
+        user_widget_path = command.get("user_widget_path")
+        widget_type = command.get("widget_type")
+        widget_name = command.get("widget_name")
+        parent_name = command.get("parent_widget_name", "") # Default to empty string if not provided
+
+        log.log_command("add_widget_to_user_widget", f"Path: {user_widget_path}, Type: {widget_type}, Name: {widget_name}, Parent: {parent_name}")
+
+        if not all([user_widget_path, widget_type, widget_name]):
+            return {"success": False, "error": "Missing required arguments: user_widget_path, widget_type, widget_name"}
+
+        # Call the C++ function
+        response_str = widget_gen_utils.add_widget_to_user_widget(user_widget_path, widget_type, widget_name, parent_name)
+
+        # Parse the JSON response from C++
+        response_json = json.loads(response_str)
+        log.log_result("add_widget_to_user_widget", response_json.get("success", False), response_json.get("message") or response_json.get("error"))
+        return response_json
+
+    except Exception as e:
+        log.log_error(f"Error in handle_add_widget_to_user_widget: {str(e)}", include_traceback=True)
+        return {"success": False, "error": f"Python Handler Error: {str(e)}"}
+
+def parse_property_value(property_name: str, value_string: str) -> Union[unreal.Vector2D, unreal.LinearColor, unreal.Anchors, bool, float, int, str]:
+    """
+    Helper function to parse property values based on their type.
+
+    Args:
+        property_name: Name of the property being set
+        value_string: String representation of the value
+
+    Returns:
+        Parsed value in appropriate Unreal type
+    """
+    # Vector2D properties (Position, Size)
+    if property_name.lower() in ['position', 'size']:
+        # Parse "(X=100.0,Y=200.0)" format
+        if 'X=' in value_string and 'Y=' in value_string:
+            x_match = re.search(r'X=([\d.-]+)', value_string)
+            y_match = re.search(r'Y=([\d.-]+)', value_string)
+            if x_match and y_match:
+                return unreal.Vector2D(float(x_match.group(1)), float(y_match.group(1)))
+        # Parse "[100, 200]" or "100, 200" format
+        elif '[' in value_string or ',' in value_string:
+            value_string = value_string.strip('[]')
+            coords = [float(x.strip()) for x in value_string.split(',')]
+            if len(coords) >= 2:
+                return unreal.Vector2D(coords[0], coords[1])
+
+    # Anchors
+    if property_name.lower() == 'anchors':
+        # Parse "(Minimum=(X=0.5,Y=0.0),Maximum=(X=0.5,Y=0.0))" format
+        min_x = re.search(r'Minimum=\(X=([\d.-]+)', value_string)
+        min_y = re.search(r'Minimum=\(X=[\d.-]+,Y=([\d.-]+)', value_string)
+        max_x = re.search(r'Maximum=\(X=([\d.-]+)', value_string)
+        max_y = re.search(r'Maximum=\(X=[\d.-]+,Y=([\d.-]+)', value_string)
+
+        if all([min_x, min_y, max_x, max_y]):
+            anchors = unreal.Anchors()
+            anchors.minimum = unreal.Vector2D(float(min_x.group(1)), float(min_y.group(1)))
+            anchors.maximum = unreal.Vector2D(float(max_x.group(1)), float(max_y.group(1)))
+            return anchors
+
+    # LinearColor (ColorAndOpacity, etc.)
+    if 'color' in property_name.lower():
+        # Parse "(R=1.0,G=0.0,B=0.0,A=1.0)" format
+        r = re.search(r'R=([\d.-]+)', value_string)
+        g = re.search(r'G=([\d.-]+)', value_string)
+        b = re.search(r'B=([\d.-]+)', value_string)
+        a = re.search(r'A=([\d.-]+)', value_string)
+
+        if all([r, g, b, a]):
+            return unreal.LinearColor(
+                float(r.group(1)),
+                float(g.group(1)),
+                float(b.group(1)),
+                float(a.group(1))
+            )
+
+    # Boolean
+    if value_string.lower() in ['true', 'false']:
+        return value_string.lower() == 'true'
+
+    # Float
+    try:
+        if '.' in value_string:
+            return float(value_string)
+    except:
+        pass
+
+    # Integer
+    try:
+        return int(value_string)
+    except:
+        pass
+
+    # Default: return as string
+    return value_string
+
+def handle_edit_widget_property(command: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Handles editing a property of a widget inside a User Widget Blueprint.
+    Supports Text properties with unreal.Text conversion and other property types.
+    """
+    try:
+        widget_gen_utils = get_widget_gen_utils()
+        user_widget_path = command.get("user_widget_path")
+        widget_name = command.get("widget_name")
+        property_name = command.get("property_name")
+        value_str = command.get("value") # Value is expected as a string
+
+        log.log_command("edit_widget_property", f"Path: {user_widget_path}, Widget: {widget_name}, Property: {property_name}, Value: {value_str}")
+
+        if not all([user_widget_path, widget_name, property_name, value_str is not None]):
+            return {"success": False, "error": "Missing required arguments: user_widget_path, widget_name, property_name, value"}
+
+        # ENHANCED: Special handling for Text properties using unreal.Text()
+        if property_name.lower() == "text":
+            try:
+                # Try to create unreal.Text object directly
+                # This is the recommended approach for UE5
+                text_obj = unreal.Text(value_str)
+                # Convert to string representation that C++ can parse
+                value_str = f'NSLOCTEXT("", "", "{value_str}")'
+                log.log_info(f"Converted to FText format: {value_str}")
+            except Exception as text_err:
+                log.log_warning(f"Could not create unreal.Text object, using fallback: {text_err}")
+                # Fallback to NSLOCTEXT format
+                value_str = f'NSLOCTEXT("", "", "{value_str}")'
+
+        # ENHANCED: Parse other property types for better type safety
+        elif property_name.lower() in ['position', 'size', 'anchors'] or 'color' in property_name.lower():
+            try:
+                parsed_value = parse_property_value(property_name, value_str)
+                # Convert back to string format that C++ can parse
+                if isinstance(parsed_value, unreal.Vector2D):
+                    value_str = f"(X={parsed_value.x},Y={parsed_value.y})"
+                elif isinstance(parsed_value, unreal.LinearColor):
+                    value_str = f"(R={parsed_value.r},G={parsed_value.g},B={parsed_value.b},A={parsed_value.a})"
+                elif isinstance(parsed_value, unreal.Anchors):
+                    value_str = f"(Minimum=(X={parsed_value.minimum.x},Y={parsed_value.minimum.y}),Maximum=(X={parsed_value.maximum.x},Y={parsed_value.maximum.y}))"
+                log.log_info(f"Parsed property value to: {value_str}")
+            except Exception as parse_err:
+                log.log_warning(f"Could not parse property value, using raw string: {parse_err}")
+
+        # Call the C++ function
+        response_str = widget_gen_utils.edit_widget_property(user_widget_path, widget_name, property_name, value_str)
+
+        # Parse the JSON response from C++
+        response_json = json.loads(response_str)
+        log.log_result("edit_widget_property", response_json.get("success", False), response_json.get("message") or response_json.get("error"))
+        return response_json
+
+    except Exception as e:
+        log.log_error(f"Error in handle_edit_widget_property: {str(e)}", include_traceback=True)
+        return {"success": False, "error": f"Python Handler Error: {str(e)}"}

UMCP.it-Unreal-Organizer-Assistant/Content/Python/init_unreal.py

@@ -0,0 +1,143 @@
+# Content/Python/init_unreal.py - Using UE settings integration
+import unreal
+import importlib.util
+import os
+import sys
+import subprocess
+import atexit
+from utils import logging as log
+
+# Global process handle for MCP server
+mcp_server_process = None
+
+def shutdown_mcp_server():
+    """Shutdown the MCP server process when Unreal Editor closes"""
+    global mcp_server_process
+    if mcp_server_process:
+        log.log_info("Shutting down MCP server process...")
+        try:
+            mcp_server_process.terminate()
+            mcp_server_process = None
+            log.log_info("MCP server process terminated successfully")
+        except Exception as e:
+            log.log_error(f"Error terminating MCP server: {e}")
+
+def start_mcp_server():
+    """Start the external MCP server process"""
+    global mcp_server_process
+    try:
+        # Find our plugin's Python directory - search for UMCP/Content/Python
+        # Skip subdirectories like blueprint_connections
+        plugin_python_path = None
+        for path in sys.path:
+            if ("UMCP/Content/Python" in path or "Content/Python" in path) and "blueprint_connections" not in path:
+                plugin_python_path = path
+                break
+
+        if not plugin_python_path:
+            log.log_error("Could not find plugin Python path")
+            return False
+
+        # Get the mcp_server.py path
+        mcp_server_path = os.path.join(plugin_python_path, "mcp_server.py")
+
+        if not os.path.exists(mcp_server_path):
+            log.log_error(f"MCP server script not found at: {mcp_server_path}")
+            return False
+
+        # Start the MCP server as a separate process
+        python_exe = sys.executable
+        log.log_info(f"Starting MCP server using Python: {python_exe}")
+        log.log_info(f"MCP server script path: {mcp_server_path}")
+
+        # Create a detached process that will continue running
+        # even if Unreal crashes (we'll handle proper shutdown with atexit)
+        creationflags = 0
+        if sys.platform == 'win32':
+            creationflags = subprocess.CREATE_NEW_PROCESS_GROUP
+
+        mcp_server_process = subprocess.Popen(
+            [python_exe, mcp_server_path],
+            creationflags=creationflags,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True
+        )
+
+        log.log_info(f"MCP server started with PID: {mcp_server_process.pid}")
+
+        # Register cleanup handler to ensure process is terminated when Unreal exits
+        atexit.register(shutdown_mcp_server)
+
+        return True
+    except Exception as e:
+        log.log_error(f"Error starting MCP server: {e}")
+        return False
+def initialize_socket_server():
+    """
+    Initialize the socket server if auto-start is enabled in UE settings
+    """
+    auto_start = False
+    
+    # Get settings from UE settings system
+    try:
+        # First get the class reference
+        settings_class = unreal.load_class(None, '/Script/GenerativeAISupportEditor.GenerativeAISupportSettings')
+        if settings_class:
+            # Get the settings object using the class reference
+            settings = unreal.get_default_object(settings_class)
+            
+            # Log available properties for debugging
+            log.log_info(f"Settings object properties: {dir(settings)}")
+            
+            # Check if auto-start is enabled
+            # Unreal Python API converts bAutoStartSocketServer -> auto_start_socket_server
+            if hasattr(settings, 'auto_start_socket_server'):
+                auto_start = settings.auto_start_socket_server
+                log.log_info(f"Socket server auto-start setting: {auto_start}")
+            else:
+                log.log_warning("auto_start_socket_server property not found in settings")
+                # Try alternative property names that might exist
+                for prop in dir(settings):
+                    if 'auto' in prop.lower() or 'socket' in prop.lower() or 'server' in prop.lower():
+                        log.log_info(f"Found similar property: {prop}")
+        else:
+            log.log_error("Could not find GenerativeAISupportSettings class")
+    except Exception as e:
+        log.log_error(f"Error reading UE settings: {e}")
+        log.log_info("Falling back to disabled auto-start")
+
+    # Auto-start if configured
+    if auto_start:
+        log.log_info("Auto-starting Unreal Socket Server...")
+
+        # Start Unreal Socket Server
+        try:
+            # Find our plugin's Python directory - search for UMCP/Content/Python
+            # Skip subdirectories like blueprint_connections
+            plugin_python_path = None
+            for path in sys.path:
+                if ("UMCP/Content/Python" in path or "Content/Python" in path) and "blueprint_connections" not in path:
+                    plugin_python_path = path
+                    break
+
+            if plugin_python_path:
+                server_path = os.path.join(plugin_python_path, "unreal_socket_server.py")
+    
+                if os.path.exists(server_path):
+                    # Import and execute the server module
+                    spec = importlib.util.spec_from_file_location("unreal_socket_server", server_path)
+                    server_module = importlib.util.module_from_spec(spec)
+                    spec.loader.exec_module(server_module)
+                    log.log_info("Unreal Socket Server started successfully")
+                else:
+                    log.log_error(f"Server file not found at: {server_path}")
+            else:
+                log.log_error("Could not find plugin Python path")
+        except Exception as e:
+            log.log_error(f"Error starting socket server: {e}")
+    else:
+        log.log_info("Unreal Socket Server auto-start is disabled")
+
+# Run initialization when this script is loaded
+initialize_socket_server()

UMCP.it-Unreal-Organizer-Assistant/Content/Python/knowledge_base/how_to_use.md

@@ -0,0 +1,289 @@
+# Note: This guide is not for humans, LLMs can refer it to understand how to use the Unreal Engine MCP Plugin.
+
+# Unreal Engine MCP Plugin Guide
+
+This plugin lets an LLM (like you, Claude) boss around Unreal Engine with MCP. Automates Blueprint wizard-ry, node hookups, all that jazz. Check this s to not f it up.
+
+## Key Notes
+
+- **Pin Connections**: For inbuilt Events like BeginPlay Use "then" for execution pin, not "OutputDelegate" (delegates). Verify pin names in JSON.
+- **Node Types**: Use `add_node_to_blueprint` with "EventBeginPlay", "Multiply_FloatFloat", or basics like "Branch", "Sequence". Unrecognized types return suggestions.
+- **Node Spacing**: Set `node_position` in JSON (e.g., [0, 0], [400, 0])—maintain 400x, 300y gaps to prevent overlap.
+- **Inputs**: Use `add_input_binding` to set up the binding (e.g., "Jump", "SpaceBar"), then `add_node_to_blueprint` with "K2Node_InputAction" and `"action_name": "Jump"` in `node_properties`. Ensure `action_name` matches.
+- **Colliders**: Add via `add_component_with_events` (e.g., "MyBox", "BoxComponent")—returns `"begin_overlap_guid"` (BeginOverlap node) and `"end_overlap_guid"` (EndOverlap node).
+- **Materials**: Use `edit_component_property` with property_name as "Material", "SetMaterial", or "BaseMaterial" and value as a material path (e.g., "'/Game/Materials/M_MyMaterial'") to set on mesh components (slot 0 default).
+
+## Enhanced Input System (UE 5.6+)
+
+Legacy input bindings are deprecated. Use Enhanced Input instead:
+
+1. **Create Input Action**: `create_enhanced_input_action("IA_Jump", "/Game/Input")` - Creates an Input Action asset
+2. **Create Mapping Context**: `create_enhanced_input_mapping_context("IMC_Default", "/Game/Input")` - Creates a Mapping Context asset
+3. **Add Key Mappings**: Open the Mapping Context asset in Content Browser and add key mappings manually
+4. **Use in Blueprint**: Reference the Input Action and Mapping Context using Enhanced Input nodes
+
+**Value Types**: "BOOLEAN" (default), "AXIS_1D" (float), "AXIS_2D" (Vector2D), "AXIS_3D" (Vector)
+
+**Example**:
+```python
+create_enhanced_input_action("IA_Jump", "/Game/Input", "BOOLEAN")
+create_enhanced_input_mapping_context("IMC_Default", "/Game/Input")
+# Then open IMC_Default in Content Browser and map IA_Jump to SpaceBar
+```
+
+If `add_input_binding` fails with Enhanced Input error, it'll give you these instructions automatically.
+
+## UMG Text Properties
+
+Text properties on UMG widgets (TextBlocks, Buttons, etc.) are auto-converted. Just pass the string value:
+
+```python
+edit_widget_property("/Game/UI/WBP_Menu", "TitleText", "Text", "My Game Title")
+```
+
+No need for INVTEXT() or NSLOCTEXT() macros—the plugin handles it. Works for all text widgets.
+
+**Other UMG Properties**:
+- **Position/Size**: `"(X=100.0,Y=200.0)"` or `"[100, 200]"`
+- **Color**: `"(R=1.0,G=0.0,B=0.0,A=1.0)"`
+- **Anchors**: `"(Minimum=(X=0.5,Y=0.0),Maximum=(X=0.5,Y=0.0))"`
+- **Boolean**: `"true"` or `"false"`
+
+## Finding Component Names
+
+Scene actor components are auto-numbered (e.g., "StaticMeshComponent0"). To discover available components:
+
+**For Scene Actors**:
+```python
+get_component_names(actor_name="Cube_1", is_scene_actor=True)
+```
+
+**For Blueprints**:
+```python
+get_component_names(blueprint_path="/Game/BP_Player")
+```
+
+Returns JSON with all component names and their classes. Use these exact names in `edit_component_property`.
+
+## Finding Pin Names
+
+When connecting Blueprint nodes, you need exact pin names. Get them with:
+
+```python
+get_node_pin_names("/Game/BP_Test", "FUNCTION_GUID", "NODE_GUID")
+```
+
+Returns JSON with:
+- `input_pins`: Array of input pins with name, type, and is_array
+- `output_pins`: Array of output pins with name, type, and is_array
+- `node_type`: Class name of the node
+
+Use these pin names in `connect_blueprint_nodes` or `connect_blueprint_nodes_bulk`.
+
+**Example Workflow**:
+1. Add node → Get node GUID
+2. Call `get_node_pin_names` with that GUID
+3. Use returned pin names to connect nodes
+
+## JSON Response Format
+
+All MCP commands return JSON strings with consistent structure:
+
+**Success**:
+```json
+{
+  "success": true,
+  "message": "Operation completed",
+  "data": { ... }
+}
+```
+
+**Failure**:
+```json
+{
+  "success": false,
+  "error": "Error description",
+  "available_options": ["option1", "option2"],
+  "suggestion": "Try using option1"
+}
+```
+
+Error messages include suggestions and available options when applicable. Read them—they're helpful.
+
+## Asset & World Organization
+
+Comprehensive system for organizing Content Browser assets and World Outliner actors. All functions tested in UE 5.6.1.
+
+### Create Folder Structure
+
+Create hierarchical folder structure in Content Browser:
+
+```python
+create_folder_structure("/Game/MyProject", '{"Blueprints": ["Characters", "Weapons"], "Input": ["Actions", "Contexts"], "Materials": []}')
+```
+
+Creates parent folders and subfolders in one command. Useful for new project setup.
+
+### Organize Assets by Type
+
+Automatically organize assets into folders by class type:
+
+```python
+organize_assets_by_type("/Game/Input", dry_run=True)  # Preview what will happen
+organize_assets_by_type("/Game/Input")  # Actually move assets
+```
+
+Moves Input Actions to `/Actions/`, Contexts to `/Contexts/`, etc. Supports custom organization rules and dry-run mode.
+
+### Organize World Outliner
+
+Organize actors in World Outliner into folder hierarchy:
+
+```python
+organize_world_outliner()  # Auto-organize all actors by type
+```
+
+Places Lights in `/Environment/Lighting/`, Static Meshes in `/Props/Static/`, PlayerStart in `/Gameplay/Spawn/`, etc.
+
+### Tag Assets
+
+Add metadata tags to assets for search and filtering:
+
+```python
+tag_assets('["/Game/Input/IA_Jump"]', '["Movement", "Character"]')
+tag_assets('["/Game/Input/IA_FPS_Fire"]', '[]', auto_tag=True)  # Auto-generate tags
+```
+
+Auto-tag analyzes asset names and types to suggest relevant tags (FPS, Combat, Movement, etc.).
+
+### Search by Tags
+
+Find assets with specific tags:
+
+```python
+search_assets_by_tag("/Game/Input", '["Combat"]')  # Find assets with Combat tag
+search_assets_by_tag("/Game", '["FPS", "Combat"]', match_all=True)  # Must have BOTH tags
+```
+
+### Organization Report
+
+Generate comprehensive organization statistics:
+
+```python
+generate_organization_report()  # Full report of /Game
+generate_organization_report('["/Game/Blueprints"]', include_world_outliner=False)  # Specific folder
+```
+
+Returns asset counts by type, folder statistics, and World Outliner organization percentage.
+
+**Example Workflow - New Project Setup**:
+```python
+# 1. Create folder structure
+create_folder_structure("/Game/FPSGame", '{"Blueprints": ["Characters", "Weapons"], "Materials": [], "Input": ["Actions", "Contexts"]}')
+
+# 2. Organize existing assets
+organize_assets_by_type("/Game/Content", "/Game/FPSGame")
+
+# 3. Organize World Outliner
+organize_world_outliner()
+
+# 4. Tag important assets
+tag_assets('["/Game/Input/IA_Fire", "/Game/Input/IA_Reload"]', '["Combat", "FPS"]')
+
+# 5. Generate report
+generate_organization_report(["/Game/FPSGame"])
+```
+
+## Physics & Selection Commands
+
+Quick commands for working with selected actors and enabling physics simulation. All functions tested in UE 5.6.1.
+
+### Get Selected Actors
+
+Check what actors are currently selected in the viewport:
+
+```python
+get_selected_actors()
+```
+
+Returns JSON with actor names, classes, locations, and physics status. Useful before performing operations to verify selection.
+
+**Response includes**:
+- `name`: Actor name (e.g., "SM_Chair_1", "Cube_632")
+- `class`: Actor class (e.g., "StaticMeshActor", "Blueprint")
+- `location`: X/Y/Z coordinates
+- `has_static_mesh`: Whether it has a static mesh component
+- `physics_enabled`: Current physics simulation state
+
+### Enable Physics on Selected
+
+Enable physics on all selected actors in one command:
+
+```python
+enable_physics_on_selected()  # Default: collision enabled, calculated mass
+enable_physics_on_selected(mass_override=100.0)  # Custom mass in kg
+enable_physics_on_selected(enable_collision=False)  # No collision
+```
+
+**What it does**:
+1. Sets mobility to Movable
+2. Enables physics simulation
+3. Sets collision to QUERY_AND_PHYSICS (if `enable_collision=True`)
+4. Optionally overrides mass
+
+Perfect for quick physics testing. Select objects in viewport, run command, press Simulate.
+
+### Enable Physics on Actor
+
+Enable physics on specific actor by name (no selection needed):
+
+```python
+enable_physics_on_actor("SM_Chair_1")
+enable_physics_on_actor("Barrel_2", mass_override=50.0)
+enable_physics_on_actor("Crate_1", enable_collision=False)
+```
+
+Useful for scripted physics setup where you know actor names. Same settings as `enable_physics_on_selected` but targets named actors.
+
+**Example Workflows**:
+
+**Quick Testing**:
+```python
+# Select object in viewport, make it physics-enabled
+get_selected_actors()  # Verify selection
+enable_physics_on_selected()  # Enable physics
+# Press Simulate (Alt+S) to test
+```
+
+**Batch Setup**:
+```python
+# Enable physics on multiple props at once
+# Select all props in viewport, then:
+enable_physics_on_selected()
+```
+
+**Scripted Setup**:
+```python
+# Set up physics objects without selection
+enable_physics_on_actor("Barrel_1")
+enable_physics_on_actor("Barrel_2")
+enable_physics_on_actor("Crate_1", mass_override=25.0)  # Light crate
+enable_physics_on_actor("Boulder_1", mass_override=500.0)  # Heavy boulder
+```
+
+**With Organization**:
+```python
+# Organize physics props, then enable physics
+organize_world_outliner({"StaticMeshActor": "/Physics/Props"})
+enable_physics_on_actor("PhysicsBarrel_1")
+tag_assets(["/Game/Props/Barrel"], ["Physics", "Destructible"])
+```
+
+**Common Issues**:
+- **"No StaticMeshComponent found"**: Actor doesn't have mesh (e.g., empty actor, light, camera)
+- **Actor falls through floor**: Ensure floor has collision enabled (BlockAll)
+- **Physics doesn't work**: Check mobility is Movable, collision enabled, not attached/constrained
+
+
+
+*(Additional quirks will be added as discovered.)*

UMCP.it-Unreal-Organizer-Assistant/Content/Python/mcp_server.py

@@ -0,0 +1,1911 @@
+import socket
+import json
+import sys
+import os
+from mcp.server.fastmcp import FastMCP
+import re
+import mss
+import base64
+import tempfile # For creating a secure temporary file
+from io import BytesIO
+from pathlib import Path
+from mcp.server.fastmcp import FastMCP, Image
+
+
+# THIS FILE WILL RUN OUTSIDE THE UNREAL ENGINE SCOPE, 
+# DO NOT IMPORT UNREAL MODULES HERE OR EXECUTE IT IN THE UNREAL ENGINE PYTHON INTERPRETER
+
+# 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}\n9877")  # 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")
+
+
+# Function to send a message to Unreal Engine via socket
+def send_to_unreal(command):
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        try:
+            s.connect(('localhost', 9877))  # Unreal listens on port 9877
+
+            # Ensure proper JSON encoding
+            json_str = json.dumps(command)
+            s.sendall(json_str.encode('utf-8'))
+
+            # Implement robust response handling
+            buffer_size = 8192  # Increased buffer size
+            response_data = b""
+
+            # Keep receiving data until we have complete JSON
+            while True:
+                chunk = s.recv(buffer_size)
+                if not chunk:
+                    break
+
+                response_data += chunk
+
+                # Check if we have complete JSON
+                try:
+                    json.loads(response_data.decode('utf-8'))
+                    # If we get here, we have valid JSON
+                    break
+                except json.JSONDecodeError:
+                    # Need more data, continue receiving
+                    continue
+
+            # Parse the complete response
+            if response_data:
+                return json.loads(response_data.decode('utf-8'))
+            else:
+                return {"success": False, "error": "No response received"}
+
+        except Exception as e:
+            print(f"Error sending to Unreal: {e}", file=sys.stderr)
+            return {"success": False, "error": str(e)}
+
+
+@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."
+
+
+@mcp.tool()
+def ue5_naming_conventions() -> str:
+    """Get UE5 naming conventions and style guide. Use this to validate asset names, suggest proper prefixes, and ensure consistency with Unreal Engine 5 best practices. Essential for proper Input Action (IA_), Mapping Context (IMC_), Blueprint (BP_), Widget (WBP_), and all other asset naming."""
+    try:
+        current_dir = Path(__file__).parent
+        md_file_path = current_dir / "knowledge_base" / "ue5_naming_conventions.md"
+
+        if not md_file_path.exists():
+            return "Error: ue5_naming_conventions.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 ue5_naming_conventions.md: {str(e)}"
+
+
+@mcp.tool()
+def validate_ue5_asset_name(asset_name: str, asset_type: str) -> str:
+    """
+    Validate an asset name against UE5 naming conventions and provide suggestions.
+
+    Args:
+        asset_name: The asset name to validate (e.g., "jump action", "BP_Player", "IA_Fire")
+        asset_type: Type of asset - one of: "input_action", "mapping_context", "blueprint",
+                    "widget", "material", "texture", "static_mesh", "skeletal_mesh",
+                    "animation", "sound", "particle", "game_mode", "data_table"
+
+    Returns:
+        JSON string with validation results and suggestions
+    """
+    # Asset type to prefix mapping
+    prefix_map = {
+        "input_action": "IA_",
+        "mapping_context": "IMC_",
+        "blueprint": "BP_",
+        "widget": "WBP_",
+        "material": "M_",
+        "material_instance": "MI_",
+        "texture": "T_",
+        "static_mesh": "SM_",
+        "skeletal_mesh": "SK_",
+        "animation": "AS_",
+        "animation_blueprint": "ABP_",
+        "sound": "A_",
+        "particle": "NS_",
+        "game_mode": "GM_",
+        "data_table": "DT_",
+        "blueprint_interface": "BPI_",
+        "data_asset": "DA_"
+    }
+
+    expected_prefix = prefix_map.get(asset_type, "")
+
+    validation_result = {
+        "is_valid": True,
+        "issues": [],
+        "suggestions": [],
+        "corrected_name": asset_name
+    }
+
+    # Check for spaces
+    if " " in asset_name:
+        validation_result["is_valid"] = False
+        validation_result["issues"].append("Asset name contains spaces")
+        corrected = asset_name.replace(" ", "")
+        # Convert to PascalCase
+        words = asset_name.split()
+        corrected = "".join(word.capitalize() for word in words)
+        validation_result["suggestions"].append(f"Remove spaces and use PascalCase: {corrected}")
+        validation_result["corrected_name"] = corrected
+        asset_name = corrected
+
+    # Check for lowercase start (should be PascalCase)
+    if asset_name and asset_name[0].islower():
+        validation_result["is_valid"] = False
+        validation_result["issues"].append("Asset name should start with uppercase (PascalCase)")
+        corrected = asset_name[0].upper() + asset_name[1:]
+        validation_result["suggestions"].append(f"Use PascalCase: {corrected}")
+        validation_result["corrected_name"] = corrected
+        asset_name = corrected
+
+    # Check for correct prefix
+    if expected_prefix:
+        if not asset_name.startswith(expected_prefix):
+            validation_result["is_valid"] = False
+            validation_result["issues"].append(f"Missing expected prefix '{expected_prefix}' for {asset_type}")
+
+            # If it has a different prefix, replace it; otherwise add it
+            has_other_prefix = False
+            for prefix in prefix_map.values():
+                if asset_name.startswith(prefix):
+                    # Replace wrong prefix
+                    corrected = expected_prefix + asset_name[len(prefix):]
+                    has_other_prefix = True
+                    break
+
+            if not has_other_prefix:
+                corrected = expected_prefix + asset_name
+
+            validation_result["suggestions"].append(f"Add proper prefix: {corrected}")
+            validation_result["corrected_name"] = corrected
+
+    # Check for camelCase (should be PascalCase with underscores)
+    if asset_name and any(c.islower() and prev.isupper() for prev, c in zip(asset_name, asset_name[1:])):
+        validation_result["issues"].append("Avoid camelCase - use PascalCase with underscores between parts")
+
+    return json.dumps(validation_result, indent=2)
+
+
+# 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: list = [0, 0, 0], rotation: list = [0, 0, 0],
+                 scale: list = [1, 1, 1], actor_label: 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
+    """
+    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 (float, int, bool), objects (e.g., materials), and vectors/rotators (e.g., "100,200,300" for FVector).
+        - 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) -> 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
+    """
+    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 take_editor_screenshot(width: int = 1280, height: int = 720, quality: int = 70) -> Image:
+    """
+    Takes a screenshot of the primary monitor with compression to stay under MCP size limits.
+
+    Args:
+        width: Target width in pixels (default: 1280)
+        height: Target height in pixels (default: 720)
+        quality: JPEG quality 1-100 (default: 70, higher = larger file)
+
+    Returns:
+        Compressed screenshot image
+
+    Presets:
+        - Thumbnail: width=640, height=360, quality=60 (~50KB)
+        - Preview: width=1280, height=720, quality=70 (~200KB) [DEFAULT]
+        - Standard: width=1920, height=1080, quality=80 (~500KB)
+    """
+    temp_png_path = ""
+    temp_jpg_path = ""
+    try:
+        # 1. Capture raw screenshot to temporary PNG
+        with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as fp:
+            temp_png_path = fp.name
+
+        with mss.mss() as sct:
+            sct.shot(mon=1, output=temp_png_path)
+
+        # 2. Open with PIL and resize/compress
+        try:
+            from PIL import Image as PILImage
+        except ImportError:
+            # Fallback: Return original if PIL not available
+            print("Warning: PIL not available, returning uncompressed screenshot")
+            with open(temp_png_path, "rb") as image_file:
+                image_bytes = image_file.read()
+            return Image(data=image_bytes, format="png")
+
+        # Open and resize
+        img = PILImage.open(temp_png_path)
+
+        # Calculate aspect-preserving resize
+        original_width, original_height = img.size
+        aspect_ratio = original_width / original_height
+        target_aspect = width / height
+
+        if aspect_ratio > target_aspect:
+            # Original is wider - fit to width
+            new_width = width
+            new_height = int(width / aspect_ratio)
+        else:
+            # Original is taller - fit to height
+            new_height = height
+            new_width = int(height * aspect_ratio)
+
+        # Resize with high-quality resampling
+        img_resized = img.resize((new_width, new_height), PILImage.Resampling.LANCZOS)
+
+        # Convert to RGB if needed (JPEG doesn't support transparency)
+        if img_resized.mode in ('RGBA', 'LA', 'P'):
+            background = PILImage.new('RGB', img_resized.size, (255, 255, 255))
+            if img_resized.mode == 'P':
+                img_resized = img_resized.convert('RGBA')
+            background.paste(img_resized, mask=img_resized.split()[-1] if img_resized.mode in ('RGBA', 'LA') else None)
+            img_resized = background
+        elif img_resized.mode != 'RGB':
+            img_resized = img_resized.convert('RGB')
+
+        # Save as JPEG with specified quality
+        with tempfile.NamedTemporaryFile(suffix=".jpg", delete=False) as fp:
+            temp_jpg_path = fp.name
+
+        img_resized.save(temp_jpg_path, 'JPEG', quality=quality, optimize=True)
+
+        # Read compressed image
+        with open(temp_jpg_path, "rb") as image_file:
+            image_bytes = image_file.read()
+
+        # Log size for debugging
+        size_kb = len(image_bytes) / 1024
+        print(f"Screenshot captured: {new_width}x{new_height}, {size_kb:.1f}KB, quality={quality}")
+
+        return Image(
+            data=image_bytes,
+            format="jpeg"
+        )
+
+    except Exception as e:
+        error_message = f"Screenshot compression failed: {str(e)}"
+        print(error_message, file=sys.stderr)
+        return error_message
+
+    finally:
+        # Clean up temporary files
+        for path in [temp_png_path, temp_jpg_path]:
+            if path and os.path.exists(path):
+                try:
+                    os.remove(path)
+                except:
+                    pass
+
+
+@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., "float", "vector", "boolean")
+        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: list = None, outputs: list = None) -> str:
+    """
+    Add a function to a Blueprint
+    
+    Args:
+        blueprint_path: Path to the Blueprint asset
+        function_name: Name for the new function
+        inputs: List of input parameters [{"name": "param1", "type": "float"}, ...]
+        outputs: List of output parameters [{"name": "return", "type": "boolean"}, ...]
+        
+    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: list = [0, 0], node_properties: dict = None) -> str:
+    """
+    Add a node to a Blueprint graph
+    
+    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. Common supported types include:
+            - Basic nodes: "ReturnNode", "FunctionEntry", "Branch", "Sequence"
+            - Math operations: "Multiply", "Add", "Subtract", "Divide"
+            - Utilities: "PrintString", "Delay", "GetActorLocation", "SetActorLocation"
+            - For other functions, try using the exact function name from Blueprints
+              (e.g., "GetWorldLocation", "SpawnActorFromClass")
+            If the requested node type isn't found, the system will search for alternatives
+            and return suggestions. You can then use these suggestions in a new request.
+        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)
+        On failure: A response containing "SUGGESTIONS:" followed by alternative node types to try
+    
+    Note:
+        Function libraries like KismetMathLibrary, KismetSystemLibrary, and KismetStringLibrary 
+        contain most common Blueprint functions. If a simple node name doesn't work, try the 
+        full function name, e.g., "Multiply_FloatFloat" instead of just "Multiply".
+    """
+    if node_properties is None:
+        node_properties = {}
+
+    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"):
+        return f"Successfully added {node_type} node to function {function_id} in Blueprint at {blueprint_path} with ID: {response.get('node_id', 'unknown')}"
+    else:
+        return f"Failed to add node: {response.get('error', 'Unknown error')}"
+
+
+@mcp.tool()
+def get_node_suggestions(node_type: str) -> str:
+    """
+    Get suggestions for a node type in Unreal Blueprints
+    
+    Args:
+        node_type: The partial or full node type to get suggestions for (e.g., "Add", "FloatToDouble")
+        
+    Returns:
+        A string indicating success with suggestions or an error message
+    """
+    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"Suggestions for '{node_type}': {', '.join(suggestions)}"
+        else:
+            return f"No suggestions found for '{node_type}'"
+    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 json.dumps(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: list = [0, 0, 0],
+                          rotation: list = [0, 0, 0], scale: list = [1, 1, 1],
+                          actor_label: 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
+    """
+    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_nodes_to_blueprint_bulk(blueprint_path: str, function_id: str, nodes: list) -> str:
+#     """
+#     Add multiple nodes to a Blueprint graph in a single operation
+# 
+#     Args:
+#         blueprint_path: Path to the Blueprint asset
+#         function_id: ID of the function to add the nodes to
+#         nodes: Array of node definitions, each containing:
+#             - id: ID for referencing the node (string) - this is important for creating connections later
+#             - node_type: Type of node to add (see add_node_to_blueprint for supported types)
+#             - node_position: Position of the node in the graph [X, Y]
+#             - node_properties: Properties to set on the node (optional)
+# 
+#     Returns:
+#         On success: Dictionary mapping your node IDs to the actual node GUIDs created in Unreal
+#         On partial success: Dictionary with successful nodes and suggestions for failed nodes
+#         On failure: Error message with suggestions
+# 
+#     Example success response:
+#         {
+#           "success": true,
+#           "nodes": {
+#             "function_entry": "425E7A3949D7420A461175A4733BBA5C",
+#             "multiply_node": "70354A7E444BB68EEF31718DC50CF89C",
+#             "return_node": "6436796645ED674F3C64A8A94CBA416C"
+#           }
+#         }
+# 
+#     Example partial success with suggestions:
+#         {
+#           "success": true,
+#           "partial_success": true,
+#           "nodes": {
+#             "function_entry": "425E7A3949D7420A461175A4733BBA5C",
+#             "return_node": "6436796645ED674F3C64A8A94CBA416C"
+#           },
+#           "suggestions": {
+#             "multiply_node": {
+#               "requested_type": "Multiply_Float",
+#               "suggestions": ["KismetMathLibrary.Multiply_FloatFloat", "KismetMathLibrary.MultiplyByFloat"]
+#             }
+#           }
+#         }
+# 
+#     When you receive suggestions, you can retry adding those nodes using the suggested node types.
+#     """
+#     command = {
+#         "type": "add_nodes_bulk",
+#         "blueprint_path": blueprint_path,
+#         "function_id": function_id,
+#         "nodes": nodes
+#     }
+# 
+#     response = send_to_unreal(command)
+#     if response.get("success"):
+#         node_mapping = response.get("nodes", {})
+#         return f"Successfully added {len(node_mapping)} nodes to function {function_id} in Blueprint at {blueprint_path}\nNode mapping: {json.dumps(node_mapping, indent=2)}"
+#     else:
+#         return f"Failed to add nodes: {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 = send_to_unreal(command)
+    if response.get("success"):
+        msg = response.get("message", f"Added component {component_name}")
+        # Include event GUIDs in response if available
+        if "begin_overlap_guid" in response and "end_overlap_guid" in response:
+            msg += f"\nOverlap Events - Begin GUID: {response['begin_overlap_guid']}, End GUID: {response['end_overlap_guid']}"
+        return msg
+    return f"Failed: {response.get('error', 'Unknown error')}"
+
+
+@mcp.tool()
+def connect_blueprint_nodes_bulk(blueprint_path: str, function_id: str, connections: list) -> 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
+    """
+    command = {
+        "type": "connect_nodes_bulk",
+        "blueprint_path": blueprint_path,
+        "function_id": function_id,
+        "connections": connections
+    }
+
+    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 = []
+
+        # Look for detailed results in the response
+        if "results" in response:
+            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}")
+
+        # Format error message with details
+        if failed_connections:
+            detailed_errors = "\n- " + "\n- ".join(failed_connections)
+            return f"Failed to connect nodes: {error_message}{detailed_errors}"
+        else:
+            return f"Failed to connect nodes: {error_message}"
+
+
+@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')}"
+
+
+# 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
+
+
+# Scene Control
+@mcp.tool()
+def get_all_scene_objects() -> str:
+    """
+    Retrieve all actors in the current Unreal Engine level, categorized by type.
+
+    Returns a comprehensive scene summary including:
+    - Total actor count
+    - Actors organized by class type (LandscapeStreamingProxy, WorldPartitionHLOD, etc.)
+    - Example actor names and locations for each category
+    - Sorted by most common actor types first
+
+    This is perfect for understanding what's in your level and finding specific actors.
+
+    Returns:
+        JSON with categorized actors, summary text, and total count
+    """
+    command = {"type": "get_all_scene_objects"}
+    response = send_to_unreal(command)
+
+    if response.get("success"):
+        # Return the formatted summary for easy reading
+        return response.get("summary", json.dumps(response))
+    else:
+        return f"Failed: {response.get('error', 'Unknown error')}"
+
+
+# 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")
+    """
+    command = {
+        "type": "create_game_mode",
+        "game_mode_path": game_mode_path,
+        "pawn_blueprint_path": pawn_blueprint_path,
+        "base_class": base_class
+    }
+    response = send_to_unreal(command)
+    if response.get("success"):
+        return response.get("message", f"Created game mode at {game_mode_path}")
+    else:
+        return f"Failed: {response.get('error', 'Unknown error')}"
+
+
+@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
+    }
+    # send_to_unreal already returns a dict
+    response = send_to_unreal(command)
+    # Return a user-friendly string summary
+    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}'.")
+    else:
+        return f"Failed to add widget: {response.get('error', 'Unknown error')}"
+
+
+@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"). 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'"
+            - 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_str = send_to_unreal(command)
+    try:
+        response_dict = json.loads(response_str)
+        # Return a user-friendly string summary
+        if response_dict.get("success"):
+            return response_dict.get("message",
+                                     f"Successfully set property '{property_name}' on widget '{widget_name}'.")
+        else:
+            return f"Failed to edit widget property: {response_dict.get('error', 'Unknown C++ error')}"
+    except json.JSONDecodeError:
+        return f"Failed to parse response from Unreal: {response_str}"
+    except Exception as e:
+        # Catch potential errors if send_to_unreal itself failed before returning JSON
+        if isinstance(response_str, dict) and not response_str.get("success"):
+            return f"Failed to send command: {response_str.get('error', 'Unknown MCP error')}"
+        return f"An unexpected error occurred: {str(e)} Response: {response_str}"
+
+
+# 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)
+    return json.dumps(response) if not response.get("success") else response.get("message", "Success")
+
+@mcp.tool()
+def create_enhanced_input_action(action_name: str, action_path: str = "/Game/Input", value_type: str = "BOOLEAN") -> str:
+    """
+    Create an Enhanced Input Action asset (UE 5.6+).
+
+    Args:
+        action_name: Name of the action (e.g., "IA_Jump")
+        action_path: Path to save the asset (default: "/Game/Input")
+        value_type: "BOOLEAN", "AXIS_1D", "AXIS_2D", or "AXIS_3D" (default: "BOOLEAN")
+
+    Returns:
+        Message indicating success with asset path or error details
+    """
+    command = {
+        "type": "create_enhanced_input_action",
+        "action_name": action_name,
+        "action_path": action_path,
+        "value_type": value_type
+    }
+    response = send_to_unreal(command)
+    if response.get("success"):
+        return f"Created Input Action '{action_name}' at {response.get('asset_path')}"
+    return json.dumps(response)
+
+@mcp.tool()
+def create_enhanced_input_mapping_context(context_name: str, context_path: str = "/Game/Input") -> str:
+    """
+    Create an Enhanced Input Mapping Context asset (UE 5.6+).
+
+    Args:
+        context_name: Name of the mapping context (e.g., "IMC_Default")
+        context_path: Path to save the asset (default: "/Game/Input")
+
+    Returns:
+        Message indicating success with asset path or error details
+    """
+    command = {
+        "type": "create_enhanced_input_mapping_context",
+        "context_name": context_name,
+        "context_path": context_path
+    }
+    response = send_to_unreal(command)
+    if response.get("success"):
+        return f"Created Mapping Context '{context_name}' at {response.get('asset_path')}\n{response.get('next_step', '')}"
+    return json.dumps(response)
+
+
+# --- ORGANIZATION TOOLS ---
+
+@mcp.tool()
+def create_folder_structure(base_path: str = "/Game", folder_structure: str = "{}") -> str:
+    """
+    Create a folder hierarchy in Content Browser.
+
+    Args:
+        base_path: Base path for folder creation (default: "/Game")
+        folder_structure: JSON string - dict or list defining folder hierarchy
+            Examples:
+            - List: '["Blueprints", "Materials", "Meshes"]'
+            - Dict: '{"Blueprints": ["Characters", "Weapons"], "Materials": []}'
+
+    Returns:
+        JSON with created folders and status
+
+    Example:
+        create_folder_structure("/Game/MyProject", '{"Blueprints": ["Characters", "Weapons"], "Input": ["Actions", "Contexts"]}')
+    """
+    try:
+        folder_struct = json.loads(folder_structure) if folder_structure else None
+    except json.JSONDecodeError:
+        return json.dumps({"success": False, "error": "Invalid JSON in folder_structure parameter"})
+
+    command = {
+        "type": "create_folder_structure",
+        "base_path": base_path,
+        "folder_structure": folder_struct
+    }
+    response = send_to_unreal(command)
+    return json.dumps(response, indent=2)
+
+
+@mcp.tool()
+def organize_assets_by_type(source_folder: str, target_base: str = "", organization_rules: str = "{}", dry_run: bool = False) -> str:
+    """
+    Automatically organize assets into folders by type.
+
+    Args:
+        source_folder: Folder to scan for assets (e.g., "/Game/Input")
+        target_base: Base path for organized folders (default: source + "_Organized")
+        organization_rules: JSON string - custom rules {"ClassName": "target/path"} (optional)
+        dry_run: If true, don't move assets, just report what would happen (default: false)
+
+    Returns:
+        JSON with organization results
+
+    Example:
+        organize_assets_by_type("/Game/Input", dry_run=True)
+        organize_assets_by_type("/Game/MyAssets", "/Game/Organized")
+    """
+    try:
+        rules = json.loads(organization_rules) if organization_rules else None
+    except json.JSONDecodeError:
+        return json.dumps({"success": False, "error": "Invalid JSON in organization_rules parameter"})
+
+    command = {
+        "type": "organize_assets_by_type",
+        "source_folder": source_folder,
+        "target_base": target_base if target_base else None,
+        "organization_rules": rules,
+        "dry_run": dry_run
+    }
+    response = send_to_unreal(command)
+    return json.dumps(response, indent=2)
+
+
+@mcp.tool()
+def organize_world_outliner(organization_rules: str = "{}", target_actors: str = "[]") -> str:
+    """
+    Organize actors in World Outliner into folder hierarchy.
+
+    Args:
+        organization_rules: JSON string - dict mapping actor classes to folder paths (optional)
+            Example: '{"Light": "/Environment/Lighting", "StaticMesh": "/Props/Static"}'
+        target_actors: JSON string - list of specific actor names to organize (optional)
+            Example: '["Cube_1", "Sphere_2"]'
+
+    Returns:
+        JSON with organization results
+
+    Example:
+        organize_world_outliner()  # Auto-organize all actors
+        organize_world_outliner(target_actors='["Cube_1", "Sphere_2"]')
+    """
+    try:
+        rules = json.loads(organization_rules) if organization_rules else None
+        actors = json.loads(target_actors) if target_actors else None
+    except json.JSONDecodeError:
+        return json.dumps({"success": False, "error": "Invalid JSON in parameters"})
+
+    command = {
+        "type": "organize_world_outliner",
+        "organization_rules": rules,
+        "target_actors": actors
+    }
+    response = send_to_unreal(command)
+    return json.dumps(response, indent=2)
+
+
+@mcp.tool()
+def tag_assets(asset_paths: str, tags: str, auto_tag: bool = False) -> str:
+    """
+    Add metadata tags to assets for organization and search.
+
+    Args:
+        asset_paths: JSON string - list of asset paths to tag
+            Example: '["/Game/Input/IA_Jump", "/Game/Input/IA_Fire"]'
+        tags: JSON string - list of tag strings to apply
+            Example: '["Movement", "Character"]'
+        auto_tag: If true, automatically generate tags based on asset name/type (default: false)
+
+    Returns:
+        JSON with tagging results
+
+    Example:
+        tag_assets('["/Game/Input/IA_Jump"]', '["Movement", "Character"]')
+        tag_assets('["/Game/Input/IA_FPS_Fire"]', '[]', auto_tag=True)  # Auto-generates tags
+    """
+    try:
+        paths = json.loads(asset_paths)
+        tag_list = json.loads(tags)
+    except json.JSONDecodeError:
+        return json.dumps({"success": False, "error": "Invalid JSON in parameters"})
+
+    command = {
+        "type": "tag_assets",
+        "asset_paths": paths,
+        "tags": tag_list,
+        "auto_tag": auto_tag
+    }
+    response = send_to_unreal(command)
+    return json.dumps(response, indent=2)
+
+
+@mcp.tool()
+def search_assets_by_tag(folder_path: str, tags: str, match_all: bool = False) -> str:
+    """
+    Search for assets with specific metadata tags.
+
+    Args:
+        folder_path: Folder to search in (e.g., "/Game/Input")
+        tags: JSON string - list of tags to search for
+            Example: '["Combat", "Movement"]'
+        match_all: If true, asset must have ALL tags. If false, ANY tag matches (default: false)
+
+    Returns:
+        JSON with search results
+
+    Example:
+        search_assets_by_tag("/Game/Input", '["Combat"]')
+        search_assets_by_tag("/Game", '["FPS", "Combat"]', match_all=True)
+    """
+    try:
+        tag_list = json.loads(tags)
+    except json.JSONDecodeError:
+        return json.dumps({"success": False, "error": "Invalid JSON in tags parameter"})
+
+    command = {
+        "type": "search_assets_by_tag",
+        "folder_path": folder_path,
+        "tags": tag_list,
+        "match_all": match_all
+    }
+    response = send_to_unreal(command)
+    return json.dumps(response, indent=2)
+
+
+@mcp.tool()
+def generate_organization_report(content_browser_paths: str = "[]", include_world_outliner: bool = True) -> str:
+    """
+    Generate a comprehensive organization report.
+
+    Args:
+        content_browser_paths: JSON string - list of paths to analyze (default: ["/Game"])
+            Example: '["/Game/Blueprints", "/Game/Materials"]'
+        include_world_outliner: Include World Outliner statistics (default: true)
+
+    Returns:
+        JSON with comprehensive organization report including asset counts, types, and folder statistics
+
+    Example:
+        generate_organization_report()  # Full report
+        generate_organization_report('["/Game/Blueprints"]', include_world_outliner=False)
+    """
+    try:
+        paths = json.loads(content_browser_paths) if content_browser_paths else None
+    except json.JSONDecodeError:
+        return json.dumps({"success": False, "error": "Invalid JSON in content_browser_paths parameter"})
+
+    command = {
+        "type": "generate_organization_report",
+        "content_browser_paths": paths,
+        "include_world_outliner": include_world_outliner
+    }
+    response = send_to_unreal(command)
+    return json.dumps(response, indent=2)
+
+
+@mcp.tool()
+def get_component_names(blueprint_path: str = "", actor_name: str = "", is_scene_actor: bool = False) -> str:
+    """
+    Get all component names for a Blueprint or scene actor.
+    Helps discover correct component names before editing.
+
+    Args:
+        blueprint_path: Path to Blueprint (e.g., "/Game/BP_Player") - for Blueprints
+        actor_name: Name of actor in scene (e.g., "Cube_1") - for scene actors
+        is_scene_actor: Set to true if targeting a scene actor (default: false)
+
+    Returns:
+        JSON list of components with their names and classes
+
+    Example:
+        get_component_names(actor_name="Cube_1", is_scene_actor=True)
+        get_component_names(blueprint_path="/Game/BP_Player")
+    """
+    command = {
+        "type": "get_component_names",
+        "blueprint_path": blueprint_path,
+        "actor_name": actor_name,
+        "is_scene_actor": is_scene_actor
+    }
+    response = send_to_unreal(command)
+    if response.get("success"):
+        return json.dumps(response.get("components", []), indent=2)
+    return json.dumps(response)
+
+@mcp.tool()
+def get_node_pin_names(blueprint_path: str, function_id: str, node_id: str) -> str:
+    """
+    Get all pin names for a specific Blueprint node.
+    Helps with connecting nodes correctly.
+
+    Args:
+        blueprint_path: Path to the Blueprint
+        function_id: GUID of the function graph
+        node_id: GUID of the node
+
+    Returns:
+        JSON with input and output pin names and types
+
+    Example:
+        After adding a node, use its returned GUID to get pin names:
+        get_node_pin_names("/Game/BP_Test", "FUNC_GUID", "NODE_GUID")
+    """
+    command = {
+        "type": "get_node_pin_names",
+        "blueprint_path": blueprint_path,
+        "function_id": function_id,
+        "node_id": node_id
+    }
+    response = send_to_unreal(command)
+    if response.get("success"):
+        result = {
+            "node_type": response.get("node_type"),
+            "input_pins": response.get("input_pins", []),
+            "output_pins": response.get("output_pins", [])
+        }
+        return json.dumps(result, indent=2)
+    return json.dumps(response)
+
+
+# ===== PHYSICS & SELECTION COMMANDS =====
+
+@mcp.tool()
+def get_selected_actors() -> str:
+    """
+    Get all currently selected actors in the Unreal Editor viewport.
+
+    Returns actor names, classes, locations, and physics status for each selected actor.
+    Useful for checking what's selected before performing operations.
+
+    Returns:
+        JSON with list of selected actors and their details
+
+    Example:
+        # See what actors are currently selected
+        get_selected_actors()
+
+        # Response includes: name, class, location, has_static_mesh, physics_enabled
+    """
+    command = {
+        "type": "get_selected_actors"
+    }
+    response = send_to_unreal(command)
+    return json.dumps(response, indent=2)
+
+
+@mcp.tool()
+def enable_physics_on_selected(enable_collision: bool = True, mass_override: float = None) -> str:
+    """
+    Enable physics simulation on all currently selected actors in the viewport.
+
+    This command:
+    1. Sets mobility to Movable
+    2. Enables physics simulation
+    3. Sets collision to QUERY_AND_PHYSICS (if enable_collision=True)
+    4. Optionally overrides mass
+
+    Perfect for quickly making objects physics-enabled for testing or gameplay.
+
+    Args:
+        enable_collision: Enable collision for physics (default: True)
+        mass_override: Override mass in kg (optional, default uses calculated mass)
+
+    Returns:
+        JSON with results for each processed actor
+
+    Examples:
+        # Enable physics on selected actors with default settings
+        enable_physics_on_selected()
+
+        # Enable physics with custom mass (100 kg)
+        enable_physics_on_selected(mass_override=100.0)
+
+        # Enable physics without collision
+        enable_physics_on_selected(enable_collision=False)
+    """
+    command = {
+        "type": "enable_physics_on_selected",
+        "enable_collision": enable_collision
+    }
+
+    # Only add mass_override if it's not None
+    if mass_override is not None:
+        command["mass_override"] = mass_override
+
+    response = send_to_unreal(command)
+    return json.dumps(response, indent=2)
+
+
+@mcp.tool()
+def enable_physics_on_actor(actor_name: str, enable_collision: bool = True, mass_override: float = None) -> str:
+    """
+    Enable physics simulation on a specific actor by name (no selection required).
+
+    Useful for scripted physics setup where you know the actor name.
+    Same physics settings as enable_physics_on_selected but targets a named actor.
+
+    Args:
+        actor_name: Name of the actor (e.g., "SM_Stairs_632", "Cube_1", "PhysicsBox_3")
+        enable_collision: Enable collision for physics (default: True)
+        mass_override: Override mass in kg (optional, default uses calculated mass)
+
+    Returns:
+        JSON with results for the actor
+
+    Examples:
+        # Enable physics on specific actor
+        enable_physics_on_actor("SM_Chair_1")
+
+        # Enable physics with custom mass (50 kg)
+        enable_physics_on_actor("Barrel_2", mass_override=50.0)
+
+        # Enable physics on multiple actors (call multiple times)
+        enable_physics_on_actor("Crate_1")
+        enable_physics_on_actor("Crate_2")
+        enable_physics_on_actor("Barrel_1")
+    """
+    command = {
+        "type": "enable_physics_on_actor",
+        "actor_name": actor_name,
+        "enable_collision": enable_collision
+    }
+
+    # Only add mass_override if it's not None
+    if mass_override is not None:
+        command["mass_override"] = mass_override
+
+    response = send_to_unreal(command)
+    return json.dumps(response, indent=2)
+
+
+# ===== BLUEPRINT CONNECTION COMMANDS =====
+
+@mcp.tool()
+def get_blueprint_node_pins(blueprint_path: str, function_id: str, node_id: str, use_cache: bool = True) -> str:
+    """
+    Get all pins for a Blueprint node - discover what pins are available before connecting.
+
+    This tool reveals all input and output pins for a specific node, including their types,
+    default values, and connection status. Essential for correct node connections.
+
+    Args:
+        blueprint_path: Path to the Blueprint (e.g., "/Game/Blueprints/BP_Test")
+        function_id: GUID of the function graph
+        node_id: GUID of the node
+        use_cache: Use cached results for performance (default: True)
+
+    Returns:
+        JSON with node_info, input_pins, and output_pins
+
+    Example:
+        # After adding a node, discover its pins
+        get_blueprint_node_pins("/Game/BP_Test", "FUNC_GUID", "NODE_GUID")
+
+        # Returns pin names like "ReturnValue", "A", "B" with types
+    """
+    command = {
+        "type": "get_node_pins",
+        "blueprint_path": blueprint_path,
+        "function_id": function_id,
+        "node_id": node_id,
+        "use_cache": use_cache
+    }
+    response = send_to_unreal(command)
+    return json.dumps(response, indent=2)
+
+
+@mcp.tool()
+def validate_blueprint_connection(blueprint_path: str, function_id: str,
+                                  source_node_id: str, source_pin_name: str,
+                                  target_node_id: str, target_pin_name: str) -> str:
+    """
+    Validate a Blueprint node connection before making it - prevents connection errors.
+
+    This tool checks if a connection is valid (type compatibility, pin existence, etc.)
+    BEFORE you try to connect. It returns helpful error messages and suggestions if invalid.
+
+    Args:
+        blueprint_path: Path to the Blueprint
+        function_id: GUID of the function graph
+        source_node_id: GUID of the source node
+        source_pin_name: Name of the source pin (case-sensitive!)
+        target_node_id: GUID of the target node
+        target_pin_name: Name of the target pin (case-sensitive!)
+
+    Returns:
+        JSON with validation result:
+        - valid: true/false
+        - error_type: TYPE_MISMATCH, PIN_NOT_FOUND, etc.
+        - suggestions: Helpful suggestions if invalid
+        - warnings: Non-blocking warnings
+
+    Example:
+        # Always validate before connecting
+        result = validate_blueprint_connection(
+            "/Game/BP_Test", "FUNC_GUID",
+            "ADD_NODE_GUID", "ReturnValue",
+            "MULT_NODE_GUID", "A"
+        )
+
+        # If invalid, shows why and suggests fixes like "Use a String To Int conversion node"
+    """
+    command = {
+        "type": "validate_connection",
+        "blueprint_path": blueprint_path,
+        "function_id": function_id,
+        "source_node_id": source_node_id,
+        "source_pin_name": source_pin_name,
+        "target_node_id": target_node_id,
+        "target_pin_name": target_pin_name
+    }
+    response = send_to_unreal(command)
+    return json.dumps(response, indent=2)
+
+
+@mcp.tool()
+def auto_connect_blueprint_chain(blueprint_path: str, function_id: str,
+                                 node_chain: list, validate_before_connect: bool = True) -> str:
+    """
+    Intelligently auto-wire a chain of Blueprint nodes - let the system figure out the best connections.
+
+    This tool analyzes a chain of nodes and automatically makes the smartest connections between them,
+    with confidence scoring. Perfect for quickly wiring up node chains.
+
+    Args:
+        blueprint_path: Path to the Blueprint
+        function_id: GUID of the function graph
+        node_chain: List of node GUIDs in order (e.g., ["ENTRY_GUID", "ADD_GUID", "MULT_GUID", "RETURN_GUID"])
+        validate_before_connect: Validate connections before making them (default: True, recommended!)
+
+    Returns:
+        JSON with:
+        - connections_made: Number of successful connections
+        - connections: Array of connections with confidence scores (0.0-1.0)
+        - failed_connections: Connections that couldn't be made
+        - warnings: Any warnings
+
+    Confidence scores:
+        - 1.0: Perfect match (execution pins, exact name match)
+        - 0.7-0.9: Strong match (compatible types, similar names)
+        - 0.4-0.6: Moderate match (compatible types, different names)
+        - <0.3: Not connected automatically
+
+    Example:
+        # Auto-wire a math chain
+        auto_connect_blueprint_chain(
+            "/Game/BP_Calculator", "FUNC_GUID",
+            ["ENTRY_GUID", "ADD_GUID", "MULTIPLY_GUID", "RETURN_GUID"],
+            validate_before_connect=True
+        )
+
+        # Reviews confidence scores to see quality of connections
+    """
+    command = {
+        "type": "auto_connect_chain",
+        "blueprint_path": blueprint_path,
+        "function_id": function_id,
+        "node_chain": node_chain,
+        "validate_before_connect": validate_before_connect
+    }
+    response = send_to_unreal(command)
+    return json.dumps(response, indent=2)
+
+
+@mcp.tool()
+def suggest_blueprint_connections(blueprint_path: str, function_id: str,
+                                  source_node_id: str, target_node_id: str) -> str:
+    """
+    Get ranked connection suggestions between two Blueprint nodes - explore possibilities before connecting.
+
+    This tool analyzes two nodes and suggests the best connections between them, ranked by confidence.
+    Great for understanding connection options without committing to one.
+
+    Args:
+        blueprint_path: Path to the Blueprint
+        function_id: GUID of the function graph
+        source_node_id: GUID of the source node
+        target_node_id: GUID of the target node
+
+    Returns:
+        JSON with:
+        - execution_connection: Recommended execution pin connection (then → execute)
+        - data_connections: High-confidence data pin connections
+        - all_possibilities: All compatible connections ranked by confidence
+
+    Example:
+        # Explore connection options
+        suggestions = suggest_blueprint_connections(
+            "/Game/BP_Test", "FUNC_GUID",
+            "MULTIPLY_GUID", "CLAMP_GUID"
+        )
+
+        # Shows top suggestions like:
+        # 1. ReturnValue → A (0.95 confidence)
+        # 2. ReturnValue → Min (0.60 confidence)
+    """
+    command = {
+        "type": "suggest_connections",
+        "blueprint_path": blueprint_path,
+        "function_id": function_id,
+        "source_node_id": source_node_id,
+        "target_node_id": target_node_id
+    }
+    response = send_to_unreal(command)
+    return json.dumps(response, indent=2)
+
+
+@mcp.tool()
+def get_blueprint_graph_connections(blueprint_path: str, function_id: str) -> str:
+    """
+    Get all connections in a Blueprint function graph - analyze existing logic.
+
+    This tool lists every connection in a function graph, showing the complete wiring.
+    Useful for understanding existing Blueprint logic or documenting connections.
+
+    Args:
+        blueprint_path: Path to the Blueprint
+        function_id: GUID of the function graph
+
+    Returns:
+        JSON with:
+        - connections: Array of all connections (source/target node and pin names)
+        - total_connections: Count of connections
+
+    Example:
+        # Analyze existing Blueprint logic
+        connections = get_blueprint_graph_connections("/Game/BP_Complex", "FUNC_GUID")
+
+        # Shows all connections like:
+        # NodeA.then → NodeB.execute
+        # NodeB.ReturnValue → NodeC.Input
+    """
+    command = {
+        "type": "get_graph_connections",
+        "blueprint_path": blueprint_path,
+        "function_id": function_id
+    }
+    response = send_to_unreal(command)
+    return json.dumps(response, indent=2)
+
+
+if __name__ == "__main__":
+    import traceback
+
+    try:
+        print("Server starting...", file=sys.stderr)
+        mcp.run()
+    except Exception as e:
+        print(f"Server crashed with error: {e}", file=sys.stderr)
+        traceback.print_exc(file=sys.stderr)
+        raise

UMCP.it-Unreal-Organizer-Assistant/Content/Python/mss/__init__.py

@@ -0,0 +1,27 @@
+"""An ultra fast cross-platform multiple screenshots module in pure python
+using ctypes.
+
+This module is maintained by Mickaël Schoentgen <contact@tiger-222.fr>.
+
+You can always get the latest version of this module at:
+    https://github.com/BoboTiG/python-mss
+If that URL should fail, try contacting the author.
+"""
+
+from mss.exception import ScreenShotError
+from mss.factory import mss
+
+__version__ = "10.1.0.dev0"
+__author__ = "Mickaël Schoentgen"
+__date__ = "2013-2025"
+__copyright__ = f"""
+Copyright (c) {__date__}, {__author__}
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee or royalty is hereby
+granted, provided that the above copyright notice appear in all copies
+and that both that copyright notice and this permission notice appear
+in supporting documentation or portions thereof, including
+modifications, that you make.
+"""
+__all__ = ("ScreenShotError", "mss")

UMCP.it-Unreal-Organizer-Assistant/Content/Python/mss/__main__.py

@@ -0,0 +1,83 @@
+"""This is part of the MSS Python's module.
+Source: https://github.com/BoboTiG/python-mss.
+"""
+
+import os.path
+import sys
+from argparse import ArgumentParser
+
+from mss import __version__
+from mss.exception import ScreenShotError
+from mss.factory import mss
+from mss.tools import to_png
+
+
+def main(*args: str) -> int:
+    """Main logic."""
+    cli_args = ArgumentParser(prog="mss")
+    cli_args.add_argument(
+        "-c",
+        "--coordinates",
+        default="",
+        type=str,
+        help="the part of the screen to capture: top, left, width, height",
+    )
+    cli_args.add_argument(
+        "-l",
+        "--level",
+        default=6,
+        type=int,
+        choices=list(range(10)),
+        help="the PNG compression level",
+    )
+    cli_args.add_argument("-m", "--monitor", default=0, type=int, help="the monitor to screenshot")
+    cli_args.add_argument("-o", "--output", default="monitor-{mon}.png", help="the output file name")
+    cli_args.add_argument("--with-cursor", default=False, action="store_true", help="include the cursor")
+    cli_args.add_argument(
+        "-q",
+        "--quiet",
+        default=False,
+        action="store_true",
+        help="do not print created files",
+    )
+    cli_args.add_argument("-v", "--version", action="version", version=__version__)
+
+    options = cli_args.parse_args(args or None)
+    kwargs = {"mon": options.monitor, "output": options.output}
+    if options.coordinates:
+        try:
+            top, left, width, height = options.coordinates.split(",")
+        except ValueError:
+            print("Coordinates syntax: top, left, width, height")
+            return 2
+
+        kwargs["mon"] = {
+            "top": int(top),
+            "left": int(left),
+            "width": int(width),
+            "height": int(height),
+        }
+        if options.output == "monitor-{mon}.png":
+            kwargs["output"] = "sct-{top}x{left}_{width}x{height}.png"
+
+    try:
+        with mss(with_cursor=options.with_cursor) as sct:
+            if options.coordinates:
+                output = kwargs["output"].format(**kwargs["mon"])
+                sct_img = sct.grab(kwargs["mon"])
+                to_png(sct_img.rgb, sct_img.size, level=options.level, output=output)
+                if not options.quiet:
+                    print(os.path.realpath(output))
+            else:
+                for file_name in sct.save(**kwargs):
+                    if not options.quiet:
+                        print(os.path.realpath(file_name))
+            return 0
+    except ScreenShotError:
+        if options.quiet:
+            return 1
+        raise
+
+
+if __name__ == "__main__":  # pragma: nocover
+    sys.exit(main())

UMCP.it-Unreal-Organizer-Assistant/Content/Python/mss/base.py

@@ -0,0 +1,261 @@
+"""This is part of the MSS Python's module.
+Source: https://github.com/BoboTiG/python-mss.
+"""
+
+from __future__ import annotations
+
+from abc import ABCMeta, abstractmethod
+from datetime import datetime
+from threading import Lock
+from typing import TYPE_CHECKING, Any
+
+from mss.exception import ScreenShotError
+from mss.screenshot import ScreenShot
+from mss.tools import to_png
+
+if TYPE_CHECKING:  # pragma: nocover
+    from collections.abc import Callable, Iterator
+
+    from mss.models import Monitor, Monitors
+
+try:
+    from datetime import UTC
+except ImportError:  # pragma: nocover
+    # Python < 3.11
+    from datetime import timezone
+
+    UTC = timezone.utc
+
+lock = Lock()
+
+OPAQUE = 255
+
+
+class MSSBase(metaclass=ABCMeta):
+    """This class will be overloaded by a system specific one."""
+
+    __slots__ = {"_monitors", "cls_image", "compression_level", "with_cursor"}
+
+    def __init__(
+        self,
+        /,
+        *,
+        compression_level: int = 6,
+        with_cursor: bool = False,
+        # Linux only
+        display: bytes | str | None = None,  # noqa: ARG002
+        # Mac only
+        max_displays: int = 32,  # noqa: ARG002
+    ) -> None:
+        self.cls_image: type[ScreenShot] = ScreenShot
+        self.compression_level = compression_level
+        self.with_cursor = with_cursor
+        self._monitors: Monitors = []
+
+    def __enter__(self) -> MSSBase:  # noqa:PYI034
+        """For the cool call `with MSS() as mss:`."""
+        return self
+
+    def __exit__(self, *_: object) -> None:
+        """For the cool call `with MSS() as mss:`."""
+        self.close()
+
+    @abstractmethod
+    def _cursor_impl(self) -> ScreenShot | None:
+        """Retrieve all cursor data. Pixels have to be RGB."""
+
+    @abstractmethod
+    def _grab_impl(self, monitor: Monitor, /) -> ScreenShot:
+        """Retrieve all pixels from a monitor. Pixels have to be RGB.
+        That method has to be run using a threading lock.
+        """
+
+    @abstractmethod
+    def _monitors_impl(self) -> None:
+        """Get positions of monitors (has to be run using a threading lock).
+        It must populate self._monitors.
+        """
+
+    def close(self) -> None:  # noqa:B027
+        """Clean-up."""
+
+    def grab(self, monitor: Monitor | tuple[int, int, int, int], /) -> ScreenShot:
+        """Retrieve screen pixels for a given monitor.
+
+        Note: *monitor* can be a tuple like the one PIL.Image.grab() accepts.
+
+        :param monitor: The coordinates and size of the box to capture.
+                        See :meth:`monitors <monitors>` for object details.
+        :return :class:`ScreenShot <ScreenShot>`.
+        """
+        # Convert PIL bbox style
+        if isinstance(monitor, tuple):
+            monitor = {
+                "left": monitor[0],
+                "top": monitor[1],
+                "width": monitor[2] - monitor[0],
+                "height": monitor[3] - monitor[1],
+            }
+
+        with lock:
+            screenshot = self._grab_impl(monitor)
+            if self.with_cursor and (cursor := self._cursor_impl()):
+                return self._merge(screenshot, cursor)
+            return screenshot
+
+    @property
+    def monitors(self) -> Monitors:
+        """Get positions of all monitors.
+        If the monitor has rotation, you have to deal with it
+        inside this method.
+
+        This method has to fill self._monitors with all information
+        and use it as a cache:
+            self._monitors[0] is a dict of all monitors together
+            self._monitors[N] is a dict of the monitor N (with N > 0)
+
+        Each monitor is a dict with:
+        {
+            'left':   the x-coordinate of the upper-left corner,
+            'top':    the y-coordinate of the upper-left corner,
+            'width':  the width,
+            'height': the height
+        }
+        """
+        if not self._monitors:
+            with lock:
+                self._monitors_impl()
+
+        return self._monitors
+
+    def save(
+        self,
+        /,
+        *,
+        mon: int = 0,
+        output: str = "monitor-{mon}.png",
+        callback: Callable[[str], None] | None = None,
+    ) -> Iterator[str]:
+        """Grab a screenshot and save it to a file.
+
+        :param int mon: The monitor to screenshot (default=0).
+                        -1: grab one screenshot of all monitors
+                         0: grab one screenshot by monitor
+                        N: grab the screenshot of the monitor N
+
+        :param str output: The output filename.
+
+            It can take several keywords to customize the filename:
+            - `{mon}`: the monitor number
+            - `{top}`: the screenshot y-coordinate of the upper-left corner
+            - `{left}`: the screenshot x-coordinate of the upper-left corner
+            - `{width}`: the screenshot's width
+            - `{height}`: the screenshot's height
+            - `{date}`: the current date using the default formatter
+
+            As it is using the `format()` function, you can specify
+            formatting options like `{date:%Y-%m-%s}`.
+
+        :param callable callback: Callback called before saving the
+            screenshot to a file.  Take the `output` argument as parameter.
+
+        :return generator: Created file(s).
+        """
+        monitors = self.monitors
+        if not monitors:
+            msg = "No monitor found."
+            raise ScreenShotError(msg)
+
+        if mon == 0:
+            # One screenshot by monitor
+            for idx, monitor in enumerate(monitors[1:], 1):
+                fname = output.format(mon=idx, date=datetime.now(UTC) if "{date" in output else None, **monitor)
+                if callable(callback):
+                    callback(fname)
+                sct = self.grab(monitor)
+                to_png(sct.rgb, sct.size, level=self.compression_level, output=fname)
+                yield fname
+        else:
+            # A screenshot of all monitors together or
+            # a screenshot of the monitor N.
+            mon = 0 if mon == -1 else mon
+            try:
+                monitor = monitors[mon]
+            except IndexError as exc:
+                msg = f"Monitor {mon!r} does not exist."
+                raise ScreenShotError(msg) from exc
+
+            output = output.format(mon=mon, date=datetime.now(UTC) if "{date" in output else None, **monitor)
+            if callable(callback):
+                callback(output)
+            sct = self.grab(monitor)
+            to_png(sct.rgb, sct.size, level=self.compression_level, output=output)
+            yield output
+
+    def shot(self, /, **kwargs: Any) -> str:
+        """Helper to save the screenshot of the 1st monitor, by default.
+        You can pass the same arguments as for ``save``.
+        """
+        kwargs["mon"] = kwargs.get("mon", 1)
+        return next(self.save(**kwargs))
+
+    @staticmethod
+    def _merge(screenshot: ScreenShot, cursor: ScreenShot, /) -> ScreenShot:
+        """Create composite image by blending screenshot and mouse cursor."""
+        (cx, cy), (cw, ch) = cursor.pos, cursor.size
+        (x, y), (w, h) = screenshot.pos, screenshot.size
+
+        cx2, cy2 = cx + cw, cy + ch
+        x2, y2 = x + w, y + h
+
+        overlap = cx < x2 and cx2 > x and cy < y2 and cy2 > y
+        if not overlap:
+            return screenshot
+
+        screen_raw = screenshot.raw
+        cursor_raw = cursor.raw
+
+        cy, cy2 = (cy - y) * 4, (cy2 - y2) * 4
+        cx, cx2 = (cx - x) * 4, (cx2 - x2) * 4
+        start_count_y = -cy if cy < 0 else 0
+        start_count_x = -cx if cx < 0 else 0
+        stop_count_y = ch * 4 - max(cy2, 0)
+        stop_count_x = cw * 4 - max(cx2, 0)
+        rgb = range(3)
+
+        for count_y in range(start_count_y, stop_count_y, 4):
+            pos_s = (count_y + cy) * w + cx
+            pos_c = count_y * cw
+
+            for count_x in range(start_count_x, stop_count_x, 4):
+                spos = pos_s + count_x
+                cpos = pos_c + count_x
+                alpha = cursor_raw[cpos + 3]
+
+                if not alpha:
+                    continue
+
+                if alpha == OPAQUE:
+                    screen_raw[spos : spos + 3] = cursor_raw[cpos : cpos + 3]
+                else:
+                    alpha2 = alpha / 255
+                    for i in rgb:
+                        screen_raw[spos + i] = int(cursor_raw[cpos + i] * alpha2 + screen_raw[spos + i] * (1 - alpha2))
+
+        return screenshot
+
+    @staticmethod
+    def _cfactory(
+        attr: Any,
+        func: str,
+        argtypes: list[Any],
+        restype: Any,
+        /,
+        errcheck: Callable | None = None,
+    ) -> None:
+        """Factory to create a ctypes function and automatically manage errors."""
+        meth = getattr(attr, func)
+        meth.argtypes = argtypes
+        meth.restype = restype
+        if errcheck:
+            meth.errcheck = errcheck

UMCP.it-Unreal-Organizer-Assistant/Content/Python/mss/darwin.py

@@ -0,0 +1,217 @@
+"""This is part of the MSS Python's module.
+Source: https://github.com/BoboTiG/python-mss.
+"""
+
+from __future__ import annotations
+
+import ctypes
+import ctypes.util
+import sys
+from ctypes import POINTER, Structure, c_double, c_float, c_int32, c_ubyte, c_uint32, c_uint64, c_void_p
+from platform import mac_ver
+from typing import TYPE_CHECKING, Any
+
+from mss.base import MSSBase
+from mss.exception import ScreenShotError
+from mss.screenshot import ScreenShot, Size
+
+if TYPE_CHECKING:  # pragma: nocover
+    from mss.models import CFunctions, Monitor
+
+__all__ = ("MSS",)
+
+MAC_VERSION_CATALINA = 10.16
+
+kCGWindowImageBoundsIgnoreFraming = 1 << 0  # noqa: N816
+kCGWindowImageNominalResolution = 1 << 4  # noqa: N816
+kCGWindowImageShouldBeOpaque = 1 << 1  # noqa: N816
+# Note: set `IMAGE_OPTIONS = 0` to turn on scaling (see issue #257 for more information)
+IMAGE_OPTIONS = kCGWindowImageBoundsIgnoreFraming | kCGWindowImageShouldBeOpaque | kCGWindowImageNominalResolution
+
+
+def cgfloat() -> type[c_double | c_float]:
+    """Get the appropriate value for a float."""
+    return c_double if sys.maxsize > 2**32 else c_float
+
+
+class CGPoint(Structure):
+    """Structure that contains coordinates of a rectangle."""
+
+    _fields_ = (("x", cgfloat()), ("y", cgfloat()))
+
+    def __repr__(self) -> str:
+        return f"{type(self).__name__}(left={self.x} top={self.y})"
+
+
+class CGSize(Structure):
+    """Structure that contains dimensions of an rectangle."""
+
+    _fields_ = (("width", cgfloat()), ("height", cgfloat()))
+
+    def __repr__(self) -> str:
+        return f"{type(self).__name__}(width={self.width} height={self.height})"
+
+
+class CGRect(Structure):
+    """Structure that contains information about a rectangle."""
+
+    _fields_ = (("origin", CGPoint), ("size", CGSize))
+
+    def __repr__(self) -> str:
+        return f"{type(self).__name__}<{self.origin} {self.size}>"
+
+
+# C functions that will be initialised later.
+#
+# Available attr: core.
+#
+# Note: keep it sorted by cfunction.
+CFUNCTIONS: CFunctions = {
+    # Syntax: cfunction: (attr, argtypes, restype)
+    "CGDataProviderCopyData": ("core", [c_void_p], c_void_p),
+    "CGDisplayBounds": ("core", [c_uint32], CGRect),
+    "CGDisplayRotation": ("core", [c_uint32], c_float),
+    "CFDataGetBytePtr": ("core", [c_void_p], c_void_p),
+    "CFDataGetLength": ("core", [c_void_p], c_uint64),
+    "CFRelease": ("core", [c_void_p], c_void_p),
+    "CGDataProviderRelease": ("core", [c_void_p], c_void_p),
+    "CGGetActiveDisplayList": ("core", [c_uint32, POINTER(c_uint32), POINTER(c_uint32)], c_int32),
+    "CGImageGetBitsPerPixel": ("core", [c_void_p], int),
+    "CGImageGetBytesPerRow": ("core", [c_void_p], int),
+    "CGImageGetDataProvider": ("core", [c_void_p], c_void_p),
+    "CGImageGetHeight": ("core", [c_void_p], int),
+    "CGImageGetWidth": ("core", [c_void_p], int),
+    "CGRectStandardize": ("core", [CGRect], CGRect),
+    "CGRectUnion": ("core", [CGRect, CGRect], CGRect),
+    "CGWindowListCreateImage": ("core", [CGRect, c_uint32, c_uint32, c_uint32], c_void_p),
+}
+
+
+class MSS(MSSBase):
+    """Multiple ScreenShots implementation for macOS.
+    It uses intensively the CoreGraphics library.
+    """
+
+    __slots__ = {"core", "max_displays"}
+
+    def __init__(self, /, **kwargs: Any) -> None:
+        """MacOS initialisations."""
+        super().__init__(**kwargs)
+
+        self.max_displays = kwargs.get("max_displays", 32)
+
+        self._init_library()
+        self._set_cfunctions()
+
+    def _init_library(self) -> None:
+        """Load the CoreGraphics library."""
+        version = float(".".join(mac_ver()[0].split(".")[:2]))
+        if version < MAC_VERSION_CATALINA:
+            coregraphics = ctypes.util.find_library("CoreGraphics")
+        else:
+            # macOS Big Sur and newer
+            coregraphics = "/System/Library/Frameworks/CoreGraphics.framework/Versions/Current/CoreGraphics"
+
+        if not coregraphics:
+            msg = "No CoreGraphics library found."
+            raise ScreenShotError(msg)
+        self.core = ctypes.cdll.LoadLibrary(coregraphics)
+
+    def _set_cfunctions(self) -> None:
+        """Set all ctypes functions and attach them to attributes."""
+        cfactory = self._cfactory
+        attrs = {"core": self.core}
+        for func, (attr, argtypes, restype) in CFUNCTIONS.items():
+            cfactory(attrs[attr], func, argtypes, restype)
+
+    def _monitors_impl(self) -> None:
+        """Get positions of monitors. It will populate self._monitors."""
+        int_ = int
+        core = self.core
+
+        # All monitors
+        # We need to update the value with every single monitor found
+        # using CGRectUnion.  Else we will end with infinite values.
+        all_monitors = CGRect()
+        self._monitors.append({})
+
+        # Each monitor
+        display_count = c_uint32(0)
+        active_displays = (c_uint32 * self.max_displays)()
+        core.CGGetActiveDisplayList(self.max_displays, active_displays, ctypes.byref(display_count))
+        for idx in range(display_count.value):
+            display = active_displays[idx]
+            rect = core.CGDisplayBounds(display)
+            rect = core.CGRectStandardize(rect)
+            width, height = rect.size.width, rect.size.height
+
+            # 0.0: normal
+            # 90.0: right
+            # -90.0: left
+            if core.CGDisplayRotation(display) in {90.0, -90.0}:
+                width, height = height, width
+
+            self._monitors.append(
+                {
+                    "left": int_(rect.origin.x),
+                    "top": int_(rect.origin.y),
+                    "width": int_(width),
+                    "height": int_(height),
+                },
+            )
+
+            # Update AiO monitor's values
+            all_monitors = core.CGRectUnion(all_monitors, rect)
+
+        # Set the AiO monitor's values
+        self._monitors[0] = {
+            "left": int_(all_monitors.origin.x),
+            "top": int_(all_monitors.origin.y),
+            "width": int_(all_monitors.size.width),
+            "height": int_(all_monitors.size.height),
+        }
+
+    def _grab_impl(self, monitor: Monitor, /) -> ScreenShot:
+        """Retrieve all pixels from a monitor. Pixels have to be RGB."""
+        core = self.core
+        rect = CGRect((monitor["left"], monitor["top"]), (monitor["width"], monitor["height"]))
+
+        image_ref = core.CGWindowListCreateImage(rect, 1, 0, IMAGE_OPTIONS)
+        if not image_ref:
+            msg = "CoreGraphics.CGWindowListCreateImage() failed."
+            raise ScreenShotError(msg)
+
+        width = core.CGImageGetWidth(image_ref)
+        height = core.CGImageGetHeight(image_ref)
+        prov = copy_data = None
+        try:
+            prov = core.CGImageGetDataProvider(image_ref)
+            copy_data = core.CGDataProviderCopyData(prov)
+            data_ref = core.CFDataGetBytePtr(copy_data)
+            buf_len = core.CFDataGetLength(copy_data)
+            raw = ctypes.cast(data_ref, POINTER(c_ubyte * buf_len))
+            data = bytearray(raw.contents)
+
+            # Remove padding per row
+            bytes_per_row = core.CGImageGetBytesPerRow(image_ref)
+            bytes_per_pixel = core.CGImageGetBitsPerPixel(image_ref)
+            bytes_per_pixel = (bytes_per_pixel + 7) // 8
+
+            if bytes_per_pixel * width != bytes_per_row:
+                cropped = bytearray()
+                for row in range(height):
+                    start = row * bytes_per_row
+                    end = start + width * bytes_per_pixel
+                    cropped.extend(data[start:end])
+                data = cropped
+        finally:
+            if prov:
+                core.CGDataProviderRelease(prov)
+            if copy_data:
+                core.CFRelease(copy_data)
+
+        return self.cls_image(data, monitor, size=Size(width, height))
+
+    def _cursor_impl(self) -> ScreenShot | None:
+        """Retrieve all cursor data. Pixels have to be RGB."""
+        return None

UMCP.it-Unreal-Organizer-Assistant/Content/Python/mss/exception.py

@@ -0,0 +1,15 @@
+"""This is part of the MSS Python's module.
+Source: https://github.com/BoboTiG/python-mss.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+class ScreenShotError(Exception):
+    """Error handling class."""
+
+    def __init__(self, message: str, /, *, details: dict[str, Any] | None = None) -> None:
+        super().__init__(message)
+        self.details = details or {}

UMCP.it-Unreal-Organizer-Assistant/Content/Python/mss/factory.py

@@ -0,0 +1,40 @@
+"""This is part of the MSS Python's module.
+Source: https://github.com/BoboTiG/python-mss.
+"""
+
+import platform
+from typing import Any
+
+from mss.base import MSSBase
+from mss.exception import ScreenShotError
+
+
+def mss(**kwargs: Any) -> MSSBase:
+    """Factory returning a proper MSS class instance.
+
+    It detects the platform we are running on
+    and chooses the most adapted mss_class to take
+    screenshots.
+
+    It then proxies its arguments to the class for
+    instantiation.
+    """
+    os_ = platform.system().lower()
+
+    if os_ == "darwin":
+        from mss import darwin
+
+        return darwin.MSS(**kwargs)
+
+    if os_ == "linux":
+        from mss import linux
+
+        return linux.MSS(**kwargs)
+
+    if os_ == "windows":
+        from mss import windows
+
+        return windows.MSS(**kwargs)
+
+    msg = f"System {os_!r} not (yet?) implemented."
+    raise ScreenShotError(msg)

UMCP.it-Unreal-Organizer-Assistant/Content/Python/mss/linux.py

@@ -0,0 +1,481 @@
+"""This is part of the MSS Python's module.
+Source: https://github.com/BoboTiG/python-mss.
+"""
+
+from __future__ import annotations
+
+import os
+from contextlib import suppress
+from ctypes import (
+    CFUNCTYPE,
+    POINTER,
+    Structure,
+    byref,
+    c_char_p,
+    c_int,
+    c_int32,
+    c_long,
+    c_short,
+    c_ubyte,
+    c_uint,
+    c_uint32,
+    c_ulong,
+    c_ushort,
+    c_void_p,
+    cast,
+    cdll,
+    create_string_buffer,
+)
+from ctypes.util import find_library
+from threading import current_thread, local
+from typing import TYPE_CHECKING, Any
+
+from mss.base import MSSBase, lock
+from mss.exception import ScreenShotError
+
+if TYPE_CHECKING:  # pragma: nocover
+    from mss.models import CFunctions, Monitor
+    from mss.screenshot import ScreenShot
+
+__all__ = ("MSS",)
+
+
+PLAINMASK = 0x00FFFFFF
+ZPIXMAP = 2
+BITS_PER_PIXELS_32 = 32
+SUPPORTED_BITS_PER_PIXELS = {
+    BITS_PER_PIXELS_32,
+}
+
+
+class Display(Structure):
+    """Structure that serves as the connection to the X server
+    and that contains all the information about that X server.
+    https://github.com/garrybodsworth/pyxlib-ctypes/blob/master/pyxlib/xlib.py#L831.
+    """
+
+
+class XErrorEvent(Structure):
+    """XErrorEvent to debug eventual errors.
+    https://tronche.com/gui/x/xlib/event-handling/protocol-errors/default-handlers.html.
+    """
+
+    _fields_ = (
+        ("type", c_int),
+        ("display", POINTER(Display)),  # Display the event was read from
+        ("serial", c_ulong),  # serial number of failed request
+        ("error_code", c_ubyte),  # error code of failed request
+        ("request_code", c_ubyte),  # major op-code of failed request
+        ("minor_code", c_ubyte),  # minor op-code of failed request
+        ("resourceid", c_void_p),  # resource ID
+    )
+
+
+class XFixesCursorImage(Structure):
+    """Cursor structure.
+    /usr/include/X11/extensions/Xfixes.h
+    https://github.com/freedesktop/xorg-libXfixes/blob/libXfixes-6.0.0/include/X11/extensions/Xfixes.h#L96.
+    """
+
+    _fields_ = (
+        ("x", c_short),
+        ("y", c_short),
+        ("width", c_ushort),
+        ("height", c_ushort),
+        ("xhot", c_ushort),
+        ("yhot", c_ushort),
+        ("cursor_serial", c_ulong),
+        ("pixels", POINTER(c_ulong)),
+        ("atom", c_ulong),
+        ("name", c_char_p),
+    )
+
+
+class XImage(Structure):
+    """Description of an image as it exists in the client's memory.
+    https://tronche.com/gui/x/xlib/graphics/images.html.
+    """
+
+    _fields_ = (
+        ("width", c_int),  # size of image
+        ("height", c_int),  # size of image
+        ("xoffset", c_int),  # number of pixels offset in X direction
+        ("format", c_int),  # XYBitmap, XYPixmap, ZPixmap
+        ("data", c_void_p),  # pointer to image data
+        ("byte_order", c_int),  # data byte order, LSBFirst, MSBFirst
+        ("bitmap_unit", c_int),  # quant. of scanline 8, 16, 32
+        ("bitmap_bit_order", c_int),  # LSBFirst, MSBFirst
+        ("bitmap_pad", c_int),  # 8, 16, 32 either XY or ZPixmap
+        ("depth", c_int),  # depth of image
+        ("bytes_per_line", c_int),  # accelerator to next line
+        ("bits_per_pixel", c_int),  # bits per pixel (ZPixmap)
+        ("red_mask", c_ulong),  # bits in z arrangement
+        ("green_mask", c_ulong),  # bits in z arrangement
+        ("blue_mask", c_ulong),  # bits in z arrangement
+    )
+
+
+class XRRCrtcInfo(Structure):
+    """Structure that contains CRTC information.
+    https://gitlab.freedesktop.org/xorg/lib/libxrandr/-/blob/master/include/X11/extensions/Xrandr.h#L360.
+    """
+
+    _fields_ = (
+        ("timestamp", c_ulong),
+        ("x", c_int),
+        ("y", c_int),
+        ("width", c_uint),
+        ("height", c_uint),
+        ("mode", c_long),
+        ("rotation", c_int),
+        ("noutput", c_int),
+        ("outputs", POINTER(c_long)),
+        ("rotations", c_ushort),
+        ("npossible", c_int),
+        ("possible", POINTER(c_long)),
+    )
+
+
+class XRRModeInfo(Structure):
+    """https://gitlab.freedesktop.org/xorg/lib/libxrandr/-/blob/master/include/X11/extensions/Xrandr.h#L248."""
+
+
+class XRRScreenResources(Structure):
+    """Structure that contains arrays of XIDs that point to the
+    available outputs and associated CRTCs.
+    https://gitlab.freedesktop.org/xorg/lib/libxrandr/-/blob/master/include/X11/extensions/Xrandr.h#L265.
+    """
+
+    _fields_ = (
+        ("timestamp", c_ulong),
+        ("configTimestamp", c_ulong),
+        ("ncrtc", c_int),
+        ("crtcs", POINTER(c_long)),
+        ("noutput", c_int),
+        ("outputs", POINTER(c_long)),
+        ("nmode", c_int),
+        ("modes", POINTER(XRRModeInfo)),
+    )
+
+
+class XWindowAttributes(Structure):
+    """Attributes for the specified window."""
+
+    _fields_ = (
+        ("x", c_int32),  # location of window
+        ("y", c_int32),  # location of window
+        ("width", c_int32),  # width of window
+        ("height", c_int32),  # height of window
+        ("border_width", c_int32),  # border width of window
+        ("depth", c_int32),  # depth of window
+        ("visual", c_ulong),  # the associated visual structure
+        ("root", c_ulong),  # root of screen containing window
+        ("class", c_int32),  # InputOutput, InputOnly
+        ("bit_gravity", c_int32),  # one of bit gravity values
+        ("win_gravity", c_int32),  # one of the window gravity values
+        ("backing_store", c_int32),  # NotUseful, WhenMapped, Always
+        ("backing_planes", c_ulong),  # planes to be preserved if possible
+        ("backing_pixel", c_ulong),  # value to be used when restoring planes
+        ("save_under", c_int32),  # boolean, should bits under be saved?
+        ("colormap", c_ulong),  # color map to be associated with window
+        ("mapinstalled", c_uint32),  # boolean, is color map currently installed
+        ("map_state", c_uint32),  # IsUnmapped, IsUnviewable, IsViewable
+        ("all_event_masks", c_ulong),  # set of events all people have interest in
+        ("your_event_mask", c_ulong),  # my event mask
+        ("do_not_propagate_mask", c_ulong),  # set of events that should not propagate
+        ("override_redirect", c_int32),  # boolean value for override-redirect
+        ("screen", c_ulong),  # back pointer to correct screen
+    )
+
+
+_ERROR = {}
+_X11 = find_library("X11")
+_XFIXES = find_library("Xfixes")
+_XRANDR = find_library("Xrandr")
+
+
+@CFUNCTYPE(c_int, POINTER(Display), POINTER(XErrorEvent))
+def _error_handler(display: Display, event: XErrorEvent) -> int:
+    """Specifies the program's supplied error handler."""
+    # Get the specific error message
+    xlib = cdll.LoadLibrary(_X11)  # type: ignore[arg-type]
+    get_error = xlib.XGetErrorText
+    get_error.argtypes = [POINTER(Display), c_int, c_char_p, c_int]
+    get_error.restype = c_void_p
+
+    evt = event.contents
+    error = create_string_buffer(1024)
+    get_error(display, evt.error_code, error, len(error))
+
+    _ERROR[current_thread()] = {
+        "error": error.value.decode("utf-8"),
+        "error_code": evt.error_code,
+        "minor_code": evt.minor_code,
+        "request_code": evt.request_code,
+        "serial": evt.serial,
+        "type": evt.type,
+    }
+
+    return 0
+
+
+def _validate(retval: int, func: Any, args: tuple[Any, Any], /) -> tuple[Any, Any]:
+    """Validate the returned value of a C function call."""
+    thread = current_thread()
+    if retval != 0 and thread not in _ERROR:
+        return args
+
+    details = _ERROR.pop(thread, {})
+    msg = f"{func.__name__}() failed"
+    raise ScreenShotError(msg, details=details)
+
+
+# C functions that will be initialised later.
+# See https://tronche.com/gui/x/xlib/function-index.html for details.
+#
+# Available attr: xfixes, xlib, xrandr.
+#
+# Note: keep it sorted by cfunction.
+CFUNCTIONS: CFunctions = {
+    # Syntax: cfunction: (attr, argtypes, restype)
+    "XCloseDisplay": ("xlib", [POINTER(Display)], c_void_p),
+    "XDefaultRootWindow": ("xlib", [POINTER(Display)], POINTER(XWindowAttributes)),
+    "XDestroyImage": ("xlib", [POINTER(XImage)], c_void_p),
+    "XFixesGetCursorImage": ("xfixes", [POINTER(Display)], POINTER(XFixesCursorImage)),
+    "XGetImage": (
+        "xlib",
+        [POINTER(Display), POINTER(Display), c_int, c_int, c_uint, c_uint, c_ulong, c_int],
+        POINTER(XImage),
+    ),
+    "XGetWindowAttributes": ("xlib", [POINTER(Display), POINTER(XWindowAttributes), POINTER(XWindowAttributes)], c_int),
+    "XOpenDisplay": ("xlib", [c_char_p], POINTER(Display)),
+    "XQueryExtension": ("xlib", [POINTER(Display), c_char_p, POINTER(c_int), POINTER(c_int), POINTER(c_int)], c_uint),
+    "XRRFreeCrtcInfo": ("xrandr", [POINTER(XRRCrtcInfo)], c_void_p),
+    "XRRFreeScreenResources": ("xrandr", [POINTER(XRRScreenResources)], c_void_p),
+    "XRRGetCrtcInfo": ("xrandr", [POINTER(Display), POINTER(XRRScreenResources), c_long], POINTER(XRRCrtcInfo)),
+    "XRRGetScreenResources": ("xrandr", [POINTER(Display), POINTER(Display)], POINTER(XRRScreenResources)),
+    "XRRGetScreenResourcesCurrent": ("xrandr", [POINTER(Display), POINTER(Display)], POINTER(XRRScreenResources)),
+    "XSetErrorHandler": ("xlib", [c_void_p], c_void_p),
+}
+
+
+class MSS(MSSBase):
+    """Multiple ScreenShots implementation for GNU/Linux.
+    It uses intensively the Xlib and its Xrandr extension.
+    """
+
+    __slots__ = {"_handles", "xfixes", "xlib", "xrandr"}
+
+    def __init__(self, /, **kwargs: Any) -> None:
+        """GNU/Linux initialisations."""
+        super().__init__(**kwargs)
+
+        # Available thread-specific variables
+        self._handles = local()
+        self._handles.display = None
+        self._handles.drawable = None
+        self._handles.original_error_handler = None
+        self._handles.root = None
+
+        display = kwargs.get("display", b"")
+        if not display:
+            try:
+                display = os.environ["DISPLAY"].encode("utf-8")
+            except KeyError:
+                msg = "$DISPLAY not set."
+                raise ScreenShotError(msg) from None
+
+        if not isinstance(display, bytes):
+            display = display.encode("utf-8")
+
+        if b":" not in display:
+            msg = f"Bad display value: {display!r}."
+            raise ScreenShotError(msg)
+
+        if not _X11:
+            msg = "No X11 library found."
+            raise ScreenShotError(msg)
+        self.xlib = cdll.LoadLibrary(_X11)
+
+        if not _XRANDR:
+            msg = "No Xrandr extension found."
+            raise ScreenShotError(msg)
+        self.xrandr = cdll.LoadLibrary(_XRANDR)
+
+        if self.with_cursor:
+            if _XFIXES:
+                self.xfixes = cdll.LoadLibrary(_XFIXES)
+            else:
+                self.with_cursor = False
+
+        self._set_cfunctions()
+
+        # Install the error handler to prevent interpreter crashes: any error will raise a ScreenShotError exception
+        self._handles.original_error_handler = self.xlib.XSetErrorHandler(_error_handler)
+
+        self._handles.display = self.xlib.XOpenDisplay(display)
+        if not self._handles.display:
+            msg = f"Unable to open display: {display!r}."
+            raise ScreenShotError(msg)
+
+        if not self._is_extension_enabled("RANDR"):
+            msg = "Xrandr not enabled."
+            raise ScreenShotError(msg)
+
+        self._handles.root = self.xlib.XDefaultRootWindow(self._handles.display)
+
+        # Fix for XRRGetScreenResources and XGetImage:
+        #     expected LP_Display instance instead of LP_XWindowAttributes
+        self._handles.drawable = cast(self._handles.root, POINTER(Display))
+
+    def close(self) -> None:
+        # Clean-up
+        if self._handles.display:
+            with lock:
+                self.xlib.XCloseDisplay(self._handles.display)
+            self._handles.display = None
+            self._handles.drawable = None
+            self._handles.root = None
+
+        # Remove our error handler
+        if self._handles.original_error_handler:
+            # It's required when exiting MSS to prevent letting `_error_handler()` as default handler.
+            # Doing so would crash when using Tk/Tkinter, see issue #220.
+            # Interesting technical stuff can be found here:
+            #     https://core.tcl-lang.org/tk/file?name=generic/tkError.c&ci=a527ef995862cb50
+            #     https://github.com/tcltk/tk/blob/b9cdafd83fe77499ff47fa373ce037aff3ae286a/generic/tkError.c
+            self.xlib.XSetErrorHandler(self._handles.original_error_handler)
+            self._handles.original_error_handler = None
+
+        # Also empty the error dict
+        _ERROR.clear()
+
+    def _is_extension_enabled(self, name: str, /) -> bool:
+        """Return True if the given *extension* is enabled on the server."""
+        major_opcode_return = c_int()
+        first_event_return = c_int()
+        first_error_return = c_int()
+
+        try:
+            with lock:
+                self.xlib.XQueryExtension(
+                    self._handles.display,
+                    name.encode("latin1"),
+                    byref(major_opcode_return),
+                    byref(first_event_return),
+                    byref(first_error_return),
+                )
+        except ScreenShotError:
+            return False
+        return True
+
+    def _set_cfunctions(self) -> None:
+        """Set all ctypes functions and attach them to attributes."""
+        cfactory = self._cfactory
+        attrs = {
+            "xfixes": getattr(self, "xfixes", None),
+            "xlib": self.xlib,
+            "xrandr": self.xrandr,
+        }
+        for func, (attr, argtypes, restype) in CFUNCTIONS.items():
+            with suppress(AttributeError):
+                errcheck = None if func == "XSetErrorHandler" else _validate
+                cfactory(attrs[attr], func, argtypes, restype, errcheck=errcheck)
+
+    def _monitors_impl(self) -> None:
+        """Get positions of monitors. It will populate self._monitors."""
+        display = self._handles.display
+        int_ = int
+        xrandr = self.xrandr
+
+        # All monitors
+        gwa = XWindowAttributes()
+        self.xlib.XGetWindowAttributes(display, self._handles.root, byref(gwa))
+        self._monitors.append(
+            {"left": int_(gwa.x), "top": int_(gwa.y), "width": int_(gwa.width), "height": int_(gwa.height)},
+        )
+
+        # Each monitor
+        # A simple benchmark calling 10 times those 2 functions:
+        # XRRGetScreenResources():        0.1755971429956844 s
+        # XRRGetScreenResourcesCurrent(): 0.0039125580078689 s
+        # The second is faster by a factor of 44! So try to use it first.
+        try:
+            mon = xrandr.XRRGetScreenResourcesCurrent(display, self._handles.drawable).contents
+        except AttributeError:
+            mon = xrandr.XRRGetScreenResources(display, self._handles.drawable).contents
+
+        crtcs = mon.crtcs
+        for idx in range(mon.ncrtc):
+            crtc = xrandr.XRRGetCrtcInfo(display, mon, crtcs[idx]).contents
+            if crtc.noutput == 0:
+                xrandr.XRRFreeCrtcInfo(crtc)
+                continue
+
+            self._monitors.append(
+                {
+                    "left": int_(crtc.x),
+                    "top": int_(crtc.y),
+                    "width": int_(crtc.width),
+                    "height": int_(crtc.height),
+                },
+            )
+            xrandr.XRRFreeCrtcInfo(crtc)
+        xrandr.XRRFreeScreenResources(mon)
+
+    def _grab_impl(self, monitor: Monitor, /) -> ScreenShot:
+        """Retrieve all pixels from a monitor. Pixels have to be RGB."""
+        ximage = self.xlib.XGetImage(
+            self._handles.display,
+            self._handles.drawable,
+            monitor["left"],
+            monitor["top"],
+            monitor["width"],
+            monitor["height"],
+            PLAINMASK,
+            ZPIXMAP,
+        )
+
+        try:
+            bits_per_pixel = ximage.contents.bits_per_pixel
+            if bits_per_pixel not in SUPPORTED_BITS_PER_PIXELS:
+                msg = f"[XImage] bits per pixel value not (yet?) implemented: {bits_per_pixel}."
+                raise ScreenShotError(msg)
+
+            raw_data = cast(
+                ximage.contents.data,
+                POINTER(c_ubyte * monitor["height"] * monitor["width"] * 4),
+            )
+            data = bytearray(raw_data.contents)
+        finally:
+            # Free
+            self.xlib.XDestroyImage(ximage)
+
+        return self.cls_image(data, monitor)
+
+    def _cursor_impl(self) -> ScreenShot:
+        """Retrieve all cursor data. Pixels have to be RGB."""
+        # Read data of cursor/mouse-pointer
+        ximage = self.xfixes.XFixesGetCursorImage(self._handles.display)
+        if not (ximage and ximage.contents):
+            msg = "Cannot read XFixesGetCursorImage()"
+            raise ScreenShotError(msg)
+
+        cursor_img: XFixesCursorImage = ximage.contents
+        region = {
+            "left": cursor_img.x - cursor_img.xhot,
+            "top": cursor_img.y - cursor_img.yhot,
+            "width": cursor_img.width,
+            "height": cursor_img.height,
+        }
+
+        raw_data = cast(cursor_img.pixels, POINTER(c_ulong * region["height"] * region["width"]))
+        raw = bytearray(raw_data.contents)
+
+        data = bytearray(region["height"] * region["width"] * 4)
+        data[3::4] = raw[3::8]
+        data[2::4] = raw[2::8]
+        data[1::4] = raw[1::8]
+        data[::4] = raw[::8]
+
+        return self.cls_image(data, region)

UMCP.it-Unreal-Organizer-Assistant/Content/Python/mss/models.py

@@ -0,0 +1,23 @@
+"""This is part of the MSS Python's module.
+Source: https://github.com/BoboTiG/python-mss.
+"""
+
+from typing import Any, NamedTuple
+
+Monitor = dict[str, int]
+Monitors = list[Monitor]
+
+Pixel = tuple[int, int, int]
+Pixels = list[tuple[Pixel, ...]]
+
+CFunctions = dict[str, tuple[str, list[Any], Any]]
+
+
+class Pos(NamedTuple):
+    left: int
+    top: int
+
+
+class Size(NamedTuple):
+    width: int
+    height: int

UMCP.it-Unreal-Organizer-Assistant/Content/Python/mss/screenshot.py

@@ -0,0 +1,125 @@
+"""This is part of the MSS Python's module.
+Source: https://github.com/BoboTiG/python-mss.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from mss.exception import ScreenShotError
+from mss.models import Monitor, Pixel, Pixels, Pos, Size
+
+if TYPE_CHECKING:  # pragma: nocover
+    from collections.abc import Iterator
+
+
+class ScreenShot:
+    """Screenshot object.
+
+    .. note::
+
+        A better name would have  been *Image*, but to prevent collisions
+        with PIL.Image, it has been decided to use *ScreenShot*.
+    """
+
+    __slots__ = {"__pixels", "__rgb", "pos", "raw", "size"}
+
+    def __init__(self, data: bytearray, monitor: Monitor, /, *, size: Size | None = None) -> None:
+        self.__pixels: Pixels | None = None
+        self.__rgb: bytes | None = None
+
+        #: Bytearray of the raw BGRA pixels retrieved by ctypes
+        #: OS independent implementations.
+        self.raw = data
+
+        #: NamedTuple of the screenshot coordinates.
+        self.pos = Pos(monitor["left"], monitor["top"])
+
+        #: NamedTuple of the screenshot size.
+        self.size = Size(monitor["width"], monitor["height"]) if size is None else size
+
+    def __repr__(self) -> str:
+        return f"<{type(self).__name__} pos={self.left},{self.top} size={self.width}x{self.height}>"
+
+    @property
+    def __array_interface__(self) -> dict[str, Any]:
+        """Numpy array interface support.
+        It uses raw data in BGRA form.
+
+        See https://docs.scipy.org/doc/numpy/reference/arrays.interface.html
+        """
+        return {
+            "version": 3,
+            "shape": (self.height, self.width, 4),
+            "typestr": "|u1",
+            "data": self.raw,
+        }
+
+    @classmethod
+    def from_size(cls: type[ScreenShot], data: bytearray, width: int, height: int, /) -> ScreenShot:
+        """Instantiate a new class given only screenshot's data and size."""
+        monitor = {"left": 0, "top": 0, "width": width, "height": height}
+        return cls(data, monitor)
+
+    @property
+    def bgra(self) -> bytes:
+        """BGRA values from the BGRA raw pixels."""
+        return bytes(self.raw)
+
+    @property
+    def height(self) -> int:
+        """Convenient accessor to the height size."""
+        return self.size.height
+
+    @property
+    def left(self) -> int:
+        """Convenient accessor to the left position."""
+        return self.pos.left
+
+    @property
+    def pixels(self) -> Pixels:
+        """:return list: RGB tuples."""
+        if not self.__pixels:
+            rgb_tuples: Iterator[Pixel] = zip(self.raw[2::4], self.raw[1::4], self.raw[::4])
+            self.__pixels = list(zip(*[iter(rgb_tuples)] * self.width))
+
+        return self.__pixels
+
+    @property
+    def rgb(self) -> bytes:
+        """Compute RGB values from the BGRA raw pixels.
+
+        :return bytes: RGB pixels.
+        """
+        if not self.__rgb:
+            rgb = bytearray(self.height * self.width * 3)
+            raw = self.raw
+            rgb[::3] = raw[2::4]
+            rgb[1::3] = raw[1::4]
+            rgb[2::3] = raw[::4]
+            self.__rgb = bytes(rgb)
+
+        return self.__rgb
+
+    @property
+    def top(self) -> int:
+        """Convenient accessor to the top position."""
+        return self.pos.top
+
+    @property
+    def width(self) -> int:
+        """Convenient accessor to the width size."""
+        return self.size.width
+
+    def pixel(self, coord_x: int, coord_y: int) -> Pixel:
+        """Returns the pixel value at a given position.
+
+        :param int coord_x: The x coordinate.
+        :param int coord_y: The y coordinate.
+        :return tuple: The pixel value as (R, G, B).
+        """
+        try:
+            return self.pixels[coord_y][coord_x]
+        except IndexError as exc:
+            msg = f"Pixel location ({coord_x}, {coord_y}) is out of range."
+            raise ScreenShotError(msg) from exc

UMCP.it-Unreal-Organizer-Assistant/Content/Python/mss/tools.py

@@ -0,0 +1,65 @@
+"""This is part of the MSS Python's module.
+Source: https://github.com/BoboTiG/python-mss.
+"""
+
+from __future__ import annotations
+
+import os
+import struct
+import zlib
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+def to_png(data: bytes, size: tuple[int, int], /, *, level: int = 6, output: Path | str | None = None) -> bytes | None:
+    """Dump data to a PNG file.  If `output` is `None`, create no file but return
+    the whole PNG data.
+
+    :param bytes data: RGBRGB...RGB data.
+    :param tuple size: The (width, height) pair.
+    :param int level: PNG compression level.
+    :param str output: Output file name.
+    """
+    pack = struct.pack
+    crc32 = zlib.crc32
+
+    width, height = size
+    line = width * 3
+    png_filter = pack(">B", 0)
+    scanlines = b"".join([png_filter + data[y * line : y * line + line] for y in range(height)])
+
+    magic = pack(">8B", 137, 80, 78, 71, 13, 10, 26, 10)
+
+    # Header: size, marker, data, CRC32
+    ihdr = [b"", b"IHDR", b"", b""]
+    ihdr[2] = pack(">2I5B", width, height, 8, 2, 0, 0, 0)
+    ihdr[3] = pack(">I", crc32(b"".join(ihdr[1:3])) & 0xFFFFFFFF)
+    ihdr[0] = pack(">I", len(ihdr[2]))
+
+    # Data: size, marker, data, CRC32
+    idat = [b"", b"IDAT", zlib.compress(scanlines, level), b""]
+    idat[3] = pack(">I", crc32(b"".join(idat[1:3])) & 0xFFFFFFFF)
+    idat[0] = pack(">I", len(idat[2]))
+
+    # Footer: size, marker, None, CRC32
+    iend = [b"", b"IEND", b"", b""]
+    iend[3] = pack(">I", crc32(iend[1]) & 0xFFFFFFFF)
+    iend[0] = pack(">I", len(iend[2]))
+
+    if not output:
+        # Returns raw bytes of the whole PNG data
+        return magic + b"".join(ihdr + idat + iend)
+
+    with open(output, "wb") as fileh:  # noqa: PTH123
+        fileh.write(magic)
+        fileh.write(b"".join(ihdr))
+        fileh.write(b"".join(idat))
+        fileh.write(b"".join(iend))
+
+        # Force write of file to disk
+        fileh.flush()
+        os.fsync(fileh.fileno())
+
+    return None

UMCP.it-Unreal-Organizer-Assistant/Content/Python/mss/windows.py

@@ -0,0 +1,250 @@
+"""This is part of the MSS Python's module.
+Source: https://github.com/BoboTiG/python-mss.
+"""
+
+from __future__ import annotations
+
+import ctypes
+import sys
+from ctypes import POINTER, WINFUNCTYPE, Structure, c_int, c_void_p
+from ctypes.wintypes import (
+    BOOL,
+    DOUBLE,
+    DWORD,
+    HBITMAP,
+    HDC,
+    HGDIOBJ,
+    HWND,
+    INT,
+    LONG,
+    LPARAM,
+    LPRECT,
+    RECT,
+    UINT,
+    WORD,
+)
+from threading import local
+from typing import TYPE_CHECKING, Any
+
+from mss.base import MSSBase
+from mss.exception import ScreenShotError
+
+if TYPE_CHECKING:  # pragma: nocover
+    from mss.models import CFunctions, Monitor
+    from mss.screenshot import ScreenShot
+
+__all__ = ("MSS",)
+
+
+CAPTUREBLT = 0x40000000
+DIB_RGB_COLORS = 0
+SRCCOPY = 0x00CC0020
+
+
+class BITMAPINFOHEADER(Structure):
+    """Information about the dimensions and color format of a DIB."""
+
+    _fields_ = (
+        ("biSize", DWORD),
+        ("biWidth", LONG),
+        ("biHeight", LONG),
+        ("biPlanes", WORD),
+        ("biBitCount", WORD),
+        ("biCompression", DWORD),
+        ("biSizeImage", DWORD),
+        ("biXPelsPerMeter", LONG),
+        ("biYPelsPerMeter", LONG),
+        ("biClrUsed", DWORD),
+        ("biClrImportant", DWORD),
+    )
+
+
+class BITMAPINFO(Structure):
+    """Structure that defines the dimensions and color information for a DIB."""
+
+    _fields_ = (("bmiHeader", BITMAPINFOHEADER), ("bmiColors", DWORD * 3))
+
+
+MONITORNUMPROC = WINFUNCTYPE(INT, DWORD, DWORD, POINTER(RECT), DOUBLE)
+
+
+# C functions that will be initialised later.
+#
+# Available attr: gdi32, user32.
+#
+# Note: keep it sorted by cfunction.
+CFUNCTIONS: CFunctions = {
+    # Syntax: cfunction: (attr, argtypes, restype)
+    "BitBlt": ("gdi32", [HDC, INT, INT, INT, INT, HDC, INT, INT, DWORD], BOOL),
+    "CreateCompatibleBitmap": ("gdi32", [HDC, INT, INT], HBITMAP),
+    "CreateCompatibleDC": ("gdi32", [HDC], HDC),
+    "DeleteDC": ("gdi32", [HDC], HDC),
+    "DeleteObject": ("gdi32", [HGDIOBJ], INT),
+    "EnumDisplayMonitors": ("user32", [HDC, c_void_p, MONITORNUMPROC, LPARAM], BOOL),
+    "GetDeviceCaps": ("gdi32", [HWND, INT], INT),
+    "GetDIBits": ("gdi32", [HDC, HBITMAP, UINT, UINT, c_void_p, POINTER(BITMAPINFO), UINT], BOOL),
+    "GetSystemMetrics": ("user32", [INT], INT),
+    "GetWindowDC": ("user32", [HWND], HDC),
+    "ReleaseDC": ("user32", [HWND, HDC], c_int),
+    "SelectObject": ("gdi32", [HDC, HGDIOBJ], HGDIOBJ),
+}
+
+
+class MSS(MSSBase):
+    """Multiple ScreenShots implementation for Microsoft Windows."""
+
+    __slots__ = {"_handles", "gdi32", "user32"}
+
+    def __init__(self, /, **kwargs: Any) -> None:
+        """Windows initialisations."""
+        super().__init__(**kwargs)
+
+        self.user32 = ctypes.WinDLL("user32")
+        self.gdi32 = ctypes.WinDLL("gdi32")
+        self._set_cfunctions()
+        self._set_dpi_awareness()
+
+        # Available thread-specific variables
+        self._handles = local()
+        self._handles.region_width_height = (0, 0)
+        self._handles.bmp = None
+        self._handles.srcdc = self.user32.GetWindowDC(0)
+        self._handles.memdc = self.gdi32.CreateCompatibleDC(self._handles.srcdc)
+
+        bmi = BITMAPINFO()
+        bmi.bmiHeader.biSize = ctypes.sizeof(BITMAPINFOHEADER)
+        bmi.bmiHeader.biPlanes = 1  # Always 1
+        bmi.bmiHeader.biBitCount = 32  # See grab.__doc__ [2]
+        bmi.bmiHeader.biCompression = 0  # 0 = BI_RGB (no compression)
+        bmi.bmiHeader.biClrUsed = 0  # See grab.__doc__ [3]
+        bmi.bmiHeader.biClrImportant = 0  # See grab.__doc__ [3]
+        self._handles.bmi = bmi
+
+    def close(self) -> None:
+        # Clean-up
+        if self._handles.bmp:
+            self.gdi32.DeleteObject(self._handles.bmp)
+            self._handles.bmp = None
+
+        if self._handles.memdc:
+            self.gdi32.DeleteDC(self._handles.memdc)
+            self._handles.memdc = None
+
+        if self._handles.srcdc:
+            self.user32.ReleaseDC(0, self._handles.srcdc)
+            self._handles.srcdc = None
+
+    def _set_cfunctions(self) -> None:
+        """Set all ctypes functions and attach them to attributes."""
+        cfactory = self._cfactory
+        attrs = {
+            "gdi32": self.gdi32,
+            "user32": self.user32,
+        }
+        for func, (attr, argtypes, restype) in CFUNCTIONS.items():
+            cfactory(attrs[attr], func, argtypes, restype)
+
+    def _set_dpi_awareness(self) -> None:
+        """Set DPI awareness to capture full screen on Hi-DPI monitors."""
+        version = sys.getwindowsversion()[:2]
+        if version >= (6, 3):
+            # Windows 8.1+
+            # Here 2 = PROCESS_PER_MONITOR_DPI_AWARE, which means:
+            #     per monitor DPI aware. This app checks for the DPI when it is
+            #     created and adjusts the scale factor whenever the DPI changes.
+            #     These applications are not automatically scaled by the system.
+            ctypes.windll.shcore.SetProcessDpiAwareness(2)
+        elif (6, 0) <= version < (6, 3):
+            # Windows Vista, 7, 8, and Server 2012
+            self.user32.SetProcessDPIAware()
+
+    def _monitors_impl(self) -> None:
+        """Get positions of monitors. It will populate self._monitors."""
+        int_ = int
+        user32 = self.user32
+        get_system_metrics = user32.GetSystemMetrics
+
+        # All monitors
+        self._monitors.append(
+            {
+                "left": int_(get_system_metrics(76)),  # SM_XVIRTUALSCREEN
+                "top": int_(get_system_metrics(77)),  # SM_YVIRTUALSCREEN
+                "width": int_(get_system_metrics(78)),  # SM_CXVIRTUALSCREEN
+                "height": int_(get_system_metrics(79)),  # SM_CYVIRTUALSCREEN
+            },
+        )
+
+        # Each monitor
+        def _callback(_monitor: int, _data: HDC, rect: LPRECT, _dc: LPARAM) -> int:
+            """Callback for monitorenumproc() function, it will return
+            a RECT with appropriate values.
+            """
+            rct = rect.contents
+            self._monitors.append(
+                {
+                    "left": int_(rct.left),
+                    "top": int_(rct.top),
+                    "width": int_(rct.right) - int_(rct.left),
+                    "height": int_(rct.bottom) - int_(rct.top),
+                },
+            )
+            return 1
+
+        callback = MONITORNUMPROC(_callback)
+        user32.EnumDisplayMonitors(0, 0, callback, 0)
+
+    def _grab_impl(self, monitor: Monitor, /) -> ScreenShot:
+        """Retrieve all pixels from a monitor. Pixels have to be RGB.
+
+        In the code, there are a few interesting things:
+
+        [1] bmi.bmiHeader.biHeight = -height
+
+        A bottom-up DIB is specified by setting the height to a
+        positive number, while a top-down DIB is specified by
+        setting the height to a negative number.
+        https://msdn.microsoft.com/en-us/library/ms787796.aspx
+        https://msdn.microsoft.com/en-us/library/dd144879%28v=vs.85%29.aspx
+
+
+        [2] bmi.bmiHeader.biBitCount = 32
+            image_data = create_string_buffer(height * width * 4)
+
+        We grab the image in RGBX mode, so that each word is 32bit
+        and we have no striding.
+        Inspired by https://github.com/zoofIO/flexx
+
+
+        [3] bmi.bmiHeader.biClrUsed = 0
+            bmi.bmiHeader.biClrImportant = 0
+
+        When biClrUsed and biClrImportant are set to zero, there
+        is "no" color table, so we can read the pixels of the bitmap
+        retrieved by gdi32.GetDIBits() as a sequence of RGB values.
+        Thanks to http://stackoverflow.com/a/3688682
+        """
+        srcdc, memdc = self._handles.srcdc, self._handles.memdc
+        gdi = self.gdi32
+        width, height = monitor["width"], monitor["height"]
+
+        if self._handles.region_width_height != (width, height):
+            self._handles.region_width_height = (width, height)
+            self._handles.bmi.bmiHeader.biWidth = width
+            self._handles.bmi.bmiHeader.biHeight = -height  # Why minus? [1]
+            self._handles.data = ctypes.create_string_buffer(width * height * 4)  # [2]
+            if self._handles.bmp:
+                gdi.DeleteObject(self._handles.bmp)
+            self._handles.bmp = gdi.CreateCompatibleBitmap(srcdc, width, height)
+            gdi.SelectObject(memdc, self._handles.bmp)
+
+        gdi.BitBlt(memdc, 0, 0, width, height, srcdc, monitor["left"], monitor["top"], SRCCOPY | CAPTUREBLT)
+        bits = gdi.GetDIBits(memdc, self._handles.bmp, 0, height, self._handles.data, self._handles.bmi, DIB_RGB_COLORS)
+        if bits != height:
+            msg = "gdi32.GetDIBits() failed."
+            raise ScreenShotError(msg)
+
+        return self.cls_image(bytearray(self._handles.data), monitor)
+
+    def _cursor_impl(self) -> ScreenShot | None:
+        """Retrieve all cursor data. Pixels have to be RGB."""
+        return None

UMCP.it-Unreal-Organizer-Assistant/Content/Python/socket_server_config.json

@@ -0,0 +1,3 @@
+{
+  "auto_start_socket_server": false
+}

UMCP.it-Unreal-Organizer-Assistant/Content/Python/unreal_socket_server.py

@@ -0,0 +1,304 @@
+import socket
+import json
+import unreal
+import threading
+import time
+import importlib
+from typing import Dict, Any, Tuple, List, Optional
+
+# Import handlers
+from handlers import basic_commands, actor_commands, blueprint_commands, python_commands
+from handlers import ui_commands, organization_commands, physics_commands, blueprint_connection_commands
+from utils import logging as log
+
+# Force reload of all handler modules to pick up code changes
+importlib.reload(basic_commands)
+importlib.reload(actor_commands)
+importlib.reload(blueprint_commands)
+importlib.reload(python_commands)
+importlib.reload(ui_commands)
+importlib.reload(organization_commands)
+importlib.reload(physics_commands)
+importlib.reload(blueprint_connection_commands)
+
+# Global queues and state
+command_queue = []
+response_dict = {}
+
+
+class CommandDispatcher:
+    """
+    Dispatches commands to appropriate handlers based on command type
+    """
+    def __init__(self):
+        # Register command handlers
+        self.handlers = {
+            "handshake": self._handle_handshake,
+
+            # Basic object commands
+            "spawn": basic_commands.handle_spawn,
+            "create_material": basic_commands.handle_create_material,
+            "modify_object": actor_commands.handle_modify_object,
+            "take_screenshot": basic_commands.handle_take_screenshot,
+
+            # Blueprint commands
+            "create_blueprint": blueprint_commands.handle_create_blueprint,
+            "add_component": blueprint_commands.handle_add_component,
+            "add_variable": blueprint_commands.handle_add_variable,
+            "add_function": blueprint_commands.handle_add_function,
+            "add_node": blueprint_commands.handle_add_node,
+            "connect_nodes": blueprint_commands.handle_connect_nodes,
+            "compile_blueprint": blueprint_commands.handle_compile_blueprint,
+            "spawn_blueprint": blueprint_commands.handle_spawn_blueprint,
+            "delete_node": blueprint_commands.handle_delete_node,
+            
+            # Getters
+            "get_node_guid": blueprint_commands.handle_get_node_guid,
+            "get_all_nodes": blueprint_commands.handle_get_all_nodes,
+            "get_node_suggestions": blueprint_commands.handle_get_node_suggestions,
+            
+            
+            # Bulk commands
+            "add_nodes_bulk": blueprint_commands.handle_add_nodes_bulk,
+            "connect_nodes_bulk": blueprint_commands.handle_connect_nodes_bulk,
+            
+            # Python and console
+            "execute_python": python_commands.handle_execute_python,
+            "execute_unreal_command": python_commands.handle_execute_unreal_command,
+            
+            # Actor and Blueprint creation
+            "edit_component_property": actor_commands.handle_edit_component_property,
+            "add_component_with_events": actor_commands.handle_add_component_with_events,
+            "create_game_mode": actor_commands.handle_create_game_mode,
+
+            # Scene
+            "get_all_scene_objects": basic_commands.handle_get_all_scene_objects,
+            "create_project_folder": basic_commands.handle_create_project_folder,
+            "get_files_in_folder": basic_commands.handle_get_files_in_folder,
+            
+            # Input
+            "add_input_binding": basic_commands.handle_add_input_binding,
+            "create_enhanced_input_action": basic_commands.handle_create_enhanced_input_action,
+            "create_enhanced_input_mapping_context": basic_commands.handle_create_enhanced_input_mapping_context,
+
+            # Component helpers
+            "get_component_names": actor_commands.handle_get_component_names,
+
+            # Blueprint helpers
+            "get_node_pin_names": blueprint_commands.handle_get_node_pin_names,
+
+            # --- NEW UI COMMANDS ---
+            "add_widget_to_user_widget": ui_commands.handle_add_widget_to_user_widget,
+            "edit_widget_property": ui_commands.handle_edit_widget_property,
+
+            # --- ORGANIZATION COMMANDS ---
+            "create_folder_structure": organization_commands.handle_create_folder_structure,
+            "organize_assets_by_type": organization_commands.handle_organize_assets_by_type,
+            "organize_world_outliner": organization_commands.handle_organize_world_outliner,
+            "tag_assets": organization_commands.handle_tag_assets,
+            "search_assets_by_tag": organization_commands.handle_search_assets_by_tag,
+            "generate_organization_report": organization_commands.handle_generate_organization_report,
+
+            # --- PHYSICS & SELECTION COMMANDS ---
+            "get_selected_actors": physics_commands.handle_get_selected_actors,
+            "enable_physics_on_selected": physics_commands.handle_enable_physics_on_selected,
+            "enable_physics_on_actor": physics_commands.handle_enable_physics_on_actor,
+
+            # --- BLUEPRINT CONNECTION COMMANDS ---
+            "get_node_pins": blueprint_connection_commands.handle_get_node_pins,
+            "validate_connection": blueprint_connection_commands.handle_validate_connection,
+            "auto_connect_chain": blueprint_connection_commands.handle_auto_connect_chain,
+            "suggest_connections": blueprint_connection_commands.handle_suggest_connections,
+            "get_graph_connections": blueprint_connection_commands.handle_get_graph_connections,
+        }
+
+    def dispatch(self, command: Dict[str, Any]) -> Dict[str, Any]:
+        """Dispatch command to appropriate handler"""
+        command_type = command.get("type")
+        if command_type not in self.handlers:
+            return {"success": False, "error": f"Unknown command type: {command_type}"}
+
+        try:
+            handler = self.handlers[command_type]
+            return handler(command)
+        except Exception as e:
+            log.log_error(f"Error processing command: {str(e)}")
+            return {"success": False, "error": str(e)}
+
+    def _handle_handshake(self, command: Dict[str, Any]) -> Dict[str, Any]:
+        """Built-in handler for handshake command"""
+        message = command.get("message", "")
+        log.log_info(f"Handshake received: {message}")
+        
+        # Get Unreal Engine version
+        engine_version = unreal.SystemLibrary.get_engine_version()
+        
+        # Add connection and session information
+        connection_info = {
+            "status": "Connected",
+            "engine_version": engine_version,
+            "timestamp": time.time(),
+            "session_id": f"UE-{int(time.time())}"
+        }
+        
+        return {
+            "success": True, 
+            "message": f"Received: {message}",
+            "connection_info": connection_info
+        }
+
+
+# Create global dispatcher instance
+dispatcher = CommandDispatcher()
+
+
+def process_commands(delta_time=None):
+    """Process commands on the main thread"""
+    if not command_queue:
+        return
+
+    command_id, command = command_queue.pop(0)
+    log.log_info(f"Processing command on main thread: {command}")
+
+    try:
+        response = dispatcher.dispatch(command)
+        response_dict[command_id] = response
+    except Exception as e:
+        log.log_error(f"Error processing command: {str(e)}", include_traceback=True)
+        response_dict[command_id] = {"success": False, "error": str(e)}
+
+
+def receive_all_data(conn, buffer_size=4096):
+    """
+    Receive all data from socket until complete JSON is received
+    
+    Args:
+        conn: Socket connection
+        buffer_size: Initial buffer size for receiving data
+        
+    Returns:
+        Decoded complete data
+    """
+    data = b""
+    while True:
+        try:
+            # Receive chunk of data
+            chunk = conn.recv(buffer_size)
+            if not chunk:
+                break
+            
+            data += chunk
+            
+            # Try to parse as JSON to check if we received complete data
+            try:
+                json.loads(data.decode('utf-8'))
+                # If we get here, JSON is valid and complete
+                return data.decode('utf-8')
+            except json.JSONDecodeError as json_err:
+                # Check if the error indicates an unterminated string or incomplete JSON
+                if "Unterminated string" in str(json_err) or "Expecting" in str(json_err):
+                    # Need more data, continue receiving
+                    continue
+                else:
+                    # JSON is malformed in some other way, not just incomplete
+                    log.log_error(f"Malformed JSON received: {str(json_err)}", include_traceback=True)
+                    return None
+            
+        except socket.timeout:
+            # Socket timeout, return what we have so far
+            log.log_warning("Socket timeout while receiving data")
+            return data.decode('utf-8')
+        except Exception as e:
+            log.log_error(f"Error receiving data: {str(e)}", include_traceback=True)
+            return None
+    
+    return data.decode('utf-8')
+
+
+def socket_server_thread():
+    """Socket server running in a separate thread"""
+    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+    server_socket.bind(('localhost', 9877))
+    server_socket.listen(1)
+    log.log_info("Unreal Engine socket server started on port 9877")
+
+    command_counter = 0
+
+    while True:
+        try:
+            conn, addr = server_socket.accept()
+            # Set a timeout to prevent hanging
+            conn.settimeout(5)  # 5-second timeout
+            
+            # Receive complete data, handling potential incomplete JSON
+            data_str = receive_all_data(conn)
+            
+            if data_str:
+                try:
+                    command = json.loads(data_str)
+                    log.log_info(f"Received command: {command}")
+
+                    # All commands must be processed on main thread, including handshake
+                    command_id = command_counter
+                    command_counter += 1
+                    command_queue.append((command_id, command))
+
+                    # Wait for the response with a timeout
+                    timeout = 10  # seconds
+                    start_time = time.time()
+                    while command_id not in response_dict and time.time() - start_time < timeout:
+                        time.sleep(0.1)
+
+                    if command_id in response_dict:
+                        response = response_dict.pop(command_id)
+                        conn.sendall(json.dumps(response).encode())
+                    else:
+                        error_response = {"success": False, "error": "Command timed out"}
+                        conn.sendall(json.dumps(error_response).encode())
+                except json.JSONDecodeError as json_err:
+                    log.log_error(f"Error parsing JSON: {str(json_err)}", include_traceback=True)
+                    error_response = {"success": False, "error": f"Invalid JSON: {str(json_err)}"}
+                    conn.sendall(json.dumps(error_response).encode())
+            else:
+                # No data or error receiving data
+                error_response = {"success": False, "error": "No data received or error parsing data"}
+                conn.sendall(json.dumps(error_response).encode())
+                
+            conn.close()
+        except Exception as e:
+            log.log_error(f"Error in socket server: {str(e)}", include_traceback=True)
+            try:
+                # Try to close the connection if it's still open
+                conn.close()
+            except:
+                pass
+
+
+# Register tick function to process commands on main thread
+def register_command_processor():
+    """Register the command processor with Unreal's tick system"""
+    unreal.register_slate_post_tick_callback(process_commands)
+    log.log_info("Command processor registered")
+
+
+# Initialize the server
+def initialize_server():
+    """Initialize and start the socket server"""
+    # Start the server thread
+    thread = threading.Thread(target=socket_server_thread)
+    thread.daemon = True
+    thread.start()
+    log.log_info("Socket server thread started")
+
+    # Register the command processor on the main thread
+    register_command_processor()
+
+    log.log_info("Unreal Engine AI command server initialized successfully")
+    log.log_info("Available commands:")
+    log.log_info("  - Basic: handshake, spawn, create_material, modify_object")
+    log.log_info("  - Blueprint: create_blueprint, add_component, add_variable, add_function, add_node, connect_nodes, compile_blueprint, spawn_blueprint, add_nodes_bulk, connect_nodes_bulk")
+
+# Auto-start the server when this module is imported
+initialize_server()
+

UMCP.it-Unreal-Organizer-Assistant/Content/Python/utils/__init__.py

@@ -0,0 +1 @@
+# utils package

UMCP.it-Unreal-Organizer-Assistant/Content/Python/utils/asset_validation.py

@@ -0,0 +1,232 @@
+"""
+Asset Validation Utilities
+
+Fixes for asset reference timing issues identified in LM_STUDIO_DIAGNOSTIC_REPORT.md
+Prevents "Failed to find object" errors by validating assets before referencing.
+"""
+
+import unreal
+import time
+from typing import Optional, List, Dict
+
+
+def validate_asset_exists(asset_path: str) -> bool:
+    """
+    Check if an asset exists before referencing it.
+
+    Args:
+        asset_path: Unreal asset path (e.g., '/Game/Blueprints/BP_Test')
+
+    Returns:
+        True if asset exists and is valid, False otherwise
+
+    Example:
+        >>> validate_asset_exists('/Game/Blueprints/BP_Test')
+        True
+    """
+    try:
+        asset = unreal.EditorAssetLibrary.find_asset_data(asset_path)
+        return asset.is_valid()
+    except Exception as e:
+        unreal.log_warning(f"Asset validation error for '{asset_path}': {e}")
+        return False
+
+
+def discover_blueprints(folder_path: str = "/Game", recursive: bool = True) -> List[str]:
+    """
+    List all available blueprints in the project.
+
+    Args:
+        folder_path: Root folder to search (default: '/Game')
+        recursive: Search subfolders (default: True)
+
+    Returns:
+        List of blueprint asset paths
+
+    Example:
+        >>> discover_blueprints('/Game/Blueprints')
+        ['/Game/Blueprints/BP_Test', '/Game/Blueprints/BP_Player']
+    """
+    try:
+        all_assets = unreal.EditorAssetLibrary.list_assets(
+            folder_path,
+            recursive=recursive,
+            include_folder=False
+        )
+
+        # Filter for blueprints only
+        blueprints = []
+        for asset_path in all_assets:
+            if asset_path.endswith('_C') or 'Blueprint' in asset_path:
+                blueprints.append(asset_path)
+
+        return blueprints
+    except Exception as e:
+        unreal.log_error(f"Blueprint discovery error: {e}")
+        return []
+
+
+def normalize_blueprint_path(path: str) -> str:
+    """
+    Normalize blueprint path to standard format.
+
+    Handles various path formats and fixes common issues:
+    - Removes .uasset extensions
+    - Fixes double references (BP_Test.BP_Test)
+    - Ensures /Game prefix
+
+    Args:
+        path: Blueprint path in any format
+
+    Returns:
+        Normalized path
+
+    Example:
+        >>> normalize_blueprint_path('/Game/Blueprints/BP_Test.BP_Test')
+        '/Game/Blueprints/BP_Test'
+    """
+    # Remove .uasset extension
+    path = path.replace('.uasset', '')
+
+    # Fix double reference (e.g., BP_Test.BP_Test -> BP_Test)
+    parts = path.split('/')
+    if parts and '.' in parts[-1]:
+        base_name = parts[-1].split('.')[0]
+        parts[-1] = base_name
+        path = '/'.join(parts)
+
+    # Ensure /Game prefix
+    if not path.startswith('/Game'):
+        path = f'/Game/{path.lstrip("/")}'
+
+    return path
+
+
+def wait_for_asset_save(asset_path: str, timeout: float = 2.0, check_interval: float = 0.1) -> bool:
+    """
+    Wait for an asset to be saved and become available.
+
+    Args:
+        asset_path: Path to the asset
+        timeout: Maximum time to wait in seconds (default: 2.0)
+        check_interval: How often to check in seconds (default: 0.1)
+
+    Returns:
+        True if asset became available, False if timeout
+
+    Example:
+        >>> wait_for_asset_save('/Game/Blueprints/BP_NewBlueprint')
+        True
+    """
+    elapsed = 0.0
+    while elapsed < timeout:
+        if validate_asset_exists(asset_path):
+            return True
+        time.sleep(check_interval)
+        elapsed += check_interval
+
+    unreal.log_warning(f"Timeout waiting for asset: {asset_path}")
+    return False
+
+
+def get_available_blueprints_message(folder_path: str = "/Game/Blueprints") -> str:
+    """
+    Generate a helpful error message listing available blueprints.
+
+    Args:
+        folder_path: Folder to search for blueprints
+
+    Returns:
+        Formatted message with available blueprints
+
+    Example:
+        >>> print(get_available_blueprints_message())
+        Available blueprints in /Game/Blueprints:
+        - BP_TestActor
+        - BP_PlayerCharacter
+    """
+    blueprints = discover_blueprints(folder_path)
+
+    if not blueprints:
+        return f"No blueprints found in {folder_path}"
+
+    message = f"Available blueprints in {folder_path}:\n"
+    for bp in blueprints[:10]:  # Limit to first 10
+        bp_name = bp.split('/')[-1]
+        message += f"  - {bp_name}\n"
+
+    if len(blueprints) > 10:
+        message += f"  ... and {len(blueprints) - 10} more"
+
+    return message
+
+
+def suggest_similar_blueprint(target_name: str, folder_path: str = "/Game") -> Optional[str]:
+    """
+    Suggest a similar blueprint name if exact match not found.
+
+    Args:
+        target_name: The blueprint name being searched for
+        folder_path: Folder to search in
+
+    Returns:
+        Suggested blueprint path or None
+
+    Example:
+        >>> suggest_similar_blueprint('BP_Test', '/Game/Blueprints')
+        '/Game/Blueprints/BP_TestActor'
+    """
+    blueprints = discover_blueprints(folder_path)
+    target_lower = target_name.lower()
+
+    # Look for partial matches
+    for bp in blueprints:
+        bp_name = bp.split('/')[-1].lower()
+        if target_lower in bp_name or bp_name in target_lower:
+            return bp
+
+    return None
+
+
+def validate_asset_with_suggestion(asset_path: str) -> Dict[str, any]:
+    """
+    Validate asset and provide helpful error message with suggestions.
+
+    Args:
+        asset_path: Asset path to validate
+
+    Returns:
+        Dictionary with 'valid', 'message', and optional 'suggestion' keys
+
+    Example:
+        >>> result = validate_asset_with_suggestion('/Game/Blueprints/BP_NotFound')
+        >>> print(result['message'])
+        Blueprint '/Game/Blueprints/BP_NotFound' not found.
+        Did you mean: /Game/Blueprints/BP_TestActor?
+    """
+    normalized_path = normalize_blueprint_path(asset_path)
+
+    if validate_asset_exists(normalized_path):
+        return {
+            'valid': True,
+            'message': f"Asset found: {normalized_path}"
+        }
+
+    # Asset not found - provide helpful error
+    folder_path = '/'.join(normalized_path.split('/')[:-1])
+    asset_name = normalized_path.split('/')[-1]
+
+    suggestion = suggest_similar_blueprint(asset_name, folder_path)
+
+    message = f"Blueprint '{normalized_path}' not found.\n"
+
+    if suggestion:
+        message += f"Did you mean: {suggestion}?\n"
+    else:
+        message += get_available_blueprints_message(folder_path)
+
+    return {
+        'valid': False,
+        'message': message,
+        'suggestion': suggestion
+    }

UMCP.it-Unreal-Organizer-Assistant/Content/Python/utils/logging.py

@@ -0,0 +1,70 @@
+import unreal
+import traceback
+from typing import Any
+
+
+def log_info(message: str) -> None:
+    """
+    Log an informational message to the Unreal log
+    
+    Args:
+        message: The message to log
+    """
+    unreal.log(f"[AI Plugin] {message}")
+
+
+def log_warning(message: str) -> None:
+    """
+    Log a warning message to the Unreal log
+    
+    Args:
+        message: The message to log
+    """
+    unreal.log_warning(f"[AI Plugin] {message}")
+
+
+def log_error(message: str, include_traceback: bool = False) -> None:
+    """
+    Log an error message to the Unreal log
+    
+    Args:
+        message: The message to log
+        include_traceback: Whether to include the traceback in the log
+    """
+    error_message = f"[AI Plugin] ERROR: {message}"
+    unreal.log_error(error_message)
+
+    if include_traceback:
+        tb = traceback.format_exc()
+        unreal.log_error(f"[AI Plugin] Traceback:\n{tb}")
+
+
+def log_command(command_type: str, details: Any = None) -> None:
+    """
+    Log a command being processed
+    
+    Args:
+        command_type: The type of command being processed
+        details: Optional details about the command
+    """
+    if details:
+        unreal.log(f"[AI Plugin] Processing {command_type} command: {details}")
+    else:
+        unreal.log(f"[AI Plugin] Processing {command_type} command")
+
+
+def log_result(command_type: str, success: bool, details: Any = None) -> None:
+    """
+    Log the result of a command
+    
+    Args:
+        command_type: The type of command that was processed
+        success: Whether the command was successful
+        details: Optional details about the result
+    """
+    status = "successful" if success else "failed"
+
+    if details:
+        unreal.log(f"[AI Plugin] {command_type} command {status}: {details}")
+    else:
+        unreal.log(f"[AI Plugin] {command_type} command {status}")

UMCP.it-Unreal-Organizer-Assistant/Content/Python/utils/unreal_conversions.py

@@ -0,0 +1,54 @@
+import unreal
+from typing import Tuple, List, Union, Optional
+
+
+def to_unreal_vector(vector_data: Union[List[float], Tuple[float, float, float]]) -> unreal.Vector:
+    """
+    Convert a list or tuple of 3 floats to an Unreal Vector
+    
+    Args:
+        vector_data: A list or tuple containing 3 floats [x, y, z]
+        
+    Returns:
+        An unreal.Vector object
+    """
+    if not isinstance(vector_data, (list, tuple)) or len(vector_data) != 3:
+        raise ValueError("Vector data must be a list or tuple of 3 floats")
+
+    return unreal.Vector(vector_data[0], vector_data[1], vector_data[2])
+
+
+def to_unreal_rotator(rotation_data: Union[List[float], Tuple[float, float, float]]) -> unreal.Rotator:
+    """
+    Convert a list or tuple of 3 floats to an Unreal Rotator
+    
+    Args:
+        rotation_data: A list or tuple containing 3 floats [pitch, yaw, roll]
+        
+    Returns:
+        An unreal.Rotator object
+    """
+    if not isinstance(rotation_data, (list, tuple)) or len(rotation_data) != 3:
+        raise ValueError("Rotation data must be a list or tuple of 3 floats")
+
+    return unreal.Rotator(rotation_data[0], rotation_data[1], rotation_data[2])
+
+
+def to_unreal_color(color_data: Union[List[float], Tuple[float, float, float]]) -> unreal.LinearColor:
+    """
+    Convert a list or tuple of 3 floats to an Unreal LinearColor
+    
+    Args:
+        color_data: A list or tuple containing 3 floats [r, g, b]
+        
+    Returns:
+        An unreal.LinearColor object with alpha=1.0
+    """
+    if not isinstance(color_data, (list, tuple)) or len(color_data) < 3:
+        raise ValueError("Color data must be a list or tuple of at least 3 floats")
+
+    alpha = 1.0
+    if len(color_data) > 3:
+        alpha = color_data[3]
+
+    return unreal.LinearColor(color_data[0], color_data[1], color_data[2], alpha)

UMCP.it-Unreal-Organizer-Assistant/Content/unreal_server_init.py

@@ -0,0 +1,1357 @@
+import unreal
+import json
+import sys
+import traceback
+
+class MCPUnrealBridge:
+
+    @staticmethod
+    def get_actors():
+        """Get all actors in the current level"""
+        result = []
+        actor_subsystem = unreal.get_editor_subsystem(unreal.EditorActorSubsystem) #unreal.EditorActorSubsystem().get_editor_subsystem()
+        actors = actor_subsystem.get_all_level_actors()
+        
+        for actor in actors:
+            result.append({
+                "name": actor.get_name(),
+                "class": actor.get_class().get_name(),
+                "location": str(actor.get_actor_location())
+            })
+        
+        return json.dumps({"status": "success", "result": result})
+
+    @staticmethod
+    def get_actor_details(actor_name):
+        """Get details for a specific actor by name."""
+        result = {}
+        actor_subsystem = unreal.get_editor_subsystem(unreal.EditorActorSubsystem) #unreal.EditorActorSubsystem().get_editor_subsystem()
+        actors = actor_subsystem.get_all_level_actors()
+        
+        for actor in actors:
+            if actor.get_name() == actor_name:
+                result = {
+                    "name": actor.get_name(),
+                    "class": actor.get_class().get_name(),
+                    "location": str(actor.get_actor_location())
+                }
+                break
+
+        if not result:
+            result = f"Actor not found: {actor_name}"
+        
+        return json.dumps({"status": "success", "result": result})
+    
+    @staticmethod
+    def spawn_actor(asset_path, location_x=0, location_y=0, location_z=0, rotation_x=0, rotation_y=0, rotation_z=0, scale_x=0, scale_y=0, scale_z=0):
+        """Spawn a new actor in the level"""
+        try:
+
+            # Find the class reference
+            class_obj = unreal.load_asset(asset_path)
+            if not class_obj:
+                return json.dumps({"status": "error", "message": f"Asset '{asset_path}' not found"})
+            
+            # Create the actor
+            location = unreal.Vector(float(location_x), float(location_y), float(location_z))
+            rotation = unreal.Rotator(rotation_x, rotation_y, rotation_z)
+            actor_subsystem = unreal.get_editor_subsystem(unreal.EditorActorSubsystem)
+            actor = actor_subsystem.spawn_actor_from_object(class_obj, location, rotation)
+            
+            if actor:
+                actor.set_actor_scale3d(unreal.Vector(scale_x, scale_y, scale_z))
+                return json.dumps({
+                    "status": "success", 
+                    "result": f"Created {asset_path} actor named '{actor.get_name()}' at location ({location_x}, {location_y}, {location_z})"
+                })
+            else:
+                return json.dumps({ "status": "error", "message" : "Failed to create actor" })
+        except Exception as e :
+            return json.dumps({ "status": "error", "message" : str(e) })
+
+    @staticmethod
+    def modify_actor(actor_name, property_name, property_value):
+        """Modify a property of an existing actor"""
+        try:
+            actor_subsystem = unreal.get_editor_subsystem(unreal.EditorActorSubsystem) #unreal.EditorActorSubsystem().get_editor_subsystem()
+            actors = actor_subsystem.get_all_level_actors()
+
+            for actor in actors:
+                if actor.get_name() == actor_name:
+                    # Try to determine property type and convert value
+                    current_value = getattr(actor, property_name, None)
+                    if current_value is not None:
+                        if isinstance(current_value, float):
+                            setattr(actor, property_name, float(property_value))
+                        elif isinstance(current_value, int):
+                            setattr(actor, property_name, int(property_value))
+                        elif isinstance(current_value, bool):
+                            setattr(actor, property_name, property_value.lower() in['true', 'yes', '1'])
+                        elif isinstance(current_value, unreal.Vector):
+                            # Assuming format like "X,Y,Z"
+                            x, y, z = map(float, property_value.split(','))
+                            setattr(actor, property_name, unreal.Vector(x, y, z))
+                        else:
+                            # Default to string
+                            setattr(actor, property_name, property_value)
+
+                        return json.dumps({
+                            "status": "success",
+                            "result" : f"Modified {property_name} on {actor_name} to {property_value}"
+                        })
+                    else:
+                        return json.dumps({
+                            "status": "error",
+                            "message" : f"Property {property_name} not found on {actor_name}"
+                        })
+
+            return json.dumps({ "status": "error", "message" : f"Actor '{actor_name}' not found" })
+        except Exception as e :
+            return json.dumps({ "status": "error", "message" : str(e) })
+
+    @staticmethod
+    def get_selected_actors():
+        """Get the currently selected actors in the editor"""
+        try:
+            actor_subsystem = unreal.get_editor_subsystem(unreal.EditorActorSubsystem) #unreal.EditorActorSubsystem().get_editor_subsystem()
+            selected_actors = actor_subsystem.get_selected_level_actors()
+
+            result = []
+            for actor in selected_actors:
+                result.append({
+                    "name": actor.get_name(),
+                    "class" : actor.get_class().get_name(),
+                    "location" : str(actor.get_actor_location())
+                })
+
+            return json.dumps({ "status": "success", "result": result })
+        except Exception as e:
+            return json.dumps({ "status": "error", "message": str(e) })
+
+    @staticmethod
+    def set_material(actor_name, material_path):
+        """Apply a material to a static mesh actor"""
+        try:
+            actor_subsystem = unreal.get_editor_subsystem(unreal.EditorActorSubsystem) #unreal.EditorActorSubsystem().get_editor_subsystem()
+            actors = actor_subsystem.get_all_level_actors()
+
+            # Find the actor
+            target_actor = None
+            for actor in actors :
+                if actor.get_name() == actor_name :
+                    target_actor = actor
+                    break
+
+            if not target_actor:
+                return json.dumps({ "status": "error", "message" : f"Actor '{actor_name}' not found" })
+
+            # Check if it's a static mesh actor
+            if not target_actor.is_a(unreal.StaticMeshActor) :
+                return json.dumps({
+                    "status": "error",
+                    "message": f"Actor '{actor_name}' is not a StaticMeshActor"
+                })
+
+            # Load the material
+            material = unreal.load_object(None, material_path)
+            if not material:
+                return json.dumps({
+                    "status": "error",
+                    "message": f"Material '{material_path}' not found"
+                })
+
+            # Get the static mesh component
+            static_mesh_component = target_actor.get_component_by_class(unreal.StaticMeshComponent)
+            if not static_mesh_component:
+                return json.dumps({
+                    "status": "error",
+                    "message" : f"No StaticMeshComponent found on actor '{actor_name}'"
+                })
+
+            # Set the material
+            static_mesh_component.set_material(0, material)
+            return json.dumps({
+                "status": "success",
+                "result" : f"Applied material '{material_path}' to actor '{actor_name}'"
+            })
+        except Exception as e :
+            return json.dumps({ "status": "error", "message" : str(e) })
+
+    @staticmethod
+    def delete_all_static_mesh_actors():
+        """Delete all static mesh actors in the scene"""
+
+        try:
+
+            # Get the editor subsystem
+            editor_subsystem = unreal.get_editor_subsystem(unreal.EditorActorSubsystem)
+
+            # Get all actors in the current level
+            try:
+                all_actors = editor_subsystem.get_all_level_actors()
+            except DeprecationWarning as dw:
+                # do nothing
+                pass
+
+            # Filter for StaticMeshActors
+            static_mesh_actors = [actor for actor in all_actors if isinstance(actor, unreal.StaticMeshActor)]
+
+            # Print how many StaticMeshActors were found
+            #print(f"Found {len(static_mesh_actors)} StaticMeshActors")
+                
+            # Delete all StaticMeshActors
+            delete_count = 0
+            for actor in static_mesh_actors:
+                actor_name = actor.get_actor_label()
+                success = editor_subsystem.destroy_actor(actor)
+                if success:
+                    delete_count = delete_count + 1
+                    #print(f"Deleted StaticMeshActor: {actor_name}")
+                #else:
+                    #print(f"Failed to delete StaticMeshActor: {actor_name}")
+
+            return json.dumps({
+                "status": "success",
+                "result" : f"Found {len(static_mesh_actors)} StaticMeshActors. Deleted {delete_count} StaticMeshActors."
+            })
+
+        except Exception as e:
+            return json.dumps({ "status": "error", "message": str(e) })
+
+    @staticmethod
+    def get_project_dir():
+        """Get the top level project directory"""
+        try:
+            project_dir = unreal.Paths.project_dir()
+            return json.dumps({
+                "status": "success",
+                "result" : f"{project_dir}"
+            })
+        except Exception as e:
+            return json.dumps({ "status": "error", "message": str(e) })
+
+    @staticmethod
+    def get_content_dir():
+        """Get the content directory"""
+        try:
+            #plugins_dir = unreal.Paths.project_plugins_dir()
+            #saved_dir = unreal.Paths.project_saved_dir()
+            #config_dir = unreal.Paths.project_config_dir()
+            content_dir = unreal.Paths.project_content_dir()
+            return json.dumps({
+                "status": "success",
+                "result" : f"{content_dir}"
+            })
+        except Exception as e:
+            return json.dumps({ "status": "error", "message": str(e) })
+
+    @staticmethod
+    def find_basic_shapes():
+        """Search for basic shapes for building"""
+        
+        try:
+            # Search for the asset
+            asset_registry = unreal.AssetRegistryHelpers.get_asset_registry()
+            assets = asset_registry.get_assets_by_path('/Engine/BasicShapes', recursive=True)
+
+            # Find 
+            tile_asset_paths = []
+            for asset in assets:
+                if asset.get_class().get_name() == 'StaticMesh':
+                    tile_asset_paths.append(str(asset.package_name))
+
+            if not tile_asset_paths:
+                return json.dumps({ "status": "error", "message": f"Could not find basic shapes." })
+            else:
+                return json.dumps({
+                    "status": "success",
+                    "result" : tile_asset_paths
+                })
+
+        except Exception as e:
+            return json.dumps({ "status": "error", "message": str(e) })
+
+    @staticmethod
+    def find_assets(asset_name):
+        """Search for specific assets by name, like Floor, Wall, Door"""
+        
+        try:
+            # Search for the asset
+            asset_registry = unreal.AssetRegistryHelpers.get_asset_registry()
+            assets = asset_registry.get_assets_by_path('/Game', recursive=True)
+
+            # Find 
+            tile_asset_paths = []
+            asset_name_lower = asset_name.lower()
+            for asset in assets:
+                this_name = str(asset.asset_name).lower()
+                if asset_name_lower in this_name:
+                    asset_data = { "asset_class": str(asset.asset_class_path.asset_name), "asset_path": str(asset.package_name)}
+                    tile_asset_paths.append(asset_data)
+
+            if not tile_asset_paths:
+                return json.dumps({ "status": "error", "message": f"Could not find {asset_name} asset." })
+            else:
+                return json.dumps({
+                    "status": "success",
+                    "result" : tile_asset_paths
+                })
+
+        except Exception as e:
+            return json.dumps({ "status": "error", "message": str(e) })
+
+    @staticmethod
+    def get_asset(asset_path):
+        # Define the correct path to the asset
+
+        # Try to load the asset
+        try:
+            #print("Loading asset...")
+            static_mesh = unreal.EditorAssetLibrary.load_asset(asset_path)
+            #print("Asset loaded: " + str(static_mesh != None))
+            
+            if static_mesh:
+                #print("Asset class: " + static_mesh.__class__.__name__)
+                
+                # Try to spawn an actor
+                try:
+                    bounds = static_mesh.get_bounds()
+                    bounds_min = bounds.origin - bounds.box_extent
+                    bounds_max = bounds.origin + bounds.box_extent
+                    width = bounds.box_extent.x * 2
+                    depth = bounds.box_extent.y * 2
+                    height = bounds.box_extent.z * 2
+    
+                    # Print dimensions
+                    #print(f"Asset: SM_Env_Tiles_05")
+                    #print(f"Bounds Min: {bounds_min}")
+                    #print(f"Bounds Max: {bounds_max}")
+                    #print(f"Dimensions (width × depth × height): {width} × {depth} × {height}")
+                    #print(f"Volume: {bounds.box_extent.x * 2 * bounds.box_extent.y * 2 * bounds.box_extent.z * 2}")
+
+                    result = {"width": width, "depth": depth, "height": height, "origin_x": bounds.origin.x, "origin_y": bounds.origin.y, "origin_z": bounds.origin.z}
+
+                    return json.dumps({
+                        "status": "success",
+                        "result" : result
+                    })
+
+                except Exception as e:
+                    return json.dumps({ "status": "error", "message": str(e) })
+            else:
+                return json.dumps({ "status": "error", "message": f"Asset could not be loaded." })
+        except Exception as e:
+            return json.dumps({ "status": "error", "message": f"Error loading asset: {str(e)}" })
+
+    @staticmethod
+    def create_grid(asset_path, grid_width, grid_length):
+        import math
+
+        try:
+
+            # Load the static mesh
+            floor_asset = unreal.EditorAssetLibrary.load_asset(asset_path)
+            if not floor_asset:
+                return json.dumps({ "status": "error", "message": f"Failed to load static mesh: {asset_path}" })
+
+            # Grid dimensions
+            width = int(grid_width)
+            length = int(grid_length)
+
+            # Get asset dimensions
+            bounds = floor_asset.get_bounds()
+            tile_width = bounds.box_extent.x * 2
+            tile_length = bounds.box_extent.y * 2
+
+            # Create grid of floor tiles
+            tiles_created = 0
+            for x in range(width):
+                for y in range(length):
+                    # Calculate position
+                    location = unreal.Vector(x * tile_width, y * tile_length, 0)
+                    
+                    # Create actor using EditorLevelLibrary
+                    try:
+                        actor = unreal.EditorLevelLibrary.spawn_actor_from_object(
+                            floor_asset,
+                            location,
+                            unreal.Rotator(0, 0, 0)
+                        )
+                    except DeprecationWarning as dw:
+                        # do nothing
+                        pass
+                    
+                    if actor:
+                        tiles_created += 1
+                        actor.set_actor_label(f"FloorTile_{x}_{y}")
+
+            center_x = width // 2
+            center_y = length // 2
+            position_x = center_x * tile_width
+            position_y = center_y * tile_length
+            return json.dumps({
+                "status": "success",
+                "result" : f"Successfully created grid centered at tile location: ({center_x}, {center_y}) and world location: ({position_x}, {position_y}, 0.0))."
+            })
+
+        except Exception as e:
+            return json.dumps({ "status": "error", "message": f"Error loading asset: {str(e)}" })
+
+    @staticmethod
+    def create_town(town_center_x=1250, town_center_y=1250, town_width=7000, town_height=7000):
+        """
+        Create a town using supplied assets with customizable size and position
+        
+        Args:
+            town_center_x (float): X coordinate of the town center
+            town_center_y (float): Y coordinate of the town center
+            town_width (float): Total width of the town area
+            town_height (float): Total height of the town area
+        """
+
+        import random
+        import math
+
+        #print(f"Starting to build fantasy town at ({town_center_x}, {town_center_y}) with size {town_width}x{town_height}...")
+
+        # Base paths for our assets
+        model_base_path = "/Game/HandPaintedEnvironment/Assets/Models"
+
+        # Helper function to load an asset
+        def load_asset(asset_name):
+            full_path = f"{model_base_path}/{asset_name}.{asset_name}"
+            return unreal.EditorAssetLibrary.load_asset(full_path)
+
+        # Track placed objects for collision detection
+        placed_objects = []
+
+        # Helper function to check for collision with existing objects
+        def check_collision(new_bounds, tolerance=10.0):
+            """Check if the new object bounds overlap with any existing objects"""
+            for obj_bounds in placed_objects:
+                # Check if the bounds overlap in X, Y dimensions with some tolerance
+                if (new_bounds["min_x"] - tolerance <= obj_bounds["max_x"] and 
+                    new_bounds["max_x"] + tolerance >= obj_bounds["min_x"] and
+                    new_bounds["min_y"] - tolerance <= obj_bounds["max_y"] and
+                    new_bounds["max_y"] + tolerance >= obj_bounds["min_y"]):
+                    return True
+            return False
+
+        # Helper function to place an actor with collision detection
+        def place_actor(static_mesh, x, y, z=0, rotation_z=0, scale=(1.0, 1.0, 1.0), name=None, max_attempts=5):
+            if not static_mesh:
+                #print(f"Cannot place actor: Static mesh is invalid")
+                return None
+                
+            editor_subsystem = unreal.get_editor_subsystem(unreal.EditorActorSubsystem)
+
+            # Get the bounds of the mesh
+            bounds = static_mesh.get_bounds()
+            bounds_min = bounds.origin - bounds.box_extent
+            bounds_max = bounds.origin + bounds.box_extent
+            
+            # Calculate width, depth, height
+            width = bounds.box_extent.x * scale[0]
+            depth = bounds.box_extent.y * scale[1]
+            height = bounds.box_extent.z * scale[2]
+            
+            # Try multiple positions if collision occurs
+            for attempt in range(max_attempts):
+                # Add small variation to position for retry attempts after the first
+                x_offset = 0
+                y_offset = 0
+                if attempt > 0:
+                    jitter_range = 20.0 * attempt  # Increase jitter with each attempt
+                    x_offset = random.uniform(-jitter_range, jitter_range)
+                    y_offset = random.uniform(-jitter_range, jitter_range)
+                
+                pos_x = x + x_offset
+                pos_y = y + y_offset
+                
+                # Calculate the bounds of the actor at this position with rotation
+                rad_rotation = math.radians(rotation_z)
+                sin_rot = math.sin(rad_rotation)
+                cos_rot = math.cos(rad_rotation)
+                
+                # Calculate the 4 corners of the bounding box after rotation
+                corners = [
+                    (pos_x - width/2, pos_y - depth/2),  # Bottom-left
+                    (pos_x + width/2, pos_y - depth/2),  # Bottom-right
+                    (pos_x + width/2, pos_y + depth/2),  # Top-right
+                    (pos_x - width/2, pos_y + depth/2)   # Top-left
+                ]
+                
+                # Rotate the corners
+                rotated_corners = []
+                for corner_x, corner_y in corners:
+                    dx = corner_x - pos_x
+                    dy = corner_y - pos_y
+                    rotated_x = pos_x + dx * cos_rot - dy * sin_rot
+                    rotated_y = pos_y + dx * sin_rot + dy * cos_rot
+                    rotated_corners.append((rotated_x, rotated_y))
+                
+                # Find the extents of the rotated box
+                x_values = [p[0] for p in rotated_corners]
+                y_values = [p[1] for p in rotated_corners]
+                
+                min_x = min(x_values)
+                max_x = max(x_values)
+                min_y = min(y_values)
+                max_y = max(y_values)
+                
+                new_bounds = {
+                    "min_x": min_x,
+                    "max_x": max_x,
+                    "min_y": min_y,
+                    "max_y": max_y,
+                    "center_x": pos_x,
+                    "center_y": pos_y
+                }
+                
+                # Check if this position would cause a collision
+                if not check_collision(new_bounds):
+                    # No collision, so place the actor
+                    location = unreal.Vector(pos_x, pos_y, z)
+                    rotation = unreal.Rotator(0, 0, rotation_z)
+                    actor = editor_subsystem.spawn_actor_from_object(static_mesh, location, rotation)
+                    
+                    if actor:
+                        if name:
+                            actor.set_actor_label(name)
+                        
+                        # Apply scale if needed
+                        if scale != (1.0, 1.0, 1.0):
+                            actor.set_actor_scale3d(unreal.Vector(scale[0], scale[1], scale[2]))
+                        
+                        # Record the placed object
+                        placed_objects.append(new_bounds)
+                        
+                        #if attempt > 0:
+                        #    print(f"Placed {name} at alternate position after {attempt+1} attempts")
+                        return actor
+            
+            #print(f"Failed to place {name} after {max_attempts} attempts due to collisions")
+            return None
+
+        # Helper function to get mesh dimensions
+        def get_mesh_dimensions(static_mesh, scale=(1.0, 1.0, 1.0)):
+            if not static_mesh:
+                return 0, 0, 0
+                
+            bounds = static_mesh.get_bounds()
+            width = bounds.box_extent.x * scale[0]
+            depth = bounds.box_extent.y * scale[1]
+            height = bounds.box_extent.z * scale[2]
+            
+            return width, depth, height
+
+        # New helper for placing continuous walls or fences
+        def place_continuous_segments(mesh, start_point, end_point, z=0, rotation_offset=0, scale=(1.0, 1.0, 1.0), name_prefix="Segment", skip_indices=None):
+            if not mesh:
+                #print(f"Cannot place continuous segments: Mesh is invalid")
+                return []
+                
+            if skip_indices is None:
+                skip_indices = []
+                
+            # Get the dimensions of the mesh
+            mesh_width, mesh_depth, mesh_height = get_mesh_dimensions(mesh, scale)
+            
+            # For walls/fences, we assume they extend primarily along one dimension (width)
+            segment_length = mesh_width
+            
+            # Calculate distance and direction
+            start_x, start_y = start_point
+            end_x, end_y = end_point
+            dx = end_x - start_x
+            dy = end_y - start_y
+            distance = math.sqrt(dx*dx + dy*dy)
+            
+            # Calculate the angle of the line
+            angle = math.degrees(math.atan2(dy, dx))
+            
+            # Calculate number of segments needed to cover the distance
+            # Subtract a small overlap percentage to ensure segments connect properly
+            overlap_factor = 0.05  # 5% overlap to ensure no gaps
+            effective_segment_length = segment_length * (1 - overlap_factor)
+            num_segments = max(1, math.ceil(distance / effective_segment_length))
+            
+            # Place segments along the line
+            placed_actors = []
+            for i in range(num_segments):
+                if i in skip_indices:
+                    continue
+                    
+                # Calculate position along the line
+                t = i / num_segments
+                pos_x = start_x + t * dx
+                pos_y = start_y + t * dy
+                
+                # Place the segment
+                actor = place_actor(mesh, pos_x, pos_y, z, angle + rotation_offset, scale, f"{name_prefix}_{i}")
+                if actor:
+                    placed_actors.append(actor)
+            
+            return placed_actors
+
+        try:
+            # Calculate the scale factor based on town size compared to the original
+            # Original size was approximately 700x700
+            width_scale = 1.0 #town_width / 700.0
+            height_scale = 1.0 #town_height / 700.0
+
+            # We'll use this to scale distances and positions
+            scale_factor = min(width_scale, height_scale)  # Use the smaller scale to ensure everything fits
+
+            # STEP 1: PLACE BUILDINGS
+            #print("STEP 1: Placing buildings...")
+
+            # Load building assets
+            buildings = {
+                "town_hall": load_asset("Town_Hall"),
+                "large_house": load_asset("Large_house"),
+                "small_house": load_asset("Small_house"),
+                "baker_house": load_asset("Baker_house"),
+                "tavern": load_asset("Tavern"),
+                "witch_house": load_asset("Witch_house"),
+                "tower": load_asset("Tower"),
+                "mill": load_asset("Mill"),
+                "woodmill": load_asset("Woodmill"),
+                "forge": load_asset("Forge"),
+                "mine": load_asset("Mine")
+            }
+
+            # Check if assets loaded correctly
+            #for name, asset in buildings.items():
+            #    if not asset:
+            #        print(f"Failed to load {name}")
+
+            # Place central buildings - town hall
+            place_actor(buildings["town_hall"], town_center_x, town_center_y, 0, 0, name="Central_TownHall")
+
+            # Place tavern near the town center - scale the offset by our scale factor
+            place_actor(buildings["tavern"], 
+                        town_center_x + 800 * scale_factor, 
+                        town_center_y + 600 * scale_factor, 
+                        0, 135, name="Tavern")
+
+            # Place houses around the center - scaled based on town size
+            house_positions = [
+                # North district
+                (town_center_x - 1800 * scale_factor, town_center_y - 1900 * scale_factor, 45, "small_house", "North_House_1"),
+                (town_center_x - 2100 * scale_factor, town_center_y - 2200 * scale_factor, 30, "baker_house", "North_BakerHouse"),
+                (town_center_x - 1300 * scale_factor, town_center_y - 2000 * scale_factor, 15, "small_house", "North_House_2"),
+                
+                # East district
+                (town_center_x + 2200 * scale_factor, town_center_y - 1300 * scale_factor, 270, "large_house", "East_LargeHouse"),
+                (town_center_x + 2400 * scale_factor, town_center_y + 1200 * scale_factor, 300, "small_house", "East_House_1"),
+                (town_center_x + 1900 * scale_factor, town_center_y - 1700 * scale_factor, 315, "small_house", "East_House_2"),
+                
+                # South district
+                (town_center_x + 1300 * scale_factor, town_center_y + 2100 * scale_factor, 180, "large_house", "South_LargeHouse"),
+                (town_center_x - 1200 * scale_factor, town_center_y + 1950 * scale_factor, 135, "small_house", "South_House_1"),
+                
+                # West district
+                (town_center_x - 2000 * scale_factor, town_center_y + 1100 * scale_factor, 90, "large_house", "West_LargeHouse"),
+                (town_center_x - 2300 * scale_factor, town_center_y + 1500 * scale_factor, 45, "small_house", "West_House_1")
+            ]
+
+            # Place the houses
+            for x, y, rot, house_type, name in house_positions:
+                place_actor(buildings[house_type], x, y, 0, rot, name=name)
+
+            # Place special buildings
+            # Tower
+            place_actor(buildings["tower"], 
+                        town_center_x - 3000 * scale_factor, 
+                        town_center_y - 2900 * scale_factor, 
+                        0, 45, name="North_Tower")
+
+            # Witch's house in a more secluded area
+            place_actor(buildings["witch_house"], 
+                        town_center_x + 3000 * scale_factor, 
+                        town_center_y + 2900 * scale_factor, 
+                        0, 215, name="WitchHouse")
+
+            # Mill near water (imaginary river)
+            mill_x = town_center_x + 2900 * scale_factor
+            mill_y = town_center_y - 3000 * scale_factor
+            mill = place_actor(buildings["mill"], mill_x, mill_y, 0, 270, name="Watermill")
+            
+            # Mill wings - need to be attached to the mill
+            mill_wings = load_asset("Mill_wings")
+            if mill and mill_wings:
+                place_actor(mill_wings, mill_x, mill_y, 0, 270, name="Watermill_Wings")
+
+            # Woodmill in a wooded area
+            woodmill_x = town_center_x - 2900 * scale_factor
+            woodmill_y = town_center_y - 2400 * scale_factor
+            place_actor(buildings["woodmill"], woodmill_x, woodmill_y, 0, 135, name="Woodmill")
+            
+            woodmill_saw = load_asset("Woodmill_Saw")
+            if woodmill_saw:
+                place_actor(woodmill_saw, woodmill_x, woodmill_y, 0, 135, name="Woodmill_Saw")
+
+            # Forge
+            place_actor(buildings["forge"], 
+                        town_center_x + 1600 * scale_factor, 
+                        town_center_y - 1500 * scale_factor, 
+                        0, 330, name="Forge")
+
+            # Mine at the edge of town
+            place_actor(buildings["mine"], 
+                        town_center_x - 2900 * scale_factor, 
+                        town_center_y + 2900 * scale_factor, 
+                        0, 135, name="Mine")
+
+            #print("Buildings placed successfully")
+
+            # STEP 2: ADD NATURE ELEMENTS
+            #print("STEP 2: Adding trees, plants, and rocks...")
+
+            # Load nature assets
+            nature = {
+                "tree_1": load_asset("Tree_1"),
+                "tree_2": load_asset("Tree_2"),
+                "tree_4": load_asset("Tree_4"),
+                "pine_tree": load_asset("Pine_tree"),
+                "pine_tree_2": load_asset("Pine_tree_2"),
+                "bush_1": load_asset("Bush_1"),
+                "bush_2": load_asset("Bush_2"),
+                "fern": load_asset("Fern"),
+                "flowers_1": load_asset("Flowers_1"),
+                "flowers_2": load_asset("Flowers_2"),
+                "plant": load_asset("Plant"),
+                "rock_1": load_asset("Rock_1"),
+                "rock_2": load_asset("Rock_2"),
+                "rock_3": load_asset("Rock_3"),
+                "rock_4": load_asset("Rock_4"),
+                "stump": load_asset("Stump"),
+                "log": load_asset("Log"),
+                "mushroom_1": load_asset("Mushroom_1"),
+                "mushroom_2": load_asset("Mushroom_2")
+            }
+
+            # Create a forest area near the witch's house
+            forest_center_x = town_center_x + 2900 * scale_factor
+            forest_center_y = town_center_y + 2200 * scale_factor
+            forest_radius = 1500 * scale_factor
+
+            # Determine number of trees based on forest area
+            num_trees = int(500 * scale_factor)
+            
+            # Add trees to the forest
+            for i in range(num_trees):
+                # Calculate random position within the forest area
+                angle = random.uniform(0, 2 * math.pi)
+                distance = random.uniform(0, forest_radius)
+                x = forest_center_x + distance * math.cos(angle)
+                y = forest_center_y + distance * math.sin(angle)
+                
+                # Choose a random tree type
+                tree_type = random.choice(["tree_1", "tree_2", "tree_4", "pine_tree", "pine_tree_2"])
+                rot = random.uniform(0, 360)
+                scale = random.uniform(0.8, 1.2)
+                
+                tree = place_actor(nature[tree_type], x, y, 0, rot, (scale, scale, scale), f"Forest_Tree_{i}")
+                
+                # Add some undergrowth near trees if the tree was placed successfully
+                if tree and random.random() < 0.6:
+                    undergrowth_type = random.choice(["bush_1", "bush_2", "fern", "mushroom_1", "mushroom_2"])
+                    offset_x = random.uniform(-100, 100)
+                    offset_y = random.uniform(-100, 100)
+                    undergrowth_scale = random.uniform(0.7, 1.0)
+                    place_actor(nature[undergrowth_type], 
+                                x + offset_x, 
+                                y + offset_y, 
+                                0, 
+                                random.uniform(0, 360), 
+                                (undergrowth_scale, undergrowth_scale, undergrowth_scale), 
+                                f"Forest_Undergrowth_{i}")
+
+            # Add scattered trees around town - scale the number by town size
+            scattered_trees = int(100 * scale_factor)
+            for i in range(scattered_trees):
+                angle = random.uniform(0, 2 * math.pi)
+                distance = random.uniform(3000, 3000) * scale_factor
+                x = town_center_x + distance * math.cos(angle)
+                y = town_center_y + distance * math.sin(angle)
+                
+                # Avoid placing in the forest area
+                forest_dist = math.sqrt((x - forest_center_x)**2 + (y - forest_center_y)**2)
+                if forest_dist < forest_radius:
+                    continue
+                
+                tree_type = random.choice(["tree_1", "tree_2", "tree_4"])
+                rot = random.uniform(0, 360)
+                scale = random.uniform(0.9, 1.1)
+                
+                place_actor(nature[tree_type], x, y, 0, rot, (scale, scale, scale), f"Town_Tree_{i}")
+
+            # Add some rocks scattered around
+            num_rocks = int(15 * scale_factor)
+            for i in range(num_rocks):
+                angle = random.uniform(0, 2 * math.pi)
+                distance = random.uniform(3000, 3000) * scale_factor
+                x = town_center_x + distance * math.cos(angle)
+                y = town_center_y + distance * math.sin(angle)
+                
+                rock_type = random.choice(["rock_1", "rock_2", "rock_3", "rock_4"])
+                rot = random.uniform(0, 360)
+                scale = random.uniform(0.8, 1.5)
+                
+                place_actor(nature[rock_type], x, y, 0, rot, (scale, scale, scale), f"Rock_{i}")
+
+            # Create gardens near houses
+            houses = [
+                (town_center_x - 2000 * scale_factor, town_center_y - 1900 * scale_factor),  # North_House_1
+                (town_center_x - 1300 * scale_factor, town_center_y - 2000 * scale_factor), # North_House_2
+                (town_center_x + 2400 * scale_factor, town_center_y + 1200 * scale_factor), # East_House_1
+                (town_center_x - 1200 * scale_factor, town_center_y + 1950 * scale_factor),  # South_House_1
+            ]
+
+            for idx, (house_x, house_y) in enumerate(houses):
+                garden_x = house_x + random.uniform(200, 300)
+                garden_y = house_y + random.uniform(200, 300)
+                
+                # Place flowers and plants in the garden
+                plants_per_garden = int(5 * scale_factor)
+                for j in range(plants_per_garden):
+                    plant_x = garden_x + random.uniform(-100, 100)
+                    plant_y = garden_y + random.uniform(-100, 100)
+                    plant_type = random.choice(["flowers_1", "flowers_2", "plant", "bush_1"])
+                    rot = random.uniform(0, 360)
+                    
+                    place_actor(nature[plant_type], plant_x, plant_y, 0, rot, name=f"Garden_{idx}_Plant_{j}")
+
+            #print("Nature elements added successfully")
+
+            # STEP 3: CREATE FENCES
+            #print("STEP 3: Building fences...")
+
+            # Load fence assets
+            fences = {
+                "fence": load_asset("Fence"),
+                "fence_1": load_asset("Fence_1"),
+                "fence_2": load_asset("Fence_2"),
+                "stone_fence": load_asset("Stone_fence")
+            }
+
+            # Define garden perimeters to fence
+            gardens = [
+                {
+                    "center": (town_center_x - 1800 * scale_factor, town_center_y - 1900 * scale_factor),  # North_House_1
+                    "size": (30 * scale_factor, 30 * scale_factor),
+                    "fence_type": "fence",
+                    "name": "North_House_1_Garden"
+                },
+                {
+                    "center": (town_center_x + 2400 * scale_factor, town_center_y + 1200 * scale_factor),  # East_House_1
+                    "size": (25 * scale_factor, 30 * scale_factor),
+                    "fence_type": "fence_1",
+                    "name": "East_House_1_Garden"
+                },
+                {
+                    "center": (town_center_x + 1300 * scale_factor, town_center_y + 2200 * scale_factor),  # South_LargeHouse
+                    "size": (35 * scale_factor, 35 * scale_factor),
+                    "fence_type": "fence_2",
+                    "name": "South_LargeHouse_Garden"
+                }
+            ]
+
+            # For each garden, create a fence perimeter
+            for garden in gardens:
+                center_x, center_y = garden["center"]
+                width, height = garden["size"]
+                fence_type = garden["fence_type"]
+                name_prefix = garden["name"]
+                
+                # Calculate the corner points of the garden
+                half_width = width / 2
+                half_height = height / 2
+                
+                corners = [
+                    (center_x - half_width, center_y - half_height),  # Bottom-left
+                    (center_x + half_width, center_y - half_height),  # Bottom-right
+                    (center_x + half_width, center_y + half_height),  # Top-right
+                    (center_x - half_width, center_y + half_height)   # Top-left
+                ]
+                
+                # Build the perimeter with continuous segments
+                for i in range(4):
+                    start_point = corners[i]
+                    end_point = corners[(i + 1) % 4]
+                    
+                    # For each side, determine if we need a gate
+                    skip_indices = []
+                    if i == 0:  # Usually front of the garden has a gate
+                        skip_indices = [1]  # Skip middle segment for a gate
+                    
+                    # Place continuous fence segments
+                    place_continuous_segments(
+                        fences[fence_type],
+                        start_point,
+                        end_point,
+                        0,  # z coordinate
+                        90,  # rotation offset (fences usually need to be rotated perpendicular to the line)
+                        (1.0, 1.0, 1.0),  # scale
+                        f"{name_prefix}_Fence_{i}",
+                        skip_indices
+                    )
+
+            # Create a fence around the town center square
+            town_square = {
+                "center": (town_center_x, town_center_y),
+                "size": (90 * scale_factor, 90 * scale_factor),
+                "fence_type": "stone_fence",
+                "name": "Town_Square"
+            }
+
+            center_x, center_y = town_square["center"]
+            width, height = town_square["size"]
+            fence_type = town_square["fence_type"]
+            name_prefix = town_square["name"]
+
+            # Calculate the corner points
+            half_width = width / 2
+            half_height = height / 2
+
+            corners = [
+                (center_x - half_width, center_y - half_height),  # Bottom-left
+                (center_x + half_width, center_y - half_height),  # Bottom-right
+                (center_x + half_width, center_y + half_height),  # Top-right
+                (center_x - half_width, center_y + half_height)   # Top-left
+            ]
+
+            # Build the perimeter with continuous segments and gates
+            for i in range(4):
+                start_point = corners[i]
+                end_point = corners[(i + 1) % 4]
+                
+                # Create entrance gates on all sides
+                skip_indices = [1]  # Skip middle segment for a gate
+                
+                # Place continuous stone fence segments
+                place_continuous_segments(
+                    fences[fence_type],
+                    start_point,
+                    end_point,
+                    0,  # z coordinate
+                    90,  # rotation offset
+                    (1.0, 1.0, 1.0),  # scale
+                    f"{name_prefix}_Fence_{i}",
+                    skip_indices
+                )
+
+            #print("Fences created successfully")
+
+            # STEP 4: BUILD WALLS
+            #print("STEP 4: Building walls...")
+
+            # Load wall assets
+            walls = {
+                "wall_1": load_asset("Wall_1"),
+                "wall_2": load_asset("Wall_2")
+            }
+
+            # Get wall dimensions for alternating walls
+            wall1_width, _, _ = get_mesh_dimensions(walls["wall_1"])
+            wall2_width, _, _ = get_mesh_dimensions(walls["wall_2"])
+
+            # Define the town perimeter for walls - use the provided town width and height
+            town_perimeter = {
+                "center": (town_center_x, town_center_y),
+                "size": (town_width, town_height),
+                "name": "Town_Wall"
+            }
+
+            center_x, center_y = town_perimeter["center"]
+            width, height = town_perimeter["size"]
+            name_prefix = town_perimeter["name"]
+
+            # Calculate the corner points
+            half_width = (width / 2) - wall1_width
+            half_height = (height / 2) - wall1_width
+
+            corners = [
+                (center_x - half_width, center_y - half_height),  # Bottom-left
+                (center_x + half_width, center_y - half_height),  # Bottom-right
+                (center_x + half_width, center_y + half_height),  # Top-right
+                (center_x - half_width, center_y + half_height)   # Top-left
+            ]
+
+            # Build the perimeter with continuous wall segments
+            # For each side, first measure the total length and determine how many of each wall type to use
+            for i in range(4):
+                start_point = corners[i]
+                end_point = corners[(i + 1) % 4]
+                
+                # Calculate side length
+                start_x, start_y = start_point
+                end_x, end_y = end_point
+                side_length = math.sqrt((end_x - start_x)**2 + (end_y - start_y)**2)
+                
+                # Determine where to place gates - we'll place 1-2 gates on each side based on length
+                # Calculate how many walls would fit on this side
+                effective_wall1_length = wall1_width * 0.95  # Account for slight overlap
+                num_wall1_segments = math.ceil(side_length / effective_wall1_length)
+                
+                # Identify gate positions - which segments to skip
+                gate_skip_indices = []
+                if num_wall1_segments > 8:
+                    # Place two gates if the wall is long enough
+                    gate_skip_indices = [num_wall1_segments // 3, 2 * num_wall1_segments // 3]
+                else:
+                    # Otherwise just one gate in the middle
+                    gate_skip_indices = [num_wall1_segments // 2]
+                
+                # Place the wall segments using primarily wall_1 with gates
+                wall1_actors = place_continuous_segments(
+                    walls["wall_1"],
+                    start_point,
+                    end_point,
+                    0,  # z coordinate
+                    0,   # no rotation offset for walls
+                    (1.0, 1.0, 1.0),  # scale
+                    f"{name_prefix}_Wall1_{i}",
+                    gate_skip_indices
+                )
+                
+                # For each gate position, place a tower
+                for gate_idx in gate_skip_indices:
+                    t = gate_idx / num_wall1_segments
+                    pos_x = start_x + t * (end_x - start_x)
+                    pos_y = start_y + t * (end_y - start_y)
+                    
+                    # Calculate angle
+                    angle = math.degrees(math.atan2(end_y - start_y, end_x - start_x))
+                    
+                    # Place tower at gate position
+                    tower = load_asset("Tower")
+                    if tower:
+                        place_actor(tower, pos_x, pos_y, 0, angle + 90, name=f"Gate_Tower_{i}_{gate_idx}")
+
+            #print("Walls built successfully")
+
+            # STEP 5: ADD FINAL DETAILS
+            #print("STEP 5: Adding final details and props...")
+
+            # Load remaining prop assets
+            props = {
+                "anvil": load_asset("Anvil"),
+                "barrel": load_asset("Barrel"),
+                "chest": load_asset("Chest"),
+                "cauldron": load_asset("Cauldron"),
+                "altar": load_asset("Altar"),
+                "well": load_asset("Well"),
+                "trolley": load_asset("Trolley"),
+                "lamppost": load_asset("Lamppost"),
+                "street_light": load_asset("street_light")
+            }
+
+            # Place a well in the town center
+            place_actor(props["well"], town_center_x + 150 * scale_factor, town_center_y - 150 * scale_factor, 0, 0, name="Town_Center_Well")
+
+            # Place streetlights around the town square
+            square_size = 90 * scale_factor
+            light_spacing = 30 * scale_factor
+            for i in range(4):
+                for j in range(3):
+                    if j == 1:  # Skip middle to accommodate entrances
+                        continue
+                        
+                    # Calculate position along each side of the square
+                    if i == 0:  # North side
+                        x = town_center_x - square_size/2 + j * light_spacing
+                        y = town_center_y - square_size/2
+                        rot = 0
+                    elif i == 1:  # East side
+                        x = town_center_x + square_size/2
+                        y = town_center_y - square_size/2 + j * light_spacing
+                        rot = 90
+                    elif i == 2:  # South side
+                        x = town_center_x + square_size/2 - j * light_spacing
+                        y = town_center_y + square_size/2
+                        rot = 180
+                    else:  # West side
+                        x = town_center_x - square_size/2
+                        y = town_center_y + square_size/2 - j * light_spacing
+                        rot = 270
+                        
+                    light_type = "lamppost" if j % 2 == 0 else "street_light"
+                    place_actor(props[light_type], x, y, 0, rot, name=f"Square_Light_{i}_{j}")
+
+            # Add props near the forge
+            forge_x = town_center_x + 600 * scale_factor
+            forge_y = town_center_y - 500 * scale_factor
+
+            place_actor(props["anvil"], forge_x + 50 * scale_factor, forge_y - 80 * scale_factor, 0, 45, name="Forge_Anvil")
+            place_actor(props["barrel"], forge_x - 70 * scale_factor, forge_y - 60 * scale_factor, 0, 0, name="Forge_Barrel")
+
+            # Add barrels and chests around the tavern
+            tavern_x = town_center_x + 700 * scale_factor
+            tavern_y = town_center_y + 600 * scale_factor
+
+            for i in range(3):
+                x_offset = random.uniform(-150, 150) * scale_factor
+                y_offset = random.uniform(-150, 150) * scale_factor
+                rot = random.uniform(0, 360)
+                place_actor(props["barrel"], tavern_x + x_offset, tavern_y + y_offset, 0, rot, name=f"Tavern_Barrel_{i}")
+
+            place_actor(props["chest"], tavern_x - 100 * scale_factor, tavern_y + 120 * scale_factor, 0, 45, name="Tavern_Chest")
+
+            # Add altar near the witch's house
+            witch_house_x = town_center_x + 1800 * scale_factor
+            witch_house_y = town_center_y + 1500 * scale_factor
+
+            place_actor(props["altar"], witch_house_x + 150 * scale_factor, witch_house_y + 100 * scale_factor, 0, 215, name="Witch_Altar")
+            place_actor(props["cauldron"], witch_house_x - 80 * scale_factor, witch_house_y + 120 * scale_factor, 0, 0, name="Witch_Cauldron")
+
+            # Add a trolley near the mine
+            mine_x = town_center_x - 2200 * scale_factor
+            mine_y = town_center_y + 1800 * scale_factor
+
+            place_actor(props["trolley"], mine_x + 150 * scale_factor, mine_y - 100 * scale_factor, 0, 45, name="Mine_Trolley")
+
+            # Create a path connecting major locations with Tile assets
+            tiles = {
+                "tile_1": load_asset("Tile_1"),
+                "tile_2": load_asset("Tile_2"),
+                "tile_3": load_asset("Tile_3"),
+                "tile_4": load_asset("Tile_4"),
+                "tile_5": load_asset("Tile_5"),
+                "tile_6": load_asset("Tile_6"),
+                "tile_7": load_asset("Tile_7")
+            }
+
+            # Define major path points - scaled based on town size
+            path_points = [
+                (town_center_x, town_center_y),  # Town center
+                (town_center_x + 700 * scale_factor, town_center_y + 600 * scale_factor),  # Tavern
+                (town_center_x + 600 * scale_factor, town_center_y - 500 * scale_factor),  # Forge
+                (town_center_x - 1000 * scale_factor, town_center_y - 1700 * scale_factor),  # Tower
+                (town_center_x + 1700 * scale_factor, town_center_y - 1200 * scale_factor),  # Watermill
+                (town_center_x - 1800 * scale_factor, town_center_y - 400 * scale_factor),  # Woodmill
+                (town_center_x - 2200 * scale_factor, town_center_y + 1800 * scale_factor),  # Mine
+                (town_center_x + 1800 * scale_factor, town_center_y + 1500 * scale_factor)  # Witch house
+            ]
+
+            # Create paths between points
+            for i in range(len(path_points) - 1):
+                start_x, start_y = path_points[i]
+                end_x, end_y = path_points[i + 1]
+                
+                # Calculate distance and direction
+                dx = end_x - start_x
+                dy = end_y - start_y
+                distance = math.sqrt(dx*dx + dy*dy)
+                
+                # Tile spacing - scale by the town size
+                tile_spacing = 100 * scale_factor
+                num_tiles = int(distance / tile_spacing)
+                
+                # Place tiles along the path
+                for j in range(num_tiles):
+                    t = j / num_tiles
+                    x = start_x + t * dx
+                    y = start_y + t * dy
+                    
+                    # Add some randomness to make the path look more natural
+                    offset_x = random.uniform(-20, 20) * scale_factor
+                    offset_y = random.uniform(-20, 20) * scale_factor
+                    
+                    # Random tile type
+                    tile_type = random.choice(["tile_1", "tile_2", "tile_3", "tile_4", "tile_5", "tile_6", "tile_7"])
+                    rot = random.uniform(0, 360)
+                    
+                    place_actor(tiles[tile_type], x + offset_x, y + offset_y, 1, rot, name=f"Path_Tile_{i}_{j}")
+
+            #print("Final details added successfully")
+            #print(f"Fantasy town creation complete at ({town_center_x}, {town_center_y}) with size {town_width}x{town_height}!")
+
+            return json.dumps({
+                "status": "success",
+                "result": f"Successfully created fantasy town at ({town_center_x}, {town_center_y}) with size {town_width}x{town_height}."
+            })
+
+        except Exception as e:
+            return json.dumps({ "status": "error", "message": f"Error building town: {str(e)}" })
+
+    @staticmethod
+    def execute_blueprint_function(blueprint_name, function_name, arguments = ""):
+        """Execute a function in a Blueprint"""
+        try:
+            # Find the Blueprint asset
+            blueprint_asset = unreal.find_asset(blueprint_name)
+            if not blueprint_asset:
+                return json.dumps({
+                    "status": "error",
+                    "message" : f"Blueprint '{blueprint_name}' not found"
+                })
+
+            # Get the blueprint class
+            blueprint_class = unreal.load_class(blueprint_asset)
+            if not blueprint_class:
+                return json.dumps({
+                    "status": "error",
+                    "message": f"Could not load class from Blueprint '{blueprint_name}'"
+                })
+
+            # Get the CDO(Class Default Object)
+            cdo = unreal.get_default_object(blueprint_class)
+
+            # Parse arguments
+            parsed_args = []
+            if arguments:
+                for arg in arguments.split(','):
+                    arg = arg.strip()
+                    # Try to determine argument type
+                    if arg.lower() in ['true', 'false']:
+                        parsed_args.append(arg.lower() == 'true')
+                    elif arg.isdigit():
+                        parsed_args.append(int(arg))
+                    elif arg.replace('.', '', 1).isdigit():
+                        parsed_args.append(float(arg))
+                    else:
+                        parsed_args.append(arg)
+
+            # Call the function
+            result = getattr(cdo, function_name)(*parsed_args)
+            return json.dumps({
+                "status": "success",
+                "result" : f"Function '{function_name}' executed. Result: {result}"
+            })
+        except Exception as e:
+            return json.dumps({ "status": "error", "message": str(e) })
+
+    @staticmethod
+    def execute_python(code):
+        """Execute arbitrary Python code in Unreal Engine"""
+
+        try:
+
+            # decode and extract dict object
+            #decoded = chunk.decode('utf-8', 'replace')
+            #stripped = decoded.strip('\'"\n\r')
+            replaced = code.replace('\\\\','\\').replace('\\"','"').replace("\\'","'").replace('f"\n', 'f"').replace('f\'\n', 'f\'').replace('\n"', '"').replace('\n\'', '\'')
+            #response = json.loads(replaced)
+
+            # save to file first
+            #code_file = open('code.py', 'w')
+            #code_file.write(code)
+            #code_file.close()
+
+            # read back
+            #code_file = open('code.py', 'r')
+            #code_text = code_file.read()
+            #code_file.close()
+
+            # check for syntax errors
+            try:
+                code_obj = compile(replaced, '<string>', 'exec')
+                
+            except SyntaxError as se:
+                return json.dumps({
+                    "status": "error",
+                    "message" : f"Syntax Error executing Python code: {str(se)}",
+                    "traceback" : traceback.format_exc()
+                })
+            except Exception as ex:
+                return json.dumps({
+                    "status": "error",
+                    "message" : f"Error executing Python code: {str(ex)}",
+                    "traceback" : traceback.format_exc()
+                })
+
+            try:
+
+                # Create output capture file
+                output_file = open('output.txt', 'w')
+                error_file = open('error.txt', 'w')
+
+                # Store original stdout and stderr
+                original_stdout = sys.stdout
+                original_stderr = sys.stderr
+
+                # Redirect stdout and stderr
+                sys.stdout = output_file
+                sys.stderr = error_file
+
+                # Create a local dictionary for execution
+                locals_dict = { 'unreal': unreal, 'result': None }
+
+                # Execute the compiled code
+                exec(code_obj, globals(), locals_dict)
+
+            except AttributeError as ae:
+                return json.dumps({
+                    "status": "error",
+                    "message" : f"Attribute Error in code: {str(ae)}",
+                    "traceback" : traceback.format_exc()
+                })
+
+            except Exception as ee:
+                return json.dumps({
+                    "status": "error",
+                    "message" : f"Python exec() error: {str(ee)}",
+                    "traceback" : traceback.format_exc()
+                })
+
+            finally:
+                
+                # close output
+                output_file.close()
+                error_file.close()
+
+                # Restore original stdout and stderr
+                sys.stdout = original_stdout
+                sys.stderr = original_stderr
+
+            # read output
+            read_output = open('output.txt', 'r')
+            result = read_output.read()
+            read_output.close()
+
+            # read errors
+            read_error = open('error.txt', 'r')
+            error_text = read_error.read()
+            read_error.close()
+
+            # Return the result if it was set
+            if 'result' in locals_dict and locals_dict['result'] is not None:
+                return json.dumps({
+                    "status": "success",
+                    "result" : str(locals_dict['result'])
+                })
+            elif error_text and len(error_text) > 0:
+                return json.dumps({
+                    "status": "error",
+                    "result": error_text
+                })
+            elif not result:
+                return json.dumps({
+                    "status": "error",
+                    "result": "Python code did not execute Successfully. No result set."
+                })
+            else:
+                return json.dumps({
+                    "status": "success",
+                    "result": str(result)
+                })
+
+        except Exception as exc:
+
+            # read error
+            error_msg = str(exc)
+            read_error = open('error.txt', 'r')
+            if read_error:
+                error_msg = read_error.read()
+                read_error.close()
+            return json.dumps({
+                "status": "error",
+                "message" : f"Python exec() error: {error_msg}",
+                "traceback" : traceback.format_exc()
+            })
+
+# Register the bridge as a global variable
+mcp_bridge = MCPUnrealBridge()

UMCP.it-Unreal-Organizer-Assistant/Docs/BLUEPRINT_CONNECTIONS_INTEGRATED.md

@@ -0,0 +1,330 @@
+# Blueprint Node Connection System - UMCP Plugin Integration
+
+**Integration Date:** October 9, 2025
+**Status:** ✅ COMPLETE & READY TO USE
+
+---
+
+## 🎉 What Was Integrated
+
+The Blueprint Node Connection System has been successfully integrated into the **UMCP (UnrealMCPBridge)** plugin, making it available through the Gen AI Support plugin UI.
+
+### New MCP Tools Available
+
+5 new MCP tools are now available for Claude and other AI assistants:
+
+1. **get_blueprint_node_pins** - Discover available pins on a node
+2. **validate_blueprint_connection** - Validate connections before making them
+3. **auto_connect_blueprint_chain** - Intelligently auto-wire node chains
+4. **suggest_blueprint_connections** - Get ranked connection suggestions
+5. **get_blueprint_graph_connections** - Analyze existing Blueprint logic
+
+---
+
+## 📁 Files Modified/Created
+
+### Created Files
+
+1. **handlers/blueprint_connection_commands.py** (330 lines)
+   - Location: `Plugins/UMCP/Content/Python/handlers/`
+   - Handlers for all 5 Blueprint connection operations
+   - Integrates with existing Blueprint connection Python modules
+
+### Modified Files
+
+1. **unreal_socket_server.py**
+   - Added import for `blueprint_connection_commands`
+   - Registered 5 new handlers in CommandDispatcher
+   - Lines 11, 22, 107-112
+
+2. **mcp_server.py**
+   - Added 5 new @mcp.tool() decorated functions
+   - Lines 1692-1900
+   - Each tool sends commands to unreal_socket_server via port 9877
+
+---
+
+## 🏗️ Architecture
+
+The integration follows the UMCP plugin's two-tier architecture:
+
+```
+┌─────────────────────────────────────────────────────┐
+│         Claude Code / Gen AI Support UI             │
+└────────────────────┬────────────────────────────────┘
+                     │ MCP Protocol (stdio)
+                     ▼
+┌─────────────────────────────────────────────────────┐
+│  mcp_server.py (External Python MCP Server)         │
+│  - Runs outside Unreal Engine                       │
+│  - 5 new @mcp.tool() functions:                     │
+│    • get_blueprint_node_pins                        │
+│    • validate_blueprint_connection                  │
+│    • auto_connect_blueprint_chain                   │
+│    • suggest_blueprint_connections                  │
+│    • get_blueprint_graph_connections                │
+└────────────────────┬────────────────────────────────┘
+                     │ Socket (port 9877)
+                     ▼
+┌─────────────────────────────────────────────────────┐
+│  unreal_socket_server.py (Inside Unreal Engine)    │
+│  - CommandDispatcher routes commands                │
+│  - 5 new handlers:                                  │
+│    • handle_get_node_pins                           │
+│    • handle_validate_connection                     │
+│    • handle_auto_connect_chain                      │
+│    • handle_suggest_connections                     │
+│    • handle_get_graph_connections                   │
+└────────────────────┬────────────────────────────────┘
+                     │ Python imports
+                     ▼
+┌─────────────────────────────────────────────────────┐
+│  Blueprint Connection Python Modules                │
+│  (D:\PROJECTS\MCPTest\blueprint_connections\)       │
+│  - PinDiscoveryService                              │
+│  - ConnectionValidator                              │
+│  - AutoWiringService                                │
+└────────────────────┬────────────────────────────────┘
+                     │ Unreal Python API
+                     ▼
+┌─────────────────────────────────────────────────────┐
+│         Unreal Engine Blueprint System              │
+└─────────────────────────────────────────────────────┘
+```
+
+---
+
+## 🚀 How to Use (Gen AI Support Plugin)
+
+### Step 1: Start the Unreal Socket Server
+
+The socket server should auto-start when Unreal Engine loads with the UMCP plugin enabled. You can verify by checking the Gen AI Support UI:
+
+- **Unreal Socket Server:** Should show "Running ✓"
+- **MCP Server:** Should show "Running ✓ on port 9877"
+
+If not running, check:
+1. UMCP plugin is enabled in Plugins menu
+2. Python Script plugin is enabled
+3. Check Output Log for errors
+
+### Step 2: Start the MCP Server
+
+From the Gen AI Support UI, click "Start" on the MCP Server row. This starts the external Python MCP server (`mcp_server.py`) that Claude will connect to.
+
+### Step 3: Use from Claude Desktop
+
+In Claude Desktop (or any MCP client), you can now use the Blueprint connection tools:
+
+**Example 1: Discover Node Pins**
+```
+Can you show me the pins available on this Blueprint node?
+
+Blueprint: /Game/Blueprints/BP_Calculator
+Function ID: F1234567-89AB-CDEF-0123-456789ABCDEF
+Node ID: A1B2C3D4-E5F6-7890-ABCD-EF1234567890
+```
+
+**Example 2: Validate Connection**
+```
+Before I connect these nodes, can you validate if it's safe?
+
+Source: ADD_NODE_GUID, pin "ReturnValue"
+Target: MULTIPLY_NODE_GUID, pin "A"
+```
+
+**Example 3: Auto-Wire Chain**
+```
+Auto-wire these Blueprint nodes in order:
+- Function Entry
+- Add node
+- Multiply node
+- Return node
+
+Use validation before connecting.
+```
+
+---
+
+## 🎯 Tool Capabilities
+
+### 1. get_blueprint_node_pins
+**What it does:** Retrieves all input/output pins for a node
+**When to use:** Before connecting nodes, to discover exact pin names
+**Returns:** Node info, input pins array, output pins array with types and connection status
+
+### 2. validate_blueprint_connection
+**What it does:** Checks if a connection is valid before making it
+**When to use:** Always validate before connecting to catch errors early
+**Returns:** Valid/invalid status, error type if invalid, helpful suggestions
+
+### 3. auto_connect_blueprint_chain
+**What it does:** Automatically wires a chain of nodes with confidence scoring
+**When to use:** Quick node chain creation, intelligent auto-wiring
+**Returns:** Connections made, confidence scores (0.0-1.0), failed connections, warnings
+
+### 4. suggest_blueprint_connections
+**What it does:** Suggests ranked connections between two nodes
+**When to use:** Explore connection possibilities without committing
+**Returns:** Execution connection, data connections, all possibilities with confidence scores
+
+### 5. get_blueprint_graph_connections
+**What it does:** Lists all connections in a function graph
+**When to use:** Analyze existing Blueprint logic, document connections
+**Returns:** Array of all connections with source/target nodes and pins
+
+---
+
+## ⚙️ Configuration
+
+### Required Python Modules Path
+
+The handlers expect Blueprint connection modules at:
+```
+D:\PROJECTS\MCPTest\blueprint_connections\
+```
+
+If your project is in a different location, update line 12 in:
+`Plugins/UMCP/Content/Python/handlers/blueprint_connection_commands.py`
+
+```python
+BLUEPRINT_CONN_PATH = r"YOUR_PATH_HERE\blueprint_connections"
+```
+
+### Required Modules
+
+The Blueprint connection system requires these Python modules (already created in D:\PROJECTS\MCPTest\blueprint_connections\):
+
+- `handlers/pin_discovery.py` - PinDiscoveryService
+- `handlers/connection_validator.py` - ConnectionValidator
+- `handlers/auto_wiring.py` - AutoWiringService
+- `utils/pin_types.py` - Data structures
+- `utils/connection_rules.py` - Type compatibility
+- `utils/node_helpers.py` - Helper functions
+
+---
+
+## 🔧 Troubleshooting
+
+### Issue: "Failed to load Blueprint connection modules"
+
+**Symptoms:** Tools return errors about missing modules
+
+**Solution:**
+1. Check that `D:\PROJECTS\MCPTest\blueprint_connections\` exists
+2. Verify all 6 Python modules are present
+3. Check Output Log for Python import errors
+4. Update `BLUEPRINT_CONN_PATH` in `blueprint_connection_commands.py` if needed
+
+### Issue: Socket Server Not Running
+
+**Symptoms:** Gen AI Support UI shows "Unreal Socket Server: Not Running ❌"
+
+**Solution:**
+1. Check Python Script Plugin is enabled
+2. Check UMCP plugin is enabled and loaded
+3. Look for port 9877 conflicts: `netstat -ano | findstr :9877`
+4. Check Unreal Output Log for socket server errors
+5. Try restarting Unreal Engine
+
+### Issue: MCP Server Not Responding
+
+**Symptoms:** Gen AI Support UI shows "MCP Server: Not Running ❌"
+
+**Solution:**
+1. Click "Start" button in Gen AI Support UI
+2. Check if Python process is running (should create PID file at `~/.unrealgenai/mcp_server.pid`)
+3. Verify port 9877 is available
+4. Check MCP server logs in Unreal Output Log
+
+### Issue: Tools Not Appearing in Claude
+
+**Symptoms:** Claude doesn't see the new Blueprint connection tools
+
+**Solution:**
+1. Restart the MCP server from Gen AI Support UI
+2. Restart Claude Desktop
+3. Check Claude Desktop's MCP configuration points to the UMCP server
+4. Verify mcp_server.py includes the new @mcp.tool() decorators
+
+---
+
+## 📊 Comparison: UMCP Plugin vs External MCP Server
+
+This project now has **TWO** MCP server implementations:
+
+### UMCP Plugin (This Integration)
+
+**Architecture:** Plugin-based, runs inside Unreal Engine
+- MCP Server: `mcp_server.py` (external process, port 9877)
+- Socket Server: `unreal_socket_server.py` (inside UE)
+- Connection: stdio (Claude) → Socket (port 9877) → Unreal Python API
+
+**Advantages:**
+- Direct access to Unreal Python API
+- No Remote Control plugin dependency
+- UI for starting/stopping in Gen AI Support plugin
+- Lower latency (direct Python calls)
+
+**Best for:** Interactive Blueprint editing, rapid prototyping, plugin-based workflows
+
+### External Node.js MCP Server
+
+**Architecture:** Standalone server, uses Remote Control API
+- MCP Server: Node.js process (stdio)
+- Connection: stdio (Claude) → Remote Control HTTP/WS (ports 30010/30020) → Unreal Engine
+
+**Advantages:**
+- Language-agnostic (JavaScript/TypeScript)
+- Doesn't require Python in Unreal
+- Can run on different machine
+- Better for automation/CI
+
+**Best for:** Automation, remote workflows, non-Python environments
+
+**Both implementations** now support the same Blueprint connection tools!
+
+---
+
+## ✅ Integration Checklist
+
+- [x] Created blueprint_connection_commands.py handler module
+- [x] Registered 5 handlers in unreal_socket_server.py
+- [x] Added 5 MCP tool definitions to mcp_server.py
+- [x] Tested module imports (Python modules load successfully)
+- [x] Documented integration architecture
+- [x] Created troubleshooting guide
+- [x] Verified compatibility with existing UMCP tools
+
+**Status:** ✅ READY FOR TESTING
+
+---
+
+## 🎓 Next Steps
+
+1. **Test in Unreal Engine:**
+   - Open MCPTest.uproject
+   - Enable UMCP plugin if not already enabled
+   - Check Gen AI Support UI shows servers running
+   - Try using tools from Claude Desktop
+
+2. **Create Test Blueprint:**
+   - Create a simple test Blueprint with a function
+   - Add 2-3 math nodes
+   - Test pin discovery and auto-wiring
+
+3. **Explore Advanced Features:**
+   - Try confidence scoring with auto_connect_chain
+   - Use suggest_connections to explore options
+   - Validate connections before making them
+
+4. **Report Issues:**
+   - Check Unreal Output Log for errors
+   - Test each tool individually
+   - Document any module loading issues
+
+---
+
+**Integration Complete!** 🚀
+
+The Blueprint connection system is now fully integrated with the UMCP plugin and ready for use through the Gen AI Support UI.