unreal-engine-mcp-server 0.4.6 → 0.5.0

package/src/tools/handlers/editor-handlers.ts

@@ -0,0 +1,123 @@
+import { cleanObject } from '../../utils/safe-json.js';
+import { ITools } from '../../types/tool-interfaces.js';
+import { executeAutomationRequest, requireNonEmptyString } from './common-handlers.js';
+
+export async function handleEditorTools(action: string, args: any, tools: ITools) {
+  switch (action) {
+    case 'play': {
+      const res = await tools.editorTools.playInEditor(args.timeoutMs);
+      return cleanObject(res);
+    }
+    case 'stop':
+    case 'stop_pie': {
+      const res = await tools.editorTools.stopPlayInEditor();
+      return cleanObject(res);
+    }
+    case 'eject': {
+      const inPie = await tools.editorTools.isInPIE();
+      if (!inPie) {
+        return { success: false, error: 'NOT_IN_PIE', message: 'Cannot eject while not in PIE' };
+      }
+      return await executeAutomationRequest(tools, 'control_editor', { action: 'eject' });
+    }
+    case 'possess': {
+      const inPie = await tools.editorTools.isInPIE();
+      if (!inPie) {
+        return { success: false, error: 'NOT_IN_PIE', message: 'Cannot possess actor while not in PIE' };
+      }
+      return await executeAutomationRequest(tools, 'control_editor', args);
+    }
+    case 'pause': {
+      const res = await tools.editorTools.pausePlayInEditor();
+      return cleanObject(res);
+    }
+    case 'resume': {
+      const res = await tools.editorTools.resumePlayInEditor();
+      return cleanObject(res);
+    }
+    case 'screenshot': {
+      const res = await tools.editorTools.takeScreenshot(args.filename, args.resolution);
+      return cleanObject(res);
+    }
+    case 'console_command': {
+      const res = await tools.editorTools.executeConsoleCommand(args.command);
+      return cleanObject(res);
+    }
+    case 'set_camera': {
+      const res = await tools.editorTools.setViewportCamera(args.location, args.rotation);
+      return cleanObject(res);
+    }
+    case 'start_recording': {
+      // Use console command as fallback if bridge doesn't support it
+      const filename = args.filename || 'TestRecording';
+      await tools.editorTools.executeConsoleCommand(`DemoRec ${filename}`);
+      return { success: true, message: `Started recording to ${filename}`, action: 'start_recording' };
+    }
+    case 'stop_recording': {
+      await tools.editorTools.executeConsoleCommand('DemoStop');
+      return { success: true, message: 'Stopped recording', action: 'stop_recording' };
+    }
+    case 'step_frame': {
+      // Use console command for single frame advance
+      await tools.editorTools.executeConsoleCommand('r.SingleFrameAdvance 1');
+      return { success: true, message: 'Stepped frame', action: 'step_frame' };
+    }
+    case 'create_bookmark': {
+      const idx = parseInt(args.bookmarkName) || 0;
+      await tools.editorTools.executeConsoleCommand(`r.SetBookmark ${idx}`);
+      return { success: true, message: `Created bookmark ${idx}`, action: 'create_bookmark' };
+    }
+    case 'jump_to_bookmark': {
+      const idx = parseInt(args.bookmarkName) || 0;
+      await tools.editorTools.executeConsoleCommand(`r.JumpToBookmark ${idx}`);
+      return { success: true, message: `Jumped to bookmark ${idx}`, action: 'jump_to_bookmark' };
+    }
+    case 'set_preferences': {
+      const res = await tools.editorTools.setEditorPreferences(args.category, args.preferences);
+      return cleanObject(res);
+    }
+    case 'open_asset': {
+      const assetPath = requireNonEmptyString(args.assetPath || args.path, 'assetPath');
+      const res = await executeAutomationRequest(tools, 'control_editor', { action: 'open_asset', assetPath });
+      return cleanObject(res);
+    }
+    case 'execute_command': {
+      const command = requireNonEmptyString(args.command, 'command');
+      const res = await tools.editorTools.executeConsoleCommand(command);
+      return { ...cleanObject(res), action: 'execute_command' };
+    }
+    case 'set_camera_fov': {
+      await tools.editorTools.executeConsoleCommand(`fov ${args.fov}`);
+      return { success: true, message: `Set FOV to ${args.fov}`, action: 'set_camera_fov' };
+    }
+    case 'set_game_speed': {
+      await tools.editorTools.executeConsoleCommand(`slomo ${args.speed}`);
+      return { success: true, message: `Set game speed to ${args.speed}`, action: 'set_game_speed' };
+    }
+    case 'set_view_mode': {
+      const viewMode = requireNonEmptyString(args.viewMode, 'viewMode');
+      const validModes = [
+        'Lit', 'Unlit', 'Wireframe', 'DetailLighting', 'LightingOnly', 'Reflections',
+        'OptimizationViewmodes', 'ShaderComplexity', 'LightmapDensity', 'StationaryLightOverlap', 'LightComplexity',
+        'PathTracing', 'Visualizer', 'LODColoration', 'CollisionPawn', 'CollisionVisibility'
+      ];
+      if (!validModes.includes(viewMode)) {
+        throw new Error(`unknown_viewmode: ${viewMode}. Must be one of: ${validModes.join(', ')}`);
+      }
+      await tools.editorTools.executeConsoleCommand(`viewmode ${viewMode}`);
+      return { success: true, message: `Set view mode to ${viewMode}`, action: 'set_view_mode' };
+    }
+    case 'set_viewport_resolution': {
+      await tools.editorTools.executeConsoleCommand(`r.SetRes ${args.width}x${args.height}`);
+      return { success: true, message: `Set viewport resolution to ${args.width}x${args.height}`, action: 'set_viewport_resolution' };
+    }
+    case 'set_viewport_realtime': {
+      const enabled = args.enabled !== undefined ? args.enabled : (args.realtime !== false);
+      // Use console command since interface doesn't have setViewportRealtime
+      await tools.editorTools.executeConsoleCommand(`r.ViewportRealtime ${enabled ? 1 : 0}`);
+      return { success: true, message: `Set viewport realtime to ${enabled}`, action: 'set_viewport_realtime' };
+    }
+    default:
+      return await executeAutomationRequest(tools, 'control_editor', args);
+  }
+}

