unreal-engine-mcp-server 0.4.6 → 0.5.0

package/src/tools/sequence.ts

@@ -1,6 +1,5 @@
-import { UnrealBridge } from '../unreal-bridge.js';
-import { Logger } from '../utils/logger.js';
-import { interpretStandardResult } from '../utils/result-helpers.js';
+import { BaseTool } from './base-tool.js';
+import { ISequenceTools } from '../types/tool-interfaces.js';
 
 export interface LevelSequence {
   path: string;
@@ -23,896 +22,337 @@ export interface SequenceTrack {
   sections?: any[];
 }
 
-export class SequenceTools {
-  private log = new Logger('SequenceTools');
+export class SequenceTools extends BaseTool implements ISequenceTools {
   private sequenceCache = new Map<string, LevelSequence>();
-  private retryAttempts = 3;
-  private retryDelay = 1000;
-  
-  constructor(private bridge: UnrealBridge) {}
-
-    private async ensureSequencerPrerequisites(operation: string): Promise<string[] | null> {
-        const missing = await this.bridge.ensurePluginsEnabled(['LevelSequenceEditor', 'Sequencer'], operation);
-        return missing.length ? missing : null;
+  private activeSequencePath?: string;
+
+  private resolveSequencePath(explicitPath?: unknown): string | undefined {
+    if (typeof explicitPath === 'string' && explicitPath.trim().length > 0) {
+      return explicitPath.trim();
     }
+    return this.activeSequencePath;
+  }
 
-  /**
-   * Execute with retry logic for transient failures
-   */
-  private async executeWithRetry<T>(
-    operation: () => Promise<T>,
-    operationName: string
-  ): Promise<T> {
-    let lastError: any;
-    
-    for (let attempt = 1; attempt <= this.retryAttempts; attempt++) {
-      try {
-        return await operation();
-      } catch (error: any) {
-        lastError = error;
-        this.log.warn(`${operationName} attempt ${attempt} failed: ${error.message || error}`);
-        
-        if (attempt < this.retryAttempts) {
-          await new Promise(resolve => 
-            setTimeout(resolve, this.retryDelay * attempt)
-          );
-        }
-      }
+  private async sendAction(action: string, payload: Record<string, unknown> = {}, timeoutMs?: number) {
+    const envDefault = Number(process.env.MCP_AUTOMATION_REQUEST_TIMEOUT_MS ?? '120000');
+    const defaultTimeout = Number.isFinite(envDefault) && envDefault > 0 ? envDefault : 120000;
+    const finalTimeout = typeof timeoutMs === 'number' && timeoutMs > 0 ? timeoutMs : defaultTimeout;
+
+    try {
+      const response = await this.sendAutomationRequest(
+        action,
+        payload,
+        { timeoutMs: finalTimeout, waitForEvent: false }
+      );
+
+      const success = response && response.success !== false;
+      const result = response.result ?? response;
+
+      return { success, message: response.message ?? undefined, error: response.success === false ? (response.error ?? response.message) : undefined, result, requestId: response.requestId } as any;
+    } catch (err: any) {
+      return { success: false, error: String(err), message: String(err) } as const;
     }
-    
-    throw lastError;
   }
 
-  /**
-   * Parse Python execution result with better error handling
-   */
-    private parsePythonResult(resp: unknown, operationName: string): any {
-        const interpreted = interpretStandardResult(resp, {
-            successMessage: `${operationName} succeeded`,
-            failureMessage: `${operationName} failed`
-        });
-
-        if (interpreted.success) {
-            return {
-                ...interpreted.payload,
-                success: true
-            };
-        }
-
-        const baseError = interpreted.error ?? `${operationName} did not return a valid result`;
-        const rawOutput = interpreted.rawText ?? '';
-        const cleanedOutput = interpreted.cleanText && interpreted.cleanText.trim().length > 0
-            ? interpreted.cleanText.trim()
-            : baseError;
-
-        if (rawOutput.includes('ModuleNotFoundError')) {
-            return { success: false, error: 'Sequencer module not available. Ensure Sequencer is enabled.' };
-        }
-        if (rawOutput.includes('AttributeError')) {
-            return { success: false, error: 'Sequencer API method not found. Check Unreal Engine version compatibility.' };
-        }
-
-        this.log.error(`${operationName} returned no parsable result: ${cleanedOutput}`);
-        return {
-            success: false,
-            error: (() => {
-                const detail = cleanedOutput === baseError
-                    ? ''
-                    : (cleanedOutput ?? '').substring(0, 200).trim();
-                return detail ? `${baseError}: ${detail}` : baseError;
-            })()
-        };
+  private isUnknownActionResponse(res: any): boolean {
+    if (!res) return false;
+    const txt = String((res.error ?? res.message ?? '')).toLowerCase();
+    // Only treat specific error codes as "not implemented"
+    return txt.includes('unknown_action') || txt.includes('unknown automation action') || txt.includes('not_implemented') || txt === 'unknown_plugin_action';
   }
 
-  async create(params: { name: string; path?: string }) {
+  async create(params: { name: string; path?: string; timeoutMs?: number }) {
     const name = params.name?.trim();
     const base = (params.path || '/Game/Sequences').replace(/\/$/, '');
     if (!name) return { success: false, error: 'name is required' };
-        const missingPlugins = await this.ensureSequencerPrerequisites('SequenceTools.create');
-        if (missingPlugins?.length) {
-            const sequencePath = `${base}/${name}`;
-            this.log.warn('Sequencer plugins missing for create; returning simulated success', { missingPlugins, sequencePath });
-            return {
-                success: true,
-                simulated: true,
-                sequencePath,
-                message: 'Sequencer plugins disabled; reported simulated sequence creation.',
-                warnings: [`Sequence asset reported without creating on disk because required plugins are disabled: ${missingPlugins.join(', ')}`]
-            };
-        }
-    const py = `
-import unreal, json
-name = r"${name}"
-base = r"${base}"
-full = f"{base}/{name}"
-try:
-    # Ensure directory exists
-    try:
-        if not unreal.EditorAssetLibrary.does_directory_exist(base):
-            unreal.EditorAssetLibrary.make_directory(base)
-    except Exception:
-        pass
-
-    if unreal.EditorAssetLibrary.does_asset_exist(full):
-        print('RESULT:' + json.dumps({'success': True, 'sequencePath': full, 'existing': True}))
-    else:
-        asset_tools = unreal.AssetToolsHelpers.get_asset_tools()
-        factory = unreal.LevelSequenceFactoryNew()
-        seq = asset_tools.create_asset(asset_name=name, package_path=base, asset_class=unreal.LevelSequence, factory=factory)
-        if seq:
-            unreal.EditorAssetLibrary.save_asset(full)
-            print('RESULT:' + json.dumps({'success': True, 'sequencePath': full}))
-        else:
-            print('RESULT:' + json.dumps({'success': False, 'error': 'Create returned None'}))
-except Exception as e:
-    print('RESULT:' + json.dumps({'success': False, 'error': str(e)}))
-`.trim();
-    const resp = await this.executeWithRetry(
-      () => this.bridge.executePython(py),
-      'createSequence'
-    );
-    
-    const result = this.parsePythonResult(resp, 'createSequence');
-    
-    // Cache the sequence if successful
-    if (result.success && result.sequencePath) {
-      const sequence: LevelSequence = {
-        path: result.sequencePath,
-        name: name
-      };
+
+    const payload = { name, path: base } as Record<string, unknown>;
+    const resp = await this.sendAction('sequence_create', payload, params.timeoutMs);
+    if (!resp.success && this.isUnknownActionResponse(resp)) {
+      return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement sequence_create' } as const;
+    }
+    if (resp.success && resp.result && resp.result.sequencePath) {
+      const sequence: LevelSequence = { path: resp.result.sequencePath, name };
       this.sequenceCache.set(sequence.path, sequence);
+      return { ...resp, sequence: resp.result.sequencePath };
     }
-    
-    return result;
+    return resp;
   }
 
   async open(params: { path: string }) {
-        const missingPlugins = await this.ensureSequencerPrerequisites('SequenceTools.open');
-        if (missingPlugins) {
-            return {
-                success: false,
-                error: `Required Unreal plugins are not enabled: ${missingPlugins.join(', ')}`
-            };
-        }
-    const py = `
-import unreal, json
-path = r"${params.path}"
-try:
-    seq = unreal.load_asset(path)
-    if not seq:
-        print('RESULT:' + json.dumps({'success': False, 'error': 'Sequence not found'}))
-    else:
-        unreal.LevelSequenceEditorBlueprintLibrary.open_level_sequence(seq)
-        print('RESULT:' + json.dumps({'success': True, 'sequencePath': path}))
-except Exception as e:
-    print('RESULT:' + json.dumps({'success': False, 'error': str(e)}))
-`.trim();
-    const resp = await this.executeWithRetry(
-      () => this.bridge.executePython(py),
-      'openSequence'
-    );
-    
-    return this.parsePythonResult(resp, 'openSequence');
+    const path = params.path?.trim();
+    const resp = await this.sendAction('sequence_open', { path });
+    if (!resp.success && this.isUnknownActionResponse(resp)) {
+      return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement sequence_open' } as const;
+    }
+    if (resp && resp.success !== false && path) {
+      this.activeSequencePath = path;
+    }
+    return resp;
   }
 
-  async addCamera(params: { spawnable?: boolean }) {
-        const missingPlugins = await this.ensureSequencerPrerequisites('SequenceTools.addCamera');
-        if (missingPlugins?.length) {
-            this.log.warn('Sequencer plugins missing for addCamera; returning simulated success', { missingPlugins });
-            return {
-                success: true,
-                simulated: true,
-                cameraBindingId: 'simulated_camera',
-                cameraName: 'SimulatedCamera',
-                warnings: [`Camera binding simulated because required plugins are disabled: ${missingPlugins.join(', ')}`]
-            };
-        }
-    const py = `
-import unreal, json
-try:
-    ls = unreal.get_editor_subsystem(unreal.LevelSequenceEditorSubsystem)
-    if not ls:
-        print('RESULT:' + json.dumps({'success': False, 'error': 'LevelSequenceEditorSubsystem unavailable'}))
-    else:
-        # create_camera returns tuple: (binding_proxy, camera_actor)
-        result = ls.create_camera(spawnable=${params.spawnable !== false ? 'True' : 'False'})
-        binding_id = ''
-        camera_name = ''
-        
-        if result and len(result) >= 2:
-            binding_proxy = result[0]
-            camera_actor = result[1]
-            
-            # Get the current sequence
-            seq = unreal.LevelSequenceEditorBlueprintLibrary.get_focused_level_sequence()
-            
-            if seq and binding_proxy:
-                try:
-                    # Get GUID directly from binding proxy - this is more reliable
-                    binding_guid = unreal.MovieSceneBindingExtensions.get_id(binding_proxy)
-                    # The GUID itself is what we need
-                    binding_id = str(binding_guid).replace('<Guid ', '').replace('>', '').split(' ')[0] if str(binding_guid).startswith('<') else str(binding_guid)
-                    
-                    # If that didn't work, try the binding object
-                    if binding_id.startswith('<') or not binding_id:
-                        binding_obj = unreal.MovieSceneSequenceExtensions.get_binding_id(seq, binding_proxy)
-                        # Try to extract GUID from the object representation
-                        obj_str = str(binding_obj)
-                        if 'guid=' in obj_str:
-                            binding_id = obj_str.split('guid=')[1].split(',')[0].split('}')[0].strip()
-                        elif hasattr(binding_obj, 'guid'):
-                            binding_id = str(binding_obj.guid)
-                        else:
-                            # Use a hash of the binding for a consistent ID
-                            import hashlib
-                            binding_id = hashlib.md5(str(binding_proxy).encode()).hexdigest()[:8]
-                except Exception as e:
-                    # Generate a unique ID based on camera
-                    import hashlib
-                    camera_str = camera_actor.get_name() if camera_actor else 'spawned'
-                    binding_id = f'cam_{hashlib.md5(camera_str.encode()).hexdigest()[:8]}'
-            
-            if camera_actor:
-                try:
-                    camera_name = camera_actor.get_actor_label()
-                except:
-                    camera_name = 'CineCamera'
-            
-            print('RESULT:' + json.dumps({
-                'success': True,
-                'cameraBindingId': binding_id,
-                'cameraName': camera_name
-            }))
-        else:
-            # Even if result format is different, camera might still be created
-            print('RESULT:' + json.dumps({
-                'success': True,
-                'cameraBindingId': 'camera_created',
-                'warning': 'Camera created but binding format unexpected'
-            }))
-except Exception as e:
-    print('RESULT:' + json.dumps({'success': False, 'error': str(e)}))
-`.trim();
-    const resp = await this.executeWithRetry(
-      () => this.bridge.executePython(py),
-      'addCamera'
-    );
-    
-    return this.parsePythonResult(resp, 'addCamera');
+  async addCamera(params: { spawnable?: boolean; path?: string }) {
+    const path = this.resolveSequencePath(params.path);
+    const resp = await this.sendAction('sequence_add_camera', { path, spawnable: params.spawnable !== false });
+    if (!resp.success && this.isUnknownActionResponse(resp)) {
+      return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement sequence_add_camera' } as const;
+    }
+    return resp;
   }
 
-  async addActor(params: { actorName: string; createBinding?: boolean }) {
-        const missingPlugins = await this.ensureSequencerPrerequisites('SequenceTools.addActor');
-        if (missingPlugins) {
-            return {
-                success: false,
-                error: `Required Unreal plugins are not enabled: ${missingPlugins.join(', ')}`
-            };
-        }
-    const py = `
-import unreal, json
-try:
-    actor_sub = unreal.get_editor_subsystem(unreal.EditorActorSubsystem)
-    ls = unreal.get_editor_subsystem(unreal.LevelSequenceEditorSubsystem)
-    if not ls or not actor_sub:
-        print('RESULT:' + json.dumps({'success': False, 'error': 'Subsystem unavailable'}))
-    else:
-        target = None
-        actors = actor_sub.get_all_level_actors()
-        for a in actors:
-            if not a: continue
-            label = a.get_actor_label()
-            name = a.get_name()
-            # Check label, name, and partial matches
-            if label == r"${params.actorName}" or name == r"${params.actorName}" or label.startswith(r"${params.actorName}"):
-                target = a
-                break
-        
-        if not target:
-            # Try to find any actors to debug
-            actor_info = []
-            for a in actors[:5]:
-                if a:
-                    actor_info.append({'label': a.get_actor_label(), 'name': a.get_name()})
-            print('RESULT:' + json.dumps({'success': False, 'error': f'Actor "${params.actorName}" not found. Sample actors: {actor_info}'}))
-        else:
-            # Make sure we have a focused sequence
-            seq = unreal.LevelSequenceEditorBlueprintLibrary.get_focused_level_sequence()
-            if seq:
-                # Use add_actors method which returns binding proxies
-                bindings = ls.add_actors([target])
-                binding_info = []
-                
-                # bindings might be a list or might be empty if actor already exists
-                if bindings and len(bindings) > 0:
-                    for binding in bindings:
-                        try:
-                            # Get binding name and GUID
-                            binding_name = unreal.MovieSceneBindingExtensions.get_name(binding)
-                            binding_guid = unreal.MovieSceneBindingExtensions.get_id(binding)
-                            
-                            # Extract clean GUID string
-                            guid_str = str(binding_guid)
-                            if guid_str.startswith('<Guid '):
-                                # Extract the actual GUID value from <Guid 'XXXX-XXXX-XXXX-XXXX'>
-                                guid_clean = guid_str.replace('<Guid ', '').replace('>', '').replace("'", '').split(' ')[0]
-                            else:
-                                guid_clean = guid_str
-                            
-                            binding_info.append({
-                                'id': guid_clean,
-                                'guid': guid_clean,
-                                'name': binding_name if binding_name else target.get_actor_label()
-                            })
-                        except Exception as e:
-                            # If binding methods fail, still count it
-                            binding_info.append({
-                                'id': 'binding_' + str(len(binding_info)),
-                                'name': target.get_actor_label(),
-                                'error': str(e)
-                            })
-                    
-                    print('RESULT:' + json.dumps({
-                        'success': True, 
-                        'count': len(bindings), 
-                        'actorAdded': target.get_actor_label(), 
-                        'bindings': binding_info
-                    }))
-                else:
-                    # Actor was likely added but no new binding returned (might already exist)
-                    # Still report success since the actor is in the sequence
-                    print('RESULT:' + json.dumps({
-                        'success': True, 
-                        'count': 1, 
-                        'actorAdded': target.get_actor_label(), 
-                        'bindings': [{'name': target.get_actor_label(), 'note': 'Actor added to sequence'}],
-                        'info': 'Actor processed successfully'
-                    }))
-            else:
-                print('RESULT:' + json.dumps({'success': False, 'error': 'No sequence is currently focused'}))
-except Exception as e:
-    print('RESULT:' + json.dumps({'success': False, 'error': str(e)}))
-`.trim();
-    const resp = await this.executeWithRetry(
-      () => this.bridge.executePython(py),
-      'addActor'
-    );
-    
-    return this.parsePythonResult(resp, 'addActor');
+  async addActor(params: { actorName: string; createBinding?: boolean; path?: string }) {
+    const path = this.resolveSequencePath(params.path);
+    const resp = await this.sendAction('sequence_add_actor', { path, actorName: params.actorName, createBinding: params.createBinding });
+    if (!resp.success && this.isUnknownActionResponse(resp)) {
+      return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement sequence_add_actor' } as const;
+    }
+    return resp;
   }
 
   /**
    * Play the current level sequence
    */
-  async play(params?: { startTime?: number; loopMode?: 'once' | 'loop' | 'pingpong' }) {
-    const loop = params?.loopMode || '';
-        const missingPlugins = await this.ensureSequencerPrerequisites('SequenceTools.play');
-        if (missingPlugins) {
-            this.log.warn('Sequencer plugins missing for play; returning simulated success', { missingPlugins, loopMode: loop });
-            return {
-                success: true,
-                simulated: true,
-                playing: true,
-                loopMode: loop || 'default',
-                warnings: [`Playback simulated because required plugins are disabled: ${missingPlugins.join(', ')}`],
-                message: 'Sequencer plugins disabled; playback simulated.'
-            };
-        }
-    const py = `
-import unreal, json
-
-# Helper to resolve SequencerLoopMode from a friendly string
-def _resolve_loop_mode(mode_str):
-    try:
-        m = str(mode_str).lower()
-        slm = unreal.SequencerLoopMode
-        if m in ('once','noloop','no_loop'):
-            return getattr(slm, 'SLM_NoLoop', getattr(slm, 'NoLoop'))
-        if m in ('loop',):
-            return getattr(slm, 'SLM_Loop', getattr(slm, 'Loop'))
-        if m in ('pingpong','ping_pong'):
-            return getattr(slm, 'SLM_PingPong', getattr(slm, 'PingPong'))
-    except Exception:
-        pass
-    return None
-
-try:
-    unreal.LevelSequenceEditorBlueprintLibrary.play()
-    loop_mode = _resolve_loop_mode('${loop}')
-    if loop_mode is not None:
-        unreal.LevelSequenceEditorBlueprintLibrary.set_loop_mode(loop_mode)
-    print('RESULT:' + json.dumps({'success': True, 'playing': True, 'loopMode': '${loop || 'default'}'}))
-except Exception as e:
-    print('RESULT:' + json.dumps({'success': False, 'error': str(e)}))
-`.trim();
-
-    const resp = await this.executeWithRetry(
-      () => this.bridge.executePython(py),
-      'playSequence'
-    );
-    
-    return this.parsePythonResult(resp, 'playSequence');
+  async play(params?: { path?: string; startTime?: number; loopMode?: 'once' | 'loop' | 'pingpong' }) {
+    const path = this.resolveSequencePath(params?.path);
+    const resp = await this.sendAction('sequence_play', { path, startTime: params?.startTime, loopMode: params?.loopMode });
+    if (!resp.success && this.isUnknownActionResponse(resp)) {
+      return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement sequence_play' } as const;
+    }
+    return resp;
   }
 
   /**
    * Pause the current level sequence
    */
-  async pause() {
-        const missingPlugins = await this.ensureSequencerPrerequisites('SequenceTools.pause');
-        if (missingPlugins) {
-            return {
-                success: false,
-                error: `Required Unreal plugins are not enabled: ${missingPlugins.join(', ')}`
-            };
-        }
-    const py = `
-import unreal, json
-try:
-    unreal.LevelSequenceEditorBlueprintLibrary.pause()
-    print('RESULT:' + json.dumps({'success': True, 'paused': True}))
-except Exception as e:
-    print('RESULT:' + json.dumps({'success': False, 'error': str(e)}))
-`.trim();
-
-    const resp = await this.executeWithRetry(
-      () => this.bridge.executePython(py),
-      'pauseSequence'
-    );
-    
-    return this.parsePythonResult(resp, 'pauseSequence');
+  async pause(params?: { path?: string }) {
+    const path = this.resolveSequencePath(params?.path);
+    const resp = await this.sendAction('sequence_pause', { path });
+    if (!resp.success && this.isUnknownActionResponse(resp)) {
+      return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement sequence_pause' } as const;
+    }
+    return resp;
   }
 
   /**
    * Stop/close the current level sequence
    */
-  async stop() {
-        const missingPlugins = await this.ensureSequencerPrerequisites('SequenceTools.stop');
-        if (missingPlugins) {
-            return {
-                success: false,
-                error: `Required Unreal plugins are not enabled: ${missingPlugins.join(', ')}`
-            };
-        }
-    const py = `
-import unreal, json
-try:
-    unreal.LevelSequenceEditorBlueprintLibrary.close_level_sequence()
-    print('RESULT:' + json.dumps({'success': True, 'stopped': True}))
-except Exception as e:
-    print('RESULT:' + json.dumps({'success': False, 'error': str(e)}))
-`.trim();
-
-    const resp = await this.executeWithRetry(
-      () => this.bridge.executePython(py),
-      'stopSequence'
-    );
-    
-    return this.parsePythonResult(resp, 'stopSequence');
+  async stop(params?: { path?: string }) {
+    const path = this.resolveSequencePath(params?.path);
+    const resp = await this.sendAction('sequence_stop', { path });
+    if (!resp.success && this.isUnknownActionResponse(resp)) {
+      return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement sequence_stop' } as const;
+    }
+    return resp;
   }
 
   /**
    * Set sequence properties including frame rate and length
    */
-  async setSequenceProperties(params: { 
+  async setSequenceProperties(params: {
     path?: string;
     frameRate?: number;
     lengthInFrames?: number;
     playbackStart?: number;
     playbackEnd?: number;
   }) {
-        const missingPlugins = await this.ensureSequencerPrerequisites('SequenceTools.setSequenceProperties');
-        if (missingPlugins) {
-            this.log.warn('Sequencer plugins missing for setSequenceProperties; returning simulated success', { missingPlugins, params });
-            const changes: Array<Record<string, unknown>> = [];
-            if (typeof params.frameRate === 'number') {
-                changes.push({ property: 'frameRate', value: params.frameRate });
-            }
-            if (typeof params.lengthInFrames === 'number') {
-                changes.push({ property: 'lengthInFrames', value: params.lengthInFrames });
-            }
-            if (params.playbackStart !== undefined || params.playbackEnd !== undefined) {
-                changes.push({
-                    property: 'playbackRange',
-                    start: params.playbackStart,
-                    end: params.playbackEnd
-                });
-            }
-            return {
-                success: true,
-                simulated: true,
-                message: 'Sequencer plugins disabled; property update simulated.',
-                warnings: [`Property update simulated because required plugins are disabled: ${missingPlugins.join(', ')}`],
-                changes,
-                finalProperties: {
-                    frameRate: params.frameRate ? { numerator: params.frameRate, denominator: 1 } : undefined,
-                    playbackStart: params.playbackStart,
-                    playbackEnd: params.playbackEnd,
-                    duration: params.lengthInFrames
-                }
-            };
-        }
-    const py = `
-import unreal, json
-try:
-    # Load the sequence
-    seq_path = r"${params.path || ''}"
-    if seq_path:
-        seq = unreal.load_asset(seq_path)
-    else:
-        # Try to get the currently open sequence
-        seq = unreal.LevelSequenceEditorBlueprintLibrary.get_focused_level_sequence()
-    
-    if not seq:
-        print('RESULT:' + json.dumps({'success': False, 'error': 'No sequence found or loaded'}))
-    else:
-        result = {'success': True, 'changes': []}
-        
-        # Set frame rate if provided
-        ${params.frameRate ? `
-        frame_rate = unreal.FrameRate(numerator=${params.frameRate}, denominator=1)
-        unreal.MovieSceneSequenceExtensions.set_display_rate(seq, frame_rate)
-        result['changes'].append({'property': 'frameRate', 'value': ${params.frameRate}})
-        ` : ''}
-        
-        # Set playback range if provided
-        ${(params.playbackStart !== undefined || params.playbackEnd !== undefined) ? `
-        current_range = unreal.MovieSceneSequenceExtensions.get_playback_range(seq)
-        start = ${params.playbackStart !== undefined ? params.playbackStart : 'current_range.get_start_frame()'}
-        end = ${params.playbackEnd !== undefined ? params.playbackEnd : 'current_range.get_end_frame()'}
-        # Use set_playback_start and set_playback_end instead
-        if ${params.playbackStart !== undefined}:
-            unreal.MovieSceneSequenceExtensions.set_playback_start(seq, ${params.playbackStart})
-        if ${params.playbackEnd !== undefined}:
-            unreal.MovieSceneSequenceExtensions.set_playback_end(seq, ${params.playbackEnd})
-        result['changes'].append({'property': 'playbackRange', 'start': start, 'end': end})
-        ` : ''}
-        
-        # Set total length in frames if provided
-        ${params.lengthInFrames ? `
-        # This sets the playback end to match the desired length
-        start = unreal.MovieSceneSequenceExtensions.get_playback_start(seq)
-        end = start + ${params.lengthInFrames}
-        unreal.MovieSceneSequenceExtensions.set_playback_end(seq, end)
-        result['changes'].append({'property': 'lengthInFrames', 'value': ${params.lengthInFrames}})
-        ` : ''}
-        
-        # Get final properties for confirmation
-        final_rate = unreal.MovieSceneSequenceExtensions.get_display_rate(seq)
-        final_range = unreal.MovieSceneSequenceExtensions.get_playback_range(seq)
-        result['finalProperties'] = {
-            'frameRate': {'numerator': final_rate.numerator, 'denominator': final_rate.denominator},
-            'playbackStart': final_range.get_start_frame(),
-            'playbackEnd': final_range.get_end_frame(),
-            'duration': final_range.get_end_frame() - final_range.get_start_frame()
-        }
-        
-        print('RESULT:' + json.dumps(result))
-except Exception as e:
-    print('RESULT:' + json.dumps({'success': False, 'error': str(e)}))
-`.trim();
-
-    const resp = await this.executeWithRetry(
-      () => this.bridge.executePython(py),
-      'setSequenceProperties'
-    );
-    
-    return this.parsePythonResult(resp, 'setSequenceProperties');
+    const payload: Record<string, unknown> = {
+      path: params.path,
+      frameRate: params.frameRate,
+      lengthInFrames: params.lengthInFrames,
+      playbackStart: params.playbackStart,
+      playbackEnd: params.playbackEnd
+    };
+    const resp = await this.sendAction('sequence_set_properties', payload);
+    if (!resp.success && this.isUnknownActionResponse(resp)) {
+      return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement sequence_set_properties' } as const;
+    }
+    return resp;
+  }
+
+  /**
+   * Set display rate (fps)
+   */
+  async setDisplayRate(params: { path?: string; frameRate: string | number }) {
+    const resp = await this.sendAction('sequence_set_display_rate', { path: params.path, frameRate: params.frameRate });
+    if (!resp.success && this.isUnknownActionResponse(resp)) {
+      return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement sequence_set_display_rate' } as const;
+    }
+    return resp;
   }
 
   /**
    * Get sequence properties
    */
   async getSequenceProperties(params: { path?: string }) {
-    const py = `
-import unreal, json
-try:
-    # Load the sequence
-    seq_path = r"${params.path || ''}"
-    if seq_path:
-        seq = unreal.load_asset(seq_path)
-    else:
-        # Try to get the currently open sequence
-        seq = unreal.LevelSequenceEditorBlueprintLibrary.get_focused_level_sequence()
-    
-    if not seq:
-        print('RESULT:' + json.dumps({'success': False, 'error': 'No sequence found or loaded'}))
-    else:
-        # Get all properties
-        display_rate = unreal.MovieSceneSequenceExtensions.get_display_rate(seq)
-        playback_range = unreal.MovieSceneSequenceExtensions.get_playback_range(seq)
-        
-        # Get marked frames if any
-        marked_frames = []
-        try:
-            frames = unreal.MovieSceneSequenceExtensions.get_marked_frames(seq)
-            marked_frames = [{'frame': f.frame_number.value, 'label': f.label} for f in frames]
-        except:
-            pass
-        
-        result = {
-            'success': True,
-            'path': seq.get_path_name(),
-            'name': seq.get_name(),
-            'frameRate': {
-                'numerator': display_rate.numerator,
-                'denominator': display_rate.denominator,
-                'fps': float(display_rate.numerator) / float(display_rate.denominator) if display_rate.denominator > 0 else 0
-            },
-            'playbackStart': playback_range.get_start_frame(),
-            'playbackEnd': playback_range.get_end_frame(),
-            'duration': playback_range.get_end_frame() - playback_range.get_start_frame(),
-            'markedFrames': marked_frames
-        }
-        
-        print('RESULT:' + json.dumps(result))
-except Exception as e:
-    print('RESULT:' + json.dumps({'success': False, 'error': str(e)}))
-`.trim();
-
-    const resp = await this.executeWithRetry(
-      () => this.bridge.executePython(py),
-      'getSequenceProperties'
-    );
-    
-    return this.parsePythonResult(resp, 'getSequenceProperties');
+    const resp = await this.sendAction('sequence_get_properties', { path: params.path });
+    if (!resp.success && this.isUnknownActionResponse(resp)) {
+      return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement sequence_get_properties' } as const;
+    }
+    return resp;
   }
 
   /**
    * Set playback speed/rate
    */
-  async setPlaybackSpeed(params: { speed: number }) {
-    const py = `
-import unreal, json
-try:
-    unreal.LevelSequenceEditorBlueprintLibrary.set_playback_speed(${params.speed})
-    print('RESULT:' + json.dumps({'success': True, 'playbackSpeed': ${params.speed}}))
-except Exception as e:
-    print('RESULT:' + json.dumps({'success': False, 'error': str(e)}))
-`.trim();
-
-    const resp = await this.executeWithRetry(
-      () => this.bridge.executePython(py),
-      'setPlaybackSpeed'
-    );
-    
-    return this.parsePythonResult(resp, 'setPlaybackSpeed');
+  async setPlaybackSpeed(params: { speed: number; path?: string }) {
+    const path = this.resolveSequencePath(params.path);
+    const resp = await this.sendAction('sequence_set_playback_speed', { path, speed: params.speed });
+    if (!resp.success && this.isUnknownActionResponse(resp)) {
+      return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement sequence_set_playback_speed' } as const;
+    }
+    return resp;
   }
 
   /**
    * Get all bindings in the current sequence
    */
   async getBindings(params?: { path?: string }) {
-    const py = `
-import unreal, json
-try:
-    # Load the sequence
-    seq_path = r"${params?.path || ''}"
-    if seq_path:
-        seq = unreal.load_asset(seq_path)
-    else:
-        # Try to get the currently open sequence
-        seq = unreal.LevelSequenceEditorBlueprintLibrary.get_focused_level_sequence()
-    
-    if not seq:
-        print('RESULT:' + json.dumps({'success': False, 'error': 'No sequence found or loaded'}))
-    else:
-        bindings = unreal.MovieSceneSequenceExtensions.get_bindings(seq)
-        binding_list = []
-        for binding in bindings:
-            try:
-                binding_name = unreal.MovieSceneBindingExtensions.get_name(binding)
-                binding_guid = unreal.MovieSceneBindingExtensions.get_id(binding)
-                
-                # Extract clean GUID string
-                guid_str = str(binding_guid)
-                if guid_str.startswith('<Guid '):
-                    # Extract the actual GUID value from <Guid 'XXXX-XXXX-XXXX-XXXX'>
-                    guid_clean = guid_str.replace('<Guid ', '').replace('>', '').replace("'", '').split(' ')[0]
-                else:
-                    guid_clean = guid_str
-                
-                binding_list.append({
-                    'id': guid_clean,
-                    'name': binding_name,
-                    'guid': guid_clean
-                })
-            except:
-                pass
-        
-        print('RESULT:' + json.dumps({'success': True, 'bindings': binding_list, 'count': len(binding_list)}))
-except Exception as e:
-    print('RESULT:' + json.dumps({'success': False, 'error': str(e)}))
-`.trim();
-
-    const resp = await this.executeWithRetry(
-      () => this.bridge.executePython(py),
-      'getBindings'
-    );
-    
-    return this.parsePythonResult(resp, 'getBindings');
+    const resp = await this.sendAction('sequence_get_bindings', { path: params?.path });
+    if (!resp.success && this.isUnknownActionResponse(resp)) {
+      return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement sequence_get_bindings' } as const;
+    }
+    return resp;
   }
 
   /**
    * Add multiple actors to sequence at once
    */
-  async addActors(params: { actorNames: string[] }) {
-    const py = `
-import unreal, json
-try:
-    actor_sub = unreal.get_editor_subsystem(unreal.EditorActorSubsystem)
-    ls = unreal.get_editor_subsystem(unreal.LevelSequenceEditorSubsystem)
-    if not ls or not actor_sub:
-        print('RESULT:' + json.dumps({'success': False, 'error': 'Subsystem unavailable'}))
-    else:
-        actor_names = ${JSON.stringify(params.actorNames)}
-        actors_to_add = []
-        not_found = []
-        
-        all_actors = actor_sub.get_all_level_actors()
-        for name in actor_names:
-            found = False
-            for a in all_actors:
-                if not a: continue
-                label = a.get_actor_label()
-                actor_name = a.get_name()
-                if label == name or actor_name == name or label.startswith(name):
-                    actors_to_add.append(a)
-                    found = True
-                    break
-            if not found:
-                not_found.append(name)
-        
-        # Make sure we have a focused sequence
-        seq = unreal.LevelSequenceEditorBlueprintLibrary.get_focused_level_sequence()
-        if not seq:
-            print('RESULT:' + json.dumps({'success': False, 'error': 'No sequence is currently focused'}))
-        elif len(actors_to_add) == 0:
-            print('RESULT:' + json.dumps({'success': False, 'error': f'No actors found: {not_found}'}))
-        else:
-            # Add all actors at once
-            bindings = ls.add_actors(actors_to_add)
-            added_actors = [a.get_actor_label() for a in actors_to_add]
-            print('RESULT:' + json.dumps({
-                'success': True, 
-                'count': len(bindings) if bindings else len(actors_to_add), 
-                'actorsAdded': added_actors,
-                'notFound': not_found
-            }))
-except Exception as e:
-    print('RESULT:' + json.dumps({'success': False, 'error': str(e)}))
-`.trim();
-
-    const resp = await this.executeWithRetry(
-      () => this.bridge.executePython(py),
-      'addActors'
-    );
-    
-    return this.parsePythonResult(resp, 'addActors');
+  async addActors(params: { actorNames: string[]; path?: string }) {
+    const path = this.resolveSequencePath(params.path);
+    const resp = await this.sendAction('sequence_add_actors', { path, actorNames: params.actorNames });
+    if (!resp.success && this.isUnknownActionResponse(resp)) {
+      return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement sequence_add_actors' } as const;
+    }
+    return resp;
   }
 
   /**
    * Remove actors from binding
    */
-  async removeActors(params: { actorNames: string[] }) {
-    const py = `
-import unreal, json
-try:
-    actor_sub = unreal.get_editor_subsystem(unreal.EditorActorSubsystem)
-    ls = unreal.get_editor_subsystem(unreal.LevelSequenceEditorSubsystem)
-    
-    if not ls or not actor_sub:
-        print('RESULT:' + json.dumps({'success': False, 'error': 'Subsystem unavailable'}))
-    else:
-        # Get current sequence
-        seq = unreal.LevelSequenceEditorBlueprintLibrary.get_focused_level_sequence()
-        if not seq:
-            print('RESULT:' + json.dumps({'success': False, 'error': 'No sequence is currently focused'}))
-        else:
-            actor_names = ${JSON.stringify(params.actorNames)}
-            actors_to_remove = []
-            
-            all_actors = actor_sub.get_all_level_actors()
-            for name in actor_names:
-                for a in all_actors:
-                    if not a: continue
-                    label = a.get_actor_label()
-                    actor_name = a.get_name()
-                    if label == name or actor_name == name:
-                        actors_to_remove.append(a)
-                        break
-            
-            # Get all bindings and remove matching actors
-            bindings = unreal.MovieSceneSequenceExtensions.get_bindings(seq)
-            removed_count = 0
-            for binding in bindings:
-                try:
-                    ls.remove_actors_from_binding(actors_to_remove, binding)
-                    removed_count += 1
-                except:
-                    pass
-            
-            print('RESULT:' + json.dumps({
-                'success': True,
-                'removedActors': [a.get_actor_label() for a in actors_to_remove],
-                'bindingsProcessed': removed_count
-            }))
-except Exception as e:
-    print('RESULT:' + json.dumps({'success': False, 'error': str(e)}))
-`.trim();
-
-    const resp = await this.executeWithRetry(
-      () => this.bridge.executePython(py),
-      'removeActors'
-    );
-    
-    return this.parsePythonResult(resp, 'removeActors');
+  async removeActors(params: { actorNames: string[]; path?: string }) {
+    const path = this.resolveSequencePath(params.path);
+    const resp = await this.sendAction('sequence_remove_actors', { path, actorNames: params.actorNames });
+    if (!resp.success && this.isUnknownActionResponse(resp)) {
+      return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement sequence_remove_actors' } as const;
+    }
+    return resp;
   }
 
   /**
    * Create a spawnable from an actor class
    */
   async addSpawnableFromClass(params: { className: string; path?: string }) {
-    const py = `
-import unreal, json
-try:
-    ls = unreal.get_editor_subsystem(unreal.LevelSequenceEditorSubsystem)
-    
-    # Load the sequence
-    seq_path = r"${params.path || ''}"
-    if seq_path:
-        seq = unreal.load_asset(seq_path)
-    else:
-        seq = unreal.LevelSequenceEditorBlueprintLibrary.get_focused_level_sequence()
-    
-    if not seq:
-        print('RESULT:' + json.dumps({'success': False, 'error': 'No sequence found'}))
-    else:
-        # Try to find the class
-        class_name = r"${params.className}"
-        actor_class = None
-        
-        # Try common actor classes
-        if class_name == "StaticMeshActor":
-            actor_class = unreal.StaticMeshActor
-        elif class_name == "CineCameraActor":
-            actor_class = unreal.CineCameraActor
-        elif class_name == "CameraActor":
-            actor_class = unreal.CameraActor
-        elif class_name == "PointLight":
-            actor_class = unreal.PointLight
-        elif class_name == "DirectionalLight":
-            actor_class = unreal.DirectionalLight
-        elif class_name == "SpotLight":
-            actor_class = unreal.SpotLight
-        else:
-            # Try to load as a blueprint class
-            try:
-                actor_class = unreal.EditorAssetLibrary.load_asset(class_name)
-            except:
-                pass
-        
-        if not actor_class:
-            print('RESULT:' + json.dumps({'success': False, 'error': f'Class {class_name} not found'}))
-        else:
-            spawnable = ls.add_spawnable_from_class(seq, actor_class)
-            if spawnable:
-                binding_id = unreal.MovieSceneSequenceExtensions.get_binding_id(seq, spawnable)
-                print('RESULT:' + json.dumps({
-                    'success': True,
-                    'spawnableId': str(binding_id),
-                    'className': class_name
-                }))
-            else:
-                print('RESULT:' + json.dumps({'success': False, 'error': 'Failed to create spawnable'}))
-except Exception as e:
-    print('RESULT:' + json.dumps({'success': False, 'error': str(e)}))
-`.trim();
-
-    const resp = await this.executeWithRetry(
-      () => this.bridge.executePython(py),
-      'addSpawnableFromClass'
-    );
-    
-    return this.parsePythonResult(resp, 'addSpawnableFromClass');
+    const resp = await this.sendAction('sequence_add_spawnable_from_class', { className: params.className, path: params.path });
+    if (!resp.success && this.isUnknownActionResponse(resp)) {
+      return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement sequence_add_spawnable_from_class' } as const;
+    }
+    return resp;
+  }
+
+  async list(params?: { path?: string }) {
+    const resp = await this.sendAction('sequence_list', { path: params?.path });
+    if (!resp.success && this.isUnknownActionResponse(resp)) {
+      return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement sequence_list' } as const;
+    }
+    if (resp.success) {
+      const sequences = resp.sequences || resp.data || resp.result || [];
+      return {
+        ...resp,
+        sequences,
+        count: Array.isArray(sequences) ? sequences.length : undefined
+      };
+    }
+    return resp;
+  }
+
+  async duplicate(params: { path: string; destinationPath: string }) {
+    const resp = await this.sendAction('sequence_duplicate', { path: params.path, destinationPath: params.destinationPath });
+    if (!resp.success && this.isUnknownActionResponse(resp)) {
+      return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement sequence_duplicate' } as const;
+    }
+    return resp;
+  }
+
+  async rename(params: { path: string; newName: string }) {
+    const resp = await this.sendAction('sequence_rename', { path: params.path, newName: params.newName });
+    if (!resp.success && this.isUnknownActionResponse(resp)) {
+      return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement sequence_rename' } as const;
+    }
+    return resp;
+  }
+
+  async deleteSequence(params: { path: string }) {
+    const resp = await this.sendAction('sequence_delete', { path: params.path });
+    if (!resp.success && this.isUnknownActionResponse(resp)) {
+      return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement sequence_delete' } as const;
+    }
+    return resp;
+  }
+
+  async getMetadata(params: { path?: string }) {
+    const resp = await this.sendAction('sequence_get_metadata', { path: params.path });
+    if (!resp.success && this.isUnknownActionResponse(resp)) {
+      return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement sequence_get_metadata' } as const;
+    }
+    return resp;
+  }
+
+  /**
+   * Add a keyframe to a sequence binding
+   */
+  async addKeyframe(params: {
+    path?: string;
+    bindingId?: string;
+    actorName?: string;
+    property: 'Transform';
+    frame: number;
+    value: {
+      location?: { x: number; y: number; z: number };
+      rotation?: { roll: number; pitch: number; yaw: number };
+      scale?: { x: number; y: number; z: number };
+    };
+  }) {
+    const resp = await this.sendAction('sequence_add_keyframe', {
+      path: params.path,
+      bindingId: params.bindingId,
+      actorName: params.actorName,
+      property: params.property,
+      frame: params.frame,
+      value: params.value
+    });
+    if (!resp.success && this.isUnknownActionResponse(resp)) {
+      return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement sequence_add_keyframe' } as const;
+    }
+    return resp;
+  }
+
+  /**
+   * List tracks in a sequence
+   */
+  async listTracks(params: { path: string }) {
+    const resp = await this.sendAction('sequence_list_tracks', { path: params.path });
+    if (!resp.success && this.isUnknownActionResponse(resp)) {
+      return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement sequence_list_tracks' } as const;
+    }
+    if (resp.success) {
+      const tracks = resp.tracks || resp.data || resp.result || [];
+      return {
+        ...resp,
+        tracks,
+        count: Array.isArray(tracks) ? tracks.length : undefined
+      };
+    }
+    return resp;
+  }
+
+  /**
+   * Set playback work range
+   */
+  async setWorkRange(params: { path?: string; start: number; end: number }) {
+    const resp = await this.sendAction('sequence_set_work_range', { path: params.path, start: params.start, end: params.end });
+    if (!resp.success && this.isUnknownActionResponse(resp)) {
+      return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement sequence_set_work_range' } as const;
+    }
+    return resp;
   }
 }