unreal-engine-mcp-server 0.4.6 → 0.5.0

package/src/tools/audio.ts

@@ -1,174 +1,19 @@
 // Audio tools for Unreal Engine
-import JSON5 from 'json5';
 import { UnrealBridge } from '../unreal-bridge.js';
-import { escapePythonString } from '../utils/python.js';
+import { AutomationBridge } from '../automation/index.js';
 
 export class AudioTools {
-  constructor(private bridge: UnrealBridge) {}
-
-  private interpretResult(
-    resp: unknown,
-    defaults: { successMessage: string; failureMessage: string }
-  ): { success: true; message: string; details?: string } | { success: false; error: string; details?: string } {
-    const normalizePayload = (
-      payload: Record<string, unknown>
-    ): { success: true; message: string; details?: string } | { success: false; error: string; details?: string } => {
-      const warningsValue = payload?.warnings;
-      const warningsText = Array.isArray(warningsValue)
-        ? (warningsValue.length > 0 ? warningsValue.join('; ') : undefined)
-        : typeof warningsValue === 'string' && warningsValue.trim() !== ''
-          ? warningsValue
-          : undefined;
-
-      if (payload?.success === true) {
-        const message = typeof payload?.message === 'string' && payload.message.trim() !== ''
-          ? payload.message
-          : defaults.successMessage;
-        return {
-          success: true as const,
-          message,
-          details: warningsText
-        };
-      }
+  constructor(private bridge: UnrealBridge, private automationBridge?: AutomationBridge) { }
 
-      const error =
-        (typeof payload?.error === 'string' && payload.error.trim() !== ''
-          ? payload.error
-          : undefined)
-        ?? (typeof payload?.message === 'string' && payload.message.trim() !== ''
-          ? payload.message
-          : undefined)
-        ?? defaults.failureMessage;
+  setAutomationBridge(automationBridge?: AutomationBridge) { this.automationBridge = automationBridge; }
 
-      return {
-        success: false as const,
-        error,
-        details: warningsText
-      };
+  private validateAudioParams(volume?: number, pitch?: number) {
+    const v = volume ?? 1.0;
+    const p = pitch ?? 1.0;
+    return {
+      volume: Math.max(0.0, Math.min(v, 4.0)), // Clamp volume 0-4 (standard UE range support)
+      pitch: Math.max(0.01, Math.min(p, 4.0))   // Clamp pitch 0.01-4
     };
-
-    if (resp && typeof resp === 'object') {
-      const payload = resp as Record<string, unknown>;
-      if ('success' in payload || 'error' in payload || 'message' in payload || 'warnings' in payload) {
-        return normalizePayload(payload);
-      }
-    }
-
-    const raw = typeof resp === 'string' ? resp : JSON.stringify(resp);
-
-    const extractJson = (input: string): string | undefined => {
-      const marker = 'RESULT:';
-      const markerIndex = input.lastIndexOf(marker);
-      if (markerIndex === -1) {
-        return undefined;
-      }
-
-      const afterMarker = input.slice(markerIndex + marker.length);
-      const firstBraceIndex = afterMarker.indexOf('{');
-      if (firstBraceIndex === -1) {
-        return undefined;
-      }
-
-      let depth = 0;
-      let inString = false;
-      let escapeNext = false;
-
-      for (let i = firstBraceIndex; i < afterMarker.length; i++) {
-        const char = afterMarker[i];
-
-        if (inString) {
-          if (escapeNext) {
-            escapeNext = false;
-            continue;
-          }
-          if (char === '\\') {
-            escapeNext = true;
-            continue;
-          }
-          if (char === '"') {
-            inString = false;
-          }
-          continue;
-        }
-
-        if (char === '"') {
-          inString = true;
-          continue;
-        }
-
-        if (char === '{') {
-          depth += 1;
-        } else if (char === '}') {
-          depth -= 1;
-          if (depth === 0) {
-            return afterMarker.slice(firstBraceIndex, i + 1);
-          }
-        }
-      }
-
-      const fallbackMatch = /\{[\s\S]*\}/.exec(afterMarker);
-      return fallbackMatch ? fallbackMatch[0] : undefined;
-    };
-
-    const jsonPayload = extractJson(raw);
-
-    if (jsonPayload) {
-      const parseAttempts: Array<{ label: string; parser: () => unknown }> = [
-        {
-          label: 'json',
-          parser: () => JSON.parse(jsonPayload)
-        },
-        {
-          label: 'json5',
-          parser: () => JSON5.parse(jsonPayload)
-        }
-      ];
-
-      const sanitizedForJson5 = jsonPayload
-        .replace(/\bTrue\b/g, 'true')
-        .replace(/\bFalse\b/g, 'false')
-        .replace(/\bNone\b/g, 'null');
-
-      if (sanitizedForJson5 !== jsonPayload) {
-        parseAttempts.push({ label: 'json5-sanitized', parser: () => JSON5.parse(sanitizedForJson5) });
-      }
-
-      const parseErrors: string[] = [];
-
-      for (const attempt of parseAttempts) {
-        try {
-          const parsed = attempt.parser();
-          if (parsed && typeof parsed === 'object') {
-            return normalizePayload(parsed as Record<string, unknown>);
-          }
-        } catch (err) {
-          parseErrors.push(`${attempt.label}: ${err instanceof Error ? err.message : String(err)}`);
-        }
-      }
-
-      const errorMatch = /["']error["']\s*:\s*(?:"([^"\\]*(?:\\.[^"\\]*)*)"|'([^'\\]*(?:\\.[^'\\]*)*)')/i.exec(jsonPayload);
-      const messageMatch = /["']message["']\s*:\s*(?:"([^"\\]*(?:\\.[^"\\]*)*)"|'([^'\\]*(?:\\.[^'\\]*)*)')/i.exec(jsonPayload);
-      const fallbackText = errorMatch?.[1] ?? errorMatch?.[2] ?? messageMatch?.[1] ?? messageMatch?.[2];
-      const errorText = fallbackText && fallbackText.trim().length > 0
-        ? fallbackText.trim()
-        : `${defaults.failureMessage}: ${parseErrors[0] ?? 'Unable to parse RESULT payload'}`;
-
-      const snippet = jsonPayload.length > 240 ? `${jsonPayload.slice(0, 240)}…` : jsonPayload;
-      const detailsParts: string[] = [];
-      if (parseErrors.length > 0) {
-        detailsParts.push(`Parse attempts failed: ${parseErrors.join('; ')}`);
-      }
-      detailsParts.push(`Raw payload: ${snippet}`);
-      const detailsText = detailsParts.join(' | ');
-
-      return {
-        success: false as const,
-        error: errorText,
-        details: detailsText
-      };
-    }
-
-    return { success: false as const, error: defaults.failureMessage };
   }
 
   // Create sound cue
@@ -183,166 +28,37 @@ export class AudioTools {
       attenuationSettings?: string;
     };
   }) {
-  const escapePyString = (value: string) => value.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
-  const toPyNumber = (value?: number) =>
-    value === undefined || value === null || !Number.isFinite(value) ? 'None' : String(value);
-  const toPyBool = (value?: boolean) =>
-    value === undefined || value === null ? 'None' : value ? 'True' : 'False';
-
-  const path = params.savePath || '/Game/Audio/Cues';
-  const wavePath = params.wavePath || '';
-  const attenuationPath = params.settings?.attenuationSettings || '';
-  const volumeLiteral = toPyNumber(params.settings?.volume);
-  const pitchLiteral = toPyNumber(params.settings?.pitch);
-  const loopingLiteral = toPyBool(params.settings?.looping);
-
-  const py = `
-import unreal
-import json
-
-name = r"${escapePyString(params.name)}"
-package_path = r"${escapePyString(path)}"
-wave_path = r"${escapePyString(wavePath)}"
-attenuation_path = r"${escapePyString(attenuationPath)}"
-attach_wave = ${params.wavePath ? 'True' : 'False'}
-volume_override = ${volumeLiteral}
-pitch_override = ${pitchLiteral}
-looping_override = ${loopingLiteral}
-
-result = {
-  "success": False,
-  "message": "",
-  "error": "",
-  "warnings": []
-}
+    if (!this.automationBridge) {
+      throw new Error('Automation Bridge not available. Audio operations require plugin support.');
+    }
+
+    const path = params.savePath || '/Game/Audio/Cues';
+    const { volume, pitch } = this.validateAudioParams(params.settings?.volume, params.settings?.pitch);
 
-try:
-  asset_tools = unreal.AssetToolsHelpers.get_asset_tools()
-  if not asset_tools:
-    result["error"] = "AssetToolsHelpers unavailable"
-    raise SystemExit(0)
-
-  factory = None
-  try:
-    factory = unreal.SoundCueFactoryNew()
-  except Exception:
-    factory = None
-
-  if not factory:
-    result["error"] = "SoundCueFactoryNew unavailable"
-    raise SystemExit(0)
-
-  package_path = package_path.rstrip('/') if package_path else package_path
-
-  asset = asset_tools.create_asset(
-    asset_name=name,
-    package_path=package_path,
-    asset_class=unreal.SoundCue,
-    factory=factory
-  )
-
-  if not asset:
-    result["error"] = "Failed to create SoundCue"
-    raise SystemExit(0)
-
-  asset_subsystem = None
-  try:
-    asset_subsystem = unreal.get_editor_subsystem(unreal.EditorAssetSubsystem)
-  except Exception:
-    asset_subsystem = None
-
-  editor_library = unreal.EditorAssetLibrary
-
-  if attach_wave:
-    wave_exists = False
-    try:
-      if asset_subsystem and hasattr(asset_subsystem, "does_asset_exist"):
-        wave_exists = asset_subsystem.does_asset_exist(wave_path)
-      else:
-        wave_exists = editor_library.does_asset_exist(wave_path)
-    except Exception as existence_error:
-      result["warnings"].append(f"Wave lookup failed: {existence_error}")
-
-    if not wave_exists:
-      result["warnings"].append(f"Wave asset not found: {wave_path}")
-    else:
-      try:
-        if asset_subsystem and hasattr(asset_subsystem, "load_asset"):
-          wave_asset = asset_subsystem.load_asset(wave_path)
-        else:
-          wave_asset = editor_library.load_asset(wave_path)
-        if wave_asset:
-          # Hooking up cue nodes via Python is non-trivial; surface warning for manual setup
-          result["warnings"].append("Sound cue created without automatic wave node hookup")
-      except Exception as wave_error:
-        result["warnings"].append(f"Failed to load wave asset: {wave_error}")
-
-  if volume_override is not None and hasattr(asset, "volume_multiplier"):
-    asset.volume_multiplier = volume_override
-  if pitch_override is not None and hasattr(asset, "pitch_multiplier"):
-    asset.pitch_multiplier = pitch_override
-  if looping_override is not None and hasattr(asset, "b_looping"):
-    asset.b_looping = looping_override
-
-  if attenuation_path:
-    try:
-      attenuation_asset = editor_library.load_asset(attenuation_path)
-      if attenuation_asset:
-        applied = False
-        if hasattr(asset, "set_attenuation_settings"):
-          try:
-            asset.set_attenuation_settings(attenuation_asset)
-            applied = True
-          except Exception:
-            applied = False
-        if not applied and hasattr(asset, "attenuation_settings"):
-          asset.attenuation_settings = attenuation_asset
-          applied = True
-        if not applied:
-          result["warnings"].append("Attenuation asset loaded but could not be applied automatically")
-    except Exception as attenuation_error:
-      result["warnings"].append(f"Failed to apply attenuation: {attenuation_error}")
-
-  try:
-    save_target = f"{package_path}/{name}" if package_path else name
-    if asset_subsystem and hasattr(asset_subsystem, "save_asset"):
-      asset_subsystem.save_asset(save_target)
-    else:
-      editor_library.save_asset(save_target)
-  except Exception as save_error:
-    result["warnings"].append(f"Save failed: {save_error}")
-
-  result["success"] = True
-  result["message"] = "Sound cue created"
-
-except SystemExit:
-  pass
-except Exception as error:
-  result["error"] = str(error)
-
-finally:
-  payload = dict(result)
-  if payload.get("success"):
-    if not payload.get("message"):
-      payload["message"] = "Sound cue created"
-    payload.pop("error", None)
-  else:
-    if not payload.get("error"):
-      payload["error"] = payload.get("message") or "Failed to create SoundCue"
-    if not payload.get("message"):
-      payload["message"] = payload["error"]
-  if not payload.get("warnings"):
-    payload.pop("warnings", None)
-  print('RESULT:' + json.dumps(payload))
-`.trim();
     try {
-      const resp = await this.bridge.executePython(py);
-      return this.interpretResult(resp, {
-        successMessage: 'Sound cue created',
-        failureMessage: 'Failed to create SoundCue'
+      const response = await this.automationBridge.sendAutomationRequest('create_sound_cue', {
+        name: params.name,
+        packagePath: path,
+        wavePath: params.wavePath,
+        attenuationPath: params.settings?.attenuationSettings,
+        volume,
+        pitch,
+        looping: params.settings?.looping
+      }, {
+        timeoutMs: 60000
       });
-    } catch (e) {
-      return { success: false, error: `Failed to create sound cue: ${e}` };
+
+      if (response.success === false) {
+        return { success: false, error: response.error || response.message || 'Failed to create SoundCue' };
+      }
+
+      return {
+        success: true,
+        message: response.message || 'Sound cue created',
+        ...(response.result || {})
+      };
+    } catch (error) {
+      return { success: false, error: `Failed to create sound cue: ${error instanceof Error ? error.message : String(error)}` };
     }
   }
 
@@ -350,93 +66,45 @@ finally:
   async playSoundAtLocation(params: {
     soundPath: string;
     location: [number, number, number];
+    rotation?: [number, number, number];
     volume?: number;
     pitch?: number;
     startTime?: number;
+    attenuationPath?: string;
+    concurrencyPath?: string;
   }) {
-    const volume = params.volume ?? 1.0;
-    const pitch = params.pitch ?? 1.0;
-    const startTime = params.startTime ?? 0.0;
-    const soundPath = params.soundPath ?? '';
-
-  const py = `
-import unreal
-import json
-
-result = {
-  "success": False,
-  "message": "",
-  "error": "",
-  "warnings": []
-}
+    if (!this.automationBridge) {
+      throw new Error('Automation Bridge not available. Audio operations require plugin support.');
+    }
+
+    const { volume, pitch } = this.validateAudioParams(params.volume, params.pitch);
 
-try:
-  path = "${escapePythonString(soundPath)}"
-  if not unreal.EditorAssetLibrary.does_asset_exist(path):
-    result["error"] = "Sound asset not found"
-    raise SystemExit(0)
-
-  snd = unreal.EditorAssetLibrary.load_asset(path)
-  if not snd:
-    result["error"] = f"Failed to load sound asset: {path}"
-    raise SystemExit(0)
-
-  world = None
-  try:
-    world = unreal.EditorUtilityLibrary.get_editor_world()
-  except Exception:
-    world = None
-
-  if not world:
-    editor_subsystem = unreal.get_editor_subsystem(unreal.UnrealEditorSubsystem)
-    if editor_subsystem and hasattr(editor_subsystem, 'get_editor_world'):
-      world = editor_subsystem.get_editor_world()
-
-  if not world:
-    try:
-      world = unreal.EditorSubsystemLibrary.get_editor_world()
-    except Exception:
-      world = None
-
-  if not world:
-    result["error"] = "Unable to resolve editor world. Start PIE and ensure Editor Scripting Utilities is enabled."
-    raise SystemExit(0)
-
-  loc = unreal.Vector(${params.location[0]}, ${params.location[1]}, ${params.location[2]})
-  rot = unreal.Rotator(0.0, 0.0, 0.0)
-  unreal.GameplayStatics.spawn_sound_at_location(world, snd, loc, rot, ${volume}, ${pitch}, ${startTime})
-
-  result["success"] = True
-  result["message"] = "Sound played"
-
-except SystemExit:
-  pass
-except Exception as e:
-  result["error"] = str(e)
-finally:
-  payload = dict(result)
-  if payload.get("success"):
-    if not payload.get("message"):
-      payload["message"] = "Sound played"
-    payload.pop("error", None)
-  else:
-    if not payload.get("error"):
-      payload["error"] = payload.get("message") or "Failed to play sound"
-    if not payload.get("message"):
-      payload["message"] = payload["error"]
-  if not payload.get("warnings"):
-    payload.pop("warnings", None)
-  print('RESULT:' + json.dumps(payload))
-`.trim();
     try {
-      const resp = await this.bridge.executePythonWithResult(py);
-      return this.interpretResult(resp, {
-        successMessage: 'Sound played',
-        failureMessage: 'Failed to play sound'
+      const response = await this.automationBridge.sendAutomationRequest('play_sound_at_location', {
+        soundPath: params.soundPath,
+        location: params.location,
+        rotation: params.rotation ?? [0, 0, 0],
+        volume,
+        pitch,
+        startTime: params.startTime ?? 0.0,
+        attenuationPath: params.attenuationPath,
+        concurrencyPath: params.concurrencyPath
+      }, {
+        timeoutMs: 30000
       });
-  } catch (e) {
-    return { success: false, error: `Failed to play sound: ${e}` };
-  }
+
+      if (response.success === false) {
+        return { success: false, error: response.error || response.message || 'Failed to play sound' };
+      }
+
+      return {
+        success: true,
+        message: response.message || 'Sound played',
+        ...(response.result || {})
+      };
+    } catch (error) {
+      return { success: false, error: `Failed to play sound: ${error instanceof Error ? error.message : String(error)}` };
+    }
   }
 
   // Play sound 2D
@@ -446,192 +114,103 @@ finally:
     pitch?: number;
     startTime?: number;
   }) {
-    const volume = params.volume ?? 1.0;
-    const pitch = params.pitch ?? 1.0;
-    const startTime = params.startTime ?? 0.0;
-    const soundPath = params.soundPath ?? '';
-
-  const py = `
-import unreal
-import json
-
-result = {
-  "success": False,
-  "message": "",
-  "error": "",
-  "warnings": []
-}
+    if (!this.automationBridge) {
+      throw new Error('Automation Bridge not available. Audio operations require plugin support.');
+    }
 
-try:
-  path = "${escapePythonString(soundPath)}"
-  if not unreal.EditorAssetLibrary.does_asset_exist(path):
-    result["error"] = "Sound asset not found"
-    raise SystemExit(0)
-
-  snd = unreal.EditorAssetLibrary.load_asset(path)
-  if not snd:
-    result["error"] = f"Failed to load sound asset: {path}"
-    raise SystemExit(0)
-
-  world = None
-  try:
-    world = unreal.EditorUtilityLibrary.get_editor_world()
-  except Exception:
-    world = None
-
-  if not world:
-    editor_subsystem = unreal.get_editor_subsystem(unreal.UnrealEditorSubsystem)
-    if editor_subsystem and hasattr(editor_subsystem, 'get_editor_world'):
-      world = editor_subsystem.get_editor_world()
-
-  if not world:
-    try:
-      world = unreal.EditorSubsystemLibrary.get_editor_world()
-    except Exception:
-      world = None
-
-  if not world:
-    result["error"] = "Unable to resolve editor world. Start PIE and ensure Editor Scripting Utilities is enabled."
-    raise SystemExit(0)
-
-  ok = False
-  try:
-    unreal.GameplayStatics.spawn_sound_2d(world, snd, ${volume}, ${pitch}, ${startTime})
-    ok = True
-  except AttributeError:
-    try:
-      unreal.GameplayStatics.play_sound_2d(world, snd, ${volume}, ${pitch}, ${startTime})
-      ok = True
-    except AttributeError:
-      pass
-
-  if not ok:
-    cam_loc = unreal.Vector(0.0, 0.0, 0.0)
-    try:
-      editor_subsystem = unreal.get_editor_subsystem(unreal.UnrealEditorSubsystem)
-      if editor_subsystem and hasattr(editor_subsystem, 'get_level_viewport_camera_info'):
-        info = editor_subsystem.get_level_viewport_camera_info()
-        if isinstance(info, (list, tuple)) and len(info) > 0:
-          cam_loc = info[0]
-    except Exception:
-      try:
-        controller = world.get_first_player_controller()
-        if controller:
-          pawn = controller.get_pawn()
-          if pawn:
-            cam_loc = pawn.get_actor_location()
-      except Exception:
-        pass
-
-    try:
-      rot = unreal.Rotator(0.0, 0.0, 0.0)
-      unreal.GameplayStatics.spawn_sound_at_location(world, snd, cam_loc, rot, ${volume}, ${pitch}, ${startTime})
-      ok = True
-      result["warnings"].append("Fell back to 3D playback at camera location")
-    except Exception as location_error:
-      result["warnings"].append(f"Failed fallback playback: {location_error}")
-
-  if not ok:
-    result["error"] = "Failed to play sound in 2D or fallback configuration"
-    raise SystemExit(0)
-
-  result["success"] = True
-  result["message"] = "Sound2D played"
-
-except SystemExit:
-  pass
-except Exception as e:
-  result["error"] = str(e)
-finally:
-  payload = dict(result)
-  if payload.get("success"):
-    if not payload.get("message"):
-      payload["message"] = "Sound2D played"
-    payload.pop("error", None)
-  else:
-    if not payload.get("error"):
-      payload["error"] = payload.get("message") or "Failed to play sound2D"
-    if not payload.get("message"):
-      payload["message"] = payload["error"]
-  if not payload.get("warnings"):
-    payload.pop("warnings", None)
-  print('RESULT:' + json.dumps(payload))
-`.trim();
     try {
-      const resp = await this.bridge.executePythonWithResult(py);
-      return this.interpretResult(resp, {
-        successMessage: 'Sound2D played',
-        failureMessage: 'Failed to play sound2D'
+      const response = await this.automationBridge.sendAutomationRequest('play_sound_2d', {
+        soundPath: params.soundPath,
+        volume: params.volume ?? 1.0,
+        pitch: params.pitch ?? 1.0,
+        startTime: params.startTime ?? 0.0
+      }, {
+        timeoutMs: 30000
       });
-  } catch (e) {
-    return { success: false, error: `Failed to play sound2D: ${e}` };
+
+      if (response.success === false) {
+        return { success: false, error: response.error || response.message || 'Failed to play 2D sound' };
+      }
+
+      return {
+        success: true,
+        message: response.message || '2D sound played',
+        ...(response.result || {})
+      };
+    } catch (error) {
+      return { success: false, error: `Failed to play 2D sound: ${error instanceof Error ? error.message : String(error)}` };
+    }
   }
+
+  // Convenience wrapper used by system_control: best-effort 2D sound playback
+  async playSound(soundPath: string, volume?: number, pitch?: number) {
+    return this.playSound2D({
+      soundPath,
+      volume,
+      pitch
+    });
   }
 
-  // Create audio component
-  async createAudioComponent(params: {
+  // Create audio component (requires C++ plugin)
+  async createAudioComponent(_params: {
     actorName: string;
     componentName: string;
     soundPath: string;
     autoPlay?: boolean;
     is3D?: boolean;
   }) {
-    const commands = [];
-    
-    commands.push(`AddAudioComponent ${params.actorName} ${params.componentName} ${params.soundPath}`);
-    
-    if (params.autoPlay !== undefined) {
-      commands.push(`SetAudioComponentAutoPlay ${params.actorName}.${params.componentName} ${params.autoPlay}`);
+    if (!this.automationBridge) {
+      throw new Error('Automation Bridge not available. Creating audio components requires plugin support.');
     }
-    
-    if (params.is3D !== undefined) {
-      commands.push(`SetAudioComponent3D ${params.actorName}.${params.componentName} ${params.is3D}`);
-    }
-    
-    for (const cmd of commands) {
-      await this.bridge.executeConsoleCommand(cmd);
+
+    try {
+      const response = await this.automationBridge.sendAutomationRequest('create_audio_component', {
+        actorName: _params.actorName,
+        componentName: _params.componentName,
+        soundPath: _params.soundPath,
+        autoPlay: _params.autoPlay ?? false,
+        is3D: _params.is3D ?? true
+      });
+
+      return response.success
+        ? { success: true, message: response.message || 'Audio component created', ...(response.result || {}) }
+        : { success: false, error: response.error || response.message || 'Failed to create audio component' };
+    } catch (error) {
+      return { success: false, error: `Failed to create audio component: ${error instanceof Error ? error.message : String(error)}` };
     }
-    
-    return { success: true, message: `Audio component ${params.componentName} added to ${params.actorName}` };
   }
 
-  // Set sound attenuation
-  async setSoundAttenuation(params: {
+  // Set sound attenuation (requires C++ plugin)
+  async setSoundAttenuation(_params: {
     name: string;
     innerRadius?: number;
     falloffDistance?: number;
     attenuationShape?: 'Sphere' | 'Capsule' | 'Box' | 'Cone';
     falloffMode?: 'Linear' | 'Logarithmic' | 'Inverse' | 'LogReverse' | 'Natural';
   }) {
-    const commands = [];
-    
-    commands.push(`CreateAttenuationSettings ${params.name}`);
-    
-    if (params.innerRadius !== undefined) {
-      commands.push(`SetAttenuationInnerRadius ${params.name} ${params.innerRadius}`);
-    }
-    
-    if (params.falloffDistance !== undefined) {
-      commands.push(`SetAttenuationFalloffDistance ${params.name} ${params.falloffDistance}`);
-    }
-    
-    if (params.attenuationShape) {
-      commands.push(`SetAttenuationShape ${params.name} ${params.attenuationShape}`);
-    }
-    
-    if (params.falloffMode) {
-      commands.push(`SetAttenuationFalloffMode ${params.name} ${params.falloffMode}`);
+    if (!this.automationBridge) {
+      throw new Error('Automation Bridge not available. Setting sound attenuation requires plugin support.');
     }
-    
-    for (const cmd of commands) {
-      await this.bridge.executeConsoleCommand(cmd);
+
+    try {
+      const response = await this.automationBridge.sendAutomationRequest('set_sound_attenuation', {
+        name: _params.name,
+        innerRadius: _params.innerRadius,
+        falloffDistance: _params.falloffDistance,
+        attenuationShape: _params.attenuationShape,
+        falloffMode: _params.falloffMode
+      });
+
+      return response.success
+        ? { success: true, message: response.message || 'Sound attenuation set', ...(response.result || {}) }
+        : { success: false, error: response.error || response.message || 'Failed to set sound attenuation' };
+    } catch (error) {
+      return { success: false, error: `Failed to set sound attenuation: ${error instanceof Error ? error.message : String(error)}` };
     }
-    
-    return { success: true, message: `Attenuation settings ${params.name} configured` };
   }
 
-  // Create sound class
-  async createSoundClass(params: {
+  // Create sound class (requires C++ plugin)
+  async createSoundClass(_params: {
     name: string;
     parentClass?: string;
     properties?: {
@@ -641,35 +220,27 @@ finally:
       attenuationDistanceScale?: number;
     };
   }) {
-    const commands = [];
-    const parent = params.parentClass || 'Master';
-    
-    commands.push(`CreateSoundClass ${params.name} ${parent}`);
-    
-    if (params.properties) {
-      if (params.properties.volume !== undefined) {
-        commands.push(`SetSoundClassVolume ${params.name} ${params.properties.volume}`);
-      }
-      if (params.properties.pitch !== undefined) {
-        commands.push(`SetSoundClassPitch ${params.name} ${params.properties.pitch}`);
-      }
-      if (params.properties.lowPassFilterFrequency !== undefined) {
-        commands.push(`SetSoundClassLowPassFilter ${params.name} ${params.properties.lowPassFilterFrequency}`);
-      }
-      if (params.properties.attenuationDistanceScale !== undefined) {
-        commands.push(`SetSoundClassAttenuationScale ${params.name} ${params.properties.attenuationDistanceScale}`);
-      }
+    if (!this.automationBridge) {
+      throw new Error('Automation Bridge not available. Creating sound classes requires plugin support.');
     }
-    
-    for (const cmd of commands) {
-      await this.bridge.executeConsoleCommand(cmd);
+
+    try {
+      const response = await this.automationBridge.sendAutomationRequest('create_sound_class', {
+        name: _params.name,
+        parentClass: _params.parentClass,
+        properties: _params.properties
+      });
+
+      return response.success
+        ? { success: true, message: response.message || 'Sound class created', ...(response.result || {}) }
+        : { success: false, error: response.error || response.message || 'Failed to create sound class' };
+    } catch (error) {
+      return { success: false, error: `Failed to create sound class: ${error instanceof Error ? error.message : String(error)}` };
     }
-    
-    return { success: true, message: `Sound class ${params.name} created` };
   }
 
-  // Create sound mix
-  async createSoundMix(params: {
+  // Create sound mix (requires C++ plugin)
+  async createSoundMix(_params: {
     name: string;
     classAdjusters?: Array<{
       soundClass: string;
@@ -679,49 +250,63 @@ finally:
       fadeOutTime?: number;
     }>;
   }) {
-    const commands = [];
-    
-    commands.push(`CreateSoundMix ${params.name}`);
-    
-    if (params.classAdjusters) {
-      for (const adjuster of params.classAdjusters) {
-        commands.push(`AddSoundMixClassAdjuster ${params.name} ${adjuster.soundClass}`);
-        
-        if (adjuster.volumeAdjuster !== undefined) {
-          commands.push(`SetSoundMixVolume ${params.name} ${adjuster.soundClass} ${adjuster.volumeAdjuster}`);
-        }
-        if (adjuster.pitchAdjuster !== undefined) {
-          commands.push(`SetSoundMixPitch ${params.name} ${adjuster.soundClass} ${adjuster.pitchAdjuster}`);
-        }
-        if (adjuster.fadeInTime !== undefined) {
-          commands.push(`SetSoundMixFadeIn ${params.name} ${adjuster.soundClass} ${adjuster.fadeInTime}`);
-        }
-        if (adjuster.fadeOutTime !== undefined) {
-          commands.push(`SetSoundMixFadeOut ${params.name} ${adjuster.soundClass} ${adjuster.fadeOutTime}`);
-        }
-      }
+    if (!this.automationBridge) {
+      throw new Error('Automation Bridge not available. Creating sound mixes requires plugin support.');
     }
-    
-    for (const cmd of commands) {
-      await this.bridge.executeConsoleCommand(cmd);
+
+    try {
+      const response = await this.automationBridge.sendAutomationRequest('create_sound_mix', {
+        name: _params.name,
+        classAdjusters: _params.classAdjusters
+      });
+
+      return response.success
+        ? { success: true, message: response.message || 'Sound mix created', ...(response.result || {}) }
+        : { success: false, error: response.error || response.message || 'Failed to create sound mix' };
+    } catch (error) {
+      return { success: false, error: `Failed to create sound mix: ${error instanceof Error ? error.message : String(error)}` };
     }
-    
-    return { success: true, message: `Sound mix ${params.name} created` };
   }
 
-  // Push/Pop sound mix
-  async pushSoundMix(params: {
+  // Push/Pop sound mix (requires C++ plugin)
+  async pushSoundMix(_params: {
     mixName: string;
   }) {
-    const command = `PushSoundMix ${params.mixName}`;
-    return this.bridge.executeConsoleCommand(command);
+    if (!this.automationBridge) {
+      throw new Error('Automation Bridge not available. Pushing sound mixes requires plugin support.');
+    }
+
+    try {
+      const response = await this.automationBridge.sendAutomationRequest('push_sound_mix', {
+        mixName: _params.mixName
+      });
+
+      return response.success
+        ? { success: true, message: response.message || 'Sound mix pushed', ...(response.result || {}) }
+        : { success: false, error: response.error || response.message || 'Failed to push sound mix' };
+    } catch (error) {
+      return { success: false, error: `Failed to push sound mix: ${error instanceof Error ? error.message : String(error)}` };
+    }
   }
 
-  async popSoundMix(params: {
+  async popSoundMix(_params: {
     mixName: string;
   }) {
-    const command = `PopSoundMix ${params.mixName}`;
-    return this.bridge.executeConsoleCommand(command);
+    if (!this.automationBridge) {
+      throw new Error('Automation Bridge not available. Popping sound mixes requires plugin support.');
+    }
+
+    try {
+      const response = await this.automationBridge.sendAutomationRequest('pop_sound_mix', {
+        mixName: _params.mixName
+      });
+
+      return response.success
+        ? { success: true, message: response.message || 'Sound mix popped', ...(response.result || {}) }
+        : { success: false, error: response.error || response.message || 'Failed to pop sound mix' };
+    } catch (error) {
+      return { success: false, error: `Failed to pop sound mix: ${error instanceof Error ? error.message : String(error)}` };
+    }
   }
 
   // Set master volume
@@ -730,99 +315,54 @@ finally:
   }) {
     // Clamp volume between 0 and 1
     const vol = Math.max(0.0, Math.min(1.0, params.volume));
-    
+
     // Use the proper Unreal Engine audio command
     // Note: au.Master.Volume is the correct console variable for master volume
     const command = `au.Master.Volume ${vol}`;
-    
+
     try {
       await this.bridge.executeConsoleCommand(command);
       return { success: true, message: `Master volume set to ${vol}` };
     } catch (e) {
-      // Fallback to Python method if console command fails
-      const py = `
-  import unreal
-  import json
-  try:
-      # Try using AudioMixerBlueprintLibrary if available
-      try:
-          unreal.AudioMixerBlueprintLibrary.set_overall_volume_multiplier(${vol})
-          print('RESULT:' + json.dumps({'success': True}))
-      except AttributeError:
-          # Fallback to GameplayStatics method using modern subsystems
-          try:
-              # Try modern subsystem first
-              try:
-                  editor_subsystem = unreal.get_editor_subsystem(unreal.UnrealEditorSubsystem)
-                  if hasattr(editor_subsystem, 'get_editor_world'):
-                      world = editor_subsystem.get_editor_world()
-                  else:
-                      world = unreal.EditorLevelLibrary.get_editor_world()
-              except Exception:
-                  world = unreal.EditorLevelLibrary.get_editor_world()
-              unreal.GameplayStatics.set_global_pitch_modulation(world, 1.0, 0.0)  # Reset pitch
-              unreal.GameplayStatics.set_global_time_dilation(world, 1.0)  # Reset time
-              # Note: There's no direct master volume in GameplayStatics, use sound class
-              print('RESULT:' + json.dumps({'success': False, 'error': 'Master volume control not available, use sound classes instead'}))
-          except Exception as e2:
-              print('RESULT:' + json.dumps({'success': False, 'error': str(e2)}))
-  except Exception as e:
-      print('RESULT:' + json.dumps({'success': False, 'error': str(e)}))
-  `.trim();
-      
-      try {
-        const resp = await this.bridge.executePython(py);
-        const out = typeof resp === 'string' ? resp : JSON.stringify(resp);
-        const m = out.match(/RESULT:({.*})/);
-        if (m) {
-          try {
-            const parsed = JSON.parse(m[1]);
-            return parsed.success 
-              ? { success: true, message: `Master volume set to ${vol}` }
-              : { success: false, error: parsed.error };
-          } catch {}
-        }
-        return { success: true, message: 'Master volume set command executed' };
-      } catch {
-        return { success: false, error: `Failed to set master volume: ${e}` };
-      }
+      return { success: false, error: `Failed to set master volume: ${e instanceof Error ? e.message : String(e)}` };
     }
   }
 
-  // Create ambient sound
-  async createAmbientSound(params: {
-    name: string;
-    location: [number, number, number];
+  // Create ambient sound (requires C++ plugin)
+  async createAmbientSound(_params: {
     soundPath: string;
+    location: [number, number, number];
     volume?: number;
-    radius?: number;
-    autoPlay?: boolean;
+    pitch?: number;
+    startTime?: number;
+    attenuationPath?: string;
+    concurrencyPath?: string;
   }) {
-    const commands = [];
-    
-    commands.push(`SpawnAmbientSound ${params.name} ${params.location.join(' ')} ${params.soundPath}`);
-    
-    if (params.volume !== undefined) {
-      commands.push(`SetAmbientVolume ${params.name} ${params.volume}`);
-    }
-    
-    if (params.radius !== undefined) {
-      commands.push(`SetAmbientRadius ${params.name} ${params.radius}`);
-    }
-    
-    if (params.autoPlay !== undefined) {
-      commands.push(`SetAmbientAutoPlay ${params.name} ${params.autoPlay}`);
+    if (!this.automationBridge) {
+      throw new Error('Automation Bridge not available. Creating ambient sounds requires plugin support.');
     }
-    
-    for (const cmd of commands) {
-      await this.bridge.executeConsoleCommand(cmd);
+
+    try {
+      const response = await this.automationBridge.sendAutomationRequest('create_ambient_sound', {
+        soundPath: _params.soundPath,
+        location: _params.location,
+        volume: _params.volume ?? 1.0,
+        pitch: _params.pitch ?? 1.0,
+        startTime: _params.startTime ?? 0.0,
+        attenuationPath: _params.attenuationPath,
+        concurrencyPath: _params.concurrencyPath
+      });
+
+      return response.success
+        ? { success: true, message: response.message || 'Ambient sound created', ...(response.result || {}) }
+        : { success: false, error: response.error || response.message || 'Failed to create ambient sound' };
+    } catch (error) {
+      return { success: false, error: `Failed to create ambient sound: ${error instanceof Error ? error.message : String(error)}` };
     }
-    
-    return { success: true, message: `Ambient sound ${params.name} created` };
   }
 
-  // Create reverb zone
-  async createReverbZone(params: {
+  // Create reverb zone (requires C++ plugin)
+  async createReverbZone(_params: {
     name: string;
     location: [number, number, number];
     size: [number, number, number];
@@ -830,52 +370,51 @@ finally:
     volume?: number;
     fadeTime?: number;
   }) {
-    const commands = [];
-    
-    commands.push(`CreateReverbVolume ${params.name} ${params.location.join(' ')} ${params.size.join(' ')}`);
-    
-    if (params.reverbEffect) {
-      commands.push(`SetReverbEffect ${params.name} ${params.reverbEffect}`);
-    }
-    
-    if (params.volume !== undefined) {
-      commands.push(`SetReverbVolume ${params.name} ${params.volume}`);
-    }
-    
-    if (params.fadeTime !== undefined) {
-      commands.push(`SetReverbFadeTime ${params.name} ${params.fadeTime}`);
+    if (!this.automationBridge) {
+      throw new Error('Automation Bridge not available. Creating reverb zones requires plugin support.');
     }
-    
-    for (const cmd of commands) {
-      await this.bridge.executeConsoleCommand(cmd);
+
+    try {
+      const response = await this.automationBridge.sendAutomationRequest('create_reverb_zone', {
+        name: _params.name,
+        location: _params.location,
+        size: _params.size,
+        reverbEffect: _params.reverbEffect,
+        volume: _params.volume,
+        fadeTime: _params.fadeTime
+      });
+
+      return response.success
+        ? { success: true, message: response.message || 'Reverb zone created', ...(response.result || {}) }
+        : { success: false, error: response.error || response.message || 'Failed to create reverb zone' };
+    } catch (error) {
+      return { success: false, error: `Failed to create reverb zone: ${error instanceof Error ? error.message : String(error)}` };
     }
-    
-    return { success: true, message: `Reverb zone ${params.name} created` };
   }
 
-  // Audio analysis
-  async enableAudioAnalysis(params: {
+  // Audio analysis (requires C++ plugin)
+  async enableAudioAnalysis(_params: {
     enabled: boolean;
     fftSize?: number;
     outputType?: 'Magnitude' | 'Decibel' | 'Normalized';
   }) {
-    const commands = [];
-    
-    commands.push(`EnableAudioAnalysis ${params.enabled}`);
-    
-    if (params.enabled && params.fftSize) {
-      commands.push(`SetFFTSize ${params.fftSize}`);
+    if (!this.automationBridge) {
+      throw new Error('Automation Bridge not available. Audio analysis controls require plugin support.');
     }
-    
-    if (params.enabled && params.outputType) {
-      commands.push(`SetAudioAnalysisOutput ${params.outputType}`);
-    }
-    
-    for (const cmd of commands) {
-      await this.bridge.executeConsoleCommand(cmd);
+
+    try {
+      const response = await this.automationBridge.sendAutomationRequest('enable_audio_analysis', {
+        enabled: _params.enabled,
+        fftSize: _params.fftSize,
+        outputType: _params.outputType
+      });
+
+      return response.success
+        ? { success: true, message: response.message || `Audio analysis ${_params.enabled ? 'enabled' : 'disabled'}`, ...(response.result || {}) }
+        : { success: false, error: response.error || response.message || 'Failed to enable audio analysis' };
+    } catch (error) {
+      return { success: false, error: `Failed to enable audio analysis: ${error instanceof Error ? error.message : String(error)}` };
     }
-    
-    return { success: true, message: `Audio analysis ${params.enabled ? 'enabled' : 'disabled'}` };
   }
 
   // Stop all sounds
@@ -883,60 +422,78 @@ finally:
     return this.bridge.executeConsoleCommand('StopAllSounds');
   }
 
-  // Fade sound
-  async fadeSound(params: {
+  // Fade sound (requires C++ plugin)
+  async fadeSound(_params: {
     soundName: string;
     targetVolume: number;
     fadeTime: number;
     fadeType?: 'FadeIn' | 'FadeOut' | 'FadeTo';
   }) {
-    const type = params.fadeType || 'FadeTo';
-    const command = `${type}Sound ${params.soundName} ${params.targetVolume} ${params.fadeTime}`;
-    return this.bridge.executeConsoleCommand(command);
+    if (!this.automationBridge) {
+      throw new Error('Automation Bridge not available. Fading sound requires plugin support.');
+    }
+
+    try {
+      const response = await this.automationBridge.sendAutomationRequest('fade_sound', {
+        soundName: _params.soundName,
+        targetVolume: _params.targetVolume,
+        fadeTime: _params.fadeTime,
+        fadeType: _params.fadeType || 'FadeTo'
+      });
+
+      return response.success
+        ? { success: true, message: response.message || 'Sound faded', ...(response.result || {}) }
+        : { success: false, error: response.error || response.message || 'Failed to fade sound' };
+    } catch (error) {
+      return { success: false, error: `Failed to fade sound: ${error instanceof Error ? error.message : String(error)}` };
+    }
   }
 
-  // Set doppler effect
-  async setDopplerEffect(params: {
+  // Set doppler effect (requires C++ plugin)
+  async setDopplerEffect(_params: {
     enabled: boolean;
     scale?: number;
   }) {
-    const commands = [];
-    
-    commands.push(`EnableDoppler ${params.enabled}`);
-    
-    if (params.scale !== undefined) {
-      commands.push(`SetDopplerScale ${params.scale}`);
+    if (!this.automationBridge) {
+      throw new Error('Automation Bridge not available. Doppler effect controls require plugin support.');
     }
-    
-    for (const cmd of commands) {
-      await this.bridge.executeConsoleCommand(cmd);
+
+    try {
+      const response = await this.automationBridge.sendAutomationRequest('set_doppler_effect', {
+        enabled: _params.enabled,
+        scale: _params.scale ?? 1.0
+      });
+
+      return response.success
+        ? { success: true, message: response.message || `Doppler effect ${_params.enabled ? 'enabled' : 'disabled'}`, ...(response.result || {}) }
+        : { success: false, error: response.error || response.message || 'Failed to set doppler effect' };
+    } catch (error) {
+      return { success: false, error: `Failed to set doppler effect: ${error instanceof Error ? error.message : String(error)}` };
     }
-    
-    return { success: true, message: `Doppler effect ${params.enabled ? 'enabled' : 'disabled'}` };
   }
 
-  // Audio occlusion
-  async setAudioOcclusion(params: {
+  // Audio occlusion (requires C++ plugin)
+  async setAudioOcclusion(_params: {
     enabled: boolean;
     lowPassFilterFrequency?: number;
     volumeAttenuation?: number;
   }) {
-    const commands = [];
-    
-    commands.push(`EnableAudioOcclusion ${params.enabled}`);
-    
-    if (params.lowPassFilterFrequency !== undefined) {
-      commands.push(`SetOcclusionLowPassFilter ${params.lowPassFilterFrequency}`);
-    }
-    
-    if (params.volumeAttenuation !== undefined) {
-      commands.push(`SetOcclusionVolumeAttenuation ${params.volumeAttenuation}`);
+    if (!this.automationBridge) {
+      throw new Error('Automation Bridge not available. Audio occlusion controls require plugin support.');
     }
-    
-    for (const cmd of commands) {
-      await this.bridge.executeConsoleCommand(cmd);
+
+    try {
+      const response = await this.automationBridge.sendAutomationRequest('set_audio_occlusion', {
+        enabled: _params.enabled,
+        lowPassFilterFrequency: _params.lowPassFilterFrequency,
+        volumeAttenuation: _params.volumeAttenuation
+      });
+
+      return response.success
+        ? { success: true, message: response.message || `Audio occlusion ${_params.enabled ? 'enabled' : 'disabled'}`, ...(response.result || {}) }
+        : { success: false, error: response.error || response.message || 'Failed to set audio occlusion' };
+    } catch (error) {
+      return { success: false, error: `Failed to set audio occlusion: ${error instanceof Error ? error.message : String(error)}` };
     }
-    
-    return { success: true, message: `Audio occlusion ${params.enabled ? 'enabled' : 'disabled'}` };
   }
 }