package/src/tools/handlers/effect-handlers.ts

@@ -0,0 +1,220 @@
+import { cleanObject } from '../../utils/safe-json.js';
+import { ITools } from '../../types/tool-interfaces.js';
+import { executeAutomationRequest, requireNonEmptyString } from './common-handlers.js';
+
+function ensureActionAndSubAction(action: string, args: any) {
+  if (!args || typeof args !== 'object') return;
+  // Many callers pass the tool action as the action name (e.g. "niagara") and
+  // omit args.action; the native handler requires subAction.
+  if (!args.action) {
+    args.action = action;
+  }
+  if (!args.subAction) {
+    args.subAction = args.action;
+  }
+}
+
+function isNonEmptyString(val: unknown): val is string {
+  return typeof val === 'string' && val.trim().length > 0;
+}
+
+export async function handleEffectTools(action: string, args: any, tools: ITools) {
+  if (!args || typeof args !== 'object') {
+    args = {};
+  }
+
+  // Always ensure action/subAction are present before any routing.
+  ensureActionAndSubAction(action, args);
+
+  // Handle creation actions explicitly to use NiagaraTools helper
+  if (action === 'create_niagara_system') {
+    const res = await tools.niagaraTools.createSystem({
+      name: args.name,
+      savePath: args.savePath,
+      template: args.template
+    });
+    return cleanObject(res);
+  }
+  if (action === 'create_niagara_emitter') {
+    const res = await tools.niagaraTools.createEmitter({
+      name: args.name,
+      savePath: args.savePath,
+      systemPath: args.systemPath,
+      template: args.template
+    });
+    return cleanObject(res);
+  }
+
+  // Pre-process arguments for particle presets
+  if (args.action === 'particle') {
+    const presets: Record<string, string> = {
+      'Default': '/StarterContent/Particles/P_Steam_Lit.P_Steam_Lit',
+      'Smoke': '/StarterContent/Particles/P_Smoke.P_Smoke',
+      'Fire': '/StarterContent/Particles/P_Fire.P_Fire',
+      'Explosion': '/StarterContent/Particles/P_Explosion.P_Explosion',
+    };
+    // Check both preset and effectType fields
+    const key = args.preset || args.effectType;
+    if (key && presets[key]) {
+      args.preset = presets[key];
+    }
+  }
+
+  // Handle debug shapes (must happen before any automation request)
+  if (action === 'debug_shape' || args.action === 'debug_shape') {
+    // Map 'shape' to 'shapeType' if provided (schema uses 'shape', C++ uses 'shapeType')
+    if (args.shape && !args.shapeType) {
+      args.shapeType = args.shape;
+    }
+    requireNonEmptyString(args.shapeType, 'shapeType', 'Missing required parameter: shapeType');
+    args.action = 'debug_shape';
+    args.subAction = 'debug_shape';
+    return cleanObject(await executeAutomationRequest(tools, 'create_effect', args));
+  }
+
+  // Validate Niagara-related required parameters (keep errors explicit and early)
+  const subAction = String(args.subAction || '').trim();
+  if (subAction === 'niagara' || subAction === 'spawn_niagara') {
+    requireNonEmptyString(args.systemPath, 'systemPath', 'Missing required parameter: systemPath');
+  }
+
+  if (subAction === 'activate_niagara' || subAction === 'deactivate_niagara' || subAction === 'advance_simulation') {
+    const systemName = args.systemName ?? args.actorName;
+    requireNonEmptyString(systemName, 'systemName', 'Missing required parameter: systemName (or actorName)');
+    args.systemName = systemName;
+  }
+
+  if (subAction === 'set_niagara_parameter') {
+    const systemName = args.systemName ?? args.actorName;
+    requireNonEmptyString(systemName, 'systemName', 'Missing required parameter: systemName (or actorName)');
+    requireNonEmptyString(args.parameterName, 'parameterName', 'Missing required parameter: parameterName');
+    // parameterType is required for unambiguous native conversion; accept common aliases.
+    if (!isNonEmptyString(args.parameterType) && isNonEmptyString(args.type)) {
+      args.parameterType = args.type.charAt(0).toUpperCase() + args.type.slice(1);
+    }
+    requireNonEmptyString(args.parameterType, 'parameterType', 'Missing required parameter: parameterType');
+    args.systemName = systemName;
+  }
+
+  // Handle debug cleanup actions
+  if (action === 'clear_debug_shapes') {
+    return executeAutomationRequest(tools, action, args);
+  }
+  if (action === 'cleanup') {
+    args.action = 'cleanup';
+    args.subAction = 'cleanup';
+    return executeAutomationRequest(tools, 'create_effect', args);
+  }
+
+  // Map high-level actions to create_effect with subAction
+  const createActions = [
+    'create_volumetric_fog',
+    'create_particle_trail',
+    'create_environment_effect',
+    'create_impact_effect',
+    'create_niagara_ribbon'
+  ];
+  if (createActions.includes(action)) {
+    args.action = action;
+    return executeAutomationRequest(tools, 'create_effect', args);
+  }
+
+  // Map simulation control actions
+  if (action === 'activate' || action === 'activate_effect') {
+    args.action = 'activate_niagara';
+    args.systemName = args.actorName || args.systemName;
+    requireNonEmptyString(args.systemName, 'systemName', 'Missing required parameter: systemName (or actorName)');
+    args.reset = true;
+    return executeAutomationRequest(tools, 'create_effect', args);
+  }
+  if (action === 'deactivate') {
+    args.action = 'deactivate_niagara';
+    args.systemName = args.actorName || args.systemName;
+    requireNonEmptyString(args.systemName, 'systemName', 'Missing required parameter: systemName (or actorName)');
+    return executeAutomationRequest(tools, 'create_effect', args);
+  }
+  if (action === 'reset') {
+    args.action = 'activate_niagara';
+    args.systemName = args.actorName || args.systemName;
+    requireNonEmptyString(args.systemName, 'systemName', 'Missing required parameter: systemName (or actorName)');
+    args.reset = true;
+    return executeAutomationRequest(tools, 'create_effect', args);
+  }
+  if (action === 'advance_simulation') {
+    args.action = 'advance_simulation';
+    args.systemName = args.actorName || args.systemName;
+    requireNonEmptyString(args.systemName, 'systemName', 'Missing required parameter: systemName (or actorName)');
+    return executeAutomationRequest(tools, 'create_effect', args);
+  }
+
+  // Map parameter setting
+  if (action === 'set_niagara_parameter') {
+    args.action = 'set_niagara_parameter';
+    // If actorName is provided, use it as systemName (which C++ expects for actor label)
+    if (args.actorName && !args.systemName) {
+      args.systemName = args.actorName;
+    }
+    // Map 'type' to 'parameterType' if provided and parameterType is missing
+    if (args.type && !args.parameterType) {
+      args.parameterType = args.type.charAt(0).toUpperCase() + args.type.slice(1);
+    }
+    requireNonEmptyString(args.systemName, 'systemName', 'Missing required parameter: systemName (or actorName)');
+    requireNonEmptyString(args.parameterName, 'parameterName', 'Missing required parameter: parameterName');
+    requireNonEmptyString(args.parameterType, 'parameterType', 'Missing required parameter: parameterType');
+    return executeAutomationRequest(tools, 'create_effect', args);
+  }
+
+  const res: any = await executeAutomationRequest(
+    tools,
+    'create_effect',
+    args,
+    'Automation bridge not available for effect creation operations'
+  );
+
+  const result = res?.result ?? res ?? {};
+  const topError = typeof res?.error === 'string' ? res.error : '';
+  const nestedError = typeof result.error === 'string' ? result.error : '';
+  const errorCode = (topError || nestedError).toUpperCase();
+
+  const topMessage = typeof res?.message === 'string' ? res.message : '';
+  const nestedMessage = typeof result.message === 'string' ? result.message : '';
+  const message = topMessage || nestedMessage || '';
+
+  const combined = `${topError} ${nestedError} ${message}`.toLowerCase();
+
+  if (
+    action === 'niagara' &&
+    (
+      errorCode === 'SYSTEM_NOT_FOUND' ||
+      combined.includes('niagara system not found') ||
+      combined.includes('system asset not found')
+    )
+  ) {
+    return cleanObject({
+      success: false,
+      error: 'SYSTEM_NOT_FOUND',
+      message: message || 'Niagara system not found',
+      systemPath: args.systemPath,
+      handled: true
+    });
+  }
+
+  // If we got here and it was a spawn_niagara failure, maybe try to be helpful about paths
+  if (action === 'spawn_niagara' && errorCode === 'SYSTEM_NOT_FOUND' && args.systemPath) {
+    // Check if path ends in .Name
+    const path = args.systemPath;
+    const name = path.split('/').pop();
+    if (name && !path.endsWith(`.${name}`)) {
+      // Retry with corrected path?
+      // We can't easily retry here without recursion, but we can hint in the message.
+      return cleanObject({
+        success: false,
+        error: 'SYSTEM_NOT_FOUND',
+        message: `Niagara System not found at ${path}. Did you mean ${path}.${name}?`,
+        systemPath: path
+      });
+    }
+  }
+
+  return cleanObject(res);
+}

