unreal-engine-mcp-server 0.2.1

package/src/tools/sequence.ts

@@ -0,0 +1,791 @@
+import { UnrealBridge } from '../unreal-bridge.js';
+import { Logger } from '../utils/logger.js';
+
+export interface LevelSequence {
+  path: string;
+  name: string;
+  duration?: number;
+  frameRate?: number;
+  bindings?: SequenceBinding[];
+}
+
+export interface SequenceBinding {
+  id: string;
+  name: string;
+  type: 'actor' | 'camera' | 'spawnable';
+  tracks?: SequenceTrack[];
+}
+
+export interface SequenceTrack {
+  name: string;
+  type: string;
+  sections?: any[];
+}
+
+export class SequenceTools {
+  private log = new Logger('SequenceTools');
+  private sequenceCache = new Map<string, LevelSequence>();
+  private retryAttempts = 3;
+  private retryDelay = 1000;
+  
+  constructor(private bridge: UnrealBridge) {}
+
+  /**
+   * 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)
+          );
+        }
+      }
+    }
+    
+    throw lastError;
+  }
+
+  /**
+   * Parse Python execution result with better error handling
+   */
+  private parsePythonResult(resp: any, operationName: string): any {
+    let out = '';
+    if (resp?.LogOutput && Array.isArray((resp as any).LogOutput)) {
+      out = (resp as any).LogOutput.map((l: any) => l.Output || '').join('');
+    } else if (typeof resp === 'string') {
+      out = resp;
+    } else {
+      out = JSON.stringify(resp);
+    }
+    
+    const m = out.match(/RESULT:({.*})/);
+    if (m) {
+      try {
+        return JSON.parse(m[1]);
+      } catch (e) {
+        this.log.error(`Failed to parse ${operationName} result: ${e}`);
+      }
+    }
+    
+    // Check for common error patterns
+    if (out.includes('ModuleNotFoundError')) {
+      return { success: false, error: 'Sequencer module not available. Ensure Sequencer is enabled.' };
+    }
+    if (out.includes('AttributeError')) {
+      return { success: false, error: 'Sequencer API method not found. Check Unreal Engine version compatibility.' };
+    }
+    
+    return { success: false, error: `${operationName} did not return a valid result: ${out.substring(0, 200)}` };
+  }
+
+  async create(params: { name: string; path?: string }) {
+    const name = params.name?.trim();
+    const base = (params.path || '/Game/Sequences').replace(/\/$/, '');
+    if (!name) return { success: false, error: 'name is required' };
+    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
+      };
+      this.sequenceCache.set(sequence.path, sequence);
+    }
+    
+    return result;
+  }
+
+  async open(params: { path: string }) {
+    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');
+  }
+
+  async addCamera(params: { spawnable?: boolean }) {
+    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 addActor(params: { actorName: string; createBinding?: boolean }) {
+    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');
+  }
+
+  /**
+   * Play the current level sequence
+   */
+  async play(params?: { startTime?: number; loopMode?: 'once' | 'loop' | 'pingpong' }) {
+    const py = `
+import unreal, json
+try:
+    unreal.LevelSequenceEditorBlueprintLibrary.play()
+    ${params?.loopMode ? `unreal.LevelSequenceEditorBlueprintLibrary.set_loop_mode('${params.loopMode}')` : ''}
+    print('RESULT:' + json.dumps({'success': True, 'playing': True}))
+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');
+  }
+
+  /**
+   * Pause the current level sequence
+   */
+  async 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');
+  }
+
+  /**
+   * Stop/close the current level sequence
+   */
+  async 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');
+  }
+
+  /**
+   * Set sequence properties including frame rate and length
+   */
+  async setSequenceProperties(params: { 
+    path?: string;
+    frameRate?: number;
+    lengthInFrames?: number;
+    playbackStart?: number;
+    playbackEnd?: number;
+  }) {
+    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');
+  }
+
+  /**
+   * 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');
+  }
+
+  /**
+   * 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');
+  }
+
+  /**
+   * 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');
+  }
+
+  /**
+   * 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');
+  }
+
+  /**
+   * 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');
+  }
+
+  /**
+   * 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');
+  }
+}