unreal-engine-mcp-server 0.4.0 → 0.4.3

package/dist/tools/physics.js

@@ -1,4 +1,5 @@
 import { validateAssetParams, resolveSkeletalMeshPath, concurrencyDelay } from '../utils/validation.js';
+import { bestEffortInterpretedText, coerceString, coerceStringArray, interpretStandardResult } from '../utils/result-helpers.js';
 export class PhysicsTools {
     bridge;
     constructor(bridge) {
@@ -10,62 +11,76 @@ export class PhysicsTools {
     async findValidSkeletalMesh() {
         const pythonScript = `
 import unreal
+import json
+
+result = {
+    'success': False,
+    'meshPath': None,
+    'source': None
+}
 
-# Common skeletal mesh paths to check
 common_paths = [
-    '/Game/Mannequin/Character/Mesh/SK_Mannequin',
-    '/Game/Characters/Mannequin/Meshes/SK_Mannequin',
-    '/Game/AnimStarterPack/UE4_Mannequin/Mesh/SK_Mannequin',
-    '/Game/ThirdPerson/Meshes/SK_Mannequin',
-    '/Game/ThirdPersonBP/Meshes/SK_Mannequin',
-    '/Engine/EngineMeshes/SkeletalCube',  # Fallback engine mesh
+  '/Game/Characters/Mannequins/Meshes/SKM_Manny',
+  '/Game/Characters/Mannequins/Meshes/SKM_Manny_Simple',
+  '/Game/Characters/Mannequins/Meshes/SKM_Manny_Complex',
+  '/Game/Characters/Mannequins/Meshes/SKM_Quinn',
+  '/Game/Characters/Mannequins/Meshes/SKM_Quinn_Simple',
+  '/Game/Characters/Mannequins/Meshes/SKM_Quinn_Complex'
 ]
 
-# Try to find any skeletal mesh
-for path in common_paths:
-    if unreal.EditorAssetLibrary.does_asset_exist(path):
-        asset = unreal.EditorAssetLibrary.load_asset(path)
-        if asset and isinstance(asset, unreal.SkeletalMesh):
-            print(f"FOUND_MESH:{path}")
+for candidate in common_paths:
+    if unreal.EditorAssetLibrary.does_asset_exist(candidate):
+        mesh = unreal.EditorAssetLibrary.load_asset(candidate)
+        if mesh and isinstance(mesh, unreal.SkeletalMesh):
+            result['success'] = True
+            result['meshPath'] = candidate
+            result['source'] = 'common'
             break
-else:
-    # Search for any skeletal mesh in the project
+
+if not result['success']:
     asset_registry = unreal.AssetRegistryHelpers.get_asset_registry()
     assets = asset_registry.get_assets_by_class('SkeletalMesh', search_sub_classes=False)
     if assets:
-        # Use the first available skeletal mesh
         first_mesh = assets[0]
-        obj_path = first_mesh.get_editor_property('object_path')
+        obj_path = first_mesh.get_editor_property('object_path') if hasattr(first_mesh, 'get_editor_property') else None
+        if not obj_path and hasattr(first_mesh, 'object_path'):
+            obj_path = first_mesh.object_path
         if obj_path:
-            print(f"FOUND_MESH:{str(obj_path).split('.')[0]}")
-        else:
-            print("NO_MESH_FOUND")
-    else:
-        print("NO_MESH_FOUND")
+            result['success'] = True
+            result['meshPath'] = str(obj_path).split('.')[0]
+            result['source'] = 'registry'
+            if hasattr(first_mesh, 'asset_name'):
+                result['assetName'] = str(first_mesh.asset_name)
+
+if not result['success']:
+    result['fallback'] = '/Engine/EngineMeshes/SkeletalCube'
+
+print('RESULT:' + json.dumps(result))
 `;
         try {
             const response = await this.bridge.executePython(pythonScript);
-            let outputStr = '';
-            if (response?.LogOutput && Array.isArray(response.LogOutput)) {
-                outputStr = response.LogOutput.map((l) => l.Output || '').join('');
-            }
-            else if (typeof response === 'string') {
-                outputStr = response;
+            const interpreted = interpretStandardResult(response, {
+                successMessage: 'Skeletal mesh discovery complete',
+                failureMessage: 'Failed to discover skeletal mesh'
+            });
+            if (interpreted.success) {
+                const meshPath = coerceString(interpreted.payload.meshPath);
+                if (meshPath) {
+                    return meshPath;
+                }
             }
-            else {
-                // Fallback: stringify and still try to parse, but restrict to line content only
-                outputStr = JSON.stringify(response);
+            const fallback = coerceString(interpreted.payload.fallback);
+            if (fallback) {
+                return fallback;
             }
-            // Capture only until end-of-line to avoid trailing JSON serialization
-            const match = outputStr.match(/FOUND_MESH:([^\r\n]+)/);
-            if (match) {
-                return match[1].trim();
+            const detail = bestEffortInterpretedText(interpreted);
+            if (detail) {
+                console.error('Failed to parse skeletal mesh discovery:', detail);
             }
         }
         catch (error) {
             console.error('Failed to find skeletal mesh:', error);
         }
-        // Return engine fallback if nothing found
         return '/Engine/EngineMeshes/SkeletalCube';
     }
     /**
@@ -144,7 +159,9 @@ else:
             const skeletonToMeshMap = {
                 '/Game/Mannequin/Character/Mesh/UE4_Mannequin_Skeleton': '/Game/Characters/Mannequins/Meshes/SKM_Manny_Simple',
                 '/Game/Characters/Mannequins/Meshes/SK_Mannequin': '/Game/Characters/Mannequins/Meshes/SKM_Manny_Simple',
-                '/Game/Mannequin/Character/Mesh/SK_Mannequin': '/Game/Characters/Mannequins/Meshes/SKM_Manny_Simple'
+                '/Game/Mannequin/Character/Mesh/SK_Mannequin': '/Game/Characters/Mannequins/Meshes/SKM_Manny_Simple',
+                '/Game/Characters/Mannequins/Skeletons/UE5_Mannequin_Skeleton': '/Game/Characters/Mannequins/Meshes/SKM_Manny_Simple',
+                '/Game/Characters/Mannequins/Skeletons/UE5_Female_Mannequin_Skeleton': '/Game/Characters/Mannequins/Meshes/SKM_Quinn_Simple'
             };
             // Auto-fix common incorrect paths
             let actualSkeletonPath = params.skeletonPath;
@@ -160,231 +177,324 @@ else:
             const pythonScript = `
 import unreal
 import time
+import json
+
+result = {
+  "success": False,
+  "path": None,
+  "message": "",
+  "error": None,
+  "warnings": [],
+  "details": [],
+  "existingAsset": False,
+  "meshPath": "${meshPath}"
+}
+
+def record_detail(message):
+  result["details"].append(message)
+
+def record_warning(message):
+  result["warnings"].append(message)
+
+def record_error(message):
+  result["error"] = message
 
 # Helper function to ensure asset persistence
 def ensure_asset_persistence(asset_path):
-    try:
-        asset = unreal.EditorAssetLibrary.load_asset(asset_path)
-        if not asset:
-            return False
+  try:
+    asset = unreal.EditorAssetLibrary.load_asset(asset_path)
+    if not asset:
+      record_warning(f"Asset persistence check failed: {asset_path} not loaded")
+      return False
         
-        # Save the asset
-        saved = unreal.EditorAssetLibrary.save_asset(asset_path, only_if_is_dirty=False)
-        if saved:
-            print(f"Asset saved: {asset_path}")
+    # Save the asset
+    saved = unreal.EditorAssetLibrary.save_asset(asset_path, only_if_is_dirty=False)
+    if saved:
+      print(f"Asset saved: {asset_path}")
+      record_detail(f"Asset saved: {asset_path}")
         
-        # Refresh the asset registry minimally for the asset's directory
-        try:
-            asset_dir = asset_path.rsplit('/', 1)[0]
-            unreal.AssetRegistryHelpers.get_asset_registry().scan_paths_synchronous([asset_dir], True)
-        except Exception as _reg_e:
-            pass
+    # Refresh the asset registry minimally for the asset's directory
+    try:
+      asset_dir = asset_path.rsplit('/', 1)[0]
+      unreal.AssetRegistryHelpers.get_asset_registry().scan_paths_synchronous([asset_dir], True)
+    except Exception as _reg_e:
+      record_warning(f"Asset registry refresh warning: {_reg_e}")
         
-        # Small delay to ensure filesystem sync
-        time.sleep(0.1)
+    # Small delay to ensure filesystem sync
+    time.sleep(0.1)
         
-        return saved
-    except Exception as e:
-        print(f"Error ensuring persistence: {e}")
-        return False
+    return saved
+  except Exception as e:
+    print(f"Error ensuring persistence: {e}")
+    record_error(f"Error ensuring persistence: {e}")
+    return False
 
-# Stop PIE if it's running
+# Stop PIE if running using modern subsystems
 try:
-    if unreal.EditorLevelLibrary.is_playing_editor():
-        print("Stopping Play In Editor mode...")
-        unreal.EditorLevelLibrary.editor_end_play()
-        time.sleep(0.5)
-except:
-    pass
+  level_subsystem = unreal.get_editor_subsystem(unreal.LevelEditorSubsystem)
+  play_subsystem = None
+  try:
+    play_subsystem = unreal.get_editor_subsystem(unreal.EditorPlayWorldSubsystem)
+  except Exception:
+    play_subsystem = None
+
+  is_playing = False
+  if level_subsystem and hasattr(level_subsystem, 'is_in_play_in_editor'):
+    is_playing = level_subsystem.is_in_play_in_editor()
+  elif play_subsystem and hasattr(play_subsystem, 'is_playing_in_editor'):  # type: ignore[attr-defined]
+    is_playing = play_subsystem.is_playing_in_editor()  # type: ignore[attr-defined]
+
+  if is_playing:
+    print("Stopping Play In Editor mode...")
+    record_detail("Stopping Play In Editor mode")
+    if level_subsystem and hasattr(level_subsystem, 'editor_request_end_play'):
+      level_subsystem.editor_request_end_play()
+    elif play_subsystem and hasattr(play_subsystem, 'stop_playing_session'):  # type: ignore[attr-defined]
+      play_subsystem.stop_playing_session()  # type: ignore[attr-defined]
+    elif play_subsystem and hasattr(play_subsystem, 'end_play'):  # type: ignore[attr-defined]
+      play_subsystem.end_play()  # type: ignore[attr-defined]
+    else:
+      record_warning('Unable to stop Play In Editor via modern subsystems; please stop PIE manually.')
+    time.sleep(0.5)
+except Exception as pie_error:
+  record_warning(f"PIE stop check failed: {pie_error}")
 
 # Main execution
 success = False
 error_msg = ""
+new_asset = None
 
 # Log the attempt
 print("Setting up ragdoll for ${meshPath}")
+record_detail("Setting up ragdoll for ${meshPath}")
 
 asset_path = "${path}"
 asset_name = "${sanitizedParams.name}"
 full_path = f"{asset_path}/{asset_name}"
 
 try:
-    # Check if already exists
-    if unreal.EditorAssetLibrary.does_asset_exist(full_path):
-        print(f"Physics asset already exists at {full_path}")
-        existing = unreal.EditorAssetLibrary.load_asset(full_path)
-        if existing:
-            print(f"Loaded existing PhysicsAsset: {full_path}")
-    else:
-        # Try to load skeletal mesh first - it's required
-        skeletal_mesh_path = "${meshPath}"
-        skeletal_mesh = None
+  # Check if already exists
+  if unreal.EditorAssetLibrary.does_asset_exist(full_path):
+    print(f"Physics asset already exists at {full_path}")
+    record_detail(f"Physics asset already exists at {full_path}")
+    existing = unreal.EditorAssetLibrary.load_asset(full_path)
+    if existing:
+      print(f"Loaded existing PhysicsAsset: {full_path}")
+      record_detail(f"Loaded existing PhysicsAsset: {full_path}")
+      success = True
+      result["existingAsset"] = True
+      result["message"] = f"Physics asset already exists at {full_path}"
+  else:
+    # Try to load skeletal mesh first - it's required
+    skeletal_mesh_path = "${meshPath}"
+    skeletal_mesh = None
         
-        if skeletal_mesh_path and skeletal_mesh_path != "None":
-            if unreal.EditorAssetLibrary.does_asset_exist(skeletal_mesh_path):
-                asset = unreal.EditorAssetLibrary.load_asset(skeletal_mesh_path)
-                if asset:
-                    if isinstance(asset, unreal.SkeletalMesh):
-                        skeletal_mesh = asset
-                        print(f"Loaded skeletal mesh: {skeletal_mesh_path}")
-                    elif isinstance(asset, unreal.Skeleton):
-                        error_msg = f"Provided path is a skeleton, not a skeletal mesh: {skeletal_mesh_path}"
-                        print(f"Error: {error_msg}")
-                        print(f"Error: Physics assets require a skeletal mesh, not just a skeleton")
-                    else:
-                        error_msg = f"Asset is not a skeletal mesh: {skeletal_mesh_path}"
-                        print(f"Warning: {error_msg}")
-            else:
-                error_msg = f"Skeletal mesh not found at {skeletal_mesh_path}"
-                print(f"Error: {error_msg}")
-        
-        if not skeletal_mesh:
-            if not error_msg:
-                error_msg = "Cannot create physics asset without a valid skeletal mesh"
+    if skeletal_mesh_path and skeletal_mesh_path != "None":
+      if unreal.EditorAssetLibrary.does_asset_exist(skeletal_mesh_path):
+        asset = unreal.EditorAssetLibrary.load_asset(skeletal_mesh_path)
+        if asset:
+          if isinstance(asset, unreal.SkeletalMesh):
+            skeletal_mesh = asset
+            print(f"Loaded skeletal mesh: {skeletal_mesh_path}")
+            record_detail(f"Loaded skeletal mesh: {skeletal_mesh_path}")
+          elif isinstance(asset, unreal.Skeleton):
+            error_msg = f"Provided path is a skeleton, not a skeletal mesh: {skeletal_mesh_path}"
             print(f"Error: {error_msg}")
-        else:
-            # Create physics asset using a different approach
-            # Method 1: Direct creation with initialized factory
-            try:
-                factory = unreal.PhysicsAssetFactory()
+            record_error(error_msg)
+            result["message"] = error_msg
+            print("Error: Physics assets require a skeletal mesh, not just a skeleton")
+            record_warning("Physics assets require a skeletal mesh, not just a skeleton")
+          else:
+            error_msg = f"Asset is not a skeletal mesh: {skeletal_mesh_path}"
+            print(f"Warning: {error_msg}")
+            record_warning(error_msg)
+      else:
+        error_msg = f"Skeletal mesh not found at {skeletal_mesh_path}"
+        print(f"Error: {error_msg}")
+        record_error(error_msg)
+        result["message"] = error_msg
+        
+    if not skeletal_mesh:
+      if not error_msg:
+        error_msg = "Cannot create physics asset without a valid skeletal mesh"
+      print(f"Error: {error_msg}")
+      record_error(error_msg)
+      if not result["message"]:
+        result["message"] = error_msg
+    else:
+      # Create physics asset using a different approach
+      # Method 1: Direct creation with initialized factory
+      try:
+        factory = unreal.PhysicsAssetFactory()
                 
-                # Create a transient package for the physics asset
-                # Ensure the directory exists
-                if not unreal.EditorAssetLibrary.does_directory_exist(asset_path):
-                    unreal.EditorAssetLibrary.make_directory(asset_path)
+        # Ensure the directory exists
+        if not unreal.EditorAssetLibrary.does_directory_exist(asset_path):
+          unreal.EditorAssetLibrary.make_directory(asset_path)
                 
-                # Alternative approach: Create physics asset from skeletal mesh
-                # This is the proper way in UE5
+        # Alternative approach: Create physics asset from skeletal mesh
+        # This is the proper way in UE5
+        try:
+          # Try modern physics asset creation methods first
+          try:
+            # Method 1: Try using SkeletalMesh editor utilities if available
+            if hasattr(unreal, 'SkeletalMeshEditorSubsystem'):
+              skel_subsystem = unreal.get_editor_subsystem(unreal.SkeletalMeshEditorSubsystem)
+              if hasattr(skel_subsystem, 'create_physics_asset'):
+                physics_asset = skel_subsystem.create_physics_asset(skeletal_mesh)
+              else:
+                # Fallback to deprecated EditorSkeletalMeshLibrary
                 physics_asset = unreal.EditorSkeletalMeshLibrary.create_physics_asset(skeletal_mesh)
+            else:
+              physics_asset = unreal.EditorSkeletalMeshLibrary.create_physics_asset(skeletal_mesh)
+          except Exception as method1_modern_error:
+            record_warning(f"Modern creation path fallback: {method1_modern_error}")
+            # Final fallback to deprecated API
+            physics_asset = unreal.EditorSkeletalMeshLibrary.create_physics_asset(skeletal_mesh)
+        except Exception as e:
+          print(f"Physics asset creation failed: {str(e)}")
+          record_error(f"Physics asset creation failed: {str(e)}")
+          physics_asset = None
                 
-                if physics_asset:
-                    # Move/rename the physics asset to desired location
-                    source_path = physics_asset.get_path_name()
-                    if unreal.EditorAssetLibrary.rename_asset(source_path, full_path):
-                        print(f"Successfully created and moved PhysicsAsset to {full_path}")
-                        new_asset = physics_asset
+        if physics_asset:
+          # Move/rename the physics asset to desired location
+          source_path = physics_asset.get_path_name()
+          if unreal.EditorAssetLibrary.rename_asset(source_path, full_path):
+            print(f"Successfully created and moved PhysicsAsset to {full_path}")
+            record_detail(f"Successfully created and moved PhysicsAsset to {full_path}")
+            new_asset = physics_asset
                         
-                        # Ensure persistence
-                        if ensure_asset_persistence(full_path):
-                            # Verify it was saved
-                            if unreal.EditorAssetLibrary.does_asset_exist(full_path):
-                                print(f"Verified PhysicsAsset exists after save: {full_path}")
-                                success = True
-                            else:
-                                error_msg = f"PhysicsAsset not found after save: {full_path}"
-                                print(f"Warning: {error_msg}")
-                        else:
-                            error_msg = "Failed to persist physics asset"
-                            print(f"Warning: {error_msg}")
-                    else:
-                        print(f"Created PhysicsAsset but couldn't move to {full_path}")
-                        # Still consider it a success if we created it
-                        new_asset = physics_asset
-                        success = True
-                else:
-                    error_msg = "Failed to create PhysicsAsset from skeletal mesh"
-                    print(f"{error_msg}")
-                    new_asset = None
+            # Ensure persistence
+            if ensure_asset_persistence(full_path):
+              # Verify it was saved
+              if unreal.EditorAssetLibrary.does_asset_exist(full_path):
+                print(f"Verified PhysicsAsset exists after save: {full_path}")
+                record_detail(f"Verified PhysicsAsset exists after save: {full_path}")
+                success = True
+                result["message"] = f"Ragdoll physics setup completed for {asset_name}"
+              else:
+                error_msg = f"PhysicsAsset not found after save: {full_path}"
+                print(f"Warning: {error_msg}")
+                record_warning(error_msg)
+            else:
+              error_msg = "Failed to persist physics asset"
+              print(f"Warning: {error_msg}")
+              record_warning(error_msg)
+          else:
+            print(f"Created PhysicsAsset but couldn't move to {full_path}")
+            record_warning(f"Created PhysicsAsset but couldn't move to {full_path}")
+            # Still consider it a success if we created it
+            new_asset = physics_asset
+            success = True
+            result["message"] = f"Physics asset created but not moved to {full_path}"
+        else:
+          error_msg = "Failed to create PhysicsAsset from skeletal mesh"
+          print(error_msg)
+          record_error(error_msg)
+          new_asset = None
                     
-            except Exception as e:
-                print(f"Method 1 failed: {str(e)}")
+              successMessage: \`Skeletal mesh discovery complete\`,
+              failureMessage: \`Failed to discover skeletal mesh\`
+        record_warning(f"Method 1 failed: {str(e)}")
                 
-                # Method 2: Try older approach
-                try:
-                    asset_tools = unreal.AssetToolsHelpers.get_asset_tools()
-                    factory = unreal.PhysicsAssetFactory()
+        # Method 2: Try older approach
+        try:
+          asset_tools = unreal.AssetToolsHelpers.get_asset_tools()
+          factory = unreal.PhysicsAssetFactory()
                     
-                    # Try to initialize factory with the skeletal mesh
-                    factory.create_physics_asset_from_skeletal_mesh = skeletal_mesh
+          # Try to initialize factory with the skeletal mesh
+          factory.create_physics_asset_from_skeletal_mesh = skeletal_mesh
                     
-                    new_asset = asset_tools.create_asset(
-                        asset_name=asset_name,
-                        package_path=asset_path,
-                        asset_class=unreal.PhysicsAsset,
-                        factory=factory
-                    )
+          new_asset = asset_tools.create_asset(
+            asset_name=asset_name,
+            package_path=asset_path,
+            asset_class=unreal.PhysicsAsset,
+            factory=factory
+          )
                     
-                    if new_asset:
-                        print(f"Successfully created PhysicsAsset at {full_path} (Method 2)")
-                        # Ensure persistence
-                        if ensure_asset_persistence(full_path):
-                            success = True
-                except Exception as e2:
-                    error_msg = f"Method 2 also failed: {str(e2)}"
-                    print(error_msg)
-                    new_asset = None
-            
-            # Final check
-            if new_asset and not success:
-                # Try one more save
-                if ensure_asset_persistence(full_path):
-                    if unreal.EditorAssetLibrary.does_asset_exist(full_path):
-                        success = True
+          if new_asset:
+            print(f"Successfully created PhysicsAsset at {full_path} (Method 2)")
+            record_detail(f"Successfully created PhysicsAsset at {full_path} (Method 2)")
+            # Ensure persistence
+            if ensure_asset_persistence(full_path):
+              success = True
+              result["message"] = f"Ragdoll physics setup completed for {asset_name}"
+            else:
+              record_warning("Persistence check failed after Method 2 creation")
+        except Exception as e2:
+          error_msg = f"Method 2 also failed: {str(e2)}"
+          print(error_msg)
+          record_error(error_msg)
+          new_asset = None
             
+      # Final check
+      if new_asset and not success:
+        # Try one more save
+        if ensure_asset_persistence(full_path):
+          if unreal.EditorAssetLibrary.does_asset_exist(full_path):
+            success = True
+            result["message"] = f"Ragdoll physics setup completed for {asset_name}"
+          else:
+            record_warning(f"Final existence check failed for {full_path}")
+
 except Exception as e:
-    error_msg = str(e)
-    print(f"Error: {error_msg}")
-    import traceback
-    traceback.print_exc()
+  error_msg = str(e)
+  print(f"Error: {error_msg}")
+  record_error(error_msg)
+  import traceback
+  traceback.print_exc()
 
-# Output result markers for parsing
-if success:
-    print("SUCCESS")
-else:
-    print(f"FAILED: {error_msg}")
+# Finalize result
+result["success"] = bool(success)
+result["path"] = full_path if success else None
 
-print("DONE")
+if not result["message"]:
+  if success:
+    result["message"] = f"Ragdoll physics setup completed for {asset_name}"
+  elif error_msg:
+    result["message"] = error_msg
+  else:
+    result["message"] = "Failed to setup ragdoll"
+
+if not success:
+  if not result["error"]:
+    result["error"] = error_msg or "Unknown error"
+
+print('RESULT:' + json.dumps(result))
 `;
-            // Execute Python and parse response
+            // Execute Python and interpret response
             try {
                 const response = await this.bridge.executePython(pythonScript);
-                // Parse the response to detect actual success or failure
-                const responseStr = typeof response === 'string' ? response : JSON.stringify(response);
-                // Check for explicit success/failure markers
-                if (responseStr.includes('SUCCESS')) {
-                    return {
+                const interpreted = interpretStandardResult(response, {
+                    successMessage: `Ragdoll physics setup completed for ${sanitizedParams.name}`,
+                    failureMessage: `Failed to setup ragdoll for ${sanitizedParams.name}`
+                });
+                const warnings = interpreted.warnings ?? [];
+                const details = interpreted.details ?? [];
+                if (interpreted.success) {
+                    const successPayload = {
                         success: true,
-                        message: `Ragdoll physics setup completed for ${sanitizedParams.name}`,
-                        path: `${path}/${sanitizedParams.name}`
+                        message: interpreted.message,
+                        path: coerceString(interpreted.payload.path) ?? `${path}/${sanitizedParams.name}`
                     };
-                }
-                else if (responseStr.includes('FAILED:')) {
-                    // Extract error message after FAILED:
-                    const failMatch = responseStr.match(/FAILED:\s*(.+)/);
-                    const errorMsg = failMatch ? failMatch[1] : 'Unknown error';
-                    return {
-                        success: false,
-                        message: `Failed to setup ragdoll: ${errorMsg}`,
-                        error: errorMsg
-                    };
-                }
-                else {
-                    // Check legacy error detection for backwards compatibility
-                    const logOutput = response?.LogOutput || [];
-                    const hasSkeletonError = logOutput.some((log) => log.Output && (log.Output.includes('skeleton, not a skeletal mesh') ||
-                        log.Output.includes('Must specify a valid skeletal mesh')));
-                    if (hasSkeletonError) {
-                        return {
-                            success: false,
-                            message: 'Failed: Must specify a valid skeletal mesh',
-                            error: 'The path points to a skeleton, not a skeletal mesh. Physics assets require a skeletal mesh.'
-                        };
+                    if (interpreted.payload.existingAsset === true) {
+                        successPayload.existingAsset = true;
                     }
-                    // Check for other error indicators
-                    if (responseStr.includes('Error:') || responseStr.includes('error')) {
-                        return {
-                            success: false,
-                            message: 'Failed to setup ragdoll physics',
-                            error: responseStr
-                        };
+                    if (warnings.length > 0) {
+                        successPayload.warnings = warnings;
                     }
-                    // Default to success if no errors detected
-                    return {
-                        success: true,
-                        message: `Ragdoll physics processed for ${sanitizedParams.name}`,
-                        path: `${path}/${sanitizedParams.name}`
-                    };
+                    if (details.length > 0) {
+                        successPayload.details = details;
+                    }
+                    return successPayload;
                 }
+                const errorMessage = interpreted.error ?? `Failed to setup ragdoll for ${sanitizedParams.name}`;
+                return {
+                    success: false,
+                    message: errorMessage,
+                    error: errorMessage,
+                    warnings: warnings.length > 0 ? warnings : undefined,
+                    details: details.length > 0 ? details : undefined
+                };
             }
             catch (error) {
                 return {
@@ -429,9 +539,7 @@ print("DONE")
                     commands.push(`SetConstraintLinear ${params.name} ${limits.linear}`);
                 }
             }
-            for (const cmd of commands) {
-                await this.bridge.executeConsoleCommand(cmd);
-            }
+            await this.bridge.executeConsoleCommands(commands);
             return {
                 success: true,
                 message: `Physics constraint ${params.name} created between ${params.actor1} and ${params.actor2}`
@@ -463,9 +571,7 @@ print("DONE")
             if (params.debrisLifetime) {
                 commands.push(`SetDebrisLifetime ${params.destructionName} ${params.debrisLifetime}`);
             }
-            for (const cmd of commands) {
-                await this.bridge.executeConsoleCommand(cmd);
-            }
+            await this.bridge.executeConsoleCommands(commands);
             return {
                 success: true,
                 message: `Chaos destruction ${params.destructionName} created`,
@@ -510,9 +616,7 @@ print("DONE")
                 }
                 commands.push(`SetFinalDriveRatio ${params.vehicleName} ${params.transmission.finalDriveRatio}`);
             }
-            for (const cmd of commands) {
-                await this.bridge.executeConsoleCommand(cmd);
-            }
+            await this.bridge.executeConsoleCommands(commands);
             return {
                 success: true,
                 message: `Vehicle ${params.vehicleName} configured`
@@ -627,55 +731,42 @@ except Exception as e:
 print(f"RESULT:{json.dumps(result)}")
       `.trim();
             const response = await this.bridge.executePython(pythonCode);
-            // Extract output from Python response
-            let outputStr = '';
-            if (typeof response === 'object' && response !== null) {
-                // Check if it has LogOutput (standard Python execution response)
-                if (response.LogOutput && Array.isArray(response.LogOutput)) {
-                    // Concatenate all log outputs
-                    outputStr = response.LogOutput
-                        .map((log) => log.Output || '')
-                        .join('');
-                }
-                else if ('result' in response) {
-                    outputStr = String(response.result);
-                }
-                else {
-                    outputStr = JSON.stringify(response);
-                }
-            }
-            else {
-                outputStr = String(response || '');
+            const interpreted = interpretStandardResult(response, {
+                successMessage: `Applied ${params.forceType} to ${params.actorName}`,
+                failureMessage: 'Force application failed'
+            });
+            const availableActors = coerceStringArray(interpreted.payload.available_actors);
+            if (interpreted.success) {
+                return {
+                    success: true,
+                    message: interpreted.message,
+                    availableActors,
+                    details: interpreted.details
+                };
             }
-            // Parse the result
-            const resultMatch = outputStr.match(/RESULT:(\{.*\})/);
-            if (resultMatch) {
-                try {
-                    const forceResult = JSON.parse(resultMatch[1]);
-                    if (!forceResult.success) {
-                        return { success: false, error: forceResult.message };
-                    }
-                    return forceResult;
-                }
-                catch {
-                    // Fallback
-                    if (outputStr.includes('Applied')) {
-                        return { success: true, message: outputStr };
-                    }
-                    return { success: false, error: outputStr || 'Force application failed' };
-                }
+            const fallbackText = bestEffortInterpretedText(interpreted) ?? '';
+            if (/Applied/i.test(fallbackText)) {
+                return {
+                    success: true,
+                    message: fallbackText || interpreted.message,
+                    availableActors,
+                    details: interpreted.details
+                };
             }
-            else {
-                // Check for error patterns
-                if (outputStr.includes('not found') || outputStr.includes('Error')) {
-                    return { success: false, error: outputStr || 'Force application failed' };
-                }
-                // Only return success if we have clear indication of success
-                if (outputStr.includes('Applied')) {
-                    return { success: true, message: `Applied ${params.forceType} to ${params.actorName}` };
-                }
-                return { success: false, error: 'No valid result from Python' };
+            if (/not found/i.test(fallbackText) || /error/i.test(fallbackText)) {
+                return {
+                    success: false,
+                    error: interpreted.error ?? (fallbackText || 'Force application failed'),
+                    availableActors,
+                    details: interpreted.details ?? (fallbackText ? [fallbackText] : undefined)
+                };
             }
+            return {
+                success: false,
+                error: interpreted.error ?? 'No valid result from Python',
+                availableActors,
+                details: interpreted.details ?? (fallbackText ? [fallbackText] : undefined)
+            };
         }
         catch (err) {
             return { success: false, error: `Failed to apply force: ${err}` };
@@ -712,9 +803,7 @@ print(f"RESULT:{json.dumps(result)}")
                     commands.push(`SetClothWind ${params.meshName} ${wind[0]} ${wind[1]} ${wind[2]}`);
                 }
             }
-            for (const cmd of commands) {
-                await this.bridge.executeConsoleCommand(cmd);
-            }
+            await this.bridge.executeConsoleCommands(commands);
             return {
                 success: true,
                 message: `Cloth simulation enabled for ${params.meshName}`
@@ -753,9 +842,7 @@ print(f"RESULT:{json.dumps(result)}")
                     commands.push(`SetFluidColor ${params.name} ${color[0]} ${color[1]} ${color[2]} ${color[3]}`);
                 }
             }
-            for (const cmd of commands) {
-                await this.bridge.executeConsoleCommand(cmd);
-            }
+            await this.bridge.executeConsoleCommands(commands);
             return {
                 success: true,
                 message: `Fluid simulation ${params.name} created`
@@ -765,20 +852,5 @@ print(f"RESULT:{json.dumps(result)}")
             return { success: false, error: `Failed to create fluid simulation: ${err}` };
         }
     }
-    /**
-     * Helper function to execute console commands
-     */
-    async _executeCommand(command) {
-        return this.bridge.httpCall('/remote/object/call', 'PUT', {
-            objectPath: '/Script/Engine.Default__KismetSystemLibrary',
-            functionName: 'ExecuteConsoleCommand',
-            parameters: {
-                WorldContextObject: null,
-                Command: command,
-                SpecificPlayer: null
-            },
-            generateTransaction: false
-        });
-    }
 }
 //# sourceMappingURL=physics.js.map