unreal-engine-mcp-server 0.4.7 → 0.5.1

package/dist/tools/sequence.js

@@ -1,797 +1,258 @@
-import { Logger } from '../utils/logger.js';
-import { interpretStandardResult } from '../utils/result-helpers.js';
-export class SequenceTools {
-    bridge;
-    log = new Logger('SequenceTools');
+import { BaseTool } from './base-tool.js';
+import { wasmIntegration } from '../wasm/index.js';
+export class SequenceTools extends BaseTool {
     sequenceCache = new Map();
-    retryAttempts = 3;
-    retryDelay = 1000;
-    constructor(bridge) {
-        this.bridge = bridge;
-    }
-    async ensureSequencerPrerequisites(operation) {
-        const missing = await this.bridge.ensurePluginsEnabled(['LevelSequenceEditor', 'Sequencer'], operation);
-        return missing.length ? missing : null;
-    }
-    /**
-     * Execute with retry logic for transient failures
-     */
-    async executeWithRetry(operation, operationName) {
-        let lastError;
-        for (let attempt = 1; attempt <= this.retryAttempts; attempt++) {
-            try {
-                return await operation();
-            }
-            catch (error) {
-                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));
-                }
-            }
+    activeSequencePath;
+    resolveSequencePath(explicitPath) {
+        if (typeof explicitPath === 'string' && explicitPath.trim().length > 0) {
+            return explicitPath.trim();
         }
-        throw lastError;
+        return this.activeSequencePath;
     }
-    /**
-     * Parse Python execution result with better error handling
-     */
-    parsePythonResult(resp, operationName) {
-        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.' };
+    async sendAction(action, payload = {}, timeoutMs) {
+        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 };
         }
-        if (rawOutput.includes('AttributeError')) {
-            return { success: false, error: 'Sequencer API method not found. Check Unreal Engine version compatibility.' };
+        catch (err) {
+            return { success: false, error: String(err), message: String(err) };
         }
-        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;
-            })()
-        };
+    }
+    isUnknownActionResponse(res) {
+        if (!res)
+            return false;
+        const txt = String((res.error ?? res.message ?? '')).toLowerCase();
+        return txt.includes('unknown_action') || txt.includes('unknown automation action') || txt.includes('not_implemented') || txt === 'unknown_plugin_action';
     }
     async create(params) {
         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 payload = { name, path: base };
+        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' };
         }
-        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 = {
-                path: result.sequencePath,
-                name: name
-            };
+        if (resp.success && resp.result && resp.result.sequencePath) {
+            const sequence = { path: resp.result.sequencePath, name };
             this.sequenceCache.set(sequence.path, sequence);
+            return { ...resp, sequence: resp.result.sequencePath };
         }
-        return result;
+        return resp;
     }
     async open(params) {
-        const missingPlugins = await this.ensureSequencerPrerequisites('SequenceTools.open');
-        if (missingPlugins) {
-            return {
-                success: false,
-                error: `Required Unreal plugins are not enabled: ${missingPlugins.join(', ')}`
-            };
+        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' };
+        }
+        if (resp && resp.success !== false && path) {
+            this.activeSequencePath = path;
         }
-        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');
+        return resp;
     }
     async addCamera(params) {
-        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 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' };
         }
-        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');
+        return resp;
     }
     async addActor(params) {
-        const missingPlugins = await this.ensureSequencerPrerequisites('SequenceTools.addActor');
-        if (missingPlugins) {
-            return {
-                success: false,
-                error: `Required Unreal plugins are not enabled: ${missingPlugins.join(', ')}`
-            };
+        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' };
         }
-        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');
+        return resp;
     }
-    /**
-     * Play the current level sequence
-     */
     async play(params) {
-        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 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' };
         }
-        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');
+        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(', ')}`
-            };
+    async pause(params) {
+        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' };
         }
-        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');
+        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(', ')}`
-            };
+    async stop(params) {
+        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' };
         }
-        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');
+        return resp;
     }
-    /**
-     * Set sequence properties including frame rate and length
-     */
     async setSequenceProperties(params) {
-        const missingPlugins = await this.ensureSequencerPrerequisites('SequenceTools.setSequenceProperties');
-        if (missingPlugins) {
-            this.log.warn('Sequencer plugins missing for setSequenceProperties; returning simulated success', { missingPlugins, params });
-            const changes = [];
-            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 payload = {
+            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' };
         }
-        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()
+        return resp;
+    }
+    async setDisplayRate(params) {
+        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' };
         }
-        
-        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');
+        return resp;
     }
-    /**
-     * Get sequence properties
-     */
     async getSequenceProperties(params) {
-        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
+        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' };
         }
-        
-        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');
+        return resp;
     }
-    /**
-     * Set playback speed/rate
-     */
     async setPlaybackSpeed(params) {
-        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');
+        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' };
+        }
+        return resp;
     }
-    /**
-     * Get all bindings in the current sequence
-     */
     async getBindings(params) {
-        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' };
+        }
+        return resp;
     }
-    /**
-     * Add multiple actors to sequence at once
-     */
     async addActors(params) {
-        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');
+        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' };
+        }
+        return resp;
     }
-    /**
-     * Remove actors from binding
-     */
     async removeActors(params) {
-        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');
+        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' };
+        }
+        return resp;
     }
-    /**
-     * Create a spawnable from an actor class
-     */
     async addSpawnableFromClass(params) {
-        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' };
+        }
+        return resp;
+    }
+    async list(params) {
+        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' };
+        }
+        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) {
+        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' };
+        }
+        return resp;
+    }
+    async rename(params) {
+        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' };
+        }
+        return resp;
+    }
+    async deleteSequence(params) {
+        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' };
+        }
+        return resp;
+    }
+    async getMetadata(params) {
+        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' };
+        }
+        return resp;
+    }
+    async addKeyframe(params) {
+        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 (params.property === 'Transform' && params.value) {
+            const loc = params.value.location;
+            const rot = params.value.rotation;
+            const scale = params.value.scale;
+            if (loc && rot && scale) {
+                const locArr = [loc.x, loc.y, loc.z];
+                const rotArr = [rot.pitch, rot.yaw, rot.roll];
+                const scaleArr = [scale.x, scale.y, scale.z];
+                wasmIntegration.composeTransform(locArr, rotArr, scaleArr);
+                console.error('[WASM] Using composeTransform for keyframe validation');
+            }
+        }
+        if (!resp.success && this.isUnknownActionResponse(resp)) {
+            return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement sequence_add_keyframe' };
+        }
+        return resp;
+    }
+    async listTracks(params) {
+        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' };
+        }
+        if (resp.success) {
+            const tracks = resp.tracks || resp.data || resp.result || [];
+            return {
+                ...resp,
+                tracks,
+                count: Array.isArray(tracks) ? tracks.length : undefined
+            };
+        }
+        return resp;
+    }
+    async setWorkRange(params) {
+        const resp = await this.sendAction('sequence_set_work_range', { path: params.path, start: params.start, end: params.end });
+        if (!resp.success && this.isUnknownActionResponse(resp)) {
+            return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement sequence_set_work_range' };
+        }
+        return resp;
     }
 }
 //# sourceMappingURL=sequence.js.map