package/src/tools/handlers/environment-handlers.ts

@@ -0,0 +1,183 @@
+import { cleanObject } from '../../utils/safe-json.js';
+import { ITools } from '../../types/tool-interfaces.js';
+import { executeAutomationRequest } from './common-handlers.js';
+
+export async function handleEnvironmentTools(action: string, args: any, tools: ITools) {
+  const envAction = String(action || '').toLowerCase();
+  switch (envAction) {
+    case 'create_landscape':
+      return cleanObject(await tools.landscapeTools.createLandscape({
+        name: args.name,
+        location: args.location,
+        sizeX: args.sizeX,
+        sizeY: args.sizeY,
+        quadsPerSection: args.quadsPerSection,
+        sectionsPerComponent: args.sectionsPerComponent,
+        componentCount: args.componentCount,
+        materialPath: args.materialPath,
+        enableWorldPartition: args.enableWorldPartition,
+        runtimeGrid: args.runtimeGrid,
+        isSpatiallyLoaded: args.isSpatiallyLoaded,
+        dataLayers: args.dataLayers
+      }));
+    case 'modify_heightmap':
+      return cleanObject(await tools.landscapeTools.modifyHeightmap({
+        landscapeName: args.landscapeName || args.name,
+        heightData: args.heightData,
+        minX: args.minX,
+        minY: args.minY,
+        maxX: args.maxX,
+        maxY: args.maxY,
+        updateNormals: args.updateNormals
+      }));
+    case 'sculpt':
+    case 'sculpt_landscape': {
+      // Default to 'Raise' tool if not specified
+      const tool = args.tool || 'Raise';
+      return cleanObject(await tools.landscapeTools.sculptLandscape({
+        landscapeName: args.landscapeName || args.name,
+        tool,
+        location: args.location,
+        radius: args.radius || 500,
+        strength: args.strength || 0.5
+      }));
+    }
+    case 'add_foliage': {
+      // Check if this is adding a foliage TYPE (has meshPath) or INSTANCES (has locations/position)
+      if (args.meshPath) {
+        // Derive a better default name from mesh path if not provided
+        const defaultName = args.meshPath.split('/').pop()?.split('.')[0] + '_Foliage_Type';
+        return cleanObject(await tools.foliageTools.addFoliageType({
+          name: args.foliageType || args.name || defaultName,
+          meshPath: args.meshPath,
+          density: args.density
+        }));
+      } else {
+        // Validate foliageType is provided
+        const foliageType = args.foliageType || args.foliageTypePath;
+        if (!foliageType) {
+          return cleanObject({
+            success: false,
+            error: 'INVALID_ARGUMENT',
+            message: 'add_foliage requires either: (1) meshPath to create a new foliage type, or (2) foliageType/foliageTypePath to place instances of an existing type. Example foliage assets: /Game/StarterContent/Props/SM_Bush, /Engine/BasicShapes/Sphere'
+          });
+        }
+
+        // Support location+radius to generate locations if explicit array not provided
+        let locations = args.locations;
+        if (!locations && args.location && args.radius) {
+          // Generate locations around the center point within radius
+          const center = args.location;
+          const radius = args.radius || 500;
+          const count = args.density || args.count || 10;
+          locations = [];
+          for (let i = 0; i < count; i++) {
+            const angle = Math.random() * Math.PI * 2;
+            const dist = Math.random() * radius;
+            locations.push({
+              x: (center.x || 0) + Math.cos(angle) * dist,
+              y: (center.y || 0) + Math.sin(angle) * dist,
+              z: center.z || 0
+            });
+          }
+        } else if (!locations && args.position) {
+          locations = [args.position];
+        }
+
+        // Validate we have locations to place
+        if (!locations || locations.length === 0) {
+          return cleanObject({
+            success: false,
+            error: 'INVALID_ARGUMENT',
+            message: 'add_foliage requires locations to place foliage instances. Provide: locations array, or location+radius, or position'
+          });
+        }
+
+        return cleanObject(await tools.foliageTools.addFoliage({
+          foliageType,
+          locations
+        }));
+      }
+    }
+
+    case 'add_foliage_instances':
+      return cleanObject(await tools.foliageTools.addFoliageInstances({
+        foliageType: args.foliageType || args.foliageTypePath || args.meshPath,
+        transforms: args.transforms || (args.locations ? args.locations.map((l: any) => ({ location: [l.x, l.y, l.z] })) : [])
+      }));
+    case 'paint_foliage':
+      return cleanObject(await tools.foliageTools.paintFoliage({
+        foliageType: args.foliageType || args.foliageTypePath,
+        position: args.position || args.location, // Handle both
+        brushSize: args.brushSize || args.radius,
+        paintDensity: args.density || args.strength, // Map strength/density
+        eraseMode: args.eraseMode
+      }));
+    case 'create_procedural_terrain':
+      return cleanObject(await tools.landscapeTools.createProceduralTerrain({
+        name: args.name,
+        location: args.location,
+        subdivisions: args.subdivisions,
+        settings: args.settings
+      }));
+    case 'create_procedural_foliage':
+      return cleanObject(await tools.foliageTools.createProceduralFoliage({
+        name: args.name,
+        foliageTypes: args.foliageTypes,
+        volumeName: args.volumeName,
+        bounds: args.bounds,
+        seed: args.seed,
+        tileSize: args.tileSize
+      }));
+
+    case 'bake_lightmap':
+      return cleanObject(await tools.lightingTools.buildLighting({
+        quality: (args.quality as any) || 'Preview',
+        buildOnlySelected: false,
+        buildReflectionCaptures: false
+      }));
+    case 'create_landscape_grass_type':
+      return cleanObject(await tools.landscapeTools.createLandscapeGrassType({
+        name: args.name,
+        // Prefer explicit meshPath used by tests, fall back to path/staticMesh for
+        // compatibility with older callers.
+        meshPath: args.meshPath || args.path || args.staticMesh,
+        path: args.path,
+        staticMesh: args.staticMesh
+      }));
+    case 'export_snapshot':
+      return cleanObject(await tools.environmentTools.exportSnapshot({
+        path: args.path,
+        filename: args.filename
+      }));
+    case 'import_snapshot':
+      return cleanObject(await tools.environmentTools.importSnapshot({
+        path: args.path,
+        filename: args.filename
+      }));
+    case 'set_landscape_material':
+      return cleanObject(await tools.landscapeTools.setLandscapeMaterial({
+        landscapeName: args.landscapeName || args.name,
+        materialPath: args.materialPath
+      }));
+    case 'generate_lods':
+      return cleanObject(await executeAutomationRequest(tools, 'build_environment', {
+        action: 'generate_lods',
+        assetPaths: args.assetPaths || args.assets || (args.path ? [args.path] : []),
+        numLODs: args.numLODs
+      }, 'Bridge unavailable'));
+    case 'delete': {
+      const names = Array.isArray(args.names)
+        ? args.names
+        : (Array.isArray(args.actors) ? args.actors : []);
+      if (args.name) {
+        names.push(args.name);
+      }
+      const res = await tools.environmentTools.cleanup({ names });
+      return cleanObject(res);
+    }
+    default:
+      const res = await executeAutomationRequest(tools, 'build_environment', args, 'Automation bridge not available for environment building operations');
+      return cleanObject(res);
+  }
+}

