unreal-engine-mcp-server 0.5.2 → 0.5.4

package/dist/tools/handlers/actor-handlers.js

@@ -1,43 +1,20 @@
 import { executeAutomationRequest } from './common-handlers.js';
 import { normalizeArgs } from './argument-helper.js';
 import { ResponseFactory } from '../../utils/response-factory.js';
+import { ACTOR_CLASS_ALIASES, getRequiredComponent } from '../../config/class-aliases.js';
 const handlers = {
     spawn: async (args, tools) => {
-        const classAliases = {
-            'SplineActor': '/Script/Engine.Actor',
-            'Spline': '/Script/Engine.Actor',
-            'PointLight': '/Script/Engine.PointLight',
-            'SpotLight': '/Script/Engine.SpotLight',
-            'DirectionalLight': '/Script/Engine.DirectionalLight',
-            'Camera': '/Script/Engine.CameraActor',
-            'CameraActor': '/Script/Engine.CameraActor',
-            'StaticMeshActor': '/Script/Engine.StaticMeshActor',
-            'SkeletalMeshActor': '/Script/Engine.SkeletalMeshActor',
-            'PlayerStart': '/Script/Engine.PlayerStart',
-            'TriggerBox': '/Script/Engine.TriggerBox',
-            'TriggerSphere': '/Script/Engine.TriggerSphere',
-            'BlockingVolume': '/Script/Engine.BlockingVolume',
-            'Pawn': '/Script/Engine.Pawn',
-            'Character': '/Script/Engine.Character',
-            'Actor': '/Script/Engine.Actor'
-        };
         const params = normalizeArgs(args, [
-            { key: 'classPath', aliases: ['class', 'type', 'actorClass'], required: true, map: classAliases },
+            { key: 'classPath', aliases: ['class', 'type', 'actorClass'], required: true, map: ACTOR_CLASS_ALIASES },
             { key: 'actorName', aliases: ['name'] },
             { key: 'timeoutMs', default: undefined }
         ]);
         const timeoutMs = typeof params.timeoutMs === 'number' ? params.timeoutMs : undefined;
         if (typeof timeoutMs === 'number' && timeoutMs > 0 && timeoutMs < 200) {
-            return {
-                success: false,
-                error: `Timeout too small for spawn operation: ${timeoutMs}ms`,
-                message: 'Timeout too small for spawn operation'
-            };
+            throw new Error(`Timeout too small for spawn operation: ${timeoutMs}ms`);
         }
         const originalClass = args.classPath || args.class || args.type || args.actorClass;
-        const componentToAdd = (originalClass === 'SplineActor' || originalClass === 'Spline')
-            ? 'SplineComponent'
-            : undefined;
+        const componentToAdd = getRequiredComponent(originalClass);
         const result = await tools.actorTools.spawn({
             classPath: params.classPath,
             actorName: params.actorName,

package/dist/tools/handlers/asset-handlers.js

@@ -168,7 +168,19 @@ export async function handleAssetTools(action, args, tools) {
                 if (paths.length === 0) {
                     throw new Error('No paths provided for delete action');
                 }
-                const res = await tools.assetTools.deleteAssets({ paths });
+                const normalizedPaths = paths.map(p => {
+                    let normalized = p.replace(/\\/g, '/').trim();
+                    const lastSlash = normalized.lastIndexOf('/');
+                    if (lastSlash >= 0) {
+                        const afterSlash = normalized.substring(lastSlash + 1);
+                        const dotIndex = afterSlash.indexOf('.');
+                        if (dotIndex > 0) {
+                            normalized = normalized.substring(0, lastSlash + 1 + dotIndex);
+                        }
+                    }
+                    return normalized;
+                });
+                const res = await tools.assetTools.deleteAssets({ paths: normalizedPaths });
                 return ResponseFactory.success(res, 'Assets deleted successfully');
             }
             case 'generate_lods': {

package/dist/tools/handlers/blueprint-handlers.d.ts

@@ -1,4 +1,7 @@
 import { ITools } from '../../types/tool-interfaces.js';
 export declare function handleBlueprintTools(action: string, args: any, tools: ITools): Promise<any>;
-export declare function handleBlueprintGet(args: any, tools: ITools): Promise<any>;
+export declare function handleBlueprintGet(args: any, tools: ITools): Promise<{
+    success?: boolean;
+    message?: string;
+} | null>;
 //# sourceMappingURL=blueprint-handlers.d.ts.map

package/dist/tools/handlers/common-handlers.d.ts

@@ -1,14 +1,14 @@
 import { ITools } from '../../types/tool-interfaces.js';
-export declare function ensureArgsPresent(args: any): void;
-export declare function requireAction(args: any): string;
-export declare function requireNonEmptyString(value: any, field: string, message?: string): string;
-export declare function executeAutomationRequest(tools: ITools, toolName: string, args: any, errorMessage?: string, options?: {
+import type { HandlerArgs, Vector3, Rotator } from '../../types/handler-types.js';
+export declare function ensureArgsPresent(args: unknown): asserts args is Record<string, unknown>;
+export declare function requireAction(args: HandlerArgs): string;
+export declare function requireNonEmptyString(value: unknown, field: string, message?: string): string;
+export declare function executeAutomationRequest(tools: ITools, toolName: string, args: HandlerArgs, errorMessage?: string, options?: {
     timeoutMs?: number;
-}): Promise<import("../../automation/types.js").AutomationBridgeResponseMessage>;
-export declare function normalizeLocation(location: any): [number, number, number] | undefined;
-export declare function normalizeRotation(rotation: any): {
-    pitch: number;
-    yaw: number;
-    roll: number;
-} | undefined;
+}): Promise<unknown>;
+type LocationInput = Vector3 | [number, number, number] | number[] | null | undefined;
+export declare function normalizeLocation(location: LocationInput): [number, number, number] | undefined;
+type RotationInput = Rotator | [number, number, number] | number[] | null | undefined;
+export declare function normalizeRotation(rotation: RotationInput): Rotator | undefined;
+export {};
 //# sourceMappingURL=common-handlers.d.ts.map

package/dist/tools/handlers/common-handlers.js

@@ -34,7 +34,8 @@ export function normalizeLocation(location) {
         return [Number(location[0]) || 0, Number(location[1]) || 0, Number(location[2]) || 0];
     }
     if (typeof location === 'object' && ('x' in location || 'y' in location || 'z' in location)) {
-        return [Number(location.x) || 0, Number(location.y) || 0, Number(location.z) || 0];
+        const loc = location;
+        return [Number(loc.x) || 0, Number(loc.y) || 0, Number(loc.z) || 0];
     }
     return undefined;
 }
@@ -45,10 +46,11 @@ export function normalizeRotation(rotation) {
         return { pitch: Number(rotation[0]) || 0, yaw: Number(rotation[1]) || 0, roll: Number(rotation[2]) || 0 };
     }
     if (typeof rotation === 'object') {
+        const rot = rotation;
         return {
-            pitch: Number(rotation.pitch) || 0,
-            yaw: Number(rotation.yaw) || 0,
-            roll: Number(rotation.roll) || 0
+            pitch: Number(rot.pitch) || 0,
+            yaw: Number(rot.yaw) || 0,
+            roll: Number(rot.roll) || 0
         };
     }
     return undefined;

package/dist/tools/handlers/editor-handlers.d.ts

@@ -1,3 +1,4 @@
 import { ITools } from '../../types/tool-interfaces.js';
-export declare function handleEditorTools(action: string, args: any, tools: ITools): Promise<any>;
+import type { EditorArgs } from '../../types/handler-types.js';
+export declare function handleEditorTools(action: string, args: EditorArgs, tools: ITools): Promise<unknown>;
 //# sourceMappingURL=editor-handlers.d.ts.map

package/dist/tools/handlers/editor-handlers.js

@@ -14,14 +14,14 @@ export async function handleEditorTools(action, args, tools) {
         case 'eject': {
             const inPie = await tools.editorTools.isInPIE();
             if (!inPie) {
-                return { success: false, error: 'NOT_IN_PIE', message: 'Cannot eject while not in PIE' };
+                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) {
-                return { success: false, error: 'NOT_IN_PIE', message: 'Cannot possess actor while not in PIE' };
+                throw new Error('Cannot possess actor while not in PIE');
             }
             return await executeAutomationRequest(tools, 'control_editor', args);
         }
@@ -38,7 +38,7 @@ export async function handleEditorTools(action, args, tools) {
             return cleanObject(res);
         }
         case 'console_command': {
-            const res = await tools.editorTools.executeConsoleCommand(args.command);
+            const res = await tools.editorTools.executeConsoleCommand(args.command ?? '');
             return cleanObject(res);
         }
         case 'set_camera': {
@@ -59,17 +59,17 @@ export async function handleEditorTools(action, args, tools) {
             return { success: true, message: 'Stepped frame', action: 'step_frame' };
         }
         case 'create_bookmark': {
-            const idx = parseInt(args.bookmarkName) || 0;
+            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;
+            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);
+            const res = await tools.editorTools.setEditorPreferences(args.category ?? '', args.preferences ?? {});
             return cleanObject(res);
         }
         case 'open_asset': {

package/dist/tools/handlers/effect-handlers.js

@@ -78,6 +78,9 @@ export async function handleEffectTools(action, args, tools) {
     if (action === 'clear_debug_shapes') {
         return executeAutomationRequest(tools, action, args);
     }
+    if (action === 'list_debug_shapes') {
+        return executeAutomationRequest(tools, 'list_debug_shapes', args);
+    }
     if (action === 'cleanup') {
         args.action = 'cleanup';
         args.subAction = 'cleanup';

package/dist/tools/handlers/graph-handlers.d.ts

@@ -1,3 +1,4 @@
 import { ITools } from '../../types/tool-interfaces.js';
-export declare function handleGraphTools(toolName: string, action: string, args: any, tools: ITools): Promise<any>;
+import type { GraphArgs } from '../../types/handler-types.js';
+export declare function handleGraphTools(toolName: string, action: string, args: GraphArgs, tools: ITools): Promise<any>;
 //# sourceMappingURL=graph-handlers.d.ts.map

package/dist/tools/handlers/graph-handlers.js

@@ -13,7 +13,7 @@ export async function handleGraphTools(toolName, action, args, tools) {
         case 'manage_behavior_tree':
             return handleBehaviorTree(action, args, tools);
         default:
-            return { success: false, error: 'UNKNOWN_TOOL', message: `Unknown graph tool: ${toolName}` };
+            throw new Error(`Unknown graph tool: ${toolName}`);
     }
 }
 async function handleBlueprintGraph(action, args, tools) {

package/dist/tools/handlers/input-handlers.d.ts

@@ -1,3 +1,7 @@
 import { ITools } from '../../types/tool-interfaces.js';
-export declare function handleInputTools(action: string, args: any, tools: ITools): Promise<any>;
+export declare function handleInputTools(action: string, args: any, tools: ITools): Promise<import("../../automation/types.js").AutomationBridgeResponseMessage | import("../../types/tool-interfaces.js").StandardActionResponse<any> | {
+    success: boolean;
+    error: string;
+    message: string;
+}>;
 //# sourceMappingURL=input-handlers.d.ts.map

package/dist/tools/handlers/level-handlers.d.ts

@@ -1,3 +1,4 @@
 import { ITools } from '../../types/tool-interfaces.js';
-export declare function handleLevelTools(action: string, args: any, tools: ITools): Promise<any>;
+import type { LevelArgs } from '../../types/handler-types.js';
+export declare function handleLevelTools(action: string, args: LevelArgs, tools: ITools): Promise<any>;
 //# sourceMappingURL=level-handlers.d.ts.map

package/dist/tools/handlers/level-handlers.js

@@ -111,14 +111,14 @@ export async function handleLevelTools(action, args, tools) {
         case 'export_level': {
             const res = await tools.levelTools.exportLevel({
                 levelPath: args.levelPath,
-                exportPath: args.exportPath || args.destinationPath,
+                exportPath: args.exportPath ?? args.destinationPath ?? '',
                 timeoutMs: typeof args.timeoutMs === 'number' ? args.timeoutMs : undefined
             });
             return cleanObject(res);
         }
         case 'import_level': {
             const res = await tools.levelTools.importLevel({
-                packagePath: args.packagePath || args.sourcePath,
+                packagePath: args.packagePath ?? args.sourcePath ?? '',
                 destinationPath: args.destinationPath,
                 timeoutMs: typeof args.timeoutMs === 'number' ? args.timeoutMs : undefined
             });
@@ -133,7 +133,7 @@ export async function handleLevelTools(action, args, tools) {
             return cleanObject(res);
         }
         case 'delete': {
-            const levelPaths = Array.isArray(args.levelPaths) ? args.levelPaths : [args.levelPath];
+            const levelPaths = Array.isArray(args.levelPaths) ? args.levelPaths.filter((p) => typeof p === 'string') : (args.levelPath ? [args.levelPath] : []);
             const res = await tools.levelTools.deleteLevels({ levelPaths });
             return cleanObject(res);
         }

package/dist/tools/handlers/lighting-handlers.d.ts

@@ -1,3 +1,4 @@
 import { ITools } from '../../types/tool-interfaces.js';
-export declare function handleLightingTools(action: string, args: any, tools: ITools): Promise<any>;
+import type { LightingArgs } from '../../types/handler-types.js';
+export declare function handleLightingTools(action: string, args: LightingArgs, tools: ITools): Promise<any>;
 //# sourceMappingURL=lighting-handlers.d.ts.map

package/dist/tools/handlers/lighting-handlers.js

@@ -137,6 +137,9 @@ export async function handleLightingTools(action, args, tools) {
                 useTemplate: args.useTemplate
             }));
         }
+        case 'list_light_types': {
+            return cleanObject(await tools.lightingTools.listLightTypes());
+        }
         default:
             throw new Error(`Unknown lighting action: ${action}`);
     }

package/dist/tools/handlers/pipeline-handlers.d.ts

@@ -1,3 +1,4 @@
 import { ITools } from '../../types/tool-interfaces.js';
-export declare function handlePipelineTools(action: string, args: any, tools: ITools): Promise<any>;
+import type { PipelineArgs } from '../../types/handler-types.js';
+export declare function handlePipelineTools(action: string, args: PipelineArgs, tools: ITools): Promise<unknown>;
 //# sourceMappingURL=pipeline-handlers.d.ts.map

package/dist/tools/handlers/pipeline-handlers.js

@@ -3,6 +3,55 @@ import { executeAutomationRequest } from './common-handlers.js';
 import { spawn } from 'child_process';
 import path from 'path';
 import fs from 'fs';
+function validateUbtArgumentsString(extraArgs) {
+    if (!extraArgs || typeof extraArgs !== 'string') {
+        return;
+    }
+    const forbiddenChars = ['\n', '\r', ';', '|', '`', '&&', '||', '>', '<'];
+    for (const char of forbiddenChars) {
+        if (extraArgs.includes(char)) {
+            throw new Error(`UBT arguments contain forbidden character(s) and are blocked for safety. Blocked: ${JSON.stringify(char)}.`);
+        }
+    }
+}
+function tokenizeArgs(extraArgs) {
+    if (!extraArgs) {
+        return [];
+    }
+    const args = [];
+    let current = '';
+    let inQuotes = false;
+    let escapeNext = false;
+    for (let i = 0; i < extraArgs.length; i++) {
+        const ch = extraArgs[i];
+        if (escapeNext) {
+            current += ch;
+            escapeNext = false;
+            continue;
+        }
+        if (ch === '\\') {
+            escapeNext = true;
+            continue;
+        }
+        if (ch === '"') {
+            inQuotes = !inQuotes;
+            continue;
+        }
+        if (!inQuotes && /\s/.test(ch)) {
+            if (current.length > 0) {
+                args.push(current);
+                current = '';
+            }
+        }
+        else {
+            current += ch;
+        }
+    }
+    if (current.length > 0) {
+        args.push(current);
+    }
+    return args;
+}
 export async function handlePipelineTools(action, args, tools) {
     switch (action) {
         case 'run_ubt': {
@@ -11,8 +60,9 @@ export async function handlePipelineTools(action, args, tools) {
             const configuration = args.configuration || 'Development';
             const extraArgs = args.arguments || '';
             if (!target) {
-                return { success: false, error: 'MISSING_TARGET', message: 'Target is required for run_ubt' };
+                throw new Error('Target is required for run_ubt');
             }
+            validateUbtArgumentsString(extraArgs);
             let ubtPath = 'UnrealBuildTool';
             const enginePath = process.env.UE_ENGINE_PATH || process.env.UNREAL_ENGINE_PATH;
             if (enginePath) {
@@ -26,7 +76,7 @@ export async function handlePipelineTools(action, args, tools) {
                 projectPath = args.projectPath;
             }
             if (!projectPath) {
-                return { success: false, error: 'MISSING_PROJECT_PATH', message: 'UE_PROJECT_PATH environment variable is not set and no projectPath argument was provided.' };
+                throw new Error('UE_PROJECT_PATH environment variable is not set and no projectPath argument was provided.');
             }
             let uprojectFile = projectPath;
             if (!uprojectFile.endsWith('.uproject')) {
@@ -38,18 +88,20 @@ export async function handlePipelineTools(action, args, tools) {
                     }
                 }
                 catch (_e) {
-                    return { success: false, error: 'INVALID_PROJECT_PATH', message: `Could not read project directory: ${projectPath}` };
+                    throw new Error(`Could not read project directory: ${projectPath}`);
                 }
             }
+            const projectArg = `-Project="${uprojectFile}"`;
+            const extraTokens = tokenizeArgs(extraArgs);
             const cmdArgs = [
                 target,
                 platform,
                 configuration,
-                `-Project="${uprojectFile}"`,
-                extraArgs
-            ].filter(Boolean);
+                projectArg,
+                ...extraTokens
+            ];
             return new Promise((resolve) => {
-                const child = spawn(ubtPath, cmdArgs, { shell: true });
+                const child = spawn(ubtPath, cmdArgs, { shell: false });
                 const MAX_OUTPUT_SIZE = 20 * 1024;
                 let stdout = '';
                 let stderr = '';
@@ -73,12 +125,13 @@ export async function handlePipelineTools(action, args, tools) {
                     const truncatedNote = (stdout.length >= MAX_OUTPUT_SIZE || stderr.length >= MAX_OUTPUT_SIZE)
                         ? '\n[Output truncated for response payload]'
                         : '';
+                    const quotedArgs = cmdArgs.map(arg => arg.includes(' ') ? `"${arg}"` : arg);
                     if (code === 0) {
                         resolve({
                             success: true,
                             message: 'UnrealBuildTool finished successfully',
                             output: stdout + truncatedNote,
-                            command: `${ubtPath} ${cmdArgs.join(' ')}`
+                            command: `${ubtPath} ${quotedArgs.join(' ')}`
                         });
                     }
                     else {
@@ -88,16 +141,17 @@ export async function handlePipelineTools(action, args, tools) {
                             message: `UnrealBuildTool failed with code ${code}`,
                             output: stdout + truncatedNote,
                             errorOutput: stderr + truncatedNote,
-                            command: `${ubtPath} ${cmdArgs.join(' ')}`
+                            command: `${ubtPath} ${quotedArgs.join(' ')}`
                         });
                     }
                 });
                 child.on('error', (err) => {
+                    const quotedArgs = cmdArgs.map(arg => arg.includes(' ') ? `"${arg}"` : arg);
                     resolve({
                         success: false,
                         error: 'SPAWN_FAILED',
                         message: `Failed to spawn UnrealBuildTool: ${err.message}`,
-                        command: `${ubtPath} ${cmdArgs.join(' ')}`
+                        command: `${ubtPath} ${quotedArgs.join(' ')}`
                     });
                 });
             });

package/dist/tools/handlers/sequence-handlers.d.ts

@@ -1,3 +1,3 @@
 import { ITools } from '../../types/tool-interfaces.js';
-export declare function handleSequenceTools(action: string, args: Record<string, unknown>, tools: ITools): Promise<any>;
+export declare function handleSequenceTools(action: string, args: Record<string, unknown>, tools: ITools): Promise<unknown>;
 //# sourceMappingURL=sequence-handlers.d.ts.map

package/dist/tools/handlers/system-handlers.d.ts

@@ -1,4 +1,4 @@
 import { ITools } from '../../types/tool-interfaces.js';
 export declare function handleSystemTools(action: string, args: any, tools: ITools): Promise<any>;
-export declare function handleConsoleCommand(args: any, tools: ITools): Promise<any>;
+export declare function handleConsoleCommand(args: any, tools: ITools): Promise<unknown>;
 //# sourceMappingURL=system-handlers.d.ts.map

package/dist/tools/input.d.ts

@@ -11,7 +11,11 @@ export declare class InputTools {
     setAutomationBridge(bridge: AutomationBridge): void;
     createInputAction(name: string, path: string): Promise<import("../automation/types.js").AutomationBridgeResponseMessage>;
     createInputMappingContext(name: string, path: string): Promise<import("../automation/types.js").AutomationBridgeResponseMessage>;
-    addMapping(contextPath: string, actionPath: string, key: string): Promise<import("../automation/types.js").AutomationBridgeResponseMessage>;
+    addMapping(contextPath: string, actionPath: string, key: string): Promise<import("../automation/types.js").AutomationBridgeResponseMessage | {
+        success: boolean;
+        error: string;
+        message: string;
+    }>;
     removeMapping(contextPath: string, actionPath: string): Promise<import("../automation/types.js").AutomationBridgeResponseMessage>;
 }
 export declare const inputTools: ToolDefinition;

package/dist/tools/input.js

@@ -1,3 +1,25 @@
+const VALID_KEY_NAMES = new Set([
+    'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
+    'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
+    'Zero', 'One', 'Two', 'Three', 'Four', 'Five', 'Six', 'Seven', 'Eight', 'Nine',
+    'F1', 'F2', 'F3', 'F4', 'F5', 'F6', 'F7', 'F8', 'F9', 'F10', 'F11', 'F12',
+    'SpaceBar', 'Enter', 'Escape', 'Tab', 'BackSpace', 'CapsLock',
+    'LeftShift', 'RightShift', 'LeftControl', 'RightControl', 'LeftAlt', 'RightAlt',
+    'LeftCommand', 'RightCommand', 'Insert', 'Delete', 'Home', 'End', 'PageUp', 'PageDown',
+    'Up', 'Down', 'Left', 'Right',
+    'Semicolon', 'Equals', 'Comma', 'Hyphen', 'Underscore', 'Period', 'Slash', 'Tilde',
+    'LeftBracket', 'Backslash', 'RightBracket', 'Apostrophe', 'Quote',
+    'LeftMouseButton', 'RightMouseButton', 'MiddleMouseButton', 'ThumbMouseButton', 'ThumbMouseButton2',
+    'MouseX', 'MouseY', 'MouseWheelAxis', 'MouseScrollUp', 'MouseScrollDown',
+    'Gamepad_FaceButton_Bottom', 'Gamepad_FaceButton_Right', 'Gamepad_FaceButton_Left', 'Gamepad_FaceButton_Top',
+    'Gamepad_LeftShoulder', 'Gamepad_RightShoulder', 'Gamepad_LeftTrigger', 'Gamepad_RightTrigger',
+    'Gamepad_LeftTriggerAxis', 'Gamepad_RightTriggerAxis',
+    'Gamepad_LeftThumbstick', 'Gamepad_RightThumbstick',
+    'Gamepad_LeftStick_Up', 'Gamepad_LeftStick_Down', 'Gamepad_LeftStick_Left', 'Gamepad_LeftStick_Right',
+    'Gamepad_RightStick_Up', 'Gamepad_RightStick_Down', 'Gamepad_RightStick_Left', 'Gamepad_RightStick_Right',
+    'Gamepad_DPad_Up', 'Gamepad_DPad_Down', 'Gamepad_DPad_Left', 'Gamepad_DPad_Right',
+    'Gamepad_Special_Left', 'Gamepad_Special_Right'
+]);
 export class InputTools {
     automationBridge = null;
     constructor() { }
@@ -25,11 +47,25 @@ export class InputTools {
     async addMapping(contextPath, actionPath, key) {
         if (!this.automationBridge)
             throw new Error('Automation bridge not set');
+        if (!key || typeof key !== 'string' || key.trim().length === 0) {
+            return { success: false, error: 'INVALID_ARGUMENT', message: 'Key name is required.' };
+        }
+        const trimmedKey = key.trim();
+        if (trimmedKey === 'MouseXY2D' || trimmedKey === 'Mouse2D' || trimmedKey === 'MouseXY') {
+            return {
+                success: false,
+                error: 'INVALID_ARGUMENT',
+                message: `Invalid key name '${trimmedKey}'. For mouse axis input, use separate mappings with 'MouseX' and 'MouseY' keys instead of composite 2D axis names.`
+            };
+        }
+        if (!VALID_KEY_NAMES.has(trimmedKey)) {
+            console.warn(`[InputTools] Key '${trimmedKey}' is not in the standard key list. Attempting mapping anyway.`);
+        }
         return this.automationBridge.sendAutomationRequest('manage_input', {
             action: 'add_mapping',
             contextPath,
             actionPath,
-            key
+            key: trimmedKey
         });
     }
     async removeMapping(contextPath, actionPath) {

package/dist/tools/lighting.d.ts

@@ -6,6 +6,7 @@ export declare class LightingTools {
     constructor(bridge: UnrealBridge, automationBridge?: AutomationBridge | undefined);
     setAutomationBridge(automationBridge?: AutomationBridge): void;
     private normalizeName;
+    listLightTypes(): Promise<import("../automation/types.js").AutomationBridgeResponseMessage>;
     private spawnLightViaAutomation;
     createDirectionalLight(params: {
         name: string;

package/dist/tools/lighting.js

@@ -23,6 +23,13 @@ export class LightingTools {
         }
         return `Light_${Date.now()}_${Math.floor(Math.random() * 1000)}`;
     }
+    async listLightTypes() {
+        if (!this.automationBridge) {
+            throw new Error('Automation Bridge required to list light types');
+        }
+        const response = await this.automationBridge.sendAutomationRequest('list_light_types', {});
+        return response;
+    }
     async spawnLightViaAutomation(lightClass, params) {
         if (!this.automationBridge) {
             throw new Error('Automation Bridge not available. Cannot spawn lights without plugin support.');

package/dist/tools/physics.d.ts

@@ -67,7 +67,7 @@ export declare class PhysicsTools {
     }>;
     configureVehicle(params: {
         vehicleName: string;
-        vehicleType: 'Car' | 'Bike' | 'Tank' | 'Aircraft';
+        vehicleType: string;
         wheels?: Array<{
             name: string;
             radius: number;

package/dist/tools/sequence.d.ts

@@ -129,6 +129,7 @@ export declare class SequenceTools extends BaseTool implements ISequenceTools {
     listTracks(params: {
         path: string;
     }): Promise<StandardActionResponse>;
+    listTrackTypes(): Promise<StandardActionResponse>;
     setWorkRange(params: {
         path?: string;
         start: number;

package/dist/tools/sequence.js

@@ -247,6 +247,13 @@ export class SequenceTools extends BaseTool {
         }
         return resp;
     }
+    async listTrackTypes() {
+        const resp = await this.sendAction('list_track_types', {});
+        if (!resp.success && this.isUnknownActionResponse(resp)) {
+            return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement list_track_types' };
+        }
+        return resp;
+    }
     async setWorkRange(params) {
         const resp = await this.sendAction('sequence_set_work_range', { path: params.path, start: params.start, end: params.end });
         if (!resp.success && this.isUnknownActionResponse(resp)) {