unreal-engine-mcp-server 0.3.1 → 0.4.3

package/src/tools/physics.ts

@@ -1,5 +1,6 @@
 import { UnrealBridge } from '../unreal-bridge.js';
 import { validateAssetParams, resolveSkeletalMeshPath, concurrencyDelay } from '../utils/validation.js';
+import { bestEffortInterpretedText, coerceString, coerceStringArray, interpretStandardResult } from '../utils/result-helpers.js';
 
 export class PhysicsTools {
   constructor(private bridge: UnrealBridge) {}
@@ -10,62 +11,80 @@ export class PhysicsTools {
   private async findValidSkeletalMesh(): Promise<string | null> {
     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 as any).LogOutput)) {
-        outputStr = (response as any).LogOutput.map((l: any) => l.Output || '').join('');
-      } else if (typeof response === 'string') {
-        outputStr = response;
-      } else {
-        // Fallback: stringify and still try to parse, but restrict to line content only
-        outputStr = JSON.stringify(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;
+        }
       }
-      
-      // 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 fallback = coerceString(interpreted.payload.fallback);
+      if (fallback) {
+        return fallback;
+      }
+
+      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';
   }
 
@@ -170,7 +189,9 @@ else:
       const skeletonToMeshMap: { [key: string]: string } = {
         '/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
@@ -186,240 +207,343 @@ else:
       }
       
       // Build Python script with resolved mesh path
-      const pythonScript = `
+    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
-        
-        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}")
+  # 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 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()
-
-# Output result markers for parsing
-if success:
-    print("SUCCESS")
-else:
-    print(f"FAILED: {error_msg}")
-
-print("DONE")
+  error_msg = str(e)
+  print(f"Error: {error_msg}")
+  record_error(error_msg)
+  import traceback
+  traceback.print_exc()
+
+# Finalize result
+result["success"] = bool(success)
+result["path"] = full_path if success else None
+
+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 { 
-            success: true, 
-            message: `Ragdoll physics setup completed for ${sanitizedParams.name}`,
-            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
+        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: string;
+            path: string;
+            existingAsset?: boolean;
+            warnings?: string[];
+            details?: string[];
+          } = {
+            success: true,
+            message: interpreted.message,
+            path: coerceString(interpreted.payload.path) ?? `${path}/${sanitizedParams.name}`
           };
-        } else {
-          // Check legacy error detection for backwards compatibility
-          const logOutput = response?.LogOutput || [];
-          const hasSkeletonError = logOutput.some((log: any) => 
-            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 as const,
+          message: errorMessage,
+          error: errorMessage,
+          warnings: warnings.length > 0 ? warnings : undefined,
+          details: details.length > 0 ? details : undefined
+        };
       } catch (error) {
         return {
           success: false,
@@ -480,9 +604,7 @@ print("DONE")
         }
       }
       
-      for (const cmd of commands) {
-        await this.bridge.executeConsoleCommand(cmd);
-      }
+      await this.bridge.executeConsoleCommands(commands);
       
       return { 
         success: true, 
@@ -533,9 +655,7 @@ print("DONE")
         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, 
@@ -612,9 +732,7 @@ print("DONE")
         );
       }
       
-      for (const cmd of commands) {
-        await this.bridge.executeConsoleCommand(cmd);
-      }
+      await this.bridge.executeConsoleCommands(commands);
       
       return { 
         success: true, 
@@ -737,52 +855,47 @@ 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: any) => 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' };
-        }
-      } 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' };
+
+  const fallbackText = bestEffortInterpretedText(interpreted) ?? '';
+      if (/Applied/i.test(fallbackText)) {
+        return {
+          success: true,
+          message: fallbackText || interpreted.message,
+          availableActors,
+          details: interpreted.details
+        };
       }
+
+      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}` };
     }
@@ -833,9 +946,7 @@ print(f"RESULT:{json.dumps(result)}")
         }
       }
       
-      for (const cmd of commands) {
-        await this.bridge.executeConsoleCommand(cmd);
-      }
+      await this.bridge.executeConsoleCommands(commands);
       
       return { 
         success: true, 
@@ -893,9 +1004,7 @@ print(f"RESULT:{json.dumps(result)}")
         }
       }
       
-      for (const cmd of commands) {
-        await this.bridge.executeConsoleCommand(cmd);
-      }
+      await this.bridge.executeConsoleCommands(commands);
       
       return { 
         success: true, 
@@ -906,19 +1015,4 @@ print(f"RESULT:{json.dumps(result)}")
     }
   }
 
-  /**
-   * Helper function to execute console commands
-   */
-  private async _executeCommand(command: string) {
-    return this.bridge.httpCall('/remote/object/call', 'PUT', {
-      objectPath: '/Script/Engine.Default__KismetSystemLibrary',
-      functionName: 'ExecuteConsoleCommand',
-      parameters: {
-        WorldContextObject: null,
-        Command: command,
-        SpecificPlayer: null
-      },
-      generateTransaction: false
-    });
-  }
 }