package/src/tools/handlers/graph-handlers.ts

@@ -0,0 +1,116 @@
+import { cleanObject } from '../../utils/safe-json.js';
+import { ITools } from '../../types/tool-interfaces.js';
+import { executeAutomationRequest } from './common-handlers.js';
+
+export async function handleGraphTools(toolName: string, action: string, args: any, tools: ITools) {
+    // Common validation
+    if (!args.assetPath && !args.blueprintPath && !args.systemPath) {
+        // Some actions might not need a path if they operate on "currently open" asset, 
+        // but generally we want an asset path.
+    }
+
+    // Dispatch based on tool name
+    switch (toolName) {
+        case 'manage_blueprint_graph':
+            return handleBlueprintGraph(action, args, tools);
+        case 'manage_niagara_graph':
+            return handleNiagaraGraph(action, args, tools);
+        case 'manage_material_graph':
+            return handleMaterialGraph(action, args, tools);
+        case 'manage_behavior_tree':
+            return handleBehaviorTree(action, args, tools);
+        default:
+            return { success: false, error: 'UNKNOWN_TOOL', message: `Unknown graph tool: ${toolName}` };
+    }
+}
+
+async function handleBlueprintGraph(action: string, args: any, tools: ITools) {
+    const processedArgs = { ...args, subAction: action };
+
+    // Default graphName
+    if (!processedArgs.graphName) {
+        processedArgs.graphName = 'EventGraph';
+    }
+
+    // Fix Issue 1: Map FunctionCall to CallFunction
+    if (processedArgs.nodeType === 'FunctionCall') {
+        processedArgs.nodeType = 'CallFunction';
+    }
+
+    // Fix Issue 2 & 3: Map memberName to specific names based on nodeType
+    if (processedArgs.memberName) {
+        if (processedArgs.nodeType === 'VariableGet' || processedArgs.nodeType === 'VariableSet') {
+            if (!processedArgs.variableName) processedArgs.variableName = processedArgs.memberName;
+        } else if (processedArgs.nodeType === 'Event' || processedArgs.nodeType === 'CustomEvent' || (processedArgs.nodeType && processedArgs.nodeType.startsWith('K2Node_Event'))) {
+            if (!processedArgs.eventName) processedArgs.eventName = processedArgs.memberName;
+            // CustomEvent uses eventName (mapped to CustomFunctionName) or customEventName in some contexts, 
+            // but C++ CustomEvent handler uses 'eventName' payload field.
+        } else if (processedArgs.nodeType === 'CallFunction' || processedArgs.nodeType === 'K2Node_CallFunction') {
+            // C++ uses 'memberName' for CallFunction, so this is fine.
+        }
+    }
+
+    // Fix Issue 5: Map memberClass/componentClass to targetClass for Cast nodes
+    if ((processedArgs.memberClass || processedArgs.componentClass) &&
+        (processedArgs.nodeType === 'Cast' || (processedArgs.nodeType && processedArgs.nodeType.startsWith('CastTo')))) {
+        if (!processedArgs.targetClass) processedArgs.targetClass = processedArgs.memberClass || processedArgs.componentClass;
+    }
+
+    // Fix Issue 6: Support connect_pins parameter mapping
+    // Input: nodeId, pinName, linkedTo (TargetNode.Pin)
+    if (action === 'connect_pins') {
+        // Map source
+        if (!processedArgs.fromNodeId && processedArgs.nodeId) {
+            processedArgs.fromNodeId = processedArgs.nodeId;
+        }
+        if (!processedArgs.fromPinName && processedArgs.pinName) {
+            processedArgs.fromPinName = processedArgs.pinName;
+        }
+
+        // Map target from linkedTo
+        if (!processedArgs.toNodeId && processedArgs.linkedTo) {
+            if (processedArgs.linkedTo.includes('.')) {
+                const parts = processedArgs.linkedTo.split('.');
+                processedArgs.toNodeId = parts[0];
+                processedArgs.toPinName = parts.slice(1).join('.');
+            }
+        }
+    }
+
+    // Support Node.Pin format for connect_pins (existing logic preserved/enhanced)
+    if (action === 'connect_pins') {
+        if (processedArgs.fromNodeId && processedArgs.fromNodeId.includes('.') && !processedArgs.fromPinName) {
+            const parts = processedArgs.fromNodeId.split('.');
+            processedArgs.fromNodeId = parts[0];
+            processedArgs.fromPinName = parts.slice(1).join('.');
+        }
+        if (processedArgs.toNodeId && processedArgs.toNodeId.includes('.') && !processedArgs.toPinName) {
+            const parts = processedArgs.toNodeId.split('.');
+            processedArgs.toNodeId = parts[0];
+            processedArgs.toPinName = parts.slice(1).join('.');
+        }
+    }
+
+    const res: any = await executeAutomationRequest(tools, 'manage_blueprint_graph', processedArgs, 'Automation bridge not available');
+    return cleanObject({ ...res, ...(res.result || {}) });
+}
+
+async function handleNiagaraGraph(action: string, args: any, tools: ITools) {
+    const payload = { ...args, subAction: action };
+    // Map systemPath to assetPath if missing
+    if (payload.systemPath && !payload.assetPath) {
+        payload.assetPath = payload.systemPath;
+    }
+    const res: any = await executeAutomationRequest(tools, 'manage_niagara_graph', payload, 'Automation bridge not available');
+    return cleanObject({ ...res, ...(res.result || {}) });
+}
+
+async function handleMaterialGraph(action: string, args: any, tools: ITools) {
+    const res: any = await executeAutomationRequest(tools, 'manage_material_graph', { ...args, subAction: action }, 'Automation bridge not available');
+    return cleanObject({ ...res, ...(res.result || {}) });
+}
+
+async function handleBehaviorTree(action: string, args: any, tools: ITools) {
+    const res: any = await executeAutomationRequest(tools, 'manage_behavior_tree', { ...args, subAction: action }, 'Automation bridge not available');
+    return cleanObject({ ...res, ...(res.result || {}) });
+}

package/src/tools/handlers/input-handlers.ts

@@ -0,0 +1,28 @@
+import { ITools } from '../../types/tool-interfaces.js';
+import { cleanObject } from '../../utils/safe-json.js';
+import { ResponseFactory } from '../../utils/response-factory.js';
+import { InputTools } from '../input.js';
+
+export async function handleInputTools(
+    action: string,
+    args: any,
+    tools: ITools
+) {
+    const inputTools = tools.inputTools as InputTools;
+    if (!inputTools) {
+        return ResponseFactory.error('Input tools not available');
+    }
+
+    switch (action) {
+        case 'create_input_action':
+            return cleanObject(await inputTools.createInputAction(args.name, args.path));
+        case 'create_input_mapping_context':
+            return cleanObject(await inputTools.createInputMappingContext(args.name, args.path));
+        case 'add_mapping':
+            return cleanObject(await inputTools.addMapping(args.contextPath, args.actionPath, args.key));
+        case 'remove_mapping':
+            return cleanObject(await inputTools.removeMapping(args.contextPath, args.actionPath));
+        default:
+            return ResponseFactory.error(`Unknown input action: ${action}`);
+    }
+}