unreal-engine-mcp-server 0.5.4 → 0.5.5

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

@@ -1,194 +0,0 @@
-import { ITools } from '../../types/tool-interfaces.js';
-import { cleanObject } from '../../utils/safe-json.js';
-import { requireNonEmptyString } from './common-handlers.js';
-
-function toVec3Array(v: any): [number, number, number] | undefined {
-  if (!v || typeof v !== 'object') return undefined;
-  const x = Number(v.x);
-  const y = Number(v.y);
-  const z = Number(v.z);
-  if (!Number.isFinite(x) || !Number.isFinite(y) || !Number.isFinite(z)) return undefined;
-  return [x, y, z];
-}
-
-function toRotArray(r: any): [number, number, number] | undefined {
-  if (!r || typeof r !== 'object') return undefined;
-  const pitch = Number(r.pitch);
-  const yaw = Number(r.yaw);
-  const roll = Number(r.roll);
-  if (!Number.isFinite(pitch) || !Number.isFinite(yaw) || !Number.isFinite(roll)) return undefined;
-  return [pitch, yaw, roll];
-}
-
-function getTimeoutMs(): number {
-  const envDefault = Number(process.env.MCP_AUTOMATION_REQUEST_TIMEOUT_MS ?? '120000');
-  return Number.isFinite(envDefault) && envDefault > 0 ? envDefault : 120000;
-}
-
-export async function handleAudioTools(
-  action: string,
-  args: any,
-  tools: ITools
-) {
-  switch (action) {
-    case 'create_sound_cue':
-      requireNonEmptyString(args?.name, 'name', 'Missing required parameter: name');
-      requireNonEmptyString(args?.wavePath ?? args?.soundPath, 'soundPath', 'Missing required parameter: soundPath (or wavePath)');
-      return cleanObject(await tools.audioTools.createSoundCue({
-        name: args.name,
-        // MCP schema uses soundPath; AudioTools uses wavePath.
-        wavePath: args.wavePath ?? args.soundPath,
-        savePath: args.savePath,
-        settings: args.settings
-      }));
-
-    case 'play_sound_at_location':
-      requireNonEmptyString(args?.soundPath, 'soundPath', 'Missing required parameter: soundPath');
-      return cleanObject(await tools.audioTools.playSoundAtLocation({
-        soundPath: args.soundPath,
-        location: toVec3Array(args.location) ?? [0, 0, 0],
-        rotation: toRotArray(args.rotation),
-        volume: args.volume,
-        pitch: args.pitch,
-        startTime: args.startTime,
-        attenuationPath: args.attenuationPath,
-        concurrencyPath: args.concurrencyPath
-      }));
-
-    case 'play_sound_2d':
-      requireNonEmptyString(args?.soundPath, 'soundPath', 'Missing required parameter: soundPath');
-      return cleanObject(await tools.audioTools.playSound2D({
-        soundPath: args.soundPath,
-        volume: args.volume,
-        pitch: args.pitch,
-        startTime: args.startTime
-      }));
-
-    case 'create_audio_component':
-      requireNonEmptyString(args?.actorName, 'actorName', 'Missing required parameter: actorName');
-      requireNonEmptyString(args?.componentName, 'componentName', 'Missing required parameter: componentName');
-      requireNonEmptyString(args?.soundPath, 'soundPath', 'Missing required parameter: soundPath');
-      return cleanObject(await tools.audioTools.createAudioComponent({
-        actorName: args.actorName,
-        componentName: args.componentName,
-        soundPath: args.soundPath,
-        autoPlay: args.autoPlay,
-        is3D: args.is3D
-      }));
-
-    case 'set_sound_attenuation':
-      requireNonEmptyString(args?.name, 'name', 'Missing required parameter: name');
-      return cleanObject(await tools.audioTools.setSoundAttenuation({
-        name: args.name,
-        innerRadius: args.innerRadius,
-        falloffDistance: args.falloffDistance,
-        attenuationShape: args.attenuationShape,
-        falloffMode: args.falloffMode
-      }));
-
-    case 'create_sound_class':
-      requireNonEmptyString(args?.name, 'name', 'Missing required parameter: name');
-      return cleanObject(await tools.audioTools.createSoundClass({
-        name: args.name,
-        parentClass: args.parentClass,
-        properties: args.properties
-      }));
-
-    case 'create_sound_mix':
-      requireNonEmptyString(args?.name, 'name', 'Missing required parameter: name');
-      return cleanObject(await tools.audioTools.createSoundMix({
-        name: args.name,
-        classAdjusters: args.classAdjusters
-      }));
-
-    case 'push_sound_mix':
-      requireNonEmptyString(args?.mixName ?? args?.name, 'mixName', 'Missing required parameter: mixName (or name)');
-      return cleanObject(await tools.audioTools.pushSoundMix({
-        mixName: args.mixName ?? args.name
-      }));
-
-    case 'pop_sound_mix':
-      requireNonEmptyString(args?.mixName ?? args?.name, 'mixName', 'Missing required parameter: mixName (or name)');
-      return cleanObject(await tools.audioTools.popSoundMix({
-        mixName: args.mixName ?? args.name
-      }));
-
-    case 'create_ambient_sound':
-      requireNonEmptyString(args?.soundPath, 'soundPath', 'Missing required parameter: soundPath');
-      return cleanObject(await tools.audioTools.createAmbientSound({
-        soundPath: args.soundPath,
-        location: toVec3Array(args.location) ?? [0, 0, 0],
-        volume: args.volume,
-        pitch: args.pitch,
-        startTime: args.startTime,
-        attenuationPath: args.attenuationPath,
-        concurrencyPath: args.concurrencyPath
-      }));
-
-    case 'create_reverb_zone':
-      requireNonEmptyString(args?.name, 'name', 'Missing required parameter: name');
-      return cleanObject(await tools.audioTools.createReverbZone({
-        name: args.name,
-        location: toVec3Array(args.location) ?? [0, 0, 0],
-        size: toVec3Array(args.size) ?? [0, 0, 0],
-        reverbEffect: args.reverbEffect,
-        volume: args.volume,
-        fadeTime: args.fadeTime
-      }));
-
-    case 'enable_audio_analysis':
-      return cleanObject(await tools.audioTools.enableAudioAnalysis({
-        enabled: args.enabled,
-        fftSize: args.fftSize,
-        outputType: args.outputType
-      }));
-
-    case 'fade_sound':
-      requireNonEmptyString(args?.soundName, 'soundName', 'Missing required parameter: soundName');
-      return cleanObject(await tools.audioTools.fadeSound({
-        soundName: args.soundName,
-        targetVolume: args.targetVolume,
-        fadeTime: args.fadeTime,
-        fadeType: args.fadeType
-      }));
-
-    case 'set_doppler_effect':
-      return cleanObject(await tools.audioTools.setDopplerEffect({
-        enabled: args.enabled,
-        scale: args.scale
-      }));
-
-    case 'set_audio_occlusion':
-      return cleanObject(await tools.audioTools.setAudioOcclusion({
-        enabled: args.enabled,
-        lowPassFilterFrequency: args.lowPassFilterFrequency,
-        volumeAttenuation: args.volumeAttenuation
-      }));
-
-    case 'spawn_sound_at_location':
-      // Direct pass-through to C++ handler
-      return cleanObject(await tools.automationBridge?.sendAutomationRequest('spawn_sound_at_location', args, { timeoutMs: getTimeoutMs() }));
-
-    case 'play_sound_attached':
-      return cleanObject(await tools.automationBridge?.sendAutomationRequest('play_sound_attached', args, { timeoutMs: getTimeoutMs() }));
-
-    case 'set_sound_mix_class_override':
-      return cleanObject(await tools.automationBridge?.sendAutomationRequest('set_sound_mix_class_override', args, { timeoutMs: getTimeoutMs() }));
-
-    case 'clear_sound_mix_class_override':
-      return cleanObject(await tools.automationBridge?.sendAutomationRequest('clear_sound_mix_class_override', args, { timeoutMs: getTimeoutMs() }));
-
-    case 'set_base_sound_mix':
-      return cleanObject(await tools.automationBridge?.sendAutomationRequest('set_base_sound_mix', args, { timeoutMs: getTimeoutMs() }));
-
-    case 'prime_sound':
-      return cleanObject(await tools.automationBridge?.sendAutomationRequest('prime_sound', args, { timeoutMs: getTimeoutMs() }));
-
-    case 'fade_sound_in':
-    case 'fade_sound_out':
-      return cleanObject(await tools.automationBridge?.sendAutomationRequest(action, args, { timeoutMs: getTimeoutMs() }));
-
-    default:
-      return cleanObject({ success: false, error: 'UNKNOWN_ACTION', message: `Unknown audio action: ${action}` });
-  }
-}

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

