unreal-engine-mcp-server 0.5.4 → 0.5.5

package/src/tools/level.ts

@@ -1,989 +0,0 @@
-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 {
-  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: unknown) {
-      // 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 instanceof Error ? e.message : String(e)}`);
-    }
-
-    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: unknown) {
-      return { success: false, error: `Export failed: ${e instanceof Error ? e.message : String(e)}` };
-    }
-  }
-
-  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: unknown) {
-      return { success: false, error: `Import failed: ${e instanceof Error ? e.message : String(e)}` };
-    }
-  }
-
-  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)}` };
-    }
-  }
-
-  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;
-  }
-
-  async loadLevel(params: {
-    levelPath: string;
-    streaming?: boolean;
-    position?: [number, number, number];
-  }): Promise<StandardActionResponse> {
-    const normalizedPath = this.normalizeLevelPath(params.levelPath).path;
-
-    if (params.streaming) {
-      try {
-        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
-        });
-        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: `Level loaded: ${params.levelPath}`,
-            level: normalizedPath,
-            streaming: false
-          } as StandardActionResponse;
-        }
-      } catch (_e) {
-        // Fallback to console logic
-      }
-
-      try {
-        // 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;
-            }
-          }
-        } catch {
-          // If the existence check fails for any reason, fall back to the console command path below.
-        }
-
-        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: `Failed to load level: ${err}`,
-          level: normalizedPath
-        };
-      }
-    }
-  }
-
-  async saveLevel(params: {
-    levelName?: string;
-    savePath?: string;
-  }): Promise<StandardActionResponse> {
-    try {
-      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: Record<string, unknown> = { action };
-      if (params.savePath) {
-        payload.savePath = params.savePath;
-      }
-
-      const response = await this.sendAutomationRequest<LevelResponse>('manage_level', payload, {
-        timeoutMs: DEFAULT_ASSET_OP_TIMEOUT_MS
-      });
-
-      if (response.success === false) {
-        return { success: false, error: response.error || response.message || 'Failed to save level' };
-      }
-
-      const result: Record<string, unknown> = {
-        ...response,
-        success: true,
-        message: response.message || 'Level saved'
-      };
-
-      if (response.skipped) {
-        result.skipped = response.skipped;
-      }
-      if (response.reason) {
-        result.reason = response.reason;
-      }
-      if (response.warnings) {
-        result.warnings = response.warnings;
-      }
-      if (response.details) {
-        result.details = response.details;
-      }
-
-      return result as StandardActionResponse;
-    } catch (error) {
-      return { success: false, error: `Failed to save level: ${error instanceof Error ? error.message : String(error)}` };
-    }
-  }
-
-  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}`;
-
-    try {
-      const response = await this.sendAutomationRequest<LevelResponse>('create_new_level', {
-        levelPath: fullPath,
-        useWorldPartition: isPartitioned
-      }, {
-        timeoutMs: DEFAULT_ASSET_OP_TIMEOUT_MS
-      });
-
-      if (response.success === false) {
-        return {
-          success: false,
-          error: response.error || response.message || 'Failed to create level',
-          path: fullPath,
-          partitioned: isPartitioned
-        } as StandardActionResponse;
-      }
-
-      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;
-      }
-
-      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: `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 (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.
-    }
-
-    // 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;
-  }
-
-  async streamLevel(params: {
-    levelPath?: string;
-    levelName?: string;
-    shouldBeLoaded: boolean;
-    shouldBeVisible?: boolean;
-    position?: [number, number, number];
-  }): 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.sendAutomationRequest<LevelResponse>('stream_level', {
-        levelPath: levelPath || '',
-        levelName: levelName || '',
-        shouldBeLoaded: params.shouldBeLoaded,
-        shouldBeVisible
-      }, {
-        timeoutMs: DEFAULT_ASSET_OP_TIMEOUT_MS
-      });
-
-      if (response.success === false) {
-        const errorCode = typeof response.error === 'string' ? response.error : '';
-        const isExecFailed = errorCode.toLowerCase() === 'exec_failed';
-
-        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 {
-          success: false,
-          error: response.error || response.message || 'Streaming level update failed',
-          level: levelName || '',
-          levelPath: levelPath,
-          loaded: params.shouldBeLoaded,
-          visible: shouldBeVisible
-        } as StandardActionResponse;
-      }
-
-      const result: Record<string, unknown> = {
-        success: true,
-        message: response.message || 'Streaming level updated',
-        level: levelName || '',
-        levelPath,
-        loaded: params.shouldBeLoaded,
-        visible: shouldBeVisible
-      };
-
-      if (response.warnings) {
-        result.warnings = response.warnings;
-      }
-      if (response.details) {
-        result.details = response.details;
-      }
-
-      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 = shouldBeVisible ? 'Show' : 'Hide';
-      const command = `StreamLevel ${simpleName} ${loadCmd} ${visCmd}`;
-      return this.bridge.executeConsoleCommand(command);
-    }
-  }
-
-  async setupWorldComposition(params: {
-    enableComposition: boolean;
-    tileSize?: number;
-    distanceStreaming?: boolean;
-    streamingDistance?: number;
-  }): Promise<StandardActionResponse> {
-    const commands: string[] = [];
-
-    if (params.enableComposition) {
-      commands.push('EnableWorldComposition');
-      if (params.tileSize) {
-        commands.push(`SetWorldTileSize ${params.tileSize}`);
-      }
-      if (params.distanceStreaming) {
-        commands.push(`EnableDistanceStreaming ${params.streamingDistance || 5000}`);
-      }
-    } else {
-      commands.push('DisableWorldComposition');
-    }
-
-    await this.bridge.executeConsoleCommands(commands);
-
-    return { success: true, message: 'World composition configured' };
-  }
-
-  async editLevelBlueprint(params: {
-    eventType: 'BeginPlay' | 'EndPlay' | 'Tick' | 'Custom';
-    customEventName?: string;
-    nodes?: Array<{
-      nodeType: string;
-      position: [number, number];
-      connections?: string[];
-    }>;
-  }): Promise<StandardActionResponse> {
-    const command = `OpenLevelBlueprint ${params.eventType}`;
-    return this.bridge.executeConsoleCommand(command);
-  }
-
-  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);
-  }
-
-  async setWorldSettings(params: {
-    gravity?: number;
-    worldScale?: number;
-    gameMode?: string;
-    defaultPawn?: string;
-    killZ?: number;
-  }): Promise<StandardActionResponse> {
-    const commands: string[] = [];
-
-    if (params.gravity !== undefined) {
-      commands.push(`SetWorldGravity ${params.gravity}`);
-    }
-    if (params.worldScale !== undefined) {
-      commands.push(`SetWorldToMeters ${params.worldScale}`);
-    }
-    if (params.gameMode) {
-      commands.push(`SetGameMode ${params.gameMode}`);
-    }
-    if (params.defaultPawn) {
-      commands.push(`SetDefaultPawn ${params.defaultPawn}`);
-    }
-    if (params.killZ !== undefined) {
-      commands.push(`SetKillZ ${params.killZ}`);
-    }
-
-    await this.bridge.executeConsoleCommands(commands);
-
-    return { success: true, message: 'World settings updated' };
-  }
-
-  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);
-  }
-
-  async buildNavMesh(params: {
-    rebuildAll?: boolean;
-    selectedOnly?: boolean;
-  }): Promise<StandardActionResponse> {
-    try {
-      const response = await this.sendAutomationRequest<LevelResponse>('build_navigation_mesh', {
-        rebuildAll: params.rebuildAll ?? false,
-        selectedOnly: params.selectedOnly ?? false
-      }, {
-        timeoutMs: 120000
-      });
-
-      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')
-      };
-
-      if (params.rebuildAll !== undefined) {
-        result.rebuildAll = params.rebuildAll;
-      }
-      if (params.selectedOnly !== undefined) {
-        result.selectedOnly = params.selectedOnly;
-      }
-      if (response.selectionCount !== undefined) {
-        result.selectionCount = response.selectionCount;
-      }
-      if (response.warnings) {
-        result.warnings = response.warnings;
-      }
-      if (response.details) {
-        result.details = response.details;
-      }
-
-      return result as StandardActionResponse;
-    } catch (error) {
-      return {
-        success: false,
-        error: `Navigation build not available: ${error instanceof Error ? error.message : String(error)}. Please ensure a NavMeshBoundsVolume exists in the level.`
-      };
-    }
-  }
-
-  async setLevelVisibility(params: {
-    levelName: string;
-    visible: boolean;
-  }): Promise<StandardActionResponse> {
-    const command = `SetLevelVisibility ${params.levelName} ${params.visible}`;
-    return this.bridge.executeConsoleCommand(command);
-  }
-
-  async setWorldOrigin(params: {
-    location: [number, number, number];
-  }): Promise<StandardActionResponse> {
-    const command = `SetWorldOriginLocation ${params.location.join(' ')}`;
-    return this.bridge.executeConsoleCommand(command);
-  }
-
-  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);
-  }
-
-  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);
-  }
-}