unreal-engine-mcp-server 0.5.4 → 0.5.5

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

@@ -1,124 +0,0 @@
-import { cleanObject } from '../../utils/safe-json.js';
-import { ITools } from '../../types/tool-interfaces.js';
-import type { EditorArgs } from '../../types/handler-types.js';
-import { executeAutomationRequest, requireNonEmptyString } from './common-handlers.js';
-
-export async function handleEditorTools(action: string, args: EditorArgs, 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) {
-        throw new Error('Cannot eject while not in PIE');
-      }
-      return await executeAutomationRequest(tools, 'control_editor', { action: 'eject' });
-    }
-    case 'possess': {
-      const inPie = await tools.editorTools.isInPIE();
-      if (!inPie) {
-        throw new Error('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') || 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') || 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

@@ -1,224 +0,0 @@
-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);
-  }
-  // Discovery action: list available debug shape types
-  if (action === 'list_debug_shapes') {
-    return executeAutomationRequest(tools, 'list_debug_shapes', 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

@@ -1,183 +0,0 @@
-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

@@ -1,117 +0,0 @@
-import { cleanObject } from '../../utils/safe-json.js';
-import { ITools } from '../../types/tool-interfaces.js';
-import type { GraphArgs } from '../../types/handler-types.js';
-import { executeAutomationRequest } from './common-handlers.js';
-
-export async function handleGraphTools(toolName: string, action: string, args: GraphArgs, 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:
-            throw new Error(`Unknown graph tool: ${toolName}`);
-    }
-}
-
-async function handleBlueprintGraph(action: string, args: GraphArgs, 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: GraphArgs, 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: GraphArgs, 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: GraphArgs, 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

@@ -1,28 +0,0 @@
-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}`);
-    }
-}