@@ -1,380 +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 handleBlueprintTools(action: string, args: any, tools: ITools) {
-  switch (action) {
-    case 'create': {
-      // Support 'path' or 'blueprintPath' argument by splitting it into name and savePath if not provided
-      let name = args.name;
-      let savePath = args.savePath;
-      const pathArg = args.path || args.blueprintPath;
-
-      if (pathArg) {
-        const parts = pathArg.split('/');
-        const extractName = parts.pop(); // The last part is the name
-
-        // If name wasn't provided, use the extracted name
-        if (!name) {
-          name = extractName;
-        }
-
-        // If savePath wasn't provided, use the extracted path
-        if (!savePath) {
-          savePath = parts.join('/');
-        }
-      }
-
-      if (!savePath) savePath = '/Game';
-
-      const res = await tools.blueprintTools.createBlueprint({
-        name: name,
-        blueprintType: args.blueprintType,
-        savePath: savePath,
-        parentClass: args.parentClass,
-        properties: args.properties,
-        timeoutMs: args.timeoutMs,
-        waitForCompletion: args.waitForCompletion,
-        waitForCompletionTimeoutMs: args.waitForCompletionTimeoutMs
-      });
-      return cleanObject(res);
-    }
-    case 'ensure_exists': {
-      const res = await tools.blueprintTools.waitForBlueprint(args.name || args.blueprintPath || args.path, args.timeoutMs);
-      return cleanObject(res);
-    }
-    case 'add_variable': {
-      const res = await tools.blueprintTools.addVariable({
-        blueprintName: args.name || args.blueprintPath || args.path,
-        variableName: args.variableName,
-        variableType: args.variableType,
-        defaultValue: args.defaultValue,
-        category: args.category,
-        isReplicated: args.isReplicated,
-        isPublic: args.isPublic,
-        variablePinType: args.variablePinType,
-        timeoutMs: args.timeoutMs,
-        waitForCompletion: args.waitForCompletion,
-        waitForCompletionTimeoutMs: args.waitForCompletionTimeoutMs
-      });
-      return cleanObject(res);
-    }
-    case 'set_variable_metadata': {
-      const res = await tools.blueprintTools.setVariableMetadata({
-        blueprintName: args.name || args.blueprintPath || args.path,
-        variableName: args.variableName,
-        metadata: args.metadata,
-        timeoutMs: args.timeoutMs
-      });
-      return cleanObject(res);
-    }
-    case 'remove_variable': {
-      const res = await tools.blueprintTools.removeVariable({
-        blueprintName: args.name || args.blueprintPath || args.path,
-        variableName: args.variableName,
-        timeoutMs: args.timeoutMs,
-        waitForCompletion: args.waitForCompletion,
-        waitForCompletionTimeoutMs: args.waitForCompletionTimeoutMs
-      });
-      return cleanObject(res);
-    }
-    case 'rename_variable': {
-      const res = await tools.blueprintTools.renameVariable({
-        blueprintName: args.name || args.blueprintPath || args.path,
-        oldName: args.oldName,
-        newName: args.newName,
-        timeoutMs: args.timeoutMs,
-        waitForCompletion: args.waitForCompletion,
-        waitForCompletionTimeoutMs: args.waitForCompletionTimeoutMs
-      });
-      return cleanObject(res);
-    }
-    case 'set_metadata': {
-      const assetPathRaw = typeof args.assetPath === 'string' ? args.assetPath.trim() : '';
-      const blueprintPathRaw = typeof args.blueprintPath === 'string' ? args.blueprintPath.trim() : '';
-      const nameRaw = typeof args.name === 'string' ? args.name.trim() : '';
-      const savePathRaw = typeof args.savePath === 'string' ? args.savePath.trim() : '';
-
-      let assetPath = assetPathRaw;
-      if (!assetPath) {
-        if (blueprintPathRaw) {
-          assetPath = blueprintPathRaw;
-        } else if (nameRaw && savePathRaw) {
-          const base = savePathRaw.replace(/\/$/, '');
-          assetPath = `${base}/${nameRaw}`;
-        }
-      }
-      if (!assetPath) {
-        throw new Error('Invalid parameters: assetPath or blueprintPath or name+savePath required for set_metadata');
-      }
-
-      const metadata = (args.metadata && typeof args.metadata === 'object') ? args.metadata : {};
-      const res = await executeAutomationRequest(tools, 'set_metadata', { assetPath, metadata });
-      return cleanObject(res);
-    }
-    case 'add_event': {
-      const blueprintName = args.blueprintPath || args.path || args.name;
-      const usedNameForBlueprint = !args.blueprintPath && !args.path && args.name;
-
-      const res: any = await tools.blueprintTools.addEvent({
-        blueprintName: blueprintName,
-        eventType: args.eventType,
-        customEventName: args.customEventName || (!usedNameForBlueprint ? args.name : undefined),
-        parameters: args.parameters,
-        timeoutMs: args.timeoutMs,
-        waitForCompletion: args.waitForCompletion,
-        waitForCompletionTimeoutMs: args.waitForCompletionTimeoutMs
-      });
-
-      if (res && res.success === false) {
-        const msg = (res.message || '').toLowerCase();
-        if (msg.includes('already exists') || msg.includes('duplicate')) {
-          return cleanObject({
-            success: false,
-            error: 'EVENT_ALREADY_EXISTS',
-            message: res.message || 'Event already exists',
-            blueprintName
-          });
-        }
-      }
-      return cleanObject(res);
-    }
-    case 'remove_event': {
-      const res = await tools.blueprintTools.removeEvent({
-        blueprintName: args.name || args.blueprintPath || args.path,
-        eventName: args.eventName,
-        customEventName: args.customEventName,
-        timeoutMs: args.timeoutMs,
-        waitForCompletion: args.waitForCompletion,
-        waitForCompletionTimeoutMs: args.waitForCompletionTimeoutMs
-      });
-      return cleanObject(res);
-    }
-    case 'add_function': {
-      // Prioritize explicit path for blueprint, allowing 'name' to be function name
-      const blueprintName = args.blueprintPath || args.path || args.name;
-      const usedNameForBlueprint = !args.blueprintPath && !args.path && args.name;
-
-      const res = await tools.blueprintTools.addFunction({
-        blueprintName: blueprintName,
-        functionName: args.functionName || args.memberName || (!usedNameForBlueprint ? args.name : undefined),
-        inputs: args.inputs,
-        outputs: args.outputs,
-        isPublic: args.isPublic,
-        category: args.category,
-        timeoutMs: args.timeoutMs,
-        waitForCompletion: args.waitForCompletion,
-        waitForCompletionTimeoutMs: args.waitForCompletionTimeoutMs
-      });
-      return cleanObject(res);
-    }
-    case 'add_component': {
-      const res = await tools.blueprintTools.addComponent({
-        blueprintName: args.name || args.blueprintPath || args.path,
-        componentType: args.componentType || args.componentClass,
-        componentName: args.componentName,
-        attachTo: args.attachTo,
-        transform: args.transform,
-        properties: args.properties,
-        compile: args.applyAndSave,
-        save: args.applyAndSave,
-        timeoutMs: args.timeoutMs,
-        waitForCompletion: args.waitForCompletion,
-        waitForCompletionTimeoutMs: args.waitForCompletionTimeoutMs
-      });
-      return cleanObject(res);
-    }
-    case 'modify_scs': {
-      const res = await tools.blueprintTools.modifyConstructionScript({
-        blueprintPath: args.name || args.blueprintPath || args.path,
-        operations: args.operations,
-        compile: args.applyAndSave,
-        save: args.applyAndSave,
-        timeoutMs: args.timeoutMs,
-        waitForCompletion: args.waitForCompletion,
-        waitForCompletionTimeoutMs: args.waitForCompletionTimeoutMs
-      });
-      return cleanObject(res);
-    }
-    case 'set_scs_transform': {
-      const res = await tools.blueprintTools.setSCSComponentTransform({
-        blueprintPath: args.name || args.blueprintPath || args.path,
-        componentName: args.componentName,
-        location: args.location,
-        rotation: args.rotation,
-        scale: args.scale,
-        timeoutMs: args.timeoutMs
-      });
-      return cleanObject(res);
-    }
-    case 'add_construction_script': {
-      const res = await tools.blueprintTools.addConstructionScript({
-        blueprintName: args.name || args.blueprintPath || args.path,
-        scriptName: args.scriptName,
-        timeoutMs: args.timeoutMs,
-        waitForCompletion: args.waitForCompletion,
-        waitForCompletionTimeoutMs: args.waitForCompletionTimeoutMs
-      });
-      return cleanObject(res);
-    }
-    case 'add_node': {
-      if ((args.nodeType === 'CallFunction' || args.nodeType === 'K2Node_CallFunction') && !args.functionName && !args.memberName) {
-        throw new Error('CallFunction node requires functionName parameter');
-      }
-
-      // Map common node aliases to K2Node types
-      const nodeAliases: Record<string, string> = {
-        'CallFunction': 'K2Node_CallFunction',
-        'VariableGet': 'K2Node_VariableGet',
-        'VariableSet': 'K2Node_VariableSet',
-        'If': 'K2Node_IfThenElse',
-        'Branch': 'K2Node_IfThenElse',
-        'Switch': 'K2Node_Switch',
-        'Select': 'K2Node_Select',
-        'Cast': 'K2Node_DynamicCast',
-        'CustomEvent': 'K2Node_CustomEvent',
-        'Event': 'K2Node_Event',
-        'MakeArray': 'K2Node_MakeArray',
-        'ForEach': 'K2Node_ForEachElementInEnum' // Note: ForEachLoop is a macro, this is different
-      };
-
-      const resolvedNodeType = nodeAliases[args.nodeType] || args.nodeType;
-
-      // Validation for Event nodes
-      if ((resolvedNodeType === 'K2Node_Event' || resolvedNodeType === 'K2Node_CustomEvent') && !args.eventName && !args.customEventName && !args.name) {
-        // Allow 'name' as fallback for customEventName/eventName
-        if (!args.eventName) args.eventName = args.name;
-
-        if (!args.eventName) {
-          throw new Error(`${resolvedNodeType} requires eventName (or customEventName) parameter`);
-        }
-      }
-
-      const res = await tools.blueprintTools.addNode({
-        blueprintName: args.name || args.blueprintPath || args.path,
-        nodeType: resolvedNodeType,
-        graphName: args.graphName,
-        functionName: args.functionName,
-        variableName: args.variableName,
-        nodeName: args.nodeName,
-        eventName: args.eventName || args.customEventName,
-        memberClass: args.memberClass,
-        posX: args.posX,
-        posY: args.posY,
-        timeoutMs: args.timeoutMs
-      });
-      return cleanObject(res);
-    }
-    case 'add_scs_component': {
-      const res = await tools.blueprintTools.addSCSComponent({
-        blueprintPath: args.name || args.blueprintPath || args.path,
-        componentClass: args.componentClass || args.componentType,
-        componentName: args.componentName,
-        meshPath: args.meshPath,
-        materialPath: args.materialPath,
-        timeoutMs: args.timeoutMs
-      });
-      return cleanObject(res);
-    }
-    case 'reparent_scs_component': {
-      const res = await tools.blueprintTools.reparentSCSComponent({
-        blueprintPath: args.name || args.blueprintPath || args.path,
-        componentName: args.componentName,
-        newParent: args.newParent,
-        timeoutMs: args.timeoutMs
-      });
-      return cleanObject(res);
-    }
-    case 'set_scs_property': {
-      const res = await tools.blueprintTools.setSCSComponentProperty({
-        blueprintPath: args.name || args.blueprintPath || args.path,
-        componentName: args.componentName,
-        propertyName: args.propertyName,
-        propertyValue: args.propertyValue,
-        timeoutMs: args.timeoutMs
-      });
-      return cleanObject(res);
-    }
-    case 'remove_scs_component': {
-      const res = await tools.blueprintTools.removeSCSComponent({
-        blueprintPath: args.name || args.blueprintPath || args.path,
-        componentName: args.componentName,
-        timeoutMs: args.timeoutMs
-      });
-      return cleanObject(res);
-    }
-    case 'get_scs': {
-      const res = await tools.blueprintTools.getBlueprintSCS({
-        blueprintPath: args.name || args.blueprintPath || args.path,
-        timeoutMs: args.timeoutMs
-      });
-      return cleanObject(res);
-    }
-    case 'set_default': {
-      const res = await tools.blueprintTools.setBlueprintDefault({
-        blueprintName: args.name || args.blueprintPath || args.path,
-        propertyName: args.propertyName,
-        value: args.value
-      });
-      return cleanObject(res);
-    }
-    case 'compile': {
-      const res = await tools.blueprintTools.compileBlueprint({
-        blueprintName: args.name || args.blueprintPath || args.path,
-        saveAfterCompile: args.saveAfterCompile
-      });
-      return cleanObject(res);
-    }
-    case 'probe_handle': {
-      const res = await tools.blueprintTools.probeSubobjectDataHandle({
-        componentClass: args.componentClass
-      });
-      return cleanObject(res);
-    }
-    case 'get': {
-      const res = await tools.blueprintTools.getBlueprintInfo({
-        blueprintPath: args.name || args.blueprintPath || args.path,
-        timeoutMs: args.timeoutMs
-      });
-      return cleanObject(res);
-    }
-    case 'connect_pins':
-    case 'break_pin_links':
-    case 'delete_node':
-    case 'create_reroute_node':
-    case 'set_node_property':
-    case 'get_node_details':
-    case 'get_pin_details':
-    case 'get_graph_details': {
-      const processedArgs = {
-        ...args,
-        subAction: action,
-        blueprintPath: args.blueprintPath || args.path || args.name
-      };
-      const res = await executeAutomationRequest(tools, 'manage_blueprint_graph', processedArgs, 'Automation bridge not available for blueprint graph operations');
-      return cleanObject(res);
-    }
-    default: {
-      // Translate applyAndSave to compile/save flags for modify_scs action
-      const processedArgs = { ...args };
-      if (args.action === 'modify_scs' && args.applyAndSave === true) {
-        processedArgs.compile = true;
-        processedArgs.save = true;
-      }
-      const res = await executeAutomationRequest(tools, 'manage_blueprint', processedArgs, 'Automation bridge not available for blueprint operations');
-      return cleanObject(res);
-    }
-  }
-}
-
-export async function handleBlueprintGet(args: any, tools: ITools) {
-  const res = await executeAutomationRequest(tools, 'blueprint_get', args, 'Automation bridge not available for blueprint operations') as { success?: boolean; message?: string } | null;
-  if (res && res.success) {
-    return cleanObject({
-      ...res,
-      blueprint: args.blueprintPath || args.path || args.name || 'Unknown Blueprint',
-      message: res.message || 'Blueprint fetched'
-    });
-  }
-  return cleanObject(res);
-}

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

