unreal-engine-mcp-server 0.4.7 → 0.5.1

package/src/tools/level.ts

@@ -1,664 +1,832 @@
-// Level management tools for Unreal Engine
-import { UnrealBridge } from '../unreal-bridge.js';
+import { BaseTool } from './base-tool.js';
+import { ILevelTools, StandardActionResponse } from '../types/tool-interfaces.js';
+import { LevelResponse } from '../types/automation-responses.js';
+import { wasmIntegration as _wasmIntegration } from '../wasm/index.js';
+import { sanitizePath } from '../utils/path-security.js';
 import {
-  coerceBoolean,
-  coerceNumber,
-  coerceString,
-  interpretStandardResult
-} from '../utils/result-helpers.js';
+  DEFAULT_OPERATION_TIMEOUT_MS,
+  DEFAULT_ASSET_OP_TIMEOUT_MS,
+  LONG_RUNNING_OP_TIMEOUT_MS
+} from '../constants.js';
+
+type LevelExportRecord = { target: string; timestamp: number; note?: string };
+type ManagedLevelRecord = {
+  path: string;
+  name: string;
+  partitioned: boolean;
+  streaming: boolean;
+  loaded: boolean;
+  visible: boolean;
+  createdAt: number;
+  lastSavedAt?: number;
+  metadata?: Record<string, unknown>;
+  exports: LevelExportRecord[];
+  lights: Array<{ name: string; type: string; createdAt: number; details?: Record<string, unknown> }>;
+};
+
+export class LevelTools extends BaseTool implements ILevelTools {
+  private managedLevels = new Map<string, ManagedLevelRecord>();
+  private listCache?: { result: { success: true; message: string; count: number; levels: any[] }; timestamp: number };
+  private readonly LIST_CACHE_TTL_MS = 750;
+  private currentLevelPath?: string;
+
+  private invalidateListCache() {
+    this.listCache = undefined;
+  }
+
+  private normalizeLevelPath(rawPath: string | undefined): { path: string; name: string } {
+    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(/^\/+/, '')}`;
+    }
+
+    // Security validation
+    try {
+      formatted = sanitizePath(formatted);
+    } catch (e: any) {
+      // If sanitizePath fails, we should probably propagate that error, 
+      // but normalizeLevelPath signature expects to return an object.
+      // For now, let's log and rethrow or fallback? 
+      // Throwing is safer as it prevents operation on invalid path.
+      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' };
+  }
+
+  private ensureRecord(path: string, seed?: Partial<ManagedLevelRecord>): ManagedLevelRecord {
+    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;
+  }
+
+  private mutateRecord(path: string | undefined, updates: Partial<ManagedLevelRecord>): ManagedLevelRecord | undefined {
+    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;
+  }
+
+  private getRecord(path: string | undefined): ManagedLevelRecord | undefined {
+    if (!path || !path.trim()) {
+      return undefined;
+    }
+    const normalized = this.normalizeLevelPath(path);
+    return this.managedLevels.get(normalized.path);
+  }
+
+  private resolveLevelPath(explicit?: string): string | undefined {
+    if (explicit && explicit.trim()) {
+      return this.normalizeLevelPath(explicit).path;
+    }
+    return this.currentLevelPath;
+  }
+
+  private removeRecord(path: string) {
+    const normalized = this.normalizeLevelPath(path);
+    if (this.managedLevels.delete(normalized.path)) {
+      if (this.currentLevelPath === normalized.path) {
+        this.currentLevelPath = undefined;
+      }
+      this.invalidateListCache();
+    }
+  }
+
+  private listManagedLevels(): { success: true; message: string; count: number; levels: Array<Record<string, unknown>> } {
+    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 as const, message: 'Managed levels listed', count: levels.length, levels };
+    this.listCache = { result, timestamp: now };
+    return result;
+  }
+
+  private summarizeLevel(path: string): Record<string, unknown> {
+    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
+    };
+  }
+
+  private setCurrentLevel(path: string) {
+    const normalized = this.normalizeLevelPath(path);
+    this.currentLevelPath = normalized.path;
+    this.ensureRecord(normalized.path, { loaded: true, visible: true });
+  }
+
+  async listLevels(): Promise<StandardActionResponse> {
+    // Try to get actual levels from UE via automation bridge
+    try {
+      const response = await this.sendAutomationRequest<LevelResponse>('list_levels', {}, {
+        timeoutMs: 10000
+      });
+
+      if (response && response.success !== false) {
+        // Also include managed levels for backwards compatibility and immediate visibility
+        const managed = this.listManagedLevels();
+
+        // Merge managed levels into the main list if not already present
+        const ueLevels = (response.allMaps || []) as any[];
+        const managedOnly = managed.levels.filter(m => !ueLevels.some(u => u.path === m.path));
+        const finalLevels = [...ueLevels, ...managedOnly];
+
+        const result: Record<string, unknown> = {
+          ...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 as StandardActionResponse;
+      }
+    } catch {
+      // Fall back to managed levels if automation bridge fails
+    }
+
+    // Fallback to locally managed levels
+    return this.listManagedLevels();
+  }
+
+  async getLevelSummary(levelPath?: string): Promise<StandardActionResponse> {
+    const resolved = this.resolveLevelPath(levelPath);
+    if (!resolved) {
+      return { success: false, error: 'No level specified' };
+    }
+    return this.summarizeLevel(resolved) as StandardActionResponse;
+  }
+
+  registerLight(levelPath: string | undefined, info: { name: string; type: string; details?: Record<string, unknown> }) {
+    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: { levelPath?: string; exportPath: string; note?: string; timeoutMs?: number }): Promise<StandardActionResponse> {
+    const resolved = this.resolveLevelPath(params.levelPath);
+    if (!resolved) {
+      return { success: false, error: 'No level specified for export' };
+    }
+
+    try {
+      const res = await this.sendAutomationRequest<LevelResponse>('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
+        } as StandardActionResponse;
+      }
+
+      return {
+        success: true,
+        message: `Level exported to ${params.exportPath}`,
+        levelPath: resolved,
+        exportPath: params.exportPath,
+        details: res
+      } as StandardActionResponse;
+    } catch (e: any) {
+      return { success: false, error: `Export failed: ${e.message}` };
+    }
+  }
+
+  async importLevel(params: { packagePath: string; destinationPath?: string; streaming?: boolean; timeoutMs?: number }): Promise<StandardActionResponse> {
+    const destination = params.destinationPath
+      ? this.normalizeLevelPath(params.destinationPath)
+      : this.normalizeLevelPath(`/Game/Maps/Imported_${Math.floor(Date.now() / 1000)}`);
+
+    try {
+      const res = await this.sendAutomationRequest<LevelResponse>('manage_level', {
+        action: 'import_level',
+        packagePath: params.packagePath,
+        destinationPath: destination.path
+      }, { timeoutMs: params.timeoutMs ?? LONG_RUNNING_OP_TIMEOUT_MS });
+
+      if ((res as any)?.success === false) {
+        return {
+          success: false,
+          error: (res as any).error || (res as any).message || 'Import failed',
+          levelPath: destination.path,
+          details: res
+        } as StandardActionResponse;
+      }
+
+      return {
+        success: true,
+        message: `Level imported to ${destination.path}`,
+        levelPath: destination.path,
+        partitioned: true,
+        streaming: Boolean(params.streaming),
+        details: res
+      } as StandardActionResponse;
+    } catch (e: any) {
+      return { success: false, error: `Import failed: ${e.message}` };
+    }
+  }
+
+  async saveLevelAs(params: { sourcePath?: string; targetPath: string }): Promise<StandardActionResponse> {
+    const source = this.resolveLevelPath(params.sourcePath);
+    const target = this.normalizeLevelPath(params.targetPath);
+
+    // Delegate to automation bridge
+    try {
+      const response = await this.sendAutomationRequest<LevelResponse>('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 successful, update local state
+      if (!source) {
+        // If no source known, just ensure target record
+        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
+      } as StandardActionResponse;
+    } catch (error) {
+      return { success: false, error: `Failed to save level as: ${error instanceof Error ? error.message : String(error)}` };
+    }
+  }
 
-export class LevelTools {
-  constructor(private bridge: UnrealBridge) {}
+  async deleteLevels(params: { levelPaths: string[] }): Promise<StandardActionResponse> {
+    const removed: string[] = [];
+    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
+    } as StandardActionResponse;
+  }
 
-  // Load level (using LevelEditorSubsystem to avoid crashes)
   async loadLevel(params: {
     levelPath: string;
     streaming?: boolean;
     position?: [number, number, number];
-  }) {
-    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();
+  }): Promise<StandardActionResponse> {
+    const normalizedPath = this.normalizeLevelPath(params.levelPath).path;
 
+    if (params.streaming) {
       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: Record<string, unknown> = {
+        return {
+          success: true,
+          message: `Streaming level loaded: ${params.levelPath}`,
+          levelPath: normalizedPath,
+          streaming: true
+        } as StandardActionResponse;
+      } catch (err) {
+        return {
+          success: false,
+          error: `Failed to load streaming level: ${err}`,
+          levelPath: normalizedPath
+        };
+      }
+    } else {
+      // Try loading via automation bridge first (more robust)
+      try {
+        const response = await this.sendAutomationRequest<LevelResponse>('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
-          };
-          if (interpreted.warnings?.length) {
-            result.warnings = interpreted.warnings;
-          }
-          if (interpreted.details?.length) {
-            result.details = interpreted.details;
-          }
-          return result;
+            message: `Level loaded: ${params.levelPath}`,
+            level: normalizedPath,
+            streaming: false
+          } as StandardActionResponse;
         }
-      } 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();
+      } catch (_e) {
+        // Fallback to console logic
+      }
 
       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: Record<string, unknown> = {
-            success: true,
-            message: interpreted.message,
-            level: payloadLevel
-          };
-          if (interpreted.warnings?.length) {
-            result.warnings = interpreted.warnings;
-          }
-          if (interpreted.details?.length) {
-            result.details = interpreted.details;
+        // Best-effort existence check using the Automation Bridge when available.
+        try {
+          const automation = this.getAutomationBridge();
+          if (automation && typeof automation.sendAutomationRequest === 'function' && automation.isConnected()) {
+            const targetPath = (params.levelPath ?? '').toString();
+            const existsResp: any = 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
+              } as StandardActionResponse;
+            }
           }
-          return result;
+        } catch {
+          // If the existence check fails for any reason, fall back to the console command path below.
         }
 
-        const failure: Record<string, unknown> = {
+        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
+        } as StandardActionResponse;
+      } 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: {
+  async saveLevel(params: {
     levelName?: string;
     savePath?: string;
-  }) {
-    const python = `
-import unreal
-import json
-
-result = {
-  "success": False,
-  "message": "",
-  "error": "",
-  "warnings": [],
-  "details": [],
-  "skipped": False,
-  "reason": ""
-}
+  }): Promise<StandardActionResponse> {
+    try {
+      if (params.savePath && !params.savePath.startsWith('/Game/')) {
+        throw new Error(`Invalid save path: ${params.savePath}`);
+      }
 
-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();
+      const action = params.savePath ? 'save_level_as' : 'save';
+      const payload: Record<string, unknown> = { action };
+      if (params.savePath) {
+        payload.savePath = params.savePath;
+      }
 
-    try {
-      const response = await this.bridge.executePython(python);
-      const interpreted = interpretStandardResult(response, {
-        successMessage: 'Level saved',
-        failureMessage: 'Failed to save level'
+      const response = await this.sendAutomationRequest<LevelResponse>('manage_level', payload, {
+        timeoutMs: DEFAULT_ASSET_OP_TIMEOUT_MS
       });
 
-      if (interpreted.success) {
-        const result: Record<string, unknown> = {
-          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: Record<string, unknown> = {
-        success: false,
-        error: interpreted.error || interpreted.message
+      const result: Record<string, unknown> = {
+        ...response,
+        success: true,
+        message: response.message || 'Level saved'
       };
-      if (interpreted.message && interpreted.message !== failure.error) {
-        failure.message = interpreted.message;
-      }
-      const skippedFailure = coerceBoolean(interpreted.payload.skipped);
-      if (typeof skippedFailure === 'boolean') {
-        failure.skipped = skippedFailure;
+
+      if (response.skipped) {
+        result.skipped = response.skipped;
       }
-      const failureReason = coerceString(interpreted.payload.reason);
-      if (failureReason) {
-        failure.reason = failureReason;
+      if (response.reason) {
+        result.reason = response.reason;
       }
-      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;
-    } catch (e) {
-      return { success: false, error: `Failed to save level: ${e}` };
+      return result as StandardActionResponse;
+    } 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: {
     levelName: string;
     template?: 'Empty' | 'Default' | 'VR' | 'TimeOfDay';
     savePath?: string;
-  }) {
+  }): Promise<StandardActionResponse> {
     const basePath = params.savePath || '/Game/Maps';
     const isPartitioned = true; // default to World Partition for UE5
     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<LevelResponse>('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 (response.success === false) {
+        return {
+          success: false,
+          error: response.error || response.message || 'Failed to create level',
+          path: fullPath,
+          partitioned: isPartitioned
+        } as StandardActionResponse;
+      }
 
-      if (interpreted.success) {
-        const result: Record<string, unknown> = {
-          success: true,
-          message: interpreted.message,
-          path,
-          partitioned
-        };
-        if (interpreted.warnings?.length) {
-          result.warnings = interpreted.warnings;
-        }
-        if (interpreted.details?.length) {
-          result.details = interpreted.details;
-        }
-        return result;
+      const result: Record<string, unknown> = {
+        ...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;
       }
 
-      const failure: Record<string, unknown> = {
+      this.ensureRecord(fullPath, {
+        name: params.levelName,
+        partitioned: isPartitioned,
+        loaded: true,
+        visible: true,
+        createdAt: Date.now()
+      });
+
+      return result as StandardActionResponse;
+    } catch (error) {
+      return {
         success: false,
-        error: interpreted.error || interpreted.message,
-        path,
-        partitioned
-      };
-      if (interpreted.warnings?.length) {
-        failure.warnings = interpreted.warnings;
+        error: `Failed to create level: ${error instanceof Error ? error.message : String(error)}`,
+        path: fullPath,
+        partitioned: isPartitioned
+      } as StandardActionResponse;
+    }
+  }
+
+  async addSubLevel(params: {
+    parentLevel?: string;
+    subLevelPath: string;
+    streamingMethod?: 'Blueprint' | 'AlwaysLoaded';
+  }): Promise<StandardActionResponse> {
+    const parent = params.parentLevel ? this.resolveLevelPath(params.parentLevel) : this.currentLevelPath;
+    const sub = this.normalizeLevelPath(params.subLevelPath).path;
+
+    // Use console command as primary method for adding sublevels
+    // "WorldComposition" commands or generic "AddLevelToWorld"
+    // Since stream_level handles existing sublevels, we just need to ADD it.
+    // Console command: 'LevelEditor.AddLevel <Path>' works in editor context mostly, but might be tricky.
+    // Falling back to automation request if we have      const sub = this.normalizeLevelPath(params.subLevelPath).path;
+
+    // Ensure path corresponds to what automation expects (Package path usually, but C++ might check file)
+    // If C++ FPackageName::DoesPackageExist expects pure package path (e.g. /Game/Map), we are good.
+    // But if it's recently created, it might need to receive the full path as verified in createLevel.
+
+    // Attempt automation first (cleaner)
+    try {
+      let response = await this.sendAutomationRequest<LevelResponse>('manage_level', {
+        action: 'add_sublevel',
+        levelPath: sub, // Backwards compat
+        subLevelPath: sub,
+        parentPath: parent,
+        streamingMethod: params.streamingMethod
+      }, { timeoutMs: DEFAULT_OPERATION_TIMEOUT_MS });
+
+      // Retry with .umap if package not found (Workaround for C++ strictness)
+      // Also retry if ADD_FAILED, as UEditorLevelUtils might have failed due to path resolution internally
+      if (response && (response.error === 'PACKAGE_NOT_FOUND' || response.error === 'ADD_FAILED') && !sub.endsWith('.umap')) {
+        const subWithExt = sub + '.umap';
+        response = await this.sendAutomationRequest<LevelResponse>('manage_level', {
+          action: 'add_sublevel',
+          levelPath: subWithExt,
+          subLevelPath: subWithExt,
+          parentPath: parent,
+          streamingMethod: params.streamingMethod
+        }, { timeoutMs: DEFAULT_OPERATION_TIMEOUT_MS });
       }
-      if (interpreted.details?.length) {
-        failure.details = interpreted.details;
+
+      if (response.success) {
+        this.ensureRecord(sub, { loaded: true, visible: true, streaming: true });
+        return response as StandardActionResponse;
+      } else if (response.error === 'UNKNOWN_ACTION') {
+        // Fallthrough to console fallback if action not implemented
+      } else {
+        // Return actual error if it's something else (e.g. execution failed)
+        return response as StandardActionResponse;
       }
+    } catch (_e: any) {
+      // If connection failed, might fallback. But if we got a response, respect it.
+    }
 
-      return failure;
-    } catch (e) {
-      return { success: false, error: `Failed to create level: ${e}` };
+    // Console fallback
+    // Try using LevelEditor.AddLevel command which is available in Editor context
+    const consoleResponse = await this.sendAutomationRequest<LevelResponse>('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' }
+      } as StandardActionResponse;
     }
+
+    return {
+      success: false,
+      error: 'Fallbacks failed',
+      // Return the last relevant error + console error
+      message: 'Failed to add sublevel via automation or console.',
+      details: { consoleError: consoleResponse }
+    } as StandardActionResponse;
   }
 
-  // Stream level (Python attempt with fallback)
   async streamLevel(params: {
-    levelName: string;
+    levelPath?: string;
+    levelName?: string;
     shouldBeLoaded: boolean;
-    shouldBeVisible: boolean;
+    shouldBeVisible?: boolean;
     position?: [number, number, number];
-  }) {
-    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();
+  }): Promise<StandardActionResponse> {
+    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<LevelResponse>('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 (response.success === false) {
+        const errorCode = typeof response.error === 'string' ? response.error : '';
+        const isExecFailed = errorCode.toLowerCase() === 'exec_failed';
 
-      if (interpreted.success) {
-        const result: Record<string, unknown> = {
-          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 (isExecFailed) {
+          const handledResult: Record<string, unknown> = {
+            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 as StandardActionResponse;
         }
-        return result;
+
+        return {
+          success: false,
+          error: response.error || response.message || 'Streaming level update failed',
+          level: levelName || '',
+          levelPath: levelPath,
+          loaded: params.shouldBeLoaded,
+          visible: shouldBeVisible
+        } as StandardActionResponse;
       }
 
-      const failure: Record<string, unknown> = {
-        success: false,
-        error: interpreted.error || interpreted.message || 'Streaming level update failed',
-        level: levelName,
-        loaded,
-        visible
+      const result: Record<string, unknown> = {
+        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;
-    } catch {
+
+      return result as StandardActionResponse;
+    } catch (_error) {
+      // Fallback to console command
+      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: {
     enableComposition: boolean;
     tileSize?: number;
     distanceStreaming?: boolean;
     streamingDistance?: number;
-  }) {
-  const commands: string[] = [];
-    
+  }): Promise<StandardActionResponse> {
+    const commands: string[] = [];
+
     if (params.enableComposition) {
       commands.push('EnableWorldComposition');
       if (params.tileSize) {
@@ -670,13 +838,12 @@ print("RESULT:" + json.dumps(result))
     } else {
       commands.push('DisableWorldComposition');
     }
-    
+
     await this.bridge.executeConsoleCommands(commands);
-    
+
     return { success: true, message: 'World composition configured' };
   }
 
-  // Level blueprint
   async editLevelBlueprint(params: {
     eventType: 'BeginPlay' | 'EndPlay' | 'Tick' | 'Custom';
     customEventName?: string;
@@ -685,31 +852,29 @@ print("RESULT:" + json.dumps(result))
       position: [number, number];
       connections?: string[];
     }>;
-  }) {
+  }): Promise<StandardActionResponse> {
     const command = `OpenLevelBlueprint ${params.eventType}`;
     return this.bridge.executeConsoleCommand(command);
   }
 
-  // Sub-levels
   async createSubLevel(params: {
     name: string;
     type: 'Persistent' | 'Streaming' | 'Lighting' | 'Gameplay';
     parent?: string;
-  }) {
+  }): Promise<StandardActionResponse> {
     const command = `CreateSubLevel ${params.name} ${params.type} ${params.parent || 'None'}`;
     return this.bridge.executeConsoleCommand(command);
   }
 
-  // World settings
   async setWorldSettings(params: {
     gravity?: number;
     worldScale?: number;
     gameMode?: string;
     defaultPawn?: string;
     killZ?: number;
-  }) {
-  const commands: string[] = [];
-    
+  }): Promise<StandardActionResponse> {
+    const commands: string[] = [];
+
     if (params.gravity !== undefined) {
       commands.push(`SetWorldGravity ${params.gravity}`);
     }
@@ -725,187 +890,100 @@ print("RESULT:" + json.dumps(result))
     if (params.killZ !== undefined) {
       commands.push(`SetKillZ ${params.killZ}`);
     }
-    
+
     await this.bridge.executeConsoleCommands(commands);
-    
+
     return { success: true, message: 'World settings updated' };
   }
 
-  // Level bounds
   async setLevelBounds(params: {
     min: [number, number, number];
     max: [number, number, number];
-  }) {
+  }): Promise<StandardActionResponse> {
     const command = `SetLevelBounds ${params.min.join(',')} ${params.max.join(',')}`;
     return this.bridge.executeConsoleCommand(command);
   }
 
-  // Navigation mesh
   async buildNavMesh(params: {
     rebuildAll?: boolean;
     selectedOnly?: boolean;
-  }) {
-    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();
-
+  }): Promise<StandardActionResponse> {
     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<LevelResponse>('build_navigation_mesh', {
+        rebuildAll: params.rebuildAll ?? false,
+        selectedOnly: params.selectedOnly ?? false
+      }, {
+        timeoutMs: 120000
       });
 
-      const result: Record<string, unknown> = interpreted.success
-        ? { success: true, message: interpreted.message }
-        : { success: false, error: interpreted.error || interpreted.message };
+      if (response.success === false) {
+        return {
+          success: false,
+          error: response.error || response.message || 'Failed to build navigation'
+        };
+      }
+
+      const result: Record<string, unknown> = {
+        success: true,
+        message: response.message || (params.rebuildAll ? 'Navigation rebuild started' : 'Navigation update started')
+      };
 
-      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') {
+      if (params.rebuildAll !== undefined) {
         result.rebuildAll = params.rebuildAll;
       }
-      if (typeof selectedOnly === 'boolean') {
-        result.selectedOnly = selectedOnly;
-      } 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) {
+      return result as StandardActionResponse;
+    } 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: {
     levelName: string;
     visible: boolean;
-  }) {
+  }): Promise<StandardActionResponse> {
     const command = `SetLevelVisibility ${params.levelName} ${params.visible}`;
     return this.bridge.executeConsoleCommand(command);
   }
 
-  // World origin
   async setWorldOrigin(params: {
     location: [number, number, number];
-  }) {
+  }): Promise<StandardActionResponse> {
     const command = `SetWorldOriginLocation ${params.location.join(' ')}`;
     return this.bridge.executeConsoleCommand(command);
   }
 
-  // Level streaming volumes
   async createStreamingVolume(params: {
     levelName: string;
     position: [number, number, number];
     size: [number, number, number];
     streamingDistance?: number;
-  }) {
+  }): Promise<StandardActionResponse> {
     const command = `CreateStreamingVolume ${params.levelName} ${params.position.join(' ')} ${params.size.join(' ')} ${params.streamingDistance || 0}`;
     return this.bridge.executeConsoleCommand(command);
   }
 
-  // Level LOD
   async setLevelLOD(params: {
     levelName: string;
     lodLevel: number;
     distance: number;
-  }) {
+  }): Promise<StandardActionResponse> {
     const command = `SetLevelLOD ${params.levelName} ${params.lodLevel} ${params.distance}`;
     return this.bridge.executeConsoleCommand(command);
   }
-
 }