unreal-engine-mcp-server 0.3.0 → 0.4.0

package/src/tools/consolidated-tool-handlers.ts

@@ -1,6 +1,8 @@
 // Consolidated tool handlers - maps 13 tools to all 36 operations
-import { handleToolCall } from './tool-handlers.js';
 import { cleanObject } from '../utils/safe-json.js';
+import { Logger } from '../utils/logger.js';
+
+const log = new Logger('ConsolidatedToolHandler');
 
 export async function handleConsolidatedToolCall(
   name: string,
@@ -8,7 +10,8 @@ export async function handleConsolidatedToolCall(
   tools: any
 ) {
   const startTime = Date.now();
-  console.log(`[ConsolidatedToolHandler] Starting execution of ${name} at ${new Date().toISOString()}`);
+  // Use scoped logger (stderr) to avoid polluting stdout JSON
+  log.debug(`Starting execution of ${name} at ${new Date().toISOString()}`);
   
   try {
     // Validate args is not null/undefined
@@ -16,8 +19,6 @@ export async function handleConsolidatedToolCall(
       throw new Error('Invalid arguments: null or undefined');
     }
     
-    let mappedName: string;
-    let mappedArgs: any = { ...args };
 
     switch (name) {
       // 1. ASSET MANAGER
@@ -32,81 +33,34 @@ export async function handleConsolidatedToolCall(
           throw new Error('Missing required parameter: action');
         }
         
-        switch (args.action) {
-          case 'list':
-            // Directory is optional
-            if (args.directory !== undefined && args.directory !== null) {
-              if (typeof args.directory !== 'string') {
-                throw new Error('Invalid directory: must be a string');
-              }
-            }
-            
-            mappedName = 'list_assets';
-            mappedArgs = {
-              directory: args.directory
-              // recursive removed - always false internally
-            };
-            break;
-            
-          case 'import':
-            // Validate required parameters
-            if (args.sourcePath === undefined || args.sourcePath === null) {
-              throw new Error('Missing required parameter: sourcePath');
-            }
-            if (typeof args.sourcePath !== 'string') {
-              throw new Error('Invalid sourcePath: must be a string');
+switch (args.action) {
+          case 'list': {
+            if (args.directory !== undefined && args.directory !== null && typeof args.directory !== 'string') {
+              throw new Error('Invalid directory: must be a string');
             }
-            if (args.sourcePath.trim() === '') {
-              throw new Error('Invalid sourcePath: cannot be empty');
-            }
-            
-            if (args.destinationPath === undefined || args.destinationPath === null) {
-              throw new Error('Missing required parameter: destinationPath');
-            }
-            if (typeof args.destinationPath !== 'string') {
-              throw new Error('Invalid destinationPath: must be a string');
-            }
-            if (args.destinationPath.trim() === '') {
-              throw new Error('Invalid destinationPath: cannot be empty');
-            }
-            
-            mappedName = 'import_asset';
-            mappedArgs = {
-              sourcePath: args.sourcePath,
-              destinationPath: args.destinationPath
-            };
-            break;
-            
-          case 'create_material':
-            // Validate required parameters
-            if (args.name === undefined || args.name === null) {
-              throw new Error('Missing required parameter: name');
-            }
-            if (typeof args.name !== 'string') {
-              throw new Error('Invalid name: must be a string');
+            const res = await tools.assetResources.list(args.directory || '/Game', false);
+            return cleanObject({ success: true, ...res });
+          }
+          case 'import': {
+            if (typeof args.sourcePath !== 'string' || args.sourcePath.trim() === '') {
+              throw new Error('Invalid sourcePath');
             }
-            if (args.name.trim() === '') {
-              throw new Error('Invalid name: cannot be empty');
+            if (typeof args.destinationPath !== 'string' || args.destinationPath.trim() === '') {
+              throw new Error('Invalid destinationPath');
             }
-            
-            // Path is optional
-            if (args.path !== undefined && args.path !== null) {
-              if (typeof args.path !== 'string') {
-                throw new Error('Invalid path: must be a string');
-              }
+            const res = await tools.assetTools.importAsset(args.sourcePath, args.destinationPath);
+            return cleanObject(res);
+          }
+          case 'create_material': {
+            if (typeof args.name !== 'string' || args.name.trim() === '') {
+              throw new Error('Invalid name: must be a non-empty string');
             }
-            
-            mappedName = 'create_material';
-            mappedArgs = {
-              name: args.name,
-              path: args.path
-            };
-            break;
-            
+            const res = await tools.materialTools.createMaterial(args.name, args.path || '/Game/Materials');
+            return cleanObject(res);
+          }
           default:
             throw new Error(`Unknown asset action: ${args.action}`);
         }
-        break;
 
       // 2. ACTOR CONTROL
       case 'control_actor':
@@ -115,70 +69,42 @@ export async function handleConsolidatedToolCall(
           throw new Error('Missing required parameter: action');
         }
         
-        switch (args.action) {
-          case 'spawn':
-            // Validate spawn parameters
-            if (!args.classPath) {
-              throw new Error('Missing required parameter: classPath');
-            }
-            if (typeof args.classPath !== 'string' || args.classPath.trim() === '') {
+switch (args.action) {
+          case 'spawn': {
+            if (!args.classPath || typeof args.classPath !== 'string' || args.classPath.trim() === '') {
               throw new Error('Invalid classPath: must be a non-empty string');
             }
-            
-            mappedName = 'spawn_actor';
-            mappedArgs = {
+            const res = await tools.actorTools.spawn({
               classPath: args.classPath,
               location: args.location,
               rotation: args.rotation
-            };
-            break;
-            
-          case 'delete':
-            // Validate delete parameters
-            if (!args.actorName) {
-              throw new Error('Missing required parameter: actorName');
-            }
-            if (typeof args.actorName !== 'string' || args.actorName.trim() === '') {
-              throw new Error('Invalid actorName: must be a non-empty string');
-            }
-            
-            mappedName = 'delete_actor';
-            mappedArgs = {
-              actorName: args.actorName
-            };
-            break;
-            
-          case 'apply_force':
-            // Validate apply_force parameters
-            if (!args.actorName) {
-              throw new Error('Missing required parameter: actorName');
-            }
-            if (typeof args.actorName !== 'string' || args.actorName.trim() === '') {
-              throw new Error('Invalid actorName: must be a non-empty string');
-            }
-            if (!args.force) {
-              throw new Error('Missing required parameter: force');
+            });
+            return cleanObject(res);
+          }
+          case 'delete': {
+            if (!args.actorName || typeof args.actorName !== 'string' || args.actorName.trim() === '') {
+              throw new Error('Invalid actorName');
             }
-            if (typeof args.force !== 'object' || args.force === null) {
-              throw new Error('Invalid force: must be an object with x, y, z properties');
+            const res = await tools.bridge.executeEditorFunction('DELETE_ACTOR', { actor_name: args.actorName });
+            return cleanObject(res);
+          }
+          case 'apply_force': {
+            if (!args.actorName || typeof args.actorName !== 'string' || args.actorName.trim() === '') {
+              throw new Error('Invalid actorName');
             }
-            if (typeof args.force.x !== 'number' || 
-                typeof args.force.y !== 'number' || 
-                typeof args.force.z !== 'number') {
-              throw new Error('Invalid force: x, y, z must all be numbers');
+            if (!args.force || typeof args.force.x !== 'number' || typeof args.force.y !== 'number' || typeof args.force.z !== 'number') {
+              throw new Error('Invalid force: must have numeric x,y,z');
             }
-            
-            mappedName = 'apply_force';
-            mappedArgs = {
+            const res = await tools.physicsTools.applyForce({
               actorName: args.actorName,
-              force: args.force
-            };
-            break;
-            
+              forceType: 'Force',
+              vector: [args.force.x, args.force.y, args.force.z]
+            });
+            return cleanObject(res);
+          }
           default:
             throw new Error(`Unknown actor action: ${args.action}`);
         }
-        break;
 
       // 3. EDITOR CONTROL
       case 'control_editor':
@@ -187,657 +113,317 @@ export async function handleConsolidatedToolCall(
           throw new Error('Missing required parameter: action');
         }
         
-        switch (args.action) {
-          case 'play':
-            mappedName = 'play_in_editor';
-            mappedArgs = {};
-            break;
-          case 'stop':
-            mappedName = 'stop_play_in_editor';
-            mappedArgs = {};
-            break;
-          case 'pause':
-            mappedName = 'pause_play_in_editor';
-            mappedArgs = {};
-            break;
-          case 'set_game_speed':
-            // Validate game speed parameter
-            if (args.speed === undefined || args.speed === null) {
-              throw new Error('Missing required parameter: speed');
-            }
-            if (typeof args.speed !== 'number') {
-              throw new Error('Invalid speed: must be a number');
-            }
-            if (isNaN(args.speed)) {
-              throw new Error('Invalid speed: cannot be NaN');
-            }
-            if (!isFinite(args.speed)) {
-              throw new Error('Invalid speed: must be finite');
-            }
-            if (args.speed <= 0) {
-              throw new Error('Invalid speed: must be positive');
-            }
-            mappedName = 'set_game_speed';
-            mappedArgs = {
-              speed: args.speed
-            };
-            break;
-          case 'eject':
-            mappedName = 'eject_from_pawn';
-            mappedArgs = {};
-            break;
-          case 'possess':
-            mappedName = 'possess_pawn';
-            mappedArgs = {};
-            break;
-          case 'set_camera':
-            // Allow either location or rotation or both
-            // Don't require both to be present
-            mappedName = 'set_camera';
-            mappedArgs = {
-              location: args.location,
-              rotation: args.rotation
-            };
-            break;
-          case 'set_view_mode':
-            // Validate view mode parameter
-            if (!args.viewMode) {
-              throw new Error('Missing required parameter: viewMode');
-            }
-            if (typeof args.viewMode !== 'string' || args.viewMode.trim() === '') {
-              throw new Error('Invalid viewMode: must be a non-empty string');
-            }
-            
-            // Normalize view mode to match what debug.ts expects
-            const validModes = ['lit', 'unlit', 'wireframe', 'detail_lighting', 'lighting_only', 
-                              'light_complexity', 'shader_complexity', 'lightmap_density', 
-                              'stationary_light_overlap', 'reflections', 'visualize_buffer',
-                              'collision_pawn', 'collision_visibility', 'lod_coloration', 'quad_overdraw'];
-            const normalizedMode = args.viewMode.toLowerCase().replace(/_/g, '');
-            
-            // Map to proper case for debug.ts
-            let mappedMode = '';
-            switch(normalizedMode) {
-              case 'lit': mappedMode = 'Lit'; break;
-              case 'unlit': mappedMode = 'Unlit'; break;
-              case 'wireframe': mappedMode = 'Wireframe'; break;
-              case 'detaillighting': mappedMode = 'DetailLighting'; break;
-              case 'lightingonly': mappedMode = 'LightingOnly'; break;
-              case 'lightcomplexity': mappedMode = 'LightComplexity'; break;
-              case 'shadercomplexity': mappedMode = 'ShaderComplexity'; break;
-              case 'lightmapdensity': mappedMode = 'LightmapDensity'; break;
-              case 'stationarylightoverlap': mappedMode = 'StationaryLightOverlap'; break;
-              case 'reflections': mappedMode = 'ReflectionOverride'; break;
-              case 'visualizebuffer': mappedMode = 'VisualizeBuffer'; break;
-              case 'collisionpawn': mappedMode = 'CollisionPawn'; break;
-              case 'collisionvisibility': mappedMode = 'CollisionVisibility'; break;
-              case 'lodcoloration': mappedMode = 'LODColoration'; break;
-              case 'quadoverdraw': mappedMode = 'QuadOverdraw'; break;
-              default:
-                throw new Error(`Invalid viewMode: '${args.viewMode}'. Valid modes are: ${validModes.join(', ')}`);
+switch (args.action) {
+          case 'play': {
+            const res = await tools.editorTools.playInEditor();
+            return cleanObject(res);
+          }
+          case 'stop': {
+            const res = await tools.editorTools.stopPlayInEditor();
+            return cleanObject(res);
+          }
+          case 'pause': {
+            const res = await tools.editorTools.pausePlayInEditor();
+            return cleanObject(res);
+          }
+          case 'set_game_speed': {
+            if (typeof args.speed !== 'number' || !isFinite(args.speed) || args.speed <= 0) {
+              throw new Error('Invalid speed: must be a positive number');
             }
-            
-            mappedName = 'set_view_mode';
-            mappedArgs = {
-              mode: mappedMode
-            };
-            break;
+            // Use console command via bridge
+            const res = await tools.bridge.executeConsoleCommand(`slomo ${args.speed}`);
+            return cleanObject(res);
+          }
+          case 'eject': {
+            const res = await tools.bridge.executeConsoleCommand('eject');
+            return cleanObject(res);
+          }
+          case 'possess': {
+            const res = await tools.bridge.executeConsoleCommand('viewself');
+            return cleanObject(res);
+          }
+          case 'set_camera': {
+            const res = await tools.editorTools.setViewportCamera(args.location, args.rotation);
+            return cleanObject(res);
+          }
+          case 'set_view_mode': {
+            if (!args.viewMode || typeof args.viewMode !== 'string') throw new Error('Missing required parameter: viewMode');
+            const res = await tools.bridge.setSafeViewMode(args.viewMode);
+            return cleanObject(res);
+          }
           default:
             throw new Error(`Unknown editor action: ${args.action}`);
         }
-        break;
 
       // 4. LEVEL MANAGER
-      case 'manage_level':
+case 'manage_level':
+        if (!args.action) throw new Error('Missing required parameter: action');
         switch (args.action) {
-          case 'load':
-            mappedName = 'load_level';
-            mappedArgs = {
-              levelPath: args.levelPath
-            };
-            if (args.streaming !== undefined) {
-              mappedArgs.streaming = args.streaming;
-            }
-            break;
-          case 'save':
-            mappedName = 'save_level';
-            mappedArgs = {
-              levelName: args.levelName
-            };
-            if (args.savePath !== undefined) {
-              mappedArgs.savePath = args.savePath;
-            }
-            break;
-          case 'stream':
-            mappedName = 'stream_level';
-            mappedArgs = {
-              levelName: args.levelName,
-              shouldBeLoaded: args.shouldBeLoaded,
-              shouldBeVisible: args.shouldBeVisible
-            };
-            break;
-          case 'create_light':
-            // Validate light type
-            if (!args.lightType) {
-              throw new Error('Missing required parameter: lightType');
-            }
-            const validLightTypes = ['directional', 'point', 'spot', 'rect', 'sky'];
-            const normalizedLightType = String(args.lightType).toLowerCase();
-            if (!validLightTypes.includes(normalizedLightType)) {
-              throw new Error(`Invalid lightType: '${args.lightType}'. Valid types are: ${validLightTypes.join(', ')}`);
-            }
-            
-            // Validate name
-            if (!args.name) {
-              throw new Error('Missing required parameter: name');
-            }
-            if (typeof args.name !== 'string' || args.name.trim() === '') {
-              throw new Error('Invalid name: must be a non-empty string');
-            }
-            
-            // Validate intensity if provided
-            if (args.intensity !== undefined) {
-              if (typeof args.intensity !== 'number' || !isFinite(args.intensity)) {
-                throw new Error(`Invalid intensity: must be a finite number, got ${typeof args.intensity}`);
-              }
-              if (args.intensity < 0) {
-                throw new Error('Invalid intensity: must be non-negative');
-              }
-            }
-            
-            // Validate location if provided
-            if (args.location !== undefined && args.location !== null) {
-              if (!Array.isArray(args.location) && typeof args.location !== 'object') {
-                throw new Error('Invalid location: must be an array [x,y,z] or object {x,y,z}');
-              }
-            }
-            
-            mappedName = 'create_light';
-            mappedArgs = {
-              lightType: args.lightType,
-              name: args.name,
-              location: args.location,
-              intensity: args.intensity
-            };
-            break;
-          case 'build_lighting':
-            mappedName = 'build_lighting';
-            mappedArgs = {
-              quality: args.quality
-            };
-            break;
+          case 'load': {
+            if (!args.levelPath || typeof args.levelPath !== 'string') throw new Error('Missing required parameter: levelPath');
+            const res = await tools.levelTools.loadLevel({ levelPath: args.levelPath, streaming: !!args.streaming });
+            return cleanObject(res);
+          }
+          case 'save': {
+            const res = await tools.levelTools.saveLevel({ levelName: args.levelName, savePath: args.savePath });
+            return cleanObject(res);
+          }
+          case 'stream': {
+            if (!args.levelName || typeof args.levelName !== 'string') throw new Error('Missing required parameter: levelName');
+            const res = await tools.levelTools.streamLevel({ levelName: args.levelName, shouldBeLoaded: !!args.shouldBeLoaded, shouldBeVisible: !!args.shouldBeVisible });
+            return cleanObject(res);
+          }
+          case 'create_light': {
+            if (!args.lightType) throw new Error('Missing required parameter: lightType');
+            if (!args.name || typeof args.name !== 'string' || args.name.trim() === '') throw new Error('Invalid name');
+            const t = String(args.lightType).toLowerCase();
+            if (t === 'directional') return cleanObject(await tools.lightingTools.createDirectionalLight({ name: args.name, intensity: args.intensity }));
+            if (t === 'point') return cleanObject(await tools.lightingTools.createPointLight({ name: args.name, location: args.location ? [args.location.x, args.location.y, args.location.z] : [0,0,0], intensity: args.intensity }));
+            if (t === 'spot') return cleanObject(await tools.lightingTools.createSpotLight({ name: args.name, location: args.location ? [args.location.x, args.location.y, args.location.z] : [0,0,0], rotation: [0,0,0], intensity: args.intensity }));
+            if (t === 'rect') return cleanObject(await tools.lightingTools.createRectLight({ name: args.name, location: args.location ? [args.location.x, args.location.y, args.location.z] : [0,0,0], rotation: [0,0,0], intensity: args.intensity }));
+            throw new Error(`Unknown light type: ${args.lightType}`);
+          }
+          case 'build_lighting': {
+            const res = await tools.lightingTools.buildLighting({ quality: args.quality || 'High', buildReflectionCaptures: true });
+            return cleanObject(res);
+          }
           default:
             throw new Error(`Unknown level action: ${args.action}`);
         }
-        break;
 
       // 5. ANIMATION & PHYSICS
-      case 'animation_physics':
+case 'animation_physics':
         // Validate action exists
         if (!args.action) {
           throw new Error('Missing required parameter: action');
         }
         
         switch (args.action) {
-          case 'create_animation_bp':
-            // Validate required parameters
-            if (args.name === undefined || args.name === null) {
-              throw new Error('Missing required parameter: name');
-            }
-            if (typeof args.name !== 'string') {
-              throw new Error('Invalid name: must be a string');
-            }
-            if (args.name.trim() === '') {
-              throw new Error('Invalid name: cannot be empty');
-            }
-            
-            if (args.skeletonPath === undefined || args.skeletonPath === null) {
-              throw new Error('Missing required parameter: skeletonPath');
-            }
-            if (typeof args.skeletonPath !== 'string') {
-              throw new Error('Invalid skeletonPath: must be a string');
-            }
-            if (args.skeletonPath.trim() === '') {
-              throw new Error('Invalid skeletonPath: cannot be empty');
-            }
-            
-            // Optional savePath validation
-            if (args.savePath !== undefined && args.savePath !== null) {
-              if (typeof args.savePath !== 'string') {
-                throw new Error('Invalid savePath: must be a string');
-              }
-            }
-            
-            mappedName = 'create_animation_blueprint';
-            mappedArgs = {
-              name: args.name,
-              skeletonPath: args.skeletonPath,
-              savePath: args.savePath
-            };
-            break;
-            
-          case 'play_montage':
-            // Validate required parameters
-            if (args.actorName === undefined || args.actorName === null) {
-              throw new Error('Missing required parameter: actorName');
-            }
-            if (typeof args.actorName !== 'string') {
-              throw new Error('Invalid actorName: must be a string');
-            }
-            if (args.actorName.trim() === '') {
-              throw new Error('Invalid actorName: cannot be empty');
-            }
-            
-            // Check for montagePath or animationPath
+          case 'create_animation_bp': {
+            if (typeof args.name !== 'string' || args.name.trim() === '') throw new Error('Invalid name');
+            if (typeof args.skeletonPath !== 'string' || args.skeletonPath.trim() === '') throw new Error('Invalid skeletonPath');
+            const res = await tools.animationTools.createAnimationBlueprint({ name: args.name, skeletonPath: args.skeletonPath, savePath: args.savePath });
+            return cleanObject(res);
+          }
+          case 'play_montage': {
+            if (typeof args.actorName !== 'string' || args.actorName.trim() === '') throw new Error('Invalid actorName');
             const montagePath = args.montagePath || args.animationPath;
-            if (montagePath === undefined || montagePath === null) {
-              throw new Error('Missing required parameter: montagePath or animationPath');
-            }
-            if (typeof montagePath !== 'string') {
-              throw new Error('Invalid montagePath: must be a string');
-            }
-            if (montagePath.trim() === '') {
-              throw new Error('Invalid montagePath: cannot be empty');
-            }
-            
-            // Optional playRate validation
-            if (args.playRate !== undefined && args.playRate !== null) {
-              if (typeof args.playRate !== 'number') {
-                throw new Error('Invalid playRate: must be a number');
-              }
-              if (isNaN(args.playRate)) {
-                throw new Error('Invalid playRate: cannot be NaN');
-              }
-              if (!isFinite(args.playRate)) {
-                throw new Error('Invalid playRate: must be finite');
-              }
-            }
-            
-            mappedName = 'play_animation_montage';
-            mappedArgs = {
-              actorName: args.actorName,
-              montagePath: montagePath,
-              playRate: args.playRate
-            };
-            break;
-            
-          case 'setup_ragdoll':
-            // Validate required parameters
-            if (args.skeletonPath === undefined || args.skeletonPath === null) {
-              throw new Error('Missing required parameter: skeletonPath');
-            }
-            if (typeof args.skeletonPath !== 'string') {
-              throw new Error('Invalid skeletonPath: must be a string');
-            }
-            if (args.skeletonPath.trim() === '') {
-              throw new Error('Invalid skeletonPath: cannot be empty');
-            }
-            
-            if (args.physicsAssetName === undefined || args.physicsAssetName === null) {
-              throw new Error('Missing required parameter: physicsAssetName');
-            }
-            if (typeof args.physicsAssetName !== 'string') {
-              throw new Error('Invalid physicsAssetName: must be a string');
-            }
-            if (args.physicsAssetName.trim() === '') {
-              throw new Error('Invalid physicsAssetName: cannot be empty');
-            }
-            
-            // Optional blendWeight validation
-            if (args.blendWeight !== undefined && args.blendWeight !== null) {
-              if (typeof args.blendWeight !== 'number') {
-                throw new Error('Invalid blendWeight: must be a number');
-              }
-              if (isNaN(args.blendWeight)) {
-                throw new Error('Invalid blendWeight: cannot be NaN');
-              }
-              if (!isFinite(args.blendWeight)) {
-                throw new Error('Invalid blendWeight: must be finite');
-              }
-            }
-            
-            // Optional savePath validation
-            if (args.savePath !== undefined && args.savePath !== null) {
-              if (typeof args.savePath !== 'string') {
-                throw new Error('Invalid savePath: must be a string');
-              }
-            }
-            
-            mappedName = 'setup_ragdoll';
-            mappedArgs = {
-              skeletonPath: args.skeletonPath,
-              physicsAssetName: args.physicsAssetName,
-              blendWeight: args.blendWeight,
-              savePath: args.savePath
-            };
-            break;
-            
+            if (typeof montagePath !== 'string' || montagePath.trim() === '') throw new Error('Invalid montagePath');
+            const res = await tools.animationTools.playAnimation({ actorName: args.actorName, animationType: 'Montage', animationPath: montagePath, playRate: args.playRate });
+            return cleanObject(res);
+          }
+          case 'setup_ragdoll': {
+            if (typeof args.skeletonPath !== 'string' || args.skeletonPath.trim() === '') throw new Error('Invalid skeletonPath');
+            if (typeof args.physicsAssetName !== 'string' || args.physicsAssetName.trim() === '') throw new Error('Invalid physicsAssetName');
+            const res = await tools.physicsTools.setupRagdoll({ skeletonPath: args.skeletonPath, physicsAssetName: args.physicsAssetName, blendWeight: args.blendWeight, savePath: args.savePath });
+            return cleanObject(res);
+          }
           default:
             throw new Error(`Unknown animation/physics action: ${args.action}`);
         }
-        break;
 
-      // 6. EFFECTS SYSTEM
+// 6. EFFECTS SYSTEM
       case 'create_effect':
         switch (args.action) {
-          case 'particle':
-            mappedName = 'create_particle_effect';
-            mappedArgs = {
-              effectType: args.effectType,
-              name: args.name,
-              location: args.location
-            };
-            break;
-          case 'niagara':
-            mappedName = 'spawn_niagara_system';
-            mappedArgs = {
-              systemPath: args.systemPath,
-              location: args.location,
-              scale: args.scale
-            };
-            break;
-          case 'debug_shape':
-            mappedName = 'draw_debug_shape';
-            // Convert location object to array for position
-            const pos = args.location || args.position;
-            mappedArgs = {
-              shape: args.shape,
-              position: pos ? [pos.x || 0, pos.y || 0, pos.z || 0] : [0, 0, 0],
-              size: args.size,
-              color: args.color,
-              duration: args.duration
-            };
-            break;
+          case 'particle': {
+            const res = await tools.niagaraTools.createEffect({ effectType: args.effectType, name: args.name, location: args.location, scale: args.scale, customParameters: args.customParameters });
+            return cleanObject(res);
+          }
+          case 'niagara': {
+            if (typeof args.systemPath !== 'string' || args.systemPath.trim() === '') throw new Error('Invalid systemPath');
+            // Create or ensure system exists (spawning in editor is not universally supported via RC)
+            const name = args.name || args.systemPath.split('/').pop();
+            const res = await tools.niagaraTools.createSystem({ name, savePath: args.savePath || '/Game/Effects/Niagara' });
+            return cleanObject(res);
+          }
+          case 'debug_shape': {
+            const shape = String(args.shape || 'Sphere').toLowerCase();
+            const loc = args.location || { x: 0, y: 0, z: 0 };
+            const size = args.size || 100;
+            const color = args.color || [255, 0, 0, 255];
+            const duration = args.duration || 5;
+            if (shape === 'line') {
+              const end = args.end || { x: loc.x + size, y: loc.y, z: loc.z };
+              return cleanObject(await tools.debugTools.drawDebugLine({ start: [loc.x, loc.y, loc.z], end: [end.x, end.y, end.z], color, duration }));
+            } else if (shape === 'box') {
+              const extent = [size, size, size];
+              return cleanObject(await tools.debugTools.drawDebugBox({ center: [loc.x, loc.y, loc.z], extent, color, duration }));
+            } else if (shape === 'sphere') {
+              return cleanObject(await tools.debugTools.drawDebugSphere({ center: [loc.x, loc.y, loc.z], radius: size, color, duration }));
+            } else if (shape === 'capsule') {
+              return cleanObject(await tools.debugTools.drawDebugCapsule({ center: [loc.x, loc.y, loc.z], halfHeight: size, radius: Math.max(10, size/3), color, duration }));
+            } else if (shape === 'cone') {
+              return cleanObject(await tools.debugTools.drawDebugCone({ origin: [loc.x, loc.y, loc.z], direction: [0,0,1], length: size, angleWidth: 0.5, angleHeight: 0.5, color, duration }));
+            } else if (shape === 'arrow') {
+              const end = args.end || { x: loc.x + size, y: loc.y, z: loc.z };
+              return cleanObject(await tools.debugTools.drawDebugArrow({ start: [loc.x, loc.y, loc.z], end: [end.x, end.y, end.z], color, duration }));
+            } else if (shape === 'point') {
+              return cleanObject(await tools.debugTools.drawDebugPoint({ location: [loc.x, loc.y, loc.z], size, color, duration }));
+            } else if (shape === 'text' || shape === 'string') {
+              const text = args.text || 'Debug';
+              return cleanObject(await tools.debugTools.drawDebugString({ location: [loc.x, loc.y, loc.z], text, color, duration }));
+            }
+            // Default fallback
+            return cleanObject(await tools.debugTools.drawDebugSphere({ center: [loc.x, loc.y, loc.z], radius: size, color, duration }));
+          }
           default:
             throw new Error(`Unknown effect action: ${args.action}`);
         }
-        break;
 
-      // 7. BLUEPRINT MANAGER
+// 7. BLUEPRINT MANAGER
       case 'manage_blueprint':
         switch (args.action) {
-          case 'create':
-            mappedName = 'create_blueprint';
-            mappedArgs = {
-              name: args.name,
-              blueprintType: args.blueprintType,
-              savePath: args.savePath
-            };
-            break;
-          case 'add_component':
-            mappedName = 'add_blueprint_component';
-            mappedArgs = {
-              blueprintName: args.name,
-              componentType: args.componentType,
-              componentName: args.componentName
-            };
-            break;
+          case 'create': {
+            const res = await tools.blueprintTools.createBlueprint({ name: args.name, blueprintType: args.blueprintType || 'Actor', savePath: args.savePath });
+            return cleanObject(res);
+          }
+          case 'add_component': {
+            const res = await tools.blueprintTools.addComponent({ blueprintName: args.name, componentType: args.componentType, componentName: args.componentName });
+            return cleanObject(res);
+          }
           default:
             throw new Error(`Unknown blueprint action: ${args.action}`);
         }
-        break;
 
-      // 8. ENVIRONMENT BUILDER
+// 8. ENVIRONMENT BUILDER
       case 'build_environment':
         switch (args.action) {
-          case 'create_landscape':
-            mappedName = 'create_landscape';
-            mappedArgs = {
-              name: args.name,
+          case 'create_landscape': {
+            const res = await tools.landscapeTools.createLandscape({ name: args.name, sizeX: args.sizeX, sizeY: args.sizeY, materialPath: args.materialPath });
+            return cleanObject(res);
+          }
+          case 'sculpt': {
+            const res = await tools.landscapeTools.sculptLandscape({ landscapeName: args.name, tool: args.tool, brushSize: args.brushSize, strength: args.strength });
+            return cleanObject(res);
+          }
+          case 'add_foliage': {
+            const res = await tools.foliageTools.addFoliageType({ name: args.name, meshPath: args.meshPath, density: args.density });
+            return cleanObject(res);
+          }
+          case 'paint_foliage': {
+            const pos = args.position ? [args.position.x || 0, args.position.y || 0, args.position.z || 0] : [0,0,0];
+            const res = await tools.foliageTools.paintFoliage({ foliageType: args.foliageType, position: pos, brushSize: args.brushSize, paintDensity: args.paintDensity, eraseMode: args.eraseMode });
+            return cleanObject(res);
+          }
+          case 'create_procedural_terrain': {
+            const loc = args.location ? [args.location.x||0, args.location.y||0, args.location.z||0] : [0,0,0];
+            const res = await tools.buildEnvAdvanced.createProceduralTerrain({
+              name: args.name || 'ProceduralTerrain',
+              location: loc as [number,number,number],
               sizeX: args.sizeX,
               sizeY: args.sizeY,
-              materialPath: args.materialPath
-            };
-            break;
-          case 'sculpt':
-            mappedName = 'sculpt_landscape';
-            mappedArgs = {
-              landscapeName: args.name,
-              tool: args.tool,
-              brushSize: args.brushSize,
-              strength: args.strength
-            };
-            break;
-          case 'add_foliage':
-            // Validate foliage creation parameters to avoid bad console commands / engine warnings
-            if (args.name === undefined || args.name === null || typeof args.name !== 'string' || args.name.trim() === '' || String(args.name).toLowerCase() === 'undefined' || String(args.name).toLowerCase() === 'any') {
-              throw new Error(`Invalid foliage name: '${args.name}'`);
-            }
-            if (args.meshPath === undefined || args.meshPath === null || typeof args.meshPath !== 'string' || args.meshPath.trim() === '' || String(args.meshPath).toLowerCase() === 'undefined') {
-              throw new Error(`Invalid meshPath: '${args.meshPath}'`);
-            }
-            if (args.density !== undefined) {
-              if (typeof args.density !== 'number' || !isFinite(args.density) || args.density < 0) {
-                throw new Error(`Invalid density: '${args.density}' (must be non-negative finite number)`);
-              }
-            }
-            mappedName = 'add_foliage_type';
-            mappedArgs = {
-              name: args.name,
+              subdivisions: args.subdivisions,
+              heightFunction: args.heightFunction,
+              material: args.materialPath
+            });
+            return cleanObject(res);
+          }
+          case 'create_procedural_foliage': {
+            if (!args.bounds || !args.bounds.location || !args.bounds.size) throw new Error('bounds.location and bounds.size are required');
+            const bounds = {
+              location: [args.bounds.location.x||0, args.bounds.location.y||0, args.bounds.location.z||0] as [number,number,number],
+              size: [args.bounds.size.x||1000, args.bounds.size.y||1000, args.bounds.size.z||100] as [number,number,number]
+            };
+            const res = await tools.buildEnvAdvanced.createProceduralFoliage({
+              name: args.name || 'ProceduralFoliage',
+              bounds,
+              foliageTypes: args.foliageTypes || [],
+              seed: args.seed
+            });
+            return cleanObject(res);
+          }
+          case 'add_foliage_instances': {
+            if (!args.foliageType) throw new Error('foliageType is required');
+            if (!Array.isArray(args.transforms)) throw new Error('transforms array is required');
+            const transforms = (args.transforms as any[]).map(t => ({
+              location: [t.location?.x||0, t.location?.y||0, t.location?.z||0] as [number,number,number],
+              rotation: t.rotation ? [t.rotation.pitch||0, t.rotation.yaw||0, t.rotation.roll||0] as [number,number,number] : undefined,
+              scale: t.scale ? [t.scale.x||1, t.scale.y||1, t.scale.z||1] as [number,number,number] : undefined
+            }));
+            const res = await tools.buildEnvAdvanced.addFoliageInstances({ foliageType: args.foliageType, transforms });
+            return cleanObject(res);
+          }
+          case 'create_landscape_grass_type': {
+            const res = await tools.buildEnvAdvanced.createLandscapeGrassType({
+              name: args.name || 'GrassType',
               meshPath: args.meshPath,
-              density: args.density
-            };
-            break;
-          case 'paint_foliage':
-            // Validate paint parameters
-            if (args.foliageType === undefined || args.foliageType === null || typeof args.foliageType !== 'string' || args.foliageType.trim() === '' || String(args.foliageType).toLowerCase() === 'undefined' || String(args.foliageType).toLowerCase() === 'any') {
-              throw new Error(`Invalid foliageType: '${args.foliageType}'`);
-            }
-            // Convert position object to array if needed
-            let positionArray;
-            if (args.position) {
-              if (Array.isArray(args.position)) {
-                positionArray = args.position;
-              } else if (typeof args.position === 'object') {
-                positionArray = [args.position.x || 0, args.position.y || 0, args.position.z || 0];
-              } else {
-                positionArray = [0, 0, 0];
-              }
-            } else {
-              positionArray = [0, 0, 0];
-            }
-            // Validate numbers in position
-            if (!Array.isArray(positionArray) || positionArray.length !== 3 || positionArray.some(v => typeof v !== 'number' || !isFinite(v))) {
-              throw new Error(`Invalid position: '${JSON.stringify(args.position)}'`);
-            }
-            if (args.brushSize !== undefined) {
-              if (typeof args.brushSize !== 'number' || !isFinite(args.brushSize) || args.brushSize < 0) {
-                throw new Error(`Invalid brushSize: '${args.brushSize}' (must be non-negative finite number)`);
-              }
-            }
-            mappedName = 'paint_foliage';
-            mappedArgs = {
-              foliageType: args.foliageType,
-              position: positionArray,
-              brushSize: args.brushSize
-            };
-            break;
+              density: args.density,
+              minScale: args.minScale,
+              maxScale: args.maxScale
+            });
+            return cleanObject(res);
+          }
           default:
             throw new Error(`Unknown environment action: ${args.action}`);
         }
-        break;
 
       // 9. SYSTEM CONTROL
-      case 'system_control':
-        // Validate args is not null/undefined
-        if (args === null || args === undefined) {
-          throw new Error('Invalid arguments: null or undefined');
-        }
-        if (typeof args !== 'object') {
-          throw new Error('Invalid arguments: must be an object');
-        }
-        // Validate action exists
-        if (!args.action) {
-          throw new Error('Missing required parameter: action');
-        }
-        
+case 'system_control':
+        if (!args.action) throw new Error('Missing required parameter: action');
         switch (args.action) {
-          case 'profile':
-            // Validate profile type
-            const validProfileTypes = ['CPU', 'GPU', 'Memory', 'RenderThread', 'GameThread', 'All'];
-            if (!args.profileType || !validProfileTypes.includes(args.profileType)) {
-              throw new Error(`Invalid profileType: '${args.profileType}'. Valid types: ${validProfileTypes.join(', ')}`);
-            }
-            mappedName = 'start_profiling';
-            mappedArgs = {
-              type: args.profileType,
-              duration: args.duration
-            };
-            break;
-            
-          case 'show_fps':
-            // Validate enabled is boolean
-            if (args.enabled !== undefined && typeof args.enabled !== 'boolean') {
-              throw new Error(`Invalid enabled: must be boolean, got ${typeof args.enabled}`);
-            }
-            mappedName = 'show_fps';
-            mappedArgs = {
-              enabled: args.enabled,
-              verbose: args.verbose
-            };
-            break;
-            
-          case 'set_quality':
-            // Validate category - normalize aliases and singular forms used by sg.*Quality
-            const validCategories = ['ViewDistance', 'AntiAliasing', 'PostProcessing', 'PostProcess', 
-                                   'Shadows', 'Shadow', 'GlobalIllumination', 'Reflections', 'Reflection', 'Textures', 'Texture', 
-                                   'Effects', 'Foliage', 'Shading'];
-            if (!args.category || !validCategories.includes(args.category)) {
-              throw new Error(`Invalid category: '${args.category}'. Valid categories: ${validCategories.join(', ')}`);
-            }
-            // Validate level
-            if (args.level === undefined || args.level === null) {
-              throw new Error('Missing required parameter: level');
-            }
-            if (typeof args.level !== 'number' || !Number.isInteger(args.level) || args.level < 0 || args.level > 4) {
-              throw new Error(`Invalid level: must be integer 0-4, got ${args.level}`);
-            }
-            // Normalize category to sg.<Base>Quality base (singular where needed)
-            const map: Record<string, string> = {
-              ViewDistance: 'ViewDistance',
-              AntiAliasing: 'AntiAliasing',
-              PostProcessing: 'PostProcess',
-              PostProcess: 'PostProcess',
-              Shadows: 'Shadow',
-              Shadow: 'Shadow',
-              GlobalIllumination: 'GlobalIllumination',
-              Reflections: 'Reflection',
-              Reflection: 'Reflection',
-              Textures: 'Texture',
-              Texture: 'Texture',
-              Effects: 'Effects',
-              Foliage: 'Foliage',
-              Shading: 'Shading',
-            };
-            const categoryName = map[String(args.category)] || args.category;
-            mappedName = 'set_scalability';
-            mappedArgs = {
-              category: categoryName,
-              level: args.level
-            };
-            break;
-            
-          case 'play_sound':
-            // Validate sound path
-            if (!args.soundPath || typeof args.soundPath !== 'string') {
-              throw new Error('Invalid soundPath: must be a non-empty string');
-            }
-            // Validate volume if provided
-            if (args.volume !== undefined) {
-              if (typeof args.volume !== 'number' || args.volume < 0 || args.volume > 1) {
-                throw new Error(`Invalid volume: must be 0-1, got ${args.volume}`);
-              }
-            }
-            mappedName = 'play_sound';
-            mappedArgs = {
-              soundPath: args.soundPath,
-              location: args.location,
-              volume: args.volume,
-              is3D: args.is3D
-            };
-            break;
-            
-          case 'create_widget':
-            // Validate widget name
-            if (!args.widgetName || typeof args.widgetName !== 'string' || args.widgetName.trim() === '') {
-              throw new Error('Invalid widgetName: must be a non-empty string');
-            }
-            mappedName = 'create_widget';
-            mappedArgs = {
-              name: args.widgetName,
-              type: args.widgetType,
-              savePath: args.savePath
-            };
-            break;
-            
-          case 'show_widget':
-            // Validate widget name
-            if (!args.widgetName || typeof args.widgetName !== 'string') {
-              throw new Error('Invalid widgetName: must be a non-empty string');
-            }
-            // Validate visible is boolean (default to true if not provided)
-            const isVisible = args.visible !== undefined ? args.visible : true;
-            if (typeof isVisible !== 'boolean') {
-              throw new Error(`Invalid visible: must be boolean, got ${typeof isVisible}`);
-            }
-            mappedName = 'show_widget';
-            mappedArgs = {
-              widgetName: args.widgetName,
-              visible: isVisible
-            };
-            break;
-
-          case 'screenshot':
-            mappedName = 'take_screenshot';
-            mappedArgs = { resolution: args.resolution };
-            break;
-
-          case 'engine_start':
-            mappedName = 'launch_editor';
-            mappedArgs = { editorExe: args.editorExe, projectPath: args.projectPath };
-            break;
-
-          case 'engine_quit':
-            mappedName = 'quit_editor';
-            mappedArgs = {};
-            break;
-            
+          case 'profile': {
+            const res = await tools.performanceTools.startProfiling({ type: args.profileType, duration: args.duration });
+            return cleanObject(res);
+          }
+          case 'show_fps': {
+            const res = await tools.performanceTools.showFPS({ enabled: !!args.enabled, verbose: !!args.verbose });
+            return cleanObject(res);
+          }
+          case 'set_quality': {
+            const res = await tools.performanceTools.setScalability({ category: args.category, level: args.level });
+            return cleanObject(res);
+          }
+          case 'play_sound': {
+            if (args.location && typeof args.location === 'object') {
+              const loc = [args.location.x || 0, args.location.y || 0, args.location.z || 0];
+              const res = await tools.audioTools.playSoundAtLocation({ soundPath: args.soundPath, location: loc as [number, number, number], volume: args.volume, pitch: args.pitch, startTime: args.startTime });
+              return cleanObject(res);
+            }
+            const res = await tools.audioTools.playSound2D({ soundPath: args.soundPath, volume: args.volume, pitch: args.pitch, startTime: args.startTime });
+            return cleanObject(res);
+          }
+          case 'create_widget': {
+            const res = await tools.uiTools.createWidget({ name: args.widgetName, type: args.widgetType, savePath: args.savePath });
+            return cleanObject(res);
+          }
+          case 'show_widget': {
+            const res = await tools.uiTools.setWidgetVisibility({ widgetName: args.widgetName, visible: args.visible !== false });
+            return cleanObject(res);
+          }
+          case 'screenshot': {
+            const res = await tools.visualTools.takeScreenshot({ resolution: args.resolution });
+            return cleanObject(res);
+          }
+          case 'engine_start': {
+            const res = await tools.engineTools.launchEditor({ editorExe: args.editorExe, projectPath: args.projectPath });
+            return cleanObject(res);
+          }
+          case 'engine_quit': {
+            const res = await tools.engineTools.quitEditor();
+            return cleanObject(res);
+          }
           default:
             throw new Error(`Unknown system action: ${args.action}`);
         }
-        break;
 
       // 10. CONSOLE COMMAND - handle validation here
-      case 'console_command':
-        // Handle empty/invalid commands gracefully
-        if (args.command === undefined || args.command === null || args.command === '' || typeof args.command !== 'string') {
-          return {
-            content: [{
-              type: 'text',
-              text: 'Empty command ignored'
-            }],
-            isError: false,
-            success: true,
-            message: 'Empty command'
-          };
+case 'console_command':
+        if (!args.command || typeof args.command !== 'string' || args.command.trim() === '') {
+          return { success: true, message: 'Empty command' } as any;
         }
-        
-        const cmdTrimmed = args.command.trim();
-        if (cmdTrimmed.length === 0) {
-          return {
-            content: [{
-              type: 'text',
-              text: 'Empty command ignored'
-            }],
-            isError: false,
-            success: true,
-            message: 'Empty command'
-          };
+        // Basic safety filter
+        const cmd = String(args.command).trim();
+        const blocked = [/\bquit\b/i, /\bexit\b/i, /debugcrash/i];
+        if (blocked.some(r => r.test(cmd))) {
+          return { success: false, error: 'Command blocked for safety' } as any;
+        }
+        try {
+          const res = await tools.bridge.executeConsoleCommand(cmd);
+          return cleanObject({ success: true, command: cmd, result: res });
+        } catch (e: any) {
+          return cleanObject({ success: false, command: cmd, error: e?.message || String(e) });
         }
         
-        mappedName = 'console_command';
-        mappedArgs = args;
-        break;
 
       // 11. REMOTE CONTROL PRESETS - Direct implementation
       case 'manage_rc':
@@ -1035,42 +621,27 @@ export async function handleConsolidatedToolCall(
         // Clean to prevent circular references
         return cleanObject(seqResult);
       // 13. INTROSPECTION
-      case 'inspect':
+case 'inspect':
         if (!args.action) throw new Error('Missing required parameter: action');
         switch (args.action) {
-          case 'inspect_object':
-            mappedName = 'inspect_object';
-            mappedArgs = { objectPath: args.objectPath };
-            break;
-          case 'set_property':
-            mappedName = 'inspect_set_property';
-            mappedArgs = { objectPath: args.objectPath, propertyName: args.propertyName, value: args.value };
-            break;
+          case 'inspect_object': {
+            const res = await tools.introspectionTools.inspectObject({ objectPath: args.objectPath, detailed: args.detailed });
+            return cleanObject(res);
+          }
+          case 'set_property': {
+            const res = await tools.introspectionTools.setProperty({ objectPath: args.objectPath, propertyName: args.propertyName, value: args.value });
+            return cleanObject(res);
+          }
           default:
             throw new Error(`Unknown inspect action: ${args.action}`);
         }
-        break;
+        
 
       default:
         throw new Error(`Unknown consolidated tool: ${name}`);
     }
 
-    // Call the original handler with mapped name and args with timeout
-    const TOOL_TIMEOUT = 15000; // 15 seconds timeout for tool execution
-    
-    const toolPromise = handleToolCall(mappedName, mappedArgs, tools);
-    const timeoutPromise = new Promise<never>((_, reject) => {
-      setTimeout(() => {
-        reject(new Error(`Tool execution timeout after ${TOOL_TIMEOUT}ms`));
-      }, TOOL_TIMEOUT);
-    });
-    
-    const result = await Promise.race([toolPromise, timeoutPromise]);
-    const duration = Date.now() - startTime;
-    console.log(`[ConsolidatedToolHandler] Completed execution of ${name} in ${duration}ms`);
-    
-    // Clean the result to prevent circular reference errors
-    return cleanObject(result);
+// All cases return (or throw) above; this is a type guard for exhaustiveness.
 
   } catch (err: any) {
     const duration = Date.now() - startTime;