@@ -1,108 +0,0 @@
-import { ITools } from '../../types/tool-interfaces.js';
-import type { HandlerArgs, Vector3, Rotator } from '../../types/handler-types.js';
-
-/**
- * Validates that args is not null/undefined.
- */
-export function ensureArgsPresent(args: unknown): asserts args is Record<string, unknown> {
-  if (args === null || args === undefined) {
-    throw new Error('Invalid arguments: null or undefined');
-  }
-}
-
-/**
- * Extracts and validates the 'action' field from args.
- */
-export function requireAction(args: HandlerArgs): string {
-  ensureArgsPresent(args);
-  const action = args.action;
-  if (typeof action !== 'string' || action.trim() === '') {
-    throw new Error('Missing required parameter: action');
-  }
-  return action;
-}
-
-/**
- * Validates that a value is a non-empty string.
- */
-export function requireNonEmptyString(value: unknown, field: string, message?: string): string {
-  if (typeof value !== 'string' || value.trim() === '') {
-    throw new Error(message ?? `Invalid ${field}: must be a non-empty string`);
-  }
-  return value;
-}
-
-/**
- * Execute a request via the automation bridge.
- */
-export async function executeAutomationRequest(
-  tools: ITools,
-  toolName: string,
-  args: HandlerArgs,
-  errorMessage: string = 'Automation bridge not available',
-  options: { timeoutMs?: number } = {}
-): Promise<unknown> {
-  const automationBridge = tools.automationBridge;
-  // If the bridge is missing or not a function, we can't proceed with automation requests
-  if (!automationBridge || typeof automationBridge.sendAutomationRequest !== 'function') {
-    throw new Error(errorMessage);
-  }
-
-  if (!automationBridge.isConnected()) {
-    throw new Error(`Automation bridge is not connected to Unreal Engine. Please check if the editor is running and the plugin is enabled. Action: ${toolName}`);
-  }
-
-  return await automationBridge.sendAutomationRequest(toolName, args, options);
-}
-
-/** Input type for location normalization */
-type LocationInput = Vector3 | [number, number, number] | number[] | null | undefined;
-
-/**
- * Normalize location to [x, y, z] array format
- * Accepts both {x,y,z} object and [x,y,z] array formats
- */
-export function normalizeLocation(location: LocationInput): [number, number, number] | undefined {
-  if (!location) return undefined;
-
-  // Already array format
-  if (Array.isArray(location) && location.length >= 3) {
-    return [Number(location[0]) || 0, Number(location[1]) || 0, Number(location[2]) || 0];
-  }
-
-  // Object format {x, y, z}
-  if (typeof location === 'object' && ('x' in location || 'y' in location || 'z' in location)) {
-    const loc = location as Vector3;
-    return [Number(loc.x) || 0, Number(loc.y) || 0, Number(loc.z) || 0];
-  }
-
-  return undefined;
-}
-
-/** Input type for rotation normalization */
-type RotationInput = Rotator | [number, number, number] | number[] | null | undefined;
-
-/**
- * Normalize rotation to {pitch, yaw, roll} object format
- * Accepts both {pitch,yaw,roll} object and [pitch,yaw,roll] array formats
- */
-export function normalizeRotation(rotation: RotationInput): Rotator | undefined {
-  if (!rotation) return undefined;
-
-  // Array format [pitch, yaw, roll]
-  if (Array.isArray(rotation) && rotation.length >= 3) {
-    return { pitch: Number(rotation[0]) || 0, yaw: Number(rotation[1]) || 0, roll: Number(rotation[2]) || 0 };
-  }
-
-  // Already object format
-  if (typeof rotation === 'object') {
-    const rot = rotation as Rotator;
-    return {
-      pitch: Number(rot.pitch) || 0,
-      yaw: Number(rot.yaw) || 0,
-      roll: Number(rot.roll) || 0
-    };
-  }
-
-  return undefined;
-}