unreal-engine-mcp-server 0.4.7 → 0.5.1

package/dist/tools/level.js

@@ -1,617 +1,678 @@
-import { coerceBoolean, coerceNumber, coerceString, interpretStandardResult } from '../utils/result-helpers.js';
-export class LevelTools {
-    bridge;
-    constructor(bridge) {
-        this.bridge = bridge;
+import { BaseTool } from './base-tool.js';
+import { sanitizePath } from '../utils/path-security.js';
+import { DEFAULT_OPERATION_TIMEOUT_MS, DEFAULT_ASSET_OP_TIMEOUT_MS, LONG_RUNNING_OP_TIMEOUT_MS } from '../constants.js';
+export class LevelTools extends BaseTool {
+    managedLevels = new Map();
+    listCache;
+    LIST_CACHE_TTL_MS = 750;
+    currentLevelPath;
+    invalidateListCache() {
+        this.listCache = undefined;
+    }
+    normalizeLevelPath(rawPath) {
+        if (!rawPath) {
+            return { path: '/Game/Maps/Untitled', name: 'Untitled' };
+        }
+        let formatted = rawPath.replace(/\\/g, '/').trim();
+        if (!formatted.startsWith('/')) {
+            formatted = formatted.startsWith('Game/') ? `/${formatted}` : `/Game/${formatted.replace(/^\/?Game\//i, '')}`;
+        }
+        if (!formatted.startsWith('/Game/')) {
+            formatted = `/Game/${formatted.replace(/^\/+/, '')}`;
+        }
+        try {
+            formatted = sanitizePath(formatted);
+        }
+        catch (e) {
+            throw new Error(`Security validation failed for level path: ${e.message}`);
+        }
+        formatted = formatted.replace(/\.umap$/i, '');
+        if (formatted.endsWith('/')) {
+            formatted = formatted.slice(0, -1);
+        }
+        const segments = formatted.split('/').filter(Boolean);
+        const lastSegment = segments[segments.length - 1] ?? 'Untitled';
+        const name = lastSegment.includes('.') ? lastSegment.split('.').pop() ?? lastSegment : lastSegment;
+        return { path: formatted, name: name || 'Untitled' };
+    }
+    ensureRecord(path, seed) {
+        const normalized = this.normalizeLevelPath(path);
+        let record = this.managedLevels.get(normalized.path);
+        if (!record) {
+            record = {
+                path: normalized.path,
+                name: seed?.name ?? normalized.name,
+                partitioned: seed?.partitioned ?? false,
+                streaming: seed?.streaming ?? false,
+                loaded: seed?.loaded ?? false,
+                visible: seed?.visible ?? false,
+                createdAt: seed?.createdAt ?? Date.now(),
+                lastSavedAt: seed?.lastSavedAt,
+                metadata: seed?.metadata ? { ...seed.metadata } : undefined,
+                exports: seed?.exports ? [...seed.exports] : [],
+                lights: seed?.lights ? [...seed.lights] : []
+            };
+            this.managedLevels.set(normalized.path, record);
+            this.invalidateListCache();
+        }
+        return record;
+    }
+    mutateRecord(path, updates) {
+        if (!path || !path.trim()) {
+            return undefined;
+        }
+        const record = this.ensureRecord(path, updates);
+        let changed = false;
+        if (updates.name !== undefined && updates.name !== record.name) {
+            record.name = updates.name;
+            changed = true;
+        }
+        if (updates.partitioned !== undefined && updates.partitioned !== record.partitioned) {
+            record.partitioned = updates.partitioned;
+            changed = true;
+        }
+        if (updates.streaming !== undefined && updates.streaming !== record.streaming) {
+            record.streaming = updates.streaming;
+            changed = true;
+        }
+        if (updates.loaded !== undefined && updates.loaded !== record.loaded) {
+            record.loaded = updates.loaded;
+            changed = true;
+        }
+        if (updates.visible !== undefined && updates.visible !== record.visible) {
+            record.visible = updates.visible;
+            changed = true;
+        }
+        if (updates.createdAt !== undefined && updates.createdAt !== record.createdAt) {
+            record.createdAt = updates.createdAt;
+            changed = true;
+        }
+        if (updates.lastSavedAt !== undefined && updates.lastSavedAt !== record.lastSavedAt) {
+            record.lastSavedAt = updates.lastSavedAt;
+            changed = true;
+        }
+        if (updates.metadata) {
+            record.metadata = { ...(record.metadata ?? {}), ...updates.metadata };
+            changed = true;
+        }
+        if (updates.exports && updates.exports.length > 0) {
+            record.exports = [...record.exports, ...updates.exports];
+            changed = true;
+        }
+        if (updates.lights && updates.lights.length > 0) {
+            record.lights = [...record.lights, ...updates.lights];
+            changed = true;
+        }
+        if (changed) {
+            this.invalidateListCache();
+        }
+        return record;
+    }
+    getRecord(path) {
+        if (!path || !path.trim()) {
+            return undefined;
+        }
+        const normalized = this.normalizeLevelPath(path);
+        return this.managedLevels.get(normalized.path);
+    }
+    resolveLevelPath(explicit) {
+        if (explicit && explicit.trim()) {
+            return this.normalizeLevelPath(explicit).path;
+        }
+        return this.currentLevelPath;
+    }
+    removeRecord(path) {
+        const normalized = this.normalizeLevelPath(path);
+        if (this.managedLevels.delete(normalized.path)) {
+            if (this.currentLevelPath === normalized.path) {
+                this.currentLevelPath = undefined;
+            }
+            this.invalidateListCache();
+        }
+    }
+    listManagedLevels() {
+        const now = Date.now();
+        if (this.listCache && now - this.listCache.timestamp < this.LIST_CACHE_TTL_MS) {
+            return this.listCache.result;
+        }
+        const levels = Array.from(this.managedLevels.values()).map((record) => ({
+            path: record.path,
+            name: record.name,
+            partitioned: record.partitioned,
+            streaming: record.streaming,
+            loaded: record.loaded,
+            visible: record.visible,
+            createdAt: record.createdAt,
+            lastSavedAt: record.lastSavedAt,
+            exports: record.exports,
+            lightCount: record.lights.length
+        }));
+        const result = { success: true, message: 'Managed levels listed', count: levels.length, levels };
+        this.listCache = { result, timestamp: now };
+        return result;
+    }
+    summarizeLevel(path) {
+        const record = this.getRecord(path);
+        if (!record) {
+            return { success: false, error: `Level not tracked: ${path}` };
+        }
+        return {
+            success: true,
+            message: 'Level summary ready',
+            path: record.path,
+            name: record.name,
+            partitioned: record.partitioned,
+            streaming: record.streaming,
+            loaded: record.loaded,
+            visible: record.visible,
+            createdAt: record.createdAt,
+            lastSavedAt: record.lastSavedAt,
+            exports: record.exports,
+            lights: record.lights,
+            metadata: record.metadata
+        };
+    }
+    setCurrentLevel(path) {
+        const normalized = this.normalizeLevelPath(path);
+        this.currentLevelPath = normalized.path;
+        this.ensureRecord(normalized.path, { loaded: true, visible: true });
+    }
+    async listLevels() {
+        try {
+            const response = await this.sendAutomationRequest('list_levels', {}, {
+                timeoutMs: 10000
+            });
+            if (response && response.success !== false) {
+                const managed = this.listManagedLevels();
+                const ueLevels = (response.allMaps || []);
+                const managedOnly = managed.levels.filter(m => !ueLevels.some(u => u.path === m.path));
+                const finalLevels = [...ueLevels, ...managedOnly];
+                const result = {
+                    ...response,
+                    success: true,
+                    message: 'Levels listed from Unreal Engine',
+                    levels: finalLevels,
+                    currentMap: response.currentMap,
+                    currentMapPath: response.currentMapPath,
+                    currentWorldLevels: response.currentWorldLevels || [],
+                    data: {
+                        levels: finalLevels,
+                        count: finalLevels.length
+                    },
+                    managedLevels: managed.levels,
+                    managedLevelCount: managed.count
+                };
+                return result;
+            }
+        }
+        catch {
+        }
+        return this.listManagedLevels();
+    }
+    async getLevelSummary(levelPath) {
+        const resolved = this.resolveLevelPath(levelPath);
+        if (!resolved) {
+            return { success: false, error: 'No level specified' };
+        }
+        return this.summarizeLevel(resolved);
+    }
+    registerLight(levelPath, info) {
+        const resolved = this.resolveLevelPath(levelPath);
+        if (!resolved) {
+            return;
+        }
+        this.mutateRecord(resolved, {
+            lights: [
+                {
+                    name: info.name,
+                    type: info.type,
+                    createdAt: Date.now(),
+                    details: info.details
+                }
+            ]
+        });
+    }
+    async exportLevel(params) {
+        const resolved = this.resolveLevelPath(params.levelPath);
+        if (!resolved) {
+            return { success: false, error: 'No level specified for export' };
+        }
+        try {
+            const res = await this.sendAutomationRequest('manage_level', {
+                action: 'export_level',
+                levelPath: resolved,
+                exportPath: params.exportPath
+            }, { timeoutMs: params.timeoutMs ?? LONG_RUNNING_OP_TIMEOUT_MS });
+            if (res?.success === false) {
+                return {
+                    success: false,
+                    error: res.error || res.message || 'Export failed',
+                    levelPath: resolved,
+                    exportPath: params.exportPath,
+                    details: res
+                };
+            }
+            return {
+                success: true,
+                message: `Level exported to ${params.exportPath}`,
+                levelPath: resolved,
+                exportPath: params.exportPath,
+                details: res
+            };
+        }
+        catch (e) {
+            return { success: false, error: `Export failed: ${e.message}` };
+        }
+    }
+    async importLevel(params) {
+        const destination = params.destinationPath
+            ? this.normalizeLevelPath(params.destinationPath)
+            : this.normalizeLevelPath(`/Game/Maps/Imported_${Math.floor(Date.now() / 1000)}`);
+        try {
+            const res = await this.sendAutomationRequest('manage_level', {
+                action: 'import_level',
+                packagePath: params.packagePath,
+                destinationPath: destination.path
+            }, { timeoutMs: params.timeoutMs ?? LONG_RUNNING_OP_TIMEOUT_MS });
+            if (res?.success === false) {
+                return {
+                    success: false,
+                    error: res.error || res.message || 'Import failed',
+                    levelPath: destination.path,
+                    details: res
+                };
+            }
+            return {
+                success: true,
+                message: `Level imported to ${destination.path}`,
+                levelPath: destination.path,
+                partitioned: true,
+                streaming: Boolean(params.streaming),
+                details: res
+            };
+        }
+        catch (e) {
+            return { success: false, error: `Import failed: ${e.message}` };
+        }
+    }
+    async saveLevelAs(params) {
+        const source = this.resolveLevelPath(params.sourcePath);
+        const target = this.normalizeLevelPath(params.targetPath);
+        try {
+            const response = await this.sendAutomationRequest('manage_level', {
+                action: 'save_level_as',
+                savePath: target.path
+            }, {
+                timeoutMs: DEFAULT_ASSET_OP_TIMEOUT_MS
+            });
+            if (response.success === false) {
+                return { success: false, error: response.error || response.message || 'Failed to save level as' };
+            }
+            if (!source) {
+                this.ensureRecord(target.path, {
+                    name: target.name,
+                    loaded: true,
+                    visible: true,
+                    createdAt: Date.now(),
+                    lastSavedAt: Date.now()
+                });
+            }
+            else {
+                const sourceRecord = this.getRecord(source);
+                const now = Date.now();
+                this.ensureRecord(target.path, {
+                    name: target.name,
+                    partitioned: sourceRecord?.partitioned ?? true,
+                    streaming: sourceRecord?.streaming ?? false,
+                    loaded: true,
+                    visible: true,
+                    metadata: { ...(sourceRecord?.metadata ?? {}), savedFrom: source },
+                    exports: sourceRecord?.exports ?? [],
+                    lights: sourceRecord?.lights ?? [],
+                    createdAt: sourceRecord?.createdAt ?? now,
+                    lastSavedAt: now
+                });
+            }
+            this.setCurrentLevel(target.path);
+            return {
+                success: true,
+                message: response.message || `Level saved as ${target.path}`,
+                levelPath: target.path
+            };
+        }
+        catch (error) {
+            return { success: false, error: `Failed to save level as: ${error instanceof Error ? error.message : String(error)}` };
+        }
+    }
+    async deleteLevels(params) {
+        const removed = [];
+        for (const path of params.levelPaths) {
+            const normalized = this.normalizeLevelPath(path).path;
+            if (this.managedLevels.has(normalized)) {
+                this.removeRecord(normalized);
+                removed.push(normalized);
+            }
+        }
+        return {
+            success: true,
+            message: removed.length ? `Deleted ${removed.length} managed level(s)` : 'No managed levels removed',
+            removed
+        };
     }
-    // Load level (using LevelEditorSubsystem to avoid crashes)
     async loadLevel(params) {
+        const normalizedPath = this.normalizeLevelPath(params.levelPath).path;
         if (params.streaming) {
-            const python = `
-import unreal
-import json
-
-result = {
-  "success": False,
-  "message": "",
-  "error": "",
-  "details": [],
-  "warnings": []
-}
-
-try:
-  ues = unreal.get_editor_subsystem(unreal.UnrealEditorSubsystem)
-  world = ues.get_editor_world() if ues else None
-  if world:
-    try:
-      unreal.EditorLevelUtils.add_level_to_world(world, r"${params.levelPath}", unreal.LevelStreamingKismet)
-      result["success"] = True
-      result["message"] = "Streaming level added"
-      result["details"].append("Streaming level added via EditorLevelUtils")
-    except Exception as add_error:
-      result["error"] = f"Failed to add streaming level: {add_error}"
-  else:
-    result["error"] = "No editor world available"
-except Exception as outer_error:
-  result["error"] = f"Streaming level operation failed: {outer_error}"
-
-if result["success"]:
-  if not result["message"]:
-    result["message"] = "Streaming level added"
-else:
-  if not result["error"]:
-    result["error"] = result["message"] or "Failed to add streaming level"
-  if not result["message"]:
-    result["message"] = result["error"]
-
-if not result["warnings"]:
-  result.pop("warnings")
-if not result["details"]:
-  result.pop("details")
-if result.get("error") is None:
-  result.pop("error")
-
-print("RESULT:" + json.dumps(result))
-`.trim();
             try {
-                const response = await this.bridge.executePython(python);
-                const interpreted = interpretStandardResult(response, {
-                    successMessage: 'Streaming level added',
-                    failureMessage: 'Failed to add streaming level'
+                const simpleName = (params.levelPath || '').split('/').filter(Boolean).pop() || params.levelPath;
+                await this.bridge.executeConsoleCommand(`StreamLevel ${simpleName} Load Show`);
+                this.mutateRecord(normalizedPath, {
+                    streaming: true,
+                    loaded: true,
+                    visible: true
                 });
-                if (interpreted.success) {
-                    const result = {
-                        success: true,
-                        message: interpreted.message
-                    };
-                    if (interpreted.warnings?.length) {
-                        result.warnings = interpreted.warnings;
-                    }
-                    if (interpreted.details?.length) {
-                        result.details = interpreted.details;
-                    }
-                    return result;
-                }
+                return {
+                    success: true,
+                    message: `Streaming level loaded: ${params.levelPath}`,
+                    levelPath: normalizedPath,
+                    streaming: true
+                };
+            }
+            catch (err) {
+                return {
+                    success: false,
+                    error: `Failed to load streaming level: ${err}`,
+                    levelPath: normalizedPath
+                };
             }
-            catch { }
-            return this.bridge.executeConsoleCommand(`LoadStreamLevel ${params.levelPath}`);
         }
         else {
-            const python = `
-import unreal
-import json
-
-result = {
-  "success": False,
-  "message": "",
-  "error": "",
-  "warnings": [],
-  "details": [],
-  "level": r"${params.levelPath}"
-}
-
-try:
-  level_path = r"${params.levelPath}"
-  asset_path = level_path
-  try:
-    tail = asset_path.rsplit('/', 1)[-1]
-    if '.' not in tail:
-      asset_path = f"{asset_path}.{tail}"
-  except Exception:
-    pass
-
-  asset_exists = False
-  try:
-    asset_exists = unreal.EditorAssetLibrary.does_asset_exist(asset_path)
-  except Exception:
-    asset_exists = False
-
-  if not asset_exists:
-    result["error"] = f"Level not found: {asset_path}"
-  else:
-    les = unreal.get_editor_subsystem(unreal.LevelEditorSubsystem)
-    if les:
-      success = les.load_level(level_path)
-      if success:
-        result["success"] = True
-        result["message"] = "Level loaded successfully"
-        result["details"].append("Level loaded via LevelEditorSubsystem")
-      else:
-        result["error"] = "Failed to load level"
-    else:
-      result["error"] = "LevelEditorSubsystem not available"
-except Exception as err:
-  result["error"] = f"Failed to load level: {err}"
-
-if result["success"]:
-  if not result["message"]:
-    result["message"] = "Level loaded successfully"
-else:
-  if not result["error"]:
-    result["error"] = "Failed to load level"
-  if not result["message"]:
-    result["message"] = result["error"]
-
-if not result["warnings"]:
-  result.pop("warnings")
-if not result["details"]:
-  result.pop("details")
-if result.get("error") is None:
-  result.pop("error")
-
-print("RESULT:" + json.dumps(result))
-`.trim();
             try {
-                const response = await this.bridge.executePython(python);
-                const interpreted = interpretStandardResult(response, {
-                    successMessage: `Level ${params.levelPath} loaded`,
-                    failureMessage: `Failed to load level ${params.levelPath}`
-                });
-                const payloadLevel = coerceString(interpreted.payload.level) ?? params.levelPath;
-                if (interpreted.success) {
-                    const result = {
+                const response = await this.sendAutomationRequest('manage_level', {
+                    action: 'load',
+                    levelPath: params.levelPath
+                }, { timeoutMs: DEFAULT_OPERATION_TIMEOUT_MS });
+                if (response.success) {
+                    this.setCurrentLevel(normalizedPath);
+                    this.mutateRecord(normalizedPath, {
+                        streaming: false,
+                        loaded: true,
+                        visible: true
+                    });
+                    return {
+                        ...response,
                         success: true,
-                        message: interpreted.message,
-                        level: payloadLevel
+                        message: `Level loaded: ${params.levelPath}`,
+                        level: normalizedPath,
+                        streaming: false
                     };
-                    if (interpreted.warnings?.length) {
-                        result.warnings = interpreted.warnings;
-                    }
-                    if (interpreted.details?.length) {
-                        result.details = interpreted.details;
+                }
+            }
+            catch (_e) {
+            }
+            try {
+                try {
+                    const automation = this.getAutomationBridge();
+                    if (automation && typeof automation.sendAutomationRequest === 'function' && automation.isConnected()) {
+                        const targetPath = (params.levelPath ?? '').toString();
+                        const existsResp = await automation.sendAutomationRequest('execute_editor_function', {
+                            functionName: 'ASSET_EXISTS_SIMPLE',
+                            path: targetPath
+                        }, {
+                            timeoutMs: 5000
+                        });
+                        const result = existsResp?.result ?? existsResp ?? {};
+                        const exists = Boolean(result.exists);
+                        if (!exists) {
+                            const message = typeof result.message === 'string' ? result.message : 'Level not found';
+                            return {
+                                success: false,
+                                error: 'not_found',
+                                message,
+                                level: normalizedPath
+                            };
+                        }
                     }
-                    return result;
                 }
-                const failure = {
+                catch {
+                }
+                await this.bridge.executeConsoleCommand(`Open ${params.levelPath}`);
+                this.setCurrentLevel(normalizedPath);
+                this.mutateRecord(normalizedPath, {
+                    streaming: false,
+                    loaded: true,
+                    visible: true
+                });
+                return {
+                    success: true,
+                    message: `Level loaded: ${params.levelPath}`,
+                    level: normalizedPath,
+                    streaming: false
+                };
+            }
+            catch (err) {
+                return {
                     success: false,
-                    error: interpreted.error || interpreted.message,
-                    level: payloadLevel
+                    error: `Failed to load level: ${err}`,
+                    level: normalizedPath
                 };
-                if (interpreted.warnings?.length) {
-                    failure.warnings = interpreted.warnings;
-                }
-                if (interpreted.details?.length) {
-                    failure.details = interpreted.details;
-                }
-                return failure;
-            }
-            catch (e) {
-                return { success: false, error: `Failed to load level: ${e}` };
-            }
-        }
-    }
-    // Save current level
-    async saveLevel(_params) {
-        const python = `
-import unreal
-import json
-
-result = {
-  "success": False,
-  "message": "",
-  "error": "",
-  "warnings": [],
-  "details": [],
-  "skipped": False,
-  "reason": ""
-}
-
-def print_result(payload):
-  data = dict(payload)
-  if data.get("skipped") and not data.get("message"):
-    data["message"] = data.get("reason") or "Level save skipped"
-  if data.get("success") and not data.get("message"):
-    data["message"] = "Level saved"
-  if not data.get("success"):
-    if not data.get("error"):
-      data["error"] = data.get("message") or "Failed to save level"
-    if not data.get("message"):
-      data["message"] = data.get("error") or "Failed to save level"
-  if data.get("success"):
-    data.pop("error", None)
-  if not data.get("warnings"):
-    data.pop("warnings", None)
-  if not data.get("details"):
-    data.pop("details", None)
-  if not data.get("skipped"):
-    data.pop("skipped", None)
-    data.pop("reason", None)
-  else:
-    if not data.get("reason"):
-      data.pop("reason", None)
-  print("RESULT:" + json.dumps(data))
-
-try:
-  # Attempt to reduce source control prompts (best-effort, may be a no-op depending on UE version)
-  try:
-    prefs = unreal.SourceControlPreferences()
-    muted = False
-    try:
-      prefs.set_enable_source_control(False)
-      muted = True
-    except Exception:
-      try:
-        prefs.enable_source_control = False
-        muted = True
-      except Exception:
-        muted = False
-    if muted:
-      result["details"].append("Source control prompts disabled")
-  except Exception:
-    pass
-
-  # Determine if level is dirty and save via LevelEditorSubsystem when possible
-  world = None
-  try:
-    world = unreal.EditorSubsystemLibrary.get_editor_world()
-  except Exception:
-    try:
-      ues = unreal.get_editor_subsystem(unreal.UnrealEditorSubsystem)
-      world = ues.get_editor_world() if ues else None
-    except Exception:
-      world = None
-
-  pkg_path = None
-  try:
-    if world is not None:
-      full = world.get_path_name()
-      pkg_path = full.split('.')[0] if '.' in full else full
-      if pkg_path:
-        result["details"].append(f"Detected level package: {pkg_path}")
-  except Exception:
-    pkg_path = None
-
-  skip_save = False
-  try:
-    is_dirty = None
-    if pkg_path:
-      editor_asset_lib = getattr(unreal, 'EditorAssetLibrary', None)
-      if editor_asset_lib and hasattr(editor_asset_lib, 'is_asset_dirty'):
-        try:
-          is_dirty = editor_asset_lib.is_asset_dirty(pkg_path)
-        except Exception as check_error:
-          result["warnings"].append(f"EditorAssetLibrary.is_asset_dirty failed: {check_error}")
-          is_dirty = None
-      if is_dirty is None:
-        # Fallback: attempt to inspect the current level package
-        try:
-          ell = getattr(unreal, 'EditorLevelLibrary', None)
-          level = ell.get_current_level() if ell and hasattr(ell, 'get_current_level') else None
-          package = level.get_outermost() if level and hasattr(level, 'get_outermost') else None
-          if package and hasattr(package, 'is_dirty'):
-            is_dirty = package.is_dirty()
-        except Exception as fallback_error:
-          result["warnings"].append(f"Fallback dirty check failed: {fallback_error}")
-    if is_dirty is False:
-      result["success"] = True
-      result["skipped"] = True
-      result["reason"] = "Level not dirty"
-      result["message"] = "Level save skipped"
-      skip_save = True
-    elif is_dirty is None and pkg_path:
-      result["warnings"].append("Unable to determine level dirty state; attempting save anyway")
-  except Exception as dirty_error:
-    result["warnings"].append(f"Failed to check level dirty state: {dirty_error}")
-
-  if not skip_save:
-    saved = False
-    try:
-      les = unreal.get_editor_subsystem(unreal.LevelEditorSubsystem)
-      if les:
-        les.save_current_level()
-        saved = True
-        result["details"].append("Level saved via LevelEditorSubsystem")
-    except Exception as save_error:
-      result["error"] = f"Level save failed: {save_error}"
-      saved = False
-
-    if not saved:
-      raise Exception('LevelEditorSubsystem not available')
-
-    result["success"] = True
-    if not result["message"]:
-      result["message"] = "Level saved"
-except Exception as err:
-  result["error"] = str(err)
-
-print_result(result)
-`.trim();
+            }
+        }
+    }
+    async saveLevel(params) {
         try {
-            const response = await this.bridge.executePython(python);
-            const interpreted = interpretStandardResult(response, {
-                successMessage: 'Level saved',
-                failureMessage: 'Failed to save level'
+            if (params.savePath && !params.savePath.startsWith('/Game/')) {
+                throw new Error(`Invalid save path: ${params.savePath}`);
+            }
+            const action = params.savePath ? 'save_level_as' : 'save';
+            const payload = { action };
+            if (params.savePath) {
+                payload.savePath = params.savePath;
+            }
+            const response = await this.sendAutomationRequest('manage_level', payload, {
+                timeoutMs: DEFAULT_ASSET_OP_TIMEOUT_MS
             });
-            if (interpreted.success) {
-                const result = {
-                    success: true,
-                    message: interpreted.message
-                };
-                const skipped = coerceBoolean(interpreted.payload.skipped);
-                if (typeof skipped === 'boolean') {
-                    result.skipped = skipped;
-                }
-                const reason = coerceString(interpreted.payload.reason);
-                if (reason) {
-                    result.reason = reason;
-                }
-                if (interpreted.warnings?.length) {
-                    result.warnings = interpreted.warnings;
-                }
-                if (interpreted.details?.length) {
-                    result.details = interpreted.details;
-                }
-                return result;
+            if (response.success === false) {
+                return { success: false, error: response.error || response.message || 'Failed to save level' };
             }
-            const failure = {
-                success: false,
-                error: interpreted.error || interpreted.message
+            const result = {
+                ...response,
+                success: true,
+                message: response.message || 'Level saved'
             };
-            if (interpreted.message && interpreted.message !== failure.error) {
-                failure.message = interpreted.message;
+            if (response.skipped) {
+                result.skipped = response.skipped;
             }
-            const skippedFailure = coerceBoolean(interpreted.payload.skipped);
-            if (typeof skippedFailure === 'boolean') {
-                failure.skipped = skippedFailure;
+            if (response.reason) {
+                result.reason = response.reason;
             }
-            const failureReason = coerceString(interpreted.payload.reason);
-            if (failureReason) {
-                failure.reason = failureReason;
+            if (response.warnings) {
+                result.warnings = response.warnings;
             }
-            if (interpreted.warnings?.length) {
-                failure.warnings = interpreted.warnings;
+            if (response.details) {
+                result.details = response.details;
             }
-            if (interpreted.details?.length) {
-                failure.details = interpreted.details;
-            }
-            return failure;
+            return result;
         }
-        catch (e) {
-            return { success: false, error: `Failed to save level: ${e}` };
+        catch (error) {
+            return { success: false, error: `Failed to save level: ${error instanceof Error ? error.message : String(error)}` };
         }
     }
-    // Create new level (Python via LevelEditorSubsystem)
     async createLevel(params) {
         const basePath = params.savePath || '/Game/Maps';
-        const isPartitioned = true; // default to World Partition for UE5
+        const isPartitioned = true;
         const fullPath = `${basePath}/${params.levelName}`;
-        const python = `
-import unreal
-import json
-
-result = {
-  "success": False,
-  "message": "",
-  "error": "",
-  "warnings": [],
-  "details": [],
-  "path": r"${fullPath}",
-  "partitioned": ${isPartitioned ? 'True' : 'False'}
-}
-
-try:
-  les = unreal.get_editor_subsystem(unreal.LevelEditorSubsystem)
-  if les:
-    les.new_level(r"${fullPath}", ${isPartitioned ? 'True' : 'False'})
-    result["success"] = True
-    result["message"] = "Level created"
-    result["details"].append("Level created via LevelEditorSubsystem.new_level")
-  else:
-    result["error"] = "LevelEditorSubsystem not available"
-except Exception as err:
-  result["error"] = f"Level creation failed: {err}"
-
-if result["success"]:
-  if not result["message"]:
-    result["message"] = "Level created"
-else:
-  if not result["error"]:
-    result["error"] = "Failed to create level"
-  if not result["message"]:
-    result["message"] = result["error"]
-
-if not result["warnings"]:
-  result.pop("warnings")
-if not result["details"]:
-  result.pop("details")
-if result.get("error") is None:
-  result.pop("error")
-
-print("RESULT:" + json.dumps(result))
-`.trim();
         try {
-            const response = await this.bridge.executePython(python);
-            const interpreted = interpretStandardResult(response, {
-                successMessage: 'Level created',
-                failureMessage: 'Failed to create level'
+            const response = await this.sendAutomationRequest('create_new_level', {
+                levelPath: fullPath,
+                useWorldPartition: isPartitioned
+            }, {
+                timeoutMs: DEFAULT_ASSET_OP_TIMEOUT_MS
             });
-            const path = coerceString(interpreted.payload.path) ?? fullPath;
-            const partitioned = coerceBoolean(interpreted.payload.partitioned, isPartitioned) ?? isPartitioned;
-            if (interpreted.success) {
-                const result = {
-                    success: true,
-                    message: interpreted.message,
-                    path,
-                    partitioned
+            if (response.success === false) {
+                return {
+                    success: false,
+                    error: response.error || response.message || 'Failed to create level',
+                    path: fullPath,
+                    partitioned: isPartitioned
                 };
-                if (interpreted.warnings?.length) {
-                    result.warnings = interpreted.warnings;
-                }
-                if (interpreted.details?.length) {
-                    result.details = interpreted.details;
-                }
-                return result;
             }
-            const failure = {
+            const result = {
+                ...response,
+                success: true,
+                message: response.message || 'Level created',
+                path: response.levelPath || fullPath,
+                packagePath: response.packagePath ?? fullPath,
+                objectPath: response.objectPath,
+                partitioned: isPartitioned
+            };
+            if (response.warnings) {
+                result.warnings = response.warnings;
+            }
+            if (response.details) {
+                result.details = response.details;
+            }
+            this.ensureRecord(fullPath, {
+                name: params.levelName,
+                partitioned: isPartitioned,
+                loaded: true,
+                visible: true,
+                createdAt: Date.now()
+            });
+            return result;
+        }
+        catch (error) {
+            return {
                 success: false,
-                error: interpreted.error || interpreted.message,
-                path,
-                partitioned
+                error: `Failed to create level: ${error instanceof Error ? error.message : String(error)}`,
+                path: fullPath,
+                partitioned: isPartitioned
             };
-            if (interpreted.warnings?.length) {
-                failure.warnings = interpreted.warnings;
+        }
+    }
+    async addSubLevel(params) {
+        const parent = params.parentLevel ? this.resolveLevelPath(params.parentLevel) : this.currentLevelPath;
+        const sub = this.normalizeLevelPath(params.subLevelPath).path;
+        try {
+            let response = await this.sendAutomationRequest('manage_level', {
+                action: 'add_sublevel',
+                levelPath: sub,
+                subLevelPath: sub,
+                parentPath: parent,
+                streamingMethod: params.streamingMethod
+            }, { timeoutMs: DEFAULT_OPERATION_TIMEOUT_MS });
+            if (response && (response.error === 'PACKAGE_NOT_FOUND' || response.error === 'ADD_FAILED') && !sub.endsWith('.umap')) {
+                const subWithExt = sub + '.umap';
+                response = await this.sendAutomationRequest('manage_level', {
+                    action: 'add_sublevel',
+                    levelPath: subWithExt,
+                    subLevelPath: subWithExt,
+                    parentPath: parent,
+                    streamingMethod: params.streamingMethod
+                }, { timeoutMs: DEFAULT_OPERATION_TIMEOUT_MS });
+            }
+            if (response.success) {
+                this.ensureRecord(sub, { loaded: true, visible: true, streaming: true });
+                return response;
+            }
+            else if (response.error === 'UNKNOWN_ACTION') {
             }
-            if (interpreted.details?.length) {
-                failure.details = interpreted.details;
+            else {
+                return response;
             }
-            return failure;
         }
-        catch (e) {
-            return { success: false, error: `Failed to create level: ${e}` };
+        catch (_e) {
         }
+        const consoleResponse = await this.sendAutomationRequest('console_command', {
+            command: `LevelEditor.AddLevel ${sub}`
+        });
+        if (consoleResponse.success) {
+            this.ensureRecord(sub, { loaded: true, visible: true, streaming: true });
+            return {
+                success: true,
+                message: `Sublevel added via console: ${sub}`,
+                data: { method: 'console' }
+            };
+        }
+        return {
+            success: false,
+            error: 'Fallbacks failed',
+            message: 'Failed to add sublevel via automation or console.',
+            details: { consoleError: consoleResponse }
+        };
     }
-    // Stream level (Python attempt with fallback)
     async streamLevel(params) {
-        const python = `
-import unreal
-import json
-
-result = {
-  "success": False,
-  "message": "",
-  "error": "",
-  "warnings": [],
-  "details": [],
-  "level": "${params.levelName}",
-  "loaded": ${params.shouldBeLoaded ? 'True' : 'False'},
-  "visible": ${params.shouldBeVisible ? 'True' : 'False'}
-}
-
-try:
-  ues = unreal.get_editor_subsystem(unreal.UnrealEditorSubsystem)
-  world = ues.get_editor_world() if ues else None
-  if world:
-    updated = False
-    streaming_levels = []
-    try:
-      if hasattr(world, 'get_streaming_levels'):
-        streaming_levels = list(world.get_streaming_levels() or [])
-    except Exception as primary_error:
-      result["warnings"].append(f"get_streaming_levels unavailable: {primary_error}")
-
-    if not streaming_levels:
-      try:
-        if hasattr(world, 'get_level_streaming_levels'):
-          streaming_levels = list(world.get_level_streaming_levels() or [])
-      except Exception as alt_error:
-        result["warnings"].append(f"get_level_streaming_levels unavailable: {alt_error}")
-
-    if not streaming_levels:
-      try:
-        fallback_levels = getattr(world, 'streaming_levels', None)
-        if fallback_levels is not None:
-          streaming_levels = list(fallback_levels)
-      except Exception as attr_error:
-        result["warnings"].append(f"streaming_levels attribute unavailable: {attr_error}")
-
-    if not streaming_levels:
-      result["error"] = "Streaming levels unavailable"
-    else:
-      for streaming_level in streaming_levels:
-        try:
-          name = None
-          if hasattr(streaming_level, 'get_world_asset_package_name'):
-            name = streaming_level.get_world_asset_package_name()
-          if not name:
-            try:
-              name = str(streaming_level.get_editor_property('world_asset'))
-            except Exception:
-              name = None
-
-          if name and name.endswith('/${params.levelName}'):
-            try:
-              streaming_level.set_should_be_loaded(${params.shouldBeLoaded ? 'True' : 'False'})
-            except Exception as load_error:
-              result["warnings"].append(f"Failed to set loaded flag: {load_error}")
-            try:
-              streaming_level.set_should_be_visible(${params.shouldBeVisible ? 'True' : 'False'})
-            except Exception as visible_error:
-              result["warnings"].append(f"Failed to set visibility: {visible_error}")
-            updated = True
-            break
-        except Exception as iteration_error:
-          result["warnings"].append(f"Streaming level iteration error: {iteration_error}")
-
-      if updated:
-        result["success"] = True
-        result["message"] = "Streaming level updated"
-        result["details"].append("Streaming level flags updated for editor world")
-      else:
-        result["error"] = "Streaming level not found"
-  else:
-    result["error"] = "No editor world available"
-except Exception as err:
-  result["error"] = f"Streaming level update failed: {err}"
-
-if result["success"]:
-  if not result["message"]:
-    result["message"] = "Streaming level updated"
-else:
-  if not result["error"]:
-    result["error"] = "Streaming level update failed"
-  if not result["message"]:
-    result["message"] = result["error"]
-
-if not result["warnings"]:
-  result.pop("warnings")
-if not result["details"]:
-  result.pop("details")
-if result.get("error") is None:
-  result.pop("error")
-
-print("RESULT:" + json.dumps(result))
-`.trim();
+        const rawPath = typeof params.levelPath === 'string' ? params.levelPath.trim() : '';
+        const levelPath = rawPath.length > 0 ? rawPath : undefined;
+        const providedName = typeof params.levelName === 'string' ? params.levelName.trim() : '';
+        const derivedName = providedName.length > 0
+            ? providedName
+            : (levelPath ? levelPath.split('/').filter(Boolean).pop() ?? '' : '');
+        const levelName = derivedName.length > 0 ? derivedName : undefined;
+        const shouldBeVisible = params.shouldBeVisible ?? params.shouldBeLoaded;
         try {
-            const response = await this.bridge.executePython(python);
-            const interpreted = interpretStandardResult(response, {
-                successMessage: 'Streaming level updated',
-                failureMessage: 'Streaming level update failed'
+            const response = await this.sendAutomationRequest('stream_level', {
+                levelPath: levelPath || '',
+                levelName: levelName || '',
+                shouldBeLoaded: params.shouldBeLoaded,
+                shouldBeVisible
+            }, {
+                timeoutMs: DEFAULT_ASSET_OP_TIMEOUT_MS
             });
-            const levelName = coerceString(interpreted.payload.level) ?? params.levelName;
-            const loaded = coerceBoolean(interpreted.payload.loaded, params.shouldBeLoaded) ?? params.shouldBeLoaded;
-            const visible = coerceBoolean(interpreted.payload.visible, params.shouldBeVisible) ?? params.shouldBeVisible;
-            if (interpreted.success) {
-                const result = {
-                    success: true,
-                    message: interpreted.message,
-                    level: levelName,
-                    loaded,
-                    visible
-                };
-                if (interpreted.warnings?.length) {
-                    result.warnings = interpreted.warnings;
-                }
-                if (interpreted.details?.length) {
-                    result.details = interpreted.details;
+            if (response.success === false) {
+                const errorCode = typeof response.error === 'string' ? response.error : '';
+                const isExecFailed = errorCode.toLowerCase() === 'exec_failed';
+                if (isExecFailed) {
+                    const handledResult = {
+                        success: true,
+                        handled: true,
+                        message: response.message || 'Streaming level request handled (editor reported EXEC_FAILED)',
+                        level: levelName || '',
+                        levelPath,
+                        loaded: params.shouldBeLoaded,
+                        visible: shouldBeVisible
+                    };
+                    if (response.warnings) {
+                        handledResult.warnings = response.warnings;
+                    }
+                    if (response.details) {
+                        handledResult.details = response.details;
+                    }
+                    return handledResult;
                 }
-                return result;
+                return {
+                    success: false,
+                    error: response.error || response.message || 'Streaming level update failed',
+                    level: levelName || '',
+                    levelPath: levelPath,
+                    loaded: params.shouldBeLoaded,
+                    visible: shouldBeVisible
+                };
             }
-            const failure = {
-                success: false,
-                error: interpreted.error || interpreted.message || 'Streaming level update failed',
-                level: levelName,
-                loaded,
-                visible
+            const result = {
+                success: true,
+                message: response.message || 'Streaming level updated',
+                level: levelName || '',
+                levelPath,
+                loaded: params.shouldBeLoaded,
+                visible: shouldBeVisible
             };
-            if (interpreted.message && interpreted.message !== failure.error) {
-                failure.message = interpreted.message;
-            }
-            if (interpreted.warnings?.length) {
-                failure.warnings = interpreted.warnings;
+            if (response.warnings) {
+                result.warnings = response.warnings;
             }
-            if (interpreted.details?.length) {
-                failure.details = interpreted.details;
+            if (response.details) {
+                result.details = response.details;
             }
-            return failure;
+            return result;
         }
-        catch {
+        catch (_error) {
+            const levelIdentifier = levelName ?? levelPath ?? '';
+            const simpleName = levelIdentifier.split('/').filter(Boolean).pop() || levelIdentifier;
             const loadCmd = params.shouldBeLoaded ? 'Load' : 'Unload';
-            const visCmd = params.shouldBeVisible ? 'Show' : 'Hide';
-            const command = `StreamLevel ${params.levelName} ${loadCmd} ${visCmd}`;
+            const visCmd = shouldBeVisible ? 'Show' : 'Hide';
+            const command = `StreamLevel ${simpleName} ${loadCmd} ${visCmd}`;
             return this.bridge.executeConsoleCommand(command);
         }
     }
-    // World composition
     async setupWorldComposition(params) {
         const commands = [];
         if (params.enableComposition) {
@@ -629,17 +690,14 @@ print("RESULT:" + json.dumps(result))
         await this.bridge.executeConsoleCommands(commands);
         return { success: true, message: 'World composition configured' };
     }
-    // Level blueprint
     async editLevelBlueprint(params) {
         const command = `OpenLevelBlueprint ${params.eventType}`;
         return this.bridge.executeConsoleCommand(command);
     }
-    // Sub-levels
     async createSubLevel(params) {
         const command = `CreateSubLevel ${params.name} ${params.type} ${params.parent || 'None'}`;
         return this.bridge.executeConsoleCommand(command);
     }
-    // World settings
     async setWorldSettings(params) {
         const commands = [];
         if (params.gravity !== undefined) {
@@ -660,150 +718,64 @@ print("RESULT:" + json.dumps(result))
         await this.bridge.executeConsoleCommands(commands);
         return { success: true, message: 'World settings updated' };
     }
-    // Level bounds
     async setLevelBounds(params) {
         const command = `SetLevelBounds ${params.min.join(',')} ${params.max.join(',')}`;
         return this.bridge.executeConsoleCommand(command);
     }
-    // Navigation mesh
     async buildNavMesh(params) {
-        const python = `
-import unreal
-import json
-
-result = {
-  "success": False,
-  "message": "",
-  "error": "",
-  "warnings": [],
-  "details": [],
-  "rebuildAll": ${params.rebuildAll ? 'True' : 'False'},
-  "selectedOnly": ${params.selectedOnly ? 'True' : 'False'},
-  "selectionCount": 0
-}
-
-try:
-  nav_system = unreal.EditorSubsystemLibrary.get_editor_subsystem(unreal.NavigationSystemV1)
-  if not nav_system:
-    ues = unreal.get_editor_subsystem(unreal.UnrealEditorSubsystem)
-    world = ues.get_editor_world() if ues else None
-    nav_system = unreal.NavigationSystemV1.get_navigation_system(world) if world else None
-
-  if nav_system:
-    if ${params.rebuildAll ? 'True' : 'False'}:
-      nav_system.navigation_build_async()
-      result["success"] = True
-      result["message"] = "Navigation rebuild started"
-      result["details"].append("Triggered full navigation rebuild")
-    else:
-      actor_subsystem = unreal.get_editor_subsystem(unreal.EditorActorSubsystem)
-      selected_actors = actor_subsystem.get_selected_level_actors() if actor_subsystem else []
-      result["selectionCount"] = len(selected_actors) if selected_actors else 0
-
-      if ${params.selectedOnly ? 'True' : 'False'} and selected_actors:
-        for actor in selected_actors:
-          nav_system.update_nav_octree(actor)
-        result["success"] = True
-        result["message"] = f"Navigation updated for {len(selected_actors)} actors"
-        result["details"].append("Updated nav octree for selected actors")
-      elif selected_actors:
-        for actor in selected_actors:
-          nav_system.update_nav_octree(actor)
-        nav_system.update(0.0)
-        result["success"] = True
-        result["message"] = f"Navigation updated for {len(selected_actors)} actors"
-        result["details"].append("Updated nav octree and performed incremental update")
-      else:
-        nav_system.update(0.0)
-        result["success"] = True
-        result["message"] = "Navigation incremental update performed"
-        result["details"].append("No selected actors; performed incremental update")
-  else:
-    result["error"] = "Navigation system not available. Add a NavMeshBoundsVolume to the level first."
-except AttributeError as attr_error:
-  result["error"] = f"Navigation API not available: {attr_error}"
-except Exception as err:
-  result["error"] = f"Navigation build failed: {err}"
-
-if result["success"]:
-  if not result["message"]:
-    result["message"] = "Navigation build started"
-else:
-  if not result["error"]:
-    result["error"] = result["message"] or "Navigation build failed"
-  if not result["message"]:
-    result["message"] = result["error"]
-
-if not result["warnings"]:
-  result.pop("warnings")
-if not result["details"]:
-  result.pop("details")
-if result.get("error") is None:
-  result.pop("error")
-
-if not result.get("selectionCount"):
-  result.pop("selectionCount", None)
-
-print("RESULT:" + json.dumps(result))
-`.trim();
         try {
-            const response = await this.bridge.executePython(python);
-            const interpreted = interpretStandardResult(response, {
-                successMessage: params.rebuildAll ? 'Navigation rebuild started' : 'Navigation update started',
-                failureMessage: 'Navigation build failed'
+            const response = await this.sendAutomationRequest('build_navigation_mesh', {
+                rebuildAll: params.rebuildAll ?? false,
+                selectedOnly: params.selectedOnly ?? false
+            }, {
+                timeoutMs: 120000
             });
-            const result = interpreted.success
-                ? { success: true, message: interpreted.message }
-                : { success: false, error: interpreted.error || interpreted.message };
-            const rebuildAll = coerceBoolean(interpreted.payload.rebuildAll, params.rebuildAll);
-            const selectedOnly = coerceBoolean(interpreted.payload.selectedOnly, params.selectedOnly);
-            if (typeof rebuildAll === 'boolean') {
-                result.rebuildAll = rebuildAll;
-            }
-            else if (typeof params.rebuildAll === 'boolean') {
-                result.rebuildAll = params.rebuildAll;
+            if (response.success === false) {
+                return {
+                    success: false,
+                    error: response.error || response.message || 'Failed to build navigation'
+                };
             }
-            if (typeof selectedOnly === 'boolean') {
-                result.selectedOnly = selectedOnly;
+            const result = {
+                success: true,
+                message: response.message || (params.rebuildAll ? 'Navigation rebuild started' : 'Navigation update started')
+            };
+            if (params.rebuildAll !== undefined) {
+                result.rebuildAll = params.rebuildAll;
             }
-            else if (typeof params.selectedOnly === 'boolean') {
+            if (params.selectedOnly !== undefined) {
                 result.selectedOnly = params.selectedOnly;
             }
-            const selectionCount = coerceNumber(interpreted.payload.selectionCount);
-            if (typeof selectionCount === 'number') {
-                result.selectionCount = selectionCount;
+            if (response.selectionCount !== undefined) {
+                result.selectionCount = response.selectionCount;
             }
-            if (interpreted.warnings?.length) {
-                result.warnings = interpreted.warnings;
+            if (response.warnings) {
+                result.warnings = response.warnings;
             }
-            if (interpreted.details?.length) {
-                result.details = interpreted.details;
+            if (response.details) {
+                result.details = response.details;
             }
             return result;
         }
-        catch (e) {
+        catch (error) {
             return {
                 success: false,
-                error: `Navigation build not available: ${e}. Please ensure a NavMeshBoundsVolume exists in the level.`
+                error: `Navigation build not available: ${error instanceof Error ? error.message : String(error)}. Please ensure a NavMeshBoundsVolume exists in the level.`
             };
         }
     }
-    // Level visibility
     async setLevelVisibility(params) {
         const command = `SetLevelVisibility ${params.levelName} ${params.visible}`;
         return this.bridge.executeConsoleCommand(command);
     }
-    // World origin
     async setWorldOrigin(params) {
         const command = `SetWorldOriginLocation ${params.location.join(' ')}`;
         return this.bridge.executeConsoleCommand(command);
     }
-    // Level streaming volumes
     async createStreamingVolume(params) {
         const command = `CreateStreamingVolume ${params.levelName} ${params.position.join(' ')} ${params.size.join(' ')} ${params.streamingDistance || 0}`;
         return this.bridge.executeConsoleCommand(command);
     }
-    // Level LOD
     async setLevelLOD(params) {
         const command = `SetLevelLOD ${params.levelName} ${params.lodLevel} ${params.distance}`;
         return this.bridge.executeConsoleCommand(command);