unreal-engine-mcp-server 0.3.1 → 0.4.0

package/dist/tools/debug.js

@@ -20,13 +20,11 @@ export class DebugVisualizationTools {
     async pyDraw(scriptBody) {
         const script = `
 import unreal
-# Use modern UnrealEditorSubsystem instead of deprecated EditorLevelLibrary
+# Strict modern API: require UnrealEditorSubsystem (UE 5.1+)
 ues = unreal.get_editor_subsystem(unreal.UnrealEditorSubsystem)
-if ues:
-    world = ues.get_editor_world()
-else:
-    # Fallback to deprecated API if subsystem not available
-    world = unreal.EditorLevelLibrary.get_editor_world()
+if not ues:
+    raise Exception('UnrealEditorSubsystem not available')
+world = ues.get_editor_world()
 ${scriptBody}
 `.trim()
             .replace(/\r?\n/g, '\n');

package/dist/tools/rc.js

@@ -142,7 +142,7 @@ except Exception as e:
     }
     // Expose an actor by label/name into a preset
     async exposeActor(params) {
-        const python = `\nimport unreal, json\npreset_path = r"${params.presetPath}"\nactor_name = r"${params.actorName}"\ntry:\n    preset = unreal.EditorAssetLibrary.load_asset(preset_path)\n    if not preset:\n        print('RESULT:' + json.dumps({'success': False, 'error': 'Preset not found'}))\n    else:\n        actor_sub = unreal.get_editor_subsystem(unreal.EditorActorSubsystem)\n        target = None\n        for a in actor_sub.get_all_level_actors():\n            if not a: continue\n            try:\n                if a.get_actor_label() == actor_name or a.get_name() == actor_name:\n                    target = a; break\n            except Exception: pass\n        if not target:\n            print('RESULT:' + json.dumps({'success': False, 'error': 'Actor not found'}))\n        else:\n            try:\n                unreal.RemoteControlFunctionLibrary.expose_actor(preset, target, None)\n                unreal.EditorAssetLibrary.save_asset(preset_path)\n                print('RESULT:' + json.dumps({'success': True}))\n            except Exception as e:\n                print('RESULT:' + json.dumps({'success': False, 'error': str(e)}))\nexcept Exception as e:\n    print('RESULT:' + json.dumps({'success': False, 'error': str(e)}))\n`.trim();
+        const python = `\nimport unreal, json\npreset_path = r"${params.presetPath}"\nactor_name = r"${params.actorName}"\ntry:\n    preset = unreal.EditorAssetLibrary.load_asset(preset_path)\n    if not preset:\n        print('RESULT:' + json.dumps({'success': False, 'error': 'Preset not found'}))\n    else:\n        actor_sub = unreal.get_editor_subsystem(unreal.EditorActorSubsystem)\n        target = None\n        for a in actor_sub.get_all_level_actors():\n            if not a: continue\n            try:\n                if a.get_actor_label() == actor_name or a.get_name() == actor_name:\n                    target = a; break\n            except Exception: pass\n        if not target:\n            print('RESULT:' + json.dumps({'success': False, 'error': 'Actor not found'}))\n        else:\n            try:\n                # Expose with a default-initialized optional args struct (cannot pass None)\n                args = unreal.RemoteControlOptionalExposeArgs()\n                unreal.RemoteControlFunctionLibrary.expose_actor(preset, target, args)\n                unreal.EditorAssetLibrary.save_asset(preset_path)\n                print('RESULT:' + json.dumps({'success': True}))\n            except Exception as e:\n                print('RESULT:' + json.dumps({'success': False, 'error': str(e)}))\nexcept Exception as e:\n    print('RESULT:' + json.dumps({'success': False, 'error': str(e)}))\n`.trim();
         const resp = await this.executeWithRetry(() => this.bridge.executePython(python), 'exposeActor');
         const result = this.parsePythonResult(resp, 'exposeActor');
         // Clear cache for this preset to force refresh
@@ -153,7 +153,7 @@ except Exception as e:
     }
     // Expose a property on an object into a preset
     async exposeProperty(params) {
-        const python = `\nimport unreal, json\npreset_path = r"${params.presetPath}"\nobj_path = r"${params.objectPath}"\nprop_name = r"${params.propertyName}"\ntry:\n    preset = unreal.EditorAssetLibrary.load_asset(preset_path)\n    obj = unreal.load_object(None, obj_path)\n    if not preset or not obj:\n        print('RESULT:' + json.dumps({'success': False, 'error': 'Preset or object not found'}))\n    else:\n        try:\n            unreal.RemoteControlFunctionLibrary.expose_property(preset, obj, prop_name, None)\n            unreal.EditorAssetLibrary.save_asset(preset_path)\n            print('RESULT:' + json.dumps({'success': True}))\n        except Exception as e:\n            print('RESULT:' + json.dumps({'success': False, 'error': str(e)}))\nexcept Exception as e:\n    print('RESULT:' + json.dumps({'success': False, 'error': str(e)}))\n`.trim();
+        const python = `\nimport unreal, json\npreset_path = r"${params.presetPath}"\nobj_path = r"${params.objectPath}"\nprop_name = r"${params.propertyName}"\ntry:\n    preset = unreal.EditorAssetLibrary.load_asset(preset_path)\n    obj = unreal.load_object(None, obj_path)\n    if not preset or not obj:\n        print('RESULT:' + json.dumps({'success': False, 'error': 'Preset or object not found'}))\n    else:\n        try:\n            # Expose with default optional args struct (cannot pass None)\n            args = unreal.RemoteControlOptionalExposeArgs()\n            unreal.RemoteControlFunctionLibrary.expose_property(preset, obj, prop_name, args)\n            unreal.EditorAssetLibrary.save_asset(preset_path)\n            print('RESULT:' + json.dumps({'success': True}))\n        except Exception as e:\n            print('RESULT:' + json.dumps({'success': False, 'error': str(e)}))\nexcept Exception as e:\n    print('RESULT:' + json.dumps({'success': False, 'error': str(e)}))\n`.trim();
         const resp = await this.executeWithRetry(() => this.bridge.executePython(python), 'exposeProperty');
         const result = this.parsePythonResult(resp, 'exposeProperty');
         // Clear cache for this preset to force refresh

package/dist/tools/sequence.js

@@ -282,12 +282,31 @@ except Exception as e:
      * Play the current level sequence
      */
     async play(params) {
+        const loop = params?.loopMode || '';
         const py = `
 import unreal, json
+
+# Helper to resolve SequencerLoopMode from a friendly string
+def _resolve_loop_mode(mode_str):
+    try:
+        m = str(mode_str).lower()
+        slm = unreal.SequencerLoopMode
+        if m in ('once','noloop','no_loop'):
+            return getattr(slm, 'SLM_NoLoop', getattr(slm, 'NoLoop'))
+        if m in ('loop',):
+            return getattr(slm, 'SLM_Loop', getattr(slm, 'Loop'))
+        if m in ('pingpong','ping_pong'):
+            return getattr(slm, 'SLM_PingPong', getattr(slm, 'PingPong'))
+    except Exception:
+        pass
+    return None
+
 try:
     unreal.LevelSequenceEditorBlueprintLibrary.play()
-    ${params?.loopMode ? `unreal.LevelSequenceEditorBlueprintLibrary.set_loop_mode('${params.loopMode}')` : ''}
-    print('RESULT:' + json.dumps({'success': True, 'playing': True}))
+    loop_mode = _resolve_loop_mode('${loop}')
+    if loop_mode is not None:
+        unreal.LevelSequenceEditorBlueprintLibrary.set_loop_mode(loop_mode)
+    print('RESULT:' + json.dumps({'success': True, 'playing': True, 'loopMode': '${loop || 'default'}'}))
 except Exception as e:
     print('RESULT:' + json.dumps({'success': False, 'error': str(e)}))
 `.trim();

package/dist/utils/response-validator.d.ts

@@ -19,7 +19,12 @@ export declare class ResponseValidator {
         structuredContent?: any;
     };
     /**
-     * Wrap a tool response with validation
+     * Wrap a tool response with validation and MCP-compliant content shape.
+     *
+     * MCP tools/call responses must contain a `content` array. Many internal
+     * handlers return structured JSON objects (e.g., { success, message, ... }).
+     * This wrapper serializes such objects into a single text block while keeping
+     * existing `content` responses intact.
      */
     wrapResponse(toolName: string, response: any): any;
     /**

package/dist/utils/response-validator.js

@@ -76,14 +76,17 @@ export class ResponseValidator {
         };
     }
     /**
-     * Wrap a tool response with validation
+     * Wrap a tool response with validation and MCP-compliant content shape.
+     *
+     * MCP tools/call responses must contain a `content` array. Many internal
+     * handlers return structured JSON objects (e.g., { success, message, ... }).
+     * This wrapper serializes such objects into a single text block while keeping
+     * existing `content` responses intact.
      */
     wrapResponse(toolName, response) {
         // Ensure response is safe to serialize first
         try {
-            // The response should already be cleaned, but double-check
             if (response && typeof response === 'object') {
-                // Make sure we can serialize it
                 JSON.stringify(response);
             }
         }
@@ -91,21 +94,45 @@ export class ResponseValidator {
             log.error(`Response for ${toolName} contains circular references, cleaning...`);
             response = cleanObject(response);
         }
-        const validation = this.validateResponse(toolName, response);
-        // Add validation metadata
+        // If handler already returned MCP content, keep it as-is (still validate)
+        const alreadyMcpShaped = response && typeof response === 'object' && Array.isArray(response.content);
+        // Choose the payload to validate: if already MCP-shaped, validate the
+        // structured content extracted from text; otherwise validate the object directly.
+        const validationTarget = alreadyMcpShaped ? response : response;
+        const validation = this.validateResponse(toolName, validationTarget);
         if (!validation.valid) {
             log.warn(`Tool ${toolName} response validation failed:`, validation.errors);
-            // Add warning to response but don't fail
-            if (response && typeof response === 'object') {
-                response._validation = {
-                    valid: false,
-                    errors: validation.errors
-                };
+        }
+        // If it's already MCP-shaped, return as-is (optionally append validation meta)
+        if (alreadyMcpShaped) {
+            if (!validation.valid) {
+                try {
+                    response._validation = { valid: false, errors: validation.errors };
+                }
+                catch { }
             }
+            return response;
+        }
+        // Otherwise, wrap structured result into MCP content
+        let text;
+        try {
+            // Pretty-print small objects for readability
+            text = typeof response === 'string'
+                ? response
+                : JSON.stringify(response ?? { success: true }, null, 2);
+        }
+        catch (_e) {
+            text = String(response);
+        }
+        const wrapped = {
+            content: [
+                { type: 'text', text }
+            ]
+        };
+        if (!validation.valid) {
+            wrapped._validation = { valid: false, errors: validation.errors };
         }
-        // Don't add structuredContent to the response - it's for internal validation only
-        // Adding it can cause circular references
-        return response;
+        return wrapped;
     }
     /**
      * Get validation statistics

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "unreal-engine-mcp-server",
-  "version": "0.3.1",
-  "description": "Production-ready MCP server for Unreal Engine integration with consolidated and individual tool modes",
+  "version": "0.4.0",
+  "description": "Production-ready MCP server for Unreal Engine integration using consolidated tools only",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -34,9 +34,9 @@
   "license": "MIT",
   "mcpName": "io.github.ChiR24/unreal-engine-mcp",
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.4.0",
+    "@modelcontextprotocol/sdk": "^1.18.1",
     "ajv": "^8.12.0",
-    "axios": "^1.7.2",
+    "axios": "^1.12.2",
     "dotenv": "^16.4.5",
     "ws": "^8.18.0",
     "yargs": "^17.7.2",

package/server.json

@@ -2,13 +2,13 @@
   "$schema": "https://static.modelcontextprotocol.io/schemas/2025-07-09/server.schema.json",
   "name": "io.github.ChiR24/unreal-engine-mcp",
   "description": "Production-ready MCP server for Unreal Engine with comprehensive game development tools",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "packages": [
     {
       "registry_type": "npm",
       "registry_base_url": "https://registry.npmjs.org",
       "identifier": "unreal-engine-mcp-server",
-      "version": "0.3.1",
+      "version": "0.4.0",
       "transport": {
         "type": "stdio"
       },

package/src/index.ts

@@ -17,6 +17,7 @@ import { BlueprintTools } from './tools/blueprint.js';
 import { LevelTools } from './tools/level.js';
 import { LightingTools } from './tools/lighting.js';
 import { LandscapeTools } from './tools/landscape.js';
+import { BuildEnvironmentAdvanced } from './tools/build_environment_advanced.js';
 import { FoliageTools } from './tools/foliage.js';
 import { DebugVisualizationTools } from './tools/debug.js';
 import { PerformanceTools } from './tools/performance.js';
@@ -27,8 +28,6 @@ import { SequenceTools } from './tools/sequence.js';
 import { IntrospectionTools } from './tools/introspection.js';
 import { VisualTools } from './tools/visual.js';
 import { EngineTools } from './tools/engine.js';
-import { toolDefinitions } from './tools/tool-definitions.js';
-import { handleToolCall } from './tools/tool-handlers.js';
 import { consolidatedToolDefinitions } from './tools/consolidated-tool-definitions.js';
 import { handleConsolidatedToolCall } from './tools/consolidated-tool-handlers.js';
 import { prompts } from './prompts/index.js';
@@ -81,14 +80,13 @@ let lastHealthSuccessAt = 0;
 
 // Configuration
 const CONFIG = {
-  // Tool mode: true = consolidated (13 tools), false = individual (36+ tools)
-  USE_CONSOLIDATED_TOOLS: process.env.USE_CONSOLIDATED_TOOLS !== 'false',
+  // Tooling: use consolidated tools only (13 tools)
   // Connection retry settings
   MAX_RETRY_ATTEMPTS: 3,
   RETRY_DELAY_MS: 2000,
   // Server info
   SERVER_NAME: 'unreal-engine-mcp',
-  SERVER_VERSION: '0.3.1',
+  SERVER_VERSION: '0.4.0',
   // Monitoring
   HEALTH_CHECK_INTERVAL_MS: 30000 // 30 seconds
 };
@@ -149,9 +147,9 @@ export async function createServer() {
   // Disable auto-reconnect loops; connect only on-demand
   bridge.setAutoReconnectEnabled(false);
   
-  // Initialize response validation with schemas
+// Initialize response validation with schemas
   log.debug('Initializing response validation...');
-  const toolDefs = CONFIG.USE_CONSOLIDATED_TOOLS ? consolidatedToolDefinitions : toolDefinitions;
+  const toolDefs = consolidatedToolDefinitions;
   toolDefs.forEach((tool: any) => {
     if (tool.outputSchema) {
       responseValidator.registerSchema(tool.name, tool.outputSchema);
@@ -227,6 +225,7 @@ export async function createServer() {
   const lightingTools = new LightingTools(bridge);
   const landscapeTools = new LandscapeTools(bridge);
   const foliageTools = new FoliageTools(bridge);
+  const buildEnvAdvanced = new BuildEnvironmentAdvanced(bridge);
   const debugTools = new DebugVisualizationTools(bridge);
   const performanceTools = new PerformanceTools(bridge);
   const audioTools = new AudioTools(bridge);
@@ -433,15 +432,15 @@ export async function createServer() {
     throw new Error(`Unknown resource: ${uri}`);
   });
 
-  // Handle tool listing - switch between consolidated (13) or individual (36) tools
+// Handle tool listing - consolidated tools only
   server.setRequestHandler(ListToolsRequestSchema, async () => {
-    log.info(`Serving ${CONFIG.USE_CONSOLIDATED_TOOLS ? 'consolidated' : 'individual'} tools`);
+    log.info('Serving consolidated tools');
     return {
-      tools: CONFIG.USE_CONSOLIDATED_TOOLS ? consolidatedToolDefinitions : toolDefinitions
+      tools: consolidatedToolDefinitions
     };
   });
 
-  // Handle tool calls - switch between consolidated (13) or individual (36) tools
+  // Handle tool calls - consolidated tools only (13)
   server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
     const startTime = Date.now();
@@ -460,7 +459,7 @@ export async function createServer() {
       return notConnected;
     }
     
-    // Create tools object for handler
+// Create tools object for handler
     const tools = {
       actorTools,
       assetTools,
@@ -474,6 +473,7 @@ export async function createServer() {
       lightingTools,
       landscapeTools,
       foliageTools,
+      buildEnvAdvanced,
       debugTools,
       performanceTools,
       audioTools,
@@ -483,19 +483,18 @@ export async function createServer() {
       introspectionTools,
       visualTools,
       engineTools,
+      // Resources for listing and info
+      assetResources,
+      actorResources,
+      levelResources,
       bridge
     };
     
-    // Use consolidated or individual handler based on configuration
+// Execute consolidated tool handler
     try {
       log.debug(`Executing tool: ${name}`);
       
-      let result;
-      if (CONFIG.USE_CONSOLIDATED_TOOLS) {
-        result = await handleConsolidatedToolCall(name, args, tools);
-      } else {
-        result = await handleToolCall(name, args, tools);
-      }
+      let result = await handleConsolidatedToolCall(name, args, tools);
       
       log.debug(`Tool ${name} returned result`);
       

package/src/resources/assets.ts

@@ -10,11 +10,35 @@ export class AssetResources {
     return page !== undefined ? `${dir}::${recursive ? 1 : 0}::${page}` : `${dir}::${recursive ? 1 : 0}`; 
   }
 
+  // Normalize UE content paths:
+  // - Map '/Content' -> '/Game'
+  // - Ensure forward slashes
+  private normalizeDir(dir: string): string {
+    try {
+      if (!dir || typeof dir !== 'string') return '/Game';
+      let d = dir.replace(/\\/g, '/');
+      if (!d.startsWith('/')) d = '/' + d;
+      if (d.toLowerCase().startsWith('/content')) {
+        d = '/Game' + d.substring('/Content'.length);
+      }
+      // Collapse multiple slashes
+      d = d.replace(/\/+/g, '/');
+      // Remove trailing slash except root
+      if (d.length > 1) d = d.replace(/\/$/, '');
+      return d;
+    } catch {
+      return '/Game';
+    }
+  }
+
   async list(dir = '/Game', _recursive = false, limit = 50) {
     // ALWAYS use non-recursive listing to show only immediate children
     // This prevents timeouts and makes navigation clearer
     _recursive = false; // Force non-recursive
     
+    // Normalize directory first
+    dir = this.normalizeDir(dir);
+
     // Cache fast-path
     try {
       const key = this.makeKey(dir, false);
@@ -50,7 +74,8 @@ export class AssetResources {
     const safePageSize = Math.min(pageSize, 50);
     const offset = page * safePageSize;
     
-    // Check cache for this specific page
+    // Normalize directory and check cache for this specific page
+    dir = this.normalizeDir(dir);
     const cacheKey = this.makeKey(dir, recursive, page);
     const cached = this.cache.get(cacheKey);
     if (cached && (Date.now() - cached.timestamp) < this.ttlMs) {
@@ -102,8 +127,8 @@ export class AssetResources {
   }
 
   /**
-   * Directory-based listing for paths with too many assets
-   * Shows only immediate children (folders and files) to avoid timeouts
+   * Directory-based listing of immediate children using AssetRegistry.
+   * Returns both subfolders and assets at the given path.
    */
   private async listDirectoryOnly(dir: string, _recursive: boolean, limit: number) {
     // Always return only immediate children to avoid timeout and improve navigation
@@ -112,65 +137,43 @@ export class AssetResources {
 import unreal
 import json
 
-_dir = r"${dir}"
+_dir = r"${this.normalizeDir(dir)}"
 
 try:
-    # ALWAYS non-recursive - get only immediate children
-    all_paths = unreal.EditorAssetLibrary.list_assets(_dir, False, False)
-    
-    # Organize into immediate children only
-    immediate_folders = set()
-    immediate_assets = []
-    
-    for path in all_paths:
-        # Remove the base directory to get relative path
-        relative = path.replace(_dir, '').strip('/')
-        if not relative:
-            continue
-            
-        # Split to check depth
-        parts = relative.split('/')
-        
-        if len(parts) == 1:
-            # This is an immediate child asset
-            immediate_assets.append(path)
-        elif len(parts) > 1:
-            # This indicates a subfolder exists
-            immediate_folders.add(parts[0])
-    
-    result = []
-    
-    # Add folders first
-    for folder in sorted(immediate_folders):
-        result.append({
-            'n': folder,
-            'p': _dir + '/' + folder,
-            'c': 'Folder',
-            'isFolder': True
-        })
-    
-    # Add immediate assets (limit to prevent socket issues)
-    for asset_path in immediate_assets[:min(${limit}, len(immediate_assets))]:
-        name = asset_path.split('/')[-1].split('.')[0]
-        result.append({
-            'n': name,
-            'p': asset_path,
-            'c': 'Asset'
-        })
-    
-    # Always showing immediate children only
-    note = f'Showing immediate children of {_dir} ({len(immediate_folders)} folders, {len(immediate_assets)} files)'
-    
+    ar = unreal.AssetRegistryHelpers.get_asset_registry()
+    # Immediate subfolders
+    sub_paths = ar.get_sub_paths(_dir, False)
+    folders_list = []
+    for p in sub_paths:
+        try:
+            name = p.split('/')[-1]
+            folders_list.append({'n': name, 'p': p})
+        except Exception:
+            pass
+
+    # Immediate assets at this path
+    assets_data = ar.get_assets_by_path(_dir, False)
+    assets = []
+    for a in assets_data[:${limit}]:
+        try:
+            assets.append({
+                'n': str(a.asset_name),
+                'p': str(a.object_path),
+                'c': str(a.asset_class)
+            })
+        except Exception:
+            pass
+
     print("RESULT:" + json.dumps({
-        'success': True, 
-        'assets': result, 
-        'count': len(result),
-        'folders': len(immediate_folders),
-        'files': len(immediate_assets),
-        'note': note
+        'success': True,
+        'path': _dir,
+        'folders': len(folders_list),
+        'files': len(assets),
+        'folders_list': folders_list,
+        'assets': assets
     }))
 except Exception as e:
-    print("RESULT:" + json.dumps({'success': False, 'error': str(e), 'assets': []}))
+    print("RESULT:" + json.dumps({'success': False, 'error': str(e), 'path': _dir}))
 `.trim();
 
       const resp = await this.bridge.executePython(py);
@@ -188,21 +191,37 @@ except Exception as e:
         try {
           const parsed = JSON.parse(m[1]);
           if (parsed.success) {
-            // Transform to standard format
-            const assets = parsed.assets.map((a: any) => ({
+            // Map folders and assets to a clear response
+            const foldersArr = Array.isArray(parsed.folders_list) ? parsed.folders_list.map((f: any) => ({
+              Name: f.n,
+              Path: f.p,
+              Class: 'Folder',
+              isFolder: true
+            })) : [];
+
+            const assetsArr = Array.isArray(parsed.assets) ? parsed.assets.map((a: any) => ({
               Name: a.n,
               Path: a.p,
-              Class: a.c,
-              isFolder: a.isFolder || false
-            }));
-            
+              Class: a.c || 'Asset',
+              isFolder: false
+            })) : [];
+
+            const total = foldersArr.length + assetsArr.length;
+            const summary = {
+              total,
+              folders: foldersArr.length,
+              assets: assetsArr.length
+            };
+
             return {
-              assets,
-              count: parsed.count,
-              folders: parsed.folders,
-              files: parsed.files,
-              note: parsed.note,
-              method: 'directory_listing'
+              success: true,
+              path: parsed.path || this.normalizeDir(dir),
+              summary,
+              foldersList: foldersArr,
+              assets: assetsArr,
+              count: total,
+              note: `Immediate children of ${parsed.path || this.normalizeDir(dir)}: ${foldersArr.length} folder(s), ${assetsArr.length} asset(s)`,
+              method: 'asset_registry_listing'
             };
           }
         } catch {}
@@ -213,10 +232,13 @@ except Exception as e:
     
     // Fallback: return empty with explanation
     return {
+      success: true,
+      path: this.normalizeDir(dir),
+      summary: { total: 0, folders: 0, assets: 0 },
+      foldersList: [],
       assets: [],
-      warning: 'Directory contains too many assets. Showing immediate children only.',
-      suggestion: 'Navigate to specific subdirectories for detailed listings.',
-      method: 'directory_timeout_fallback'
+      warning: 'No items at this path or failed to query AssetRegistry.',
+      method: 'asset_registry_fallback'
     };
   }
 
@@ -226,9 +248,11 @@ except Exception as e:
       return false;
     }
 
+    // Normalize asset path (support users passing /Content/...)
+    const ap = this.normalizeDir(assetPath);
     const py = `
 import unreal
-apath = r"${assetPath}"
+apath = r"${ap}"
 try:
     exists = unreal.EditorAssetLibrary.does_asset_exist(apath)
     print("RESULT:{'success': True, 'exists': %s}" % ('True' if exists else 'False'))

package/src/resources/levels.ts

@@ -56,9 +56,9 @@ export class LevelResources {
   }
 
   async saveCurrentLevel() {
-    // Prefer Python save (or LevelEditorSubsystem) then fallback
+    // Strict modern API: require LevelEditorSubsystem
     try {
-      const py = '\nimport unreal, json\ntry:\n    les = unreal.get_editor_subsystem(unreal.LevelEditorSubsystem)\n    if les: les.save_current_level()\n    else: unreal.EditorLevelLibrary.save_current_level()\n    print(\'RESULT:\' + json.dumps({\'success\': True}))\nexcept Exception as e:\n    print(\'RESULT:\' + json.dumps({\'success\': False, \'error\': str(e)}))\n'.trim();
+      const py = '\nimport unreal, json\ntry:\n    les = unreal.get_editor_subsystem(unreal.LevelEditorSubsystem)\n    if not les:\n        print(\'RESULT:\' + json.dumps({\'success\': False, \'error\': \'LevelEditorSubsystem not available\'}))\n    else:\n        les.save_current_level()\n        print(\'RESULT:\' + json.dumps({\'success\': True}))\nexcept Exception as e:\n    print(\'RESULT:\' + json.dumps({\'success\': False, \'error\': str(e)}))\n'.trim();
       const resp: any = await this.bridge.executePython(py);
       // Handle LogOutput format from executePython
       let out = '';

package/src/tools/assets.ts

@@ -7,8 +7,12 @@ export class AssetTools {
 
   async importAsset(sourcePath: string, destinationPath: string) {
     try {
-      // Sanitize destination path (remove trailing slash)
-      const cleanDest = destinationPath.replace(/\/$/, '');
+      // Sanitize destination path (remove trailing slash) and normalize UE path
+      let cleanDest = destinationPath.replace(/\/$/, '');
+      // Map /Content -> /Game for UE asset destinations
+      if (/^\/?content(\/|$)/i.test(cleanDest)) {
+        cleanDest = '/Game' + cleanDest.replace(/^\/?content/i, '');
+      }
 
       // Create test FBX file if it's a test file
       if (sourcePath.includes('test_model.fbx')) {