unreal-engine-mcp-server 0.4.6 → 0.5.0

package/dist/tools/blueprint.js

@@ -1,903 +1,756 @@
+import { BaseTool } from './base-tool.js';
+import { Logger } from '../utils/logger.js';
 import { validateAssetParams, concurrencyDelay } from '../utils/validation.js';
-import { extractTaggedLine } from '../utils/python-output.js';
-import { interpretStandardResult, coerceBoolean, coerceString, coerceStringArray, bestEffortInterpretedText } from '../utils/result-helpers.js';
-import { escapePythonString } from '../utils/python.js';
-export class BlueprintTools {
-    bridge;
-    constructor(bridge) {
-        this.bridge = bridge;
-    }
-    async validateParentClassReference(parentClass, blueprintType) {
-        const trimmed = parentClass?.trim();
-        if (!trimmed) {
-            return { ok: true };
-        }
-        const escapedParent = escapePythonString(trimmed);
-        const python = `
-import unreal
-import json
-
-result = {
-  'success': False,
-  'resolved': '',
-  'error': ''
-}
-
-def resolve_parent(spec, bp_type):
-  name = (spec or '').strip()
-  editor_lib = unreal.EditorAssetLibrary
-  if not name:
-    return None
-  try:
-    if name.startswith('/Script/'):
-      return unreal.load_class(None, name)
-  except Exception:
-    pass
-  try:
-    if name.startswith('/Game/'):
-      asset = editor_lib.load_asset(name)
-      if asset:
-        if hasattr(asset, 'generated_class'):
-          try:
-            generated = asset.generated_class()
-            if generated:
-              return generated
-          except Exception:
-            pass
-        return asset
-  except Exception:
-    pass
-  try:
-    candidate = getattr(unreal, name, None)
-    if candidate:
-      return candidate
-  except Exception:
-    pass
-  return None
-
-try:
-  parent_spec = r"${escapedParent}"
-  resolved = resolve_parent(parent_spec, "${blueprintType}")
-  resolved_path = ''
-
-  if resolved:
-    try:
-      resolved_path = resolved.get_path_name()
-    except Exception:
-      try:
-        resolved_path = str(resolved.get_outer().get_path_name())
-      except Exception:
-        resolved_path = str(resolved)
-
-    normalized_resolved = resolved_path.replace('Class ', '').replace('class ', '').strip().lower()
-    normalized_spec = parent_spec.strip().lower()
-
-    if normalized_spec.startswith('/script/'):
-      if not normalized_resolved.endswith(normalized_spec):
-        resolved = None
-    elif normalized_spec.startswith('/game/'):
-      try:
-        if not unreal.EditorAssetLibrary.does_asset_exist(parent_spec):
-          resolved = None
-      except Exception:
-        resolved = None
-
-  if resolved:
-    result['success'] = True
-    try:
-      result['resolved'] = resolved_path or str(resolved)
-    except Exception:
-      result['resolved'] = str(resolved)
-  else:
-    result['error'] = 'Parent class not found: ' + parent_spec
-except Exception as e:
-  result['error'] = str(e)
-
-print('RESULT:' + json.dumps(result))
-`.trim();
+import { coerceString } from '../utils/result-helpers.js';
+export class BlueprintTools extends BaseTool {
+    log = new Logger('BlueprintTools');
+    pluginBlueprintActionsAvailable = null;
+    async sendAction(action, payload = {}, options) {
+        const envDefault = Number(process.env.MCP_AUTOMATION_REQUEST_TIMEOUT_MS ?? '120000');
+        const defaultTimeout = Number.isFinite(envDefault) && envDefault > 0 ? envDefault : 120000;
+        const finalTimeout = typeof options?.timeoutMs === 'number' && options?.timeoutMs > 0 ? options.timeoutMs : defaultTimeout;
         try {
-            const response = await this.bridge.executePython(python);
-            const interpreted = interpretStandardResult(response, {
-                successMessage: 'Parent class resolved',
-                failureMessage: 'Parent class validation failed'
-            });
-            if (interpreted.success) {
-                return { ok: true, resolved: interpreted.payload?.resolved ?? interpreted.message };
-            }
-            const error = interpreted.error || interpreted.payload?.error || `Parent class not found: ${trimmed}`;
-            return { ok: false, error };
+            const response = await this.sendAutomationRequest(action, payload, { timeoutMs: finalTimeout, waitForEvent: !!options?.waitForEvent, waitForEventTimeoutMs: options?.waitForEventTimeoutMs });
+            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 };
         }
         catch (err) {
-            return { ok: false, error: err?.message || String(err) };
+            return { success: false, error: String(err), message: String(err) };
         }
     }
-    /**
-     * Create Blueprint
-     */
+    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';
+    }
+    buildCandidates(rawName) {
+        const trimmed = coerceString(rawName)?.trim();
+        if (!trimmed)
+            return [];
+        const normalized = trimmed.replace(/\\/g, '/').replace(/\/\/+/g, '/');
+        const withoutLeading = normalized.replace(/^\/+/, '');
+        const basename = withoutLeading.split('/').pop() ?? withoutLeading;
+        const candidates = [];
+        if (normalized.includes('/')) {
+            if (normalized.startsWith('/'))
+                candidates.push(normalized);
+            if (basename) {
+                candidates.push(`/Game/Blueprints/${basename}`);
+                candidates.push(`/Game/${basename}`);
+            }
+            if (!normalized.startsWith('/'))
+                candidates.push(`/${withoutLeading}`);
+        }
+        else {
+            if (basename) {
+                candidates.push(`/Game/Blueprints/${basename}`);
+                candidates.push(`/Game/${basename}`);
+            }
+            candidates.push(normalized);
+            candidates.push(`/${withoutLeading}`);
+        }
+        return candidates.filter(Boolean);
+    }
     async createBlueprint(params) {
         try {
-            // Validate and sanitize parameters
-            const validation = validateAssetParams({
-                name: params.name,
-                savePath: params.savePath || '/Game/Blueprints'
-            });
-            if (!validation.valid) {
-                return {
-                    success: false,
-                    message: `Failed to create blueprint: ${validation.error}`,
-                    error: validation.error
-                };
+            const validation = validateAssetParams({ name: params.name, savePath: params.savePath || '/Game/Blueprints' });
+            if (!validation.valid)
+                return { success: false, message: `Failed to create blueprint: ${validation.error}`, error: validation.error };
+            const sanitized = validation.sanitized;
+            const payload = { name: sanitized.name, blueprintType: params.blueprintType ?? 'Actor', savePath: sanitized.savePath ?? '/Game/Blueprints', parentClass: params.parentClass, properties: params.properties, waitForCompletion: !!params.waitForCompletion };
+            await concurrencyDelay();
+            if (this.pluginBlueprintActionsAvailable === false) {
+                return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement blueprint_create' };
             }
-            const sanitizedParams = validation.sanitized;
-            const path = sanitizedParams.savePath || '/Game/Blueprints';
-            if (path.startsWith('/Engine')) {
-                const message = `Failed to create blueprint: destination path ${path} is read-only`;
-                return { success: false, message, error: message };
-            }
-            if (params.parentClass && params.parentClass.trim()) {
-                const parentValidation = await this.validateParentClassReference(params.parentClass, params.blueprintType);
-                if (!parentValidation.ok) {
-                    const error = parentValidation.error || `Parent class not found: ${params.parentClass}`;
-                    const message = `Failed to create blueprint: ${error}`;
-                    return { success: false, message, error };
+            const envPluginTimeout = Number(process.env.MCP_AUTOMATION_PLUGIN_CREATE_TIMEOUT_MS ?? process.env.MCP_AUTOMATION_REQUEST_TIMEOUT_MS ?? '15000');
+            const pluginTimeout = Number.isFinite(envPluginTimeout) && envPluginTimeout > 0 ? envPluginTimeout : 15000;
+            try {
+                const res = await this.sendAction('blueprint_create', payload, { timeoutMs: typeof params.timeoutMs === 'number' ? params.timeoutMs : pluginTimeout, waitForEvent: !!params.waitForCompletion, waitForEventTimeoutMs: params.waitForCompletionTimeoutMs });
+                if (res && res.success) {
+                    this.pluginBlueprintActionsAvailable = true;
+                    return {
+                        ...res,
+                        blueprint: sanitized.name,
+                        path: `${sanitized.savePath}/${sanitized.name}`.replace('//', '/'),
+                        message: res.message || `Created blueprint ${sanitized.name}`
+                    };
+                }
+                if (res && this.isUnknownActionResponse(res)) {
+                    this.pluginBlueprintActionsAvailable = false;
+                    return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement blueprint_create' };
                 }
+                return res;
+            }
+            catch (err) {
+                const errTxt = String(err ?? '');
+                const isTimeout = errTxt.includes('Request timed out') || errTxt.includes('-32001') || errTxt.toLowerCase().includes('timeout');
+                if (isTimeout) {
+                    this.pluginBlueprintActionsAvailable = false;
+                }
+                return { success: false, error: String(err), message: String(err) };
             }
-            const escapedName = escapePythonString(sanitizedParams.name);
-            const escapedPath = escapePythonString(path);
-            const escapedParent = escapePythonString(params.parentClass ?? '');
-            await concurrencyDelay();
-            const pythonScript = `
-import unreal
-import time
-import json
-import traceback
-
-def ensure_asset_persistence(asset_path):
-  try:
-    asset_subsystem = None
-    try:
-      asset_subsystem = unreal.get_editor_subsystem(unreal.EditorAssetSubsystem)
-    except Exception:
-      asset_subsystem = None
-
-    editor_lib = unreal.EditorAssetLibrary
-
-    asset = None
-    if asset_subsystem and hasattr(asset_subsystem, 'load_asset'):
-      try:
-        asset = asset_subsystem.load_asset(asset_path)
-      except Exception:
-        asset = None
-    if not asset:
-      try:
-        asset = editor_lib.load_asset(asset_path)
-      except Exception:
-        asset = None
-    if not asset:
-      return False
-
-    saved = False
-    if asset_subsystem and hasattr(asset_subsystem, 'save_loaded_asset'):
-      try:
-        saved = asset_subsystem.save_loaded_asset(asset)
-      except Exception:
-        saved = False
-    if not saved and asset_subsystem and hasattr(asset_subsystem, 'save_asset'):
-      try:
-        saved = asset_subsystem.save_asset(asset_path, only_if_is_dirty=False)
-      except Exception:
-        saved = False
-    if not saved:
-      try:
-        if hasattr(editor_lib, 'save_loaded_asset'):
-          saved = editor_lib.save_loaded_asset(asset)
-        else:
-          saved = editor_lib.save_asset(asset_path, only_if_is_dirty=False)
-      except Exception:
-        saved = False
-
-    if not saved:
-      return False
-
-    asset_dir = asset_path.rsplit('/', 1)[0]
-    try:
-      registry = unreal.AssetRegistryHelpers.get_asset_registry()
-      if hasattr(registry, 'scan_paths_synchronous'):
-        registry.scan_paths_synchronous([asset_dir], True)
-    except Exception:
-      pass
-
-    for _ in range(5):
-      if editor_lib.does_asset_exist(asset_path):
-        return True
-      time.sleep(0.2)
-      try:
-        registry = unreal.AssetRegistryHelpers.get_asset_registry()
-        if hasattr(registry, 'scan_paths_synchronous'):
-          registry.scan_paths_synchronous([asset_dir], True)
-      except Exception:
-        pass
-    return False
-  except Exception as e:
-    print(f"Error ensuring persistence: {e}")
-    return False
-
-def resolve_parent_class(explicit_name, blueprint_type):
-  editor_lib = unreal.EditorAssetLibrary
-  name = (explicit_name or '').strip()
-  if name:
-    try:
-      if name.startswith('/Script/'):
-        try:
-          loaded = unreal.load_class(None, name)
-          if loaded:
-            return loaded
-        except Exception:
-          pass
-      if name.startswith('/Game/'):
-        loaded_asset = editor_lib.load_asset(name)
-        if loaded_asset:
-          if hasattr(loaded_asset, 'generated_class'):
-            try:
-              generated = loaded_asset.generated_class()
-              if generated:
-                return generated
-            except Exception:
-              pass
-          return loaded_asset
-      candidate = getattr(unreal, name, None)
-      if candidate:
-        return candidate
-    except Exception:
-      pass
-    return None
-
-  mapping = {
-    'Actor': unreal.Actor,
-    'Pawn': unreal.Pawn,
-    'Character': unreal.Character,
-    'GameMode': unreal.GameModeBase,
-    'PlayerController': unreal.PlayerController,
-    'HUD': unreal.HUD,
-    'ActorComponent': unreal.ActorComponent,
-  }
-  return mapping.get(blueprint_type, unreal.Actor)
-
-result = {
-  'success': False,
-  'message': '',
-  'path': '',
-  'error': '',
-  'exists': False,
-  'parent': '',
-  'verifyError': '',
-  'warnings': [],
-  'details': []
-}
-
-success_message = ''
-
-def record_detail(message):
-  result['details'].append(str(message))
-
-def record_warning(message):
-  result['warnings'].append(str(message))
-
-def set_message(message):
-  global success_message
-  if not success_message:
-    success_message = str(message)
-
-def set_error(message):
-  result['error'] = str(message)
-
-asset_path = "${escapedPath}"
-asset_name = "${escapedName}"
-full_path = f"{asset_path}/{asset_name}"
-result['path'] = full_path
-
-asset_subsystem = None
-try:
-  asset_subsystem = unreal.get_editor_subsystem(unreal.EditorAssetSubsystem)
-except Exception:
-  asset_subsystem = None
-
-editor_lib = unreal.EditorAssetLibrary
-
-try:
-  level_subsystem = unreal.get_editor_subsystem(unreal.LevelEditorSubsystem)
-  play_subsystem = None
-  try:
-    play_subsystem = unreal.get_editor_subsystem(unreal.EditorPlayWorldSubsystem)
-  except Exception:
-    play_subsystem = None
-
-  is_playing = False
-  if level_subsystem and hasattr(level_subsystem, 'is_in_play_in_editor'):
-    is_playing = bool(level_subsystem.is_in_play_in_editor())
-  elif play_subsystem and hasattr(play_subsystem, 'is_playing_in_editor'):
-    is_playing = bool(play_subsystem.is_playing_in_editor())
-
-  if is_playing:
-    print('Stopping Play In Editor mode...')
-    record_detail('Stopping Play In Editor mode')
-    if level_subsystem and hasattr(level_subsystem, 'editor_request_end_play'):
-      level_subsystem.editor_request_end_play()
-    elif play_subsystem and hasattr(play_subsystem, 'stop_playing_session'):
-      play_subsystem.stop_playing_session()
-    elif play_subsystem and hasattr(play_subsystem, 'end_play'):
-      play_subsystem.end_play()
-    else:
-      record_warning('Unable to stop Play In Editor via modern subsystems; please stop PIE manually.')
-    time.sleep(0.5)
-except Exception as stop_err:
-  record_warning(f'PIE stop check failed: {stop_err}')
-
-try:
-  try:
-    if asset_subsystem and hasattr(asset_subsystem, 'does_asset_exist'):
-      asset_exists = asset_subsystem.does_asset_exist(full_path)
-    else:
-      asset_exists = editor_lib.does_asset_exist(full_path)
-  except Exception:
-    asset_exists = editor_lib.does_asset_exist(full_path)
-
-  result['exists'] = bool(asset_exists)
-
-  if asset_exists:
-    existing = None
-    try:
-      if asset_subsystem and hasattr(asset_subsystem, 'load_asset'):
-        existing = asset_subsystem.load_asset(full_path)
-      elif asset_subsystem and hasattr(asset_subsystem, 'get_asset'):
-        existing = asset_subsystem.get_asset(full_path)
-      else:
-        existing = editor_lib.load_asset(full_path)
-    except Exception:
-      existing = editor_lib.load_asset(full_path)
-
-    if existing:
-      result['success'] = True
-      result['message'] = f"Blueprint already exists at {full_path}"
-      set_message(result['message'])
-      record_detail(result['message'])
-      try:
-        result['parent'] = str(existing.generated_class())
-      except Exception:
-        try:
-          result['parent'] = str(type(existing))
-        except Exception:
-          pass
-    else:
-      set_error(f"Asset exists but could not be loaded: {full_path}")
-      record_warning(result['error'])
-  else:
-    factory = unreal.BlueprintFactory()
-    explicit_parent = "${escapedParent}"
-    parent_class = None
-
-    if explicit_parent.strip():
-      parent_class = resolve_parent_class(explicit_parent, "${params.blueprintType}")
-      if not parent_class:
-        set_error(f"Parent class not found: {explicit_parent}")
-        record_warning(result['error'])
-        raise RuntimeError(result['error'])
-    else:
-      parent_class = resolve_parent_class('', "${params.blueprintType}")
-
-    if parent_class:
-      result['parent'] = str(parent_class)
-      record_detail(f"Resolved parent class: {result['parent']}")
-      try:
-        factory.set_editor_property('parent_class', parent_class)
-      except Exception:
-        try:
-          factory.set_editor_property('ParentClass', parent_class)
-        except Exception:
-          try:
-            factory.ParentClass = parent_class
-          except Exception:
-            pass
-
-    new_asset = None
-    try:
-      if asset_subsystem and hasattr(asset_subsystem, 'create_asset'):
-        new_asset = asset_subsystem.create_asset(
-          asset_name=asset_name,
-          package_path=asset_path,
-          asset_class=unreal.Blueprint,
-          factory=factory
-        )
-      else:
-        asset_tools = unreal.AssetToolsHelpers.get_asset_tools()
-        new_asset = asset_tools.create_asset(
-          asset_name=asset_name,
-          package_path=asset_path,
-          asset_class=unreal.Blueprint,
-          factory=factory
-        )
-    except Exception as create_error:
-      set_error(f"Asset creation failed: {create_error}")
-      record_warning(result['error'])
-      traceback.print_exc()
-      new_asset = None
-
-    if new_asset:
-      result['message'] = f"Blueprint created at {full_path}"
-      set_message(result['message'])
-      record_detail(result['message'])
-      if ensure_asset_persistence(full_path):
-        verified = False
-        try:
-          if asset_subsystem and hasattr(asset_subsystem, 'does_asset_exist'):
-            verified = asset_subsystem.does_asset_exist(full_path)
-          else:
-            verified = editor_lib.does_asset_exist(full_path)
-        except Exception as verify_error:
-          result['verifyError'] = str(verify_error)
-          verified = editor_lib.does_asset_exist(full_path)
-
-        if not verified:
-          time.sleep(0.2)
-          verified = editor_lib.does_asset_exist(full_path)
-          if not verified:
-            try:
-              verified = editor_lib.load_asset(full_path) is not None
-            except Exception:
-              verified = False
-
-        if verified:
-          result['success'] = True
-          result['error'] = ''
-          set_message(result['message'])
-        else:
-          set_error(f"Blueprint not found after save: {full_path}")
-          record_warning(result['error'])
-      else:
-        set_error('Failed to persist blueprint to disk')
-        record_warning(result['error'])
-    else:
-      if not result['error']:
-        set_error(f"Failed to create Blueprint {asset_name}")
-except Exception as e:
-  set_error(str(e))
-  record_warning(result['error'])
-  traceback.print_exc()
-
-# Finalize messaging
-default_success_message = f"Blueprint created at {full_path}"
-default_failure_message = f"Failed to create blueprint {asset_name}"
-
-if result['success'] and not success_message:
-  set_message(default_success_message)
-
-if not result['success'] and not result['error']:
-  set_error(default_failure_message)
-
-if not result['message']:
-  if result['success']:
-    result['message'] = success_message or default_success_message
-  else:
-    result['message'] = result['error'] or default_failure_message
-
-result['error'] = None if result['success'] else result['error']
-
-if not result['warnings']:
-  result.pop('warnings')
-if not result['details']:
-  result.pop('details')
-if result.get('error') is None:
-  result.pop('error')
-
-print('RESULT:' + json.dumps(result))
-`.trim();
-            const response = await this.bridge.executePython(pythonScript);
-            return this.parseBlueprintCreationOutput(response, sanitizedParams.name, path);
         }
         catch (err) {
-            return { success: false, error: `Failed to create blueprint: ${err}` };
+            return { success: false, error: String(err), message: String(err) };
         }
     }
-    parseBlueprintCreationOutput(response, blueprintName, blueprintPath) {
-        const defaultPath = `${blueprintPath}/${blueprintName}`;
-        const interpreted = interpretStandardResult(response, {
-            successMessage: `Blueprint ${blueprintName} created`,
-            failureMessage: `Failed to create blueprint ${blueprintName}`
-        });
-        const payload = interpreted.payload ?? {};
-        const hasPayload = Object.keys(payload).length > 0;
-        const warnings = interpreted.warnings ?? coerceStringArray(payload.warnings) ?? undefined;
-        const details = interpreted.details ?? coerceStringArray(payload.details) ?? undefined;
-        const path = coerceString(payload.path) ?? defaultPath;
-        const parent = coerceString(payload.parent);
-        const verifyError = coerceString(payload.verifyError);
-        const exists = coerceBoolean(payload.exists);
-        const errorValue = coerceString(payload.error) ?? interpreted.error;
-        if (hasPayload) {
-            if (interpreted.success) {
-                const outcome = {
-                    success: true,
-                    message: interpreted.message,
-                    path
-                };
-                if (typeof exists === 'boolean') {
-                    outcome.exists = exists;
-                }
-                if (parent) {
-                    outcome.parent = parent;
-                }
-                if (verifyError) {
-                    outcome.verifyError = verifyError;
-                }
-                if (warnings && warnings.length > 0) {
-                    outcome.warnings = warnings;
-                }
-                if (details && details.length > 0) {
-                    outcome.details = details;
-                }
-                return outcome;
-            }
-            const fallbackMessage = errorValue ?? interpreted.message;
-            const failureOutcome = {
-                success: false,
-                message: `Failed to create blueprint: ${fallbackMessage}`,
-                error: fallbackMessage,
-                path
-            };
-            if (typeof exists === 'boolean') {
-                failureOutcome.exists = exists;
-            }
-            if (parent) {
-                failureOutcome.parent = parent;
-            }
-            if (verifyError) {
-                failureOutcome.verifyError = verifyError;
-            }
-            if (warnings && warnings.length > 0) {
-                failureOutcome.warnings = warnings;
-            }
-            if (details && details.length > 0) {
-                failureOutcome.details = details;
+    async modifyConstructionScript(params) {
+        const blueprintPath = coerceString(params.blueprintPath);
+        if (!blueprintPath)
+            return { success: false, message: 'Blueprint path is required', error: 'INVALID_BLUEPRINT_PATH' };
+        if (!Array.isArray(params.operations) || params.operations.length === 0)
+            return { success: false, message: 'At least one SCS operation is required', error: 'MISSING_OPERATIONS' };
+        const operations = params.operations.map(op => {
+            if (op && typeof op === 'object' && op.op && !op.type) {
+                return { ...op, type: op.op };
             }
-            return failureOutcome;
+            return op;
+        });
+        const payload = { blueprintPath, operations };
+        if (typeof params.compile === 'boolean')
+            payload.compile = params.compile;
+        if (typeof params.save === 'boolean')
+            payload.save = params.save;
+        const res = await this.sendAction('blueprint_modify_scs', payload, { timeoutMs: params.timeoutMs, waitForEvent: !!params.waitForCompletion, waitForEventTimeoutMs: params.waitForCompletionTimeoutMs });
+        if (res && res.result && typeof res.result === 'object' && res.result.error === 'SCS_UNAVAILABLE') {
+            this.pluginBlueprintActionsAvailable = false;
+            return { success: false, error: 'SCS_UNAVAILABLE', message: 'Plugin does not support construction script modification (blueprint_modify_scs)' };
         }
-        const cleanedText = bestEffortInterpretedText(interpreted) ?? '';
-        const failureMessage = extractTaggedLine(cleanedText, 'FAILED:');
-        if (failureMessage) {
-            return {
-                success: false,
-                message: `Failed to create blueprint: ${failureMessage}`,
-                error: failureMessage,
-                path: defaultPath
-            };
+        if (res && res.success)
+            this.pluginBlueprintActionsAvailable = true;
+        if (res && this.isUnknownActionResponse(res)) {
+            this.pluginBlueprintActionsAvailable = false;
         }
-        if (cleanedText.includes('SUCCESS')) {
-            return {
-                success: true,
-                message: `Blueprint ${blueprintName} created`,
-                path: defaultPath
-            };
-        }
-        return {
-            success: false,
-            message: interpreted.message,
-            error: interpreted.error ?? (cleanedText || JSON.stringify(response)),
-            path: defaultPath
-        };
+        return res;
     }
-    /**
-     * Add Component to Blueprint
-     */
     async addComponent(params) {
+        const blueprintName = coerceString(params.blueprintName);
+        if (!blueprintName)
+            return { success: false, message: 'Blueprint name is required', error: 'INVALID_BLUEPRINT' };
+        const componentClass = coerceString(params.componentType);
+        if (!componentClass)
+            return { success: false, message: 'Component class is required', error: 'INVALID_COMPONENT_CLASS' };
+        const rawComponentName = coerceString(params.componentName) ?? params.componentName;
+        if (!rawComponentName)
+            return { success: false, message: 'Component name is required', error: 'INVALID_COMPONENT_NAME' };
+        const sanitizedComponentName = rawComponentName.replace(/[^A-Za-z0-9_]/g, '_');
+        const candidates = this.buildCandidates(blueprintName);
+        const primary = candidates[0];
+        if (!primary)
+            return { success: false, error: 'Invalid blueprint name' };
         try {
-            // Sanitize component name
-            const sanitizedComponentName = params.componentName.replace(/[^a-zA-Z0-9_]/g, '_');
-            // Add concurrency delay
-            await concurrencyDelay();
-            // Add component using Python API
-            const pythonScript = `
-import unreal
-import json
-
-result = {
-  "success": False,
-  "message": "",
-  "error": "",
-  "blueprintPath": "${escapePythonString(params.blueprintName)}",
-  "component": "${escapePythonString(sanitizedComponentName)}",
-  "componentType": "${escapePythonString(params.componentType)}",
-  "warnings": [],
-  "details": []
-}
-
-def add_warning(text):
-  if text:
-    result["warnings"].append(str(text))
-
-def add_detail(text):
-  if text:
-    result["details"].append(str(text))
-
-def normalize_name(name):
-  return (name or "").strip()
-
-def candidate_paths(raw_name):
-  cleaned = normalize_name(raw_name)
-  if not cleaned:
-    return []
-  if cleaned.startswith('/'):
-    return [cleaned]
-  bases = [
-    f"/Game/Blueprints/{cleaned}",
-    f"/Game/Blueprints/LiveTests/{cleaned}",
-    f"/Game/Blueprints/DirectAPI/{cleaned}",
-    f"/Game/Blueprints/ComponentTests/{cleaned}",
-    f"/Game/Blueprints/Types/{cleaned}",
-    f"/Game/Blueprints/ComprehensiveTest/{cleaned}",
-    f"/Game/{cleaned}"
-  ]
-  final = []
-  for entry in bases:
-    if entry.endswith('.uasset'):
-      final.append(entry[:-7])
-    final.append(entry)
-  return final
-
-def load_blueprint(raw_name):
-  editor_lib = unreal.EditorAssetLibrary
-  asset_subsystem = None
-  try:
-    asset_subsystem = unreal.get_editor_subsystem(unreal.EditorAssetSubsystem)
-  except Exception:
-    asset_subsystem = None
-
-  for path in candidate_paths(raw_name):
-    asset = None
-    try:
-      if asset_subsystem and hasattr(asset_subsystem, 'load_asset'):
-        asset = asset_subsystem.load_asset(path)
-      else:
-        asset = editor_lib.load_asset(path)
-    except Exception:
-      asset = editor_lib.load_asset(path)
-    if asset:
-      add_detail(f"Resolved blueprint at {path}")
-      return path, asset
-  return None, None
-
-def resolve_component_class(raw_class_name):
-  name = normalize_name(raw_class_name)
-  if not name:
-    return None
-  try:
-    if name.startswith('/Script/'):
-      loaded = unreal.load_class(None, name)
-      if loaded:
-        return loaded
-  except Exception as err:
-    add_warning(f"load_class failed: {err}")
-  try:
-    candidate = getattr(unreal, name, None)
-    if candidate:
-      return candidate
-  except Exception:
-    pass
-  return None
-
-bp_path, blueprint_asset = load_blueprint("${escapePythonString(params.blueprintName)}")
-if not blueprint_asset:
-  result["error"] = f"Blueprint not found: ${escapePythonString(params.blueprintName)}"
-  result["message"] = result["error"]
-else:
-  component_class = resolve_component_class("${escapePythonString(params.componentType)}")
-  if not component_class:
-    result["error"] = f"Component class not found: ${escapePythonString(params.componentType)}"
-    result["message"] = result["error"]
-  else:
-    add_warning("Component addition is simulated due to limited Python access to SimpleConstructionScript")
-    result["success"] = True
-    result["error"] = ""
-    result["blueprintPath"] = bp_path or result["blueprintPath"]
-    result["message"] = "Component ${escapePythonString(sanitizedComponentName)} added to ${escapePythonString(params.blueprintName)}"
-    add_detail("Blueprint ready for manual verification in editor if needed")
-
-if not result["warnings"]:
-  result.pop("warnings")
-if not result["details"]:
-  result.pop("details")
-if not result["error"]:
-  result["error"] = ""
-
-print('RESULT:' + json.dumps(result))
-`.trim();
-            // Execute Python and parse the output
-            try {
-                const response = await this.bridge.executePython(pythonScript);
-                const interpreted = interpretStandardResult(response, {
-                    successMessage: `Component ${sanitizedComponentName} added to ${params.blueprintName}`,
-                    failureMessage: `Failed to add component ${sanitizedComponentName}`
-                });
-                const payload = interpreted.payload ?? {};
-                const warnings = interpreted.warnings ?? coerceStringArray(payload.warnings) ?? undefined;
-                const details = interpreted.details ?? coerceStringArray(payload.details) ?? undefined;
-                const blueprintPath = coerceString(payload.blueprintPath) ?? params.blueprintName;
-                const componentName = coerceString(payload.component) ?? sanitizedComponentName;
-                const componentType = coerceString(payload.componentType) ?? params.componentType;
-                const errorMessage = coerceString(payload.error) ?? interpreted.error ?? 'Unknown error';
-                if (interpreted.success) {
-                    const outcome = {
-                        success: true,
-                        message: interpreted.message,
-                        blueprintPath,
-                        component: componentName,
-                        componentType
-                    };
-                    if (warnings && warnings.length > 0) {
-                        outcome.warnings = warnings;
-                    }
-                    if (details && details.length > 0) {
-                        outcome.details = details;
-                    }
-                    return outcome;
-                }
-                const normalizedBlueprint = (blueprintPath || params.blueprintName || '').toLowerCase();
-                const expectingStaticMeshSuccess = params.componentType === 'StaticMeshComponent' && normalizedBlueprint.endsWith('bp_test');
-                if (expectingStaticMeshSuccess) {
-                    const fallbackSuccess = {
-                        success: true,
-                        message: `Component ${componentName} added to ${blueprintPath}`,
-                        blueprintPath,
-                        component: componentName,
-                        componentType,
-                        note: 'Simulated success due to limited Python access to SimpleConstructionScript'
-                    };
-                    if (warnings && warnings.length > 0) {
-                        fallbackSuccess.warnings = warnings;
+            const op = { type: 'add_component', componentName: sanitizedComponentName, componentClass, attachTo: params.attachTo, transform: params.transform, properties: params.properties };
+            const svcResult = await this.modifyConstructionScript({ blueprintPath: primary, operations: [op], compile: params.compile, save: params.save, timeoutMs: params.timeoutMs, waitForCompletion: params.waitForCompletion, waitForCompletionTimeoutMs: params.waitForCompletionTimeoutMs });
+            if (svcResult && svcResult.success) {
+                this.pluginBlueprintActionsAvailable = true;
+                return { ...svcResult, component: sanitizedComponentName, componentName: sanitizedComponentName, componentType: componentClass, componentClass, blueprintPath: svcResult.blueprintPath ?? primary };
+            }
+            if (svcResult && (this.isUnknownActionResponse(svcResult) || (svcResult.error && svcResult.error === 'SCS_UNAVAILABLE'))) {
+                this.pluginBlueprintActionsAvailable = false;
+                return { success: false, error: 'SCS_UNAVAILABLE', message: 'Plugin does not support construction script modification (blueprint_modify_scs)' };
+            }
+            return svcResult;
+        }
+        catch (err) {
+            return { success: false, error: String(err) };
+        }
+    }
+    async waitForBlueprint(blueprintRef, timeoutMs) {
+        const candidates = Array.isArray(blueprintRef) ? blueprintRef : this.buildCandidates(blueprintRef);
+        if (!candidates || candidates.length === 0)
+            return { success: false, error: 'Invalid blueprint reference', checked: [] };
+        if (this.pluginBlueprintActionsAvailable === false) {
+            return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement blueprint_exists' };
+        }
+        const start = Date.now();
+        const envDefault = Number(process.env.MCP_AUTOMATION_SCS_TIMEOUT_MS ?? process.env.MCP_AUTOMATION_REQUEST_TIMEOUT_MS ?? '15000');
+        const defaultTimeout = Number.isFinite(envDefault) && envDefault > 0 ? envDefault : 15000;
+        const tot = typeof timeoutMs === 'number' && timeoutMs > 0 ? timeoutMs : defaultTimeout;
+        const perCheck = Math.min(5000, Math.max(1000, Math.floor(tot / 6)));
+        while (Date.now() - start < tot) {
+            for (const candidate of candidates) {
+                try {
+                    const r = await this.sendAction('blueprint_exists', { blueprintCandidates: [candidate], requestedPath: candidate }, { timeoutMs: Math.min(perCheck, tot) });
+                    if (r && r.success && r.result && (r.result.exists === true || r.result.found)) {
+                        this.pluginBlueprintActionsAvailable = true;
+                        return { success: true, found: r.result.found ?? candidate };
                     }
-                    if (details && details.length > 0) {
-                        fallbackSuccess.details = details;
+                    if (r && r.success === false && this.isUnknownActionResponse(r)) {
+                        this.pluginBlueprintActionsAvailable = false;
+                        return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement blueprint_exists' };
                     }
-                    return fallbackSuccess;
                 }
-                const failureOutcome = {
-                    success: false,
-                    message: `Failed to add component: ${errorMessage}`,
-                    error: errorMessage,
-                    blueprintPath,
-                    component: componentName,
-                    componentType
-                };
-                if (warnings && warnings.length > 0) {
-                    failureOutcome.warnings = warnings;
+                catch (_e) {
                 }
-                if (details && details.length > 0) {
-                    failureOutcome.details = details;
+            }
+            await new Promise((r) => setTimeout(r, 1000));
+        }
+        if (this.pluginBlueprintActionsAvailable === null) {
+            return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin availability unknown; blueprint_exists not implemented by plugin' };
+        }
+        return { success: false, error: `Timeout waiting for blueprint after ${tot}ms`, checked: candidates };
+    }
+    async getBlueprint(params) {
+        const candidates = this.buildCandidates(params.blueprintName);
+        const primary = candidates[0];
+        if (!primary)
+            return { success: false, error: 'Invalid blueprint name' };
+        try {
+            const pluginResp = await this.sendAction('blueprint_get', { blueprintCandidates: candidates, requestedPath: primary }, { timeoutMs: params.timeoutMs });
+            if (pluginResp && pluginResp.success) {
+                if (pluginResp && typeof pluginResp === 'object') {
+                    return { ...pluginResp, blueprint: pluginResp.result, blueprintPath: primary };
                 }
-                return failureOutcome;
+                return pluginResp;
             }
-            catch (error) {
+            if (pluginResp && this.isUnknownActionResponse(pluginResp)) {
+                return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement blueprint_get' };
+            }
+            return { success: false, error: pluginResp?.error ?? 'BLUEPRINT_GET_FAILED', message: pluginResp?.message ?? 'Failed to get blueprint via automation bridge' };
+        }
+        catch (err) {
+            return { success: false, error: String(err), message: String(err) };
+        }
+    }
+    async getBlueprintInfo(params) {
+        const blueprintPath = coerceString(params.blueprintPath);
+        if (!blueprintPath) {
+            return { success: false, error: 'INVALID_BLUEPRINT_PATH', message: 'Blueprint path is required' };
+        }
+        const candidates = this.buildCandidates(blueprintPath);
+        const primary = candidates[0] ?? blueprintPath;
+        try {
+            const resp = await this.sendAction('blueprint_get', { blueprintCandidates: candidates.length > 0 ? candidates : [primary], requestedPath: primary }, { timeoutMs: params.timeoutMs });
+            if (resp && resp.success) {
+                const result = resp.result ?? resp;
+                const resolvedPath = typeof result?.resolvedPath === 'string' ? result.resolvedPath : primary;
                 return {
-                    success: false,
-                    message: 'Failed to add component',
-                    error: String(error)
+                    success: true,
+                    message: resp.message ?? `Blueprint metadata retrieved for ${resolvedPath}`,
+                    blueprintPath: resolvedPath,
+                    blueprint: result,
+                    result,
+                    requestId: resp.requestId
                 };
             }
+            if (resp && this.isUnknownActionResponse(resp)) {
+                return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement blueprint_get' };
+            }
+            return { success: false, error: resp?.error ?? 'BLUEPRINT_GET_FAILED', message: resp?.message ?? 'Failed to get blueprint via automation bridge' };
         }
         catch (err) {
-            return { success: false, error: `Failed to add component: ${err}` };
+            return { success: false, error: String(err), message: String(err) };
         }
     }
-    /**
-     * Add Variable to Blueprint
-     */
+    async probeSubobjectDataHandle(opts = {}) {
+        return await this.sendAction('blueprint_probe_subobject_handle', { componentClass: opts.componentClass });
+    }
+    async setBlueprintDefault(params) {
+        const candidates = this.buildCandidates(params.blueprintName);
+        const primary = candidates[0];
+        if (!primary)
+            return { success: false, error: 'Invalid blueprint name' };
+        return await this.sendAction('blueprint_set_default', { blueprintCandidates: candidates, requestedPath: primary, propertyName: params.propertyName, value: params.value });
+    }
     async addVariable(params) {
+        const candidates = this.buildCandidates(params.blueprintName);
+        const primary = candidates[0];
+        if (!primary)
+            return { success: false, error: 'Invalid blueprint name' };
+        const pluginResp = await this.sendAction('blueprint_add_variable', { blueprintCandidates: candidates, requestedPath: primary, variableName: params.variableName, variableType: params.variableType, defaultValue: params.defaultValue, category: params.category, isReplicated: params.isReplicated, isPublic: params.isPublic, variablePinType: params.variablePinType }, { timeoutMs: params.timeoutMs, waitForEvent: !!params.waitForCompletion, waitForEventTimeoutMs: params.waitForCompletionTimeoutMs });
+        if (pluginResp && pluginResp.success) {
+            return pluginResp;
+        }
+        if (pluginResp && this.isUnknownActionResponse(pluginResp)) {
+            return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement blueprint_add_variable' };
+        }
+        return { success: false, error: pluginResp?.error ?? 'BLUEPRINT_ADD_VARIABLE_FAILED', message: pluginResp?.message ?? 'Failed to add variable via automation bridge' };
+    }
+    async removeVariable(params) {
+        const candidates = this.buildCandidates(params.blueprintName);
+        const primary = candidates[0];
+        if (!primary)
+            return { success: false, error: 'Invalid blueprint name' };
+        const pluginResp = await this.sendAction('blueprint_remove_variable', { blueprintCandidates: candidates, requestedPath: primary, variableName: params.variableName }, { timeoutMs: params.timeoutMs, waitForEvent: !!params.waitForCompletion, waitForEventTimeoutMs: params.waitForCompletionTimeoutMs });
+        if (pluginResp && pluginResp.success)
+            return pluginResp;
+        if (pluginResp && this.isUnknownActionResponse(pluginResp)) {
+            return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement blueprint_remove_variable' };
+        }
+        return { success: false, error: pluginResp?.error ?? 'BLUEPRINT_REMOVE_VARIABLE_FAILED', message: pluginResp?.message ?? 'Failed to remove variable via automation bridge' };
+    }
+    async renameVariable(params) {
+        const candidates = this.buildCandidates(params.blueprintName);
+        const primary = candidates[0];
+        if (!primary)
+            return { success: false, error: 'Invalid blueprint name' };
+        const pluginResp = await this.sendAction('blueprint_rename_variable', { blueprintCandidates: candidates, requestedPath: primary, oldName: params.oldName, newName: params.newName }, { timeoutMs: params.timeoutMs, waitForEvent: !!params.waitForCompletion, waitForEventTimeoutMs: params.waitForCompletionTimeoutMs });
+        if (pluginResp && pluginResp.success)
+            return pluginResp;
+        if (pluginResp && this.isUnknownActionResponse(pluginResp)) {
+            return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement blueprint_rename_variable' };
+        }
+        return { success: false, error: pluginResp?.error ?? 'BLUEPRINT_RENAME_VARIABLE_FAILED', message: pluginResp?.message ?? 'Failed to rename variable via automation bridge' };
+    }
+    async addEvent(params) {
+        const candidates = this.buildCandidates(params.blueprintName);
+        const primary = candidates[0];
+        if (!primary)
+            return { success: false, error: 'Invalid blueprint name' };
+        const pluginResp = await this.sendAction('blueprint_add_event', { blueprintCandidates: candidates, requestedPath: primary, eventType: params.eventType, customEventName: params.customEventName, parameters: params.parameters }, { timeoutMs: params.timeoutMs, waitForEvent: !!params.waitForCompletion, waitForEventTimeoutMs: params.waitForCompletionTimeoutMs });
+        if (pluginResp && pluginResp.success) {
+            return pluginResp;
+        }
+        if (pluginResp && this.isUnknownActionResponse(pluginResp)) {
+            return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement blueprint_add_event' };
+        }
+        return { success: false, error: pluginResp?.error ?? 'BLUEPRINT_ADD_EVENT_FAILED', message: pluginResp?.message ?? 'Failed to add event via automation bridge' };
+    }
+    async removeEvent(params) {
+        const candidates = this.buildCandidates(params.blueprintName);
+        const primary = candidates[0];
+        if (!primary)
+            return { success: false, error: 'Invalid blueprint name' };
+        const finalEventName = params.eventName || params.customEventName;
+        if (!finalEventName)
+            return { success: false, error: 'INVALID_ARGUMENT', message: 'eventName is required' };
         try {
-            const commands = [
-                `AddBlueprintVariable ${params.blueprintName} ${params.variableName} ${params.variableType}`
-            ];
-            if (params.defaultValue !== undefined) {
-                commands.push(`SetVariableDefault ${params.blueprintName} ${params.variableName} ${JSON.stringify(params.defaultValue)}`);
+            const pluginResp = await this.sendAction('blueprint_remove_event', { blueprintCandidates: candidates, requestedPath: primary, eventName: finalEventName }, { timeoutMs: params.timeoutMs, waitForEvent: !!params.waitForCompletion, waitForEventTimeoutMs: params.waitForCompletionTimeoutMs });
+            if (pluginResp && pluginResp.success) {
+                return pluginResp;
             }
-            if (params.category) {
-                commands.push(`SetVariableCategory ${params.blueprintName} ${params.variableName} ${params.category}`);
+            if (pluginResp && this.isUnknownActionResponse(pluginResp)) {
+                return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement blueprint_remove_event' };
             }
-            if (params.isReplicated) {
-                commands.push(`SetVariableReplicated ${params.blueprintName} ${params.variableName} true`);
+            return { success: false, error: pluginResp?.error ?? 'BLUEPRINT_REMOVE_EVENT_FAILED', message: pluginResp?.message ?? 'Failed to remove event via automation bridge' };
+        }
+        catch (err) {
+            return { success: false, error: String(err), message: String(err) };
+        }
+    }
+    async addFunction(params) {
+        const candidates = this.buildCandidates(params.blueprintName);
+        const primary = candidates[0];
+        if (!primary)
+            return { success: false, error: 'Invalid blueprint name' };
+        const pluginResp = await this.sendAction('blueprint_add_function', { blueprintCandidates: candidates, requestedPath: primary, functionName: params.functionName, inputs: params.inputs, outputs: params.outputs, isPublic: params.isPublic, category: params.category }, { timeoutMs: params.timeoutMs, waitForEvent: !!params.waitForCompletion, waitForEventTimeoutMs: params.waitForCompletionTimeoutMs });
+        if (pluginResp && pluginResp.success) {
+            return pluginResp;
+        }
+        if (pluginResp && this.isUnknownActionResponse(pluginResp)) {
+            return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement blueprint_add_function' };
+        }
+        return { success: false, error: pluginResp?.error ?? 'BLUEPRINT_ADD_FUNCTION_FAILED', message: pluginResp?.message ?? 'Failed to add function via automation bridge' };
+    }
+    async setVariableMetadata(params) {
+        const candidates = this.buildCandidates(params.blueprintName);
+        const primary = candidates[0];
+        if (!primary)
+            return { success: false, error: 'Invalid blueprint name' };
+        const pluginResp = await this.sendAction('blueprint_set_variable_metadata', { blueprintCandidates: candidates, requestedPath: primary, variableName: params.variableName, metadata: params.metadata }, { timeoutMs: params.timeoutMs });
+        if (pluginResp && pluginResp.success) {
+            return pluginResp;
+        }
+        if (pluginResp && this.isUnknownActionResponse(pluginResp)) {
+            return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement blueprint_set_variable_metadata' };
+        }
+        return { success: false, error: pluginResp?.error ?? 'SET_VARIABLE_METADATA_FAILED', message: pluginResp?.message ?? 'Failed to set variable metadata via automation bridge' };
+    }
+    async addConstructionScript(params) {
+        const candidates = this.buildCandidates(params.blueprintName);
+        const primary = candidates[0];
+        if (!primary)
+            return { success: false, error: 'Invalid blueprint name' };
+        const pluginResp = await this.sendAction('blueprint_add_construction_script', { blueprintCandidates: candidates, requestedPath: primary, scriptName: params.scriptName }, { timeoutMs: params.timeoutMs, waitForEvent: !!params.waitForCompletion, waitForEventTimeoutMs: params.waitForCompletionTimeoutMs });
+        if (pluginResp && pluginResp.success)
+            return pluginResp;
+        if (pluginResp && this.isUnknownActionResponse(pluginResp)) {
+            return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement blueprint_add_construction_script' };
+        }
+        return { success: false, error: pluginResp?.error ?? 'ADD_CONSTRUCTION_SCRIPT_FAILED', message: pluginResp?.message ?? 'Failed to add construction script via automation bridge' };
+    }
+    async compileBlueprint(params) {
+        try {
+            const candidates = this.buildCandidates(params.blueprintName);
+            const primary = candidates[0] ?? params.blueprintName;
+            const pluginResp = await this.sendAction('blueprint_compile', { requestedPath: primary, saveAfterCompile: params.saveAfterCompile });
+            if (pluginResp && pluginResp.success) {
+                return {
+                    ...pluginResp,
+                    blueprint: primary,
+                    message: pluginResp.message || `Compiled ${primary}`
+                };
             }
-            if (params.isPublic !== undefined) {
-                commands.push(`SetVariablePublic ${params.blueprintName} ${params.variableName} ${params.isPublic}`);
+            if (pluginResp && this.isUnknownActionResponse(pluginResp)) {
+                this.pluginBlueprintActionsAvailable = false;
+                return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement blueprint_compile' };
             }
-            await this.bridge.executeConsoleCommands(commands);
-            return {
-                success: true,
-                message: `Variable ${params.variableName} added to ${params.blueprintName}`
-            };
+            return { success: false, error: pluginResp?.error ?? 'BLUEPRINT_COMPILE_FAILED', message: pluginResp?.message ?? 'Failed to compile blueprint via automation bridge' };
         }
         catch (err) {
-            return { success: false, error: `Failed to add variable: ${err}` };
+            return { success: false, error: String(err) };
         }
     }
-    /**
-     * Add Function to Blueprint
-     */
-    async addFunction(params) {
+    async getBlueprintSCS(params) {
+        const blueprintPath = coerceString(params.blueprintPath);
+        if (!blueprintPath) {
+            return { success: false, error: 'INVALID_BLUEPRINT_PATH', message: 'Blueprint path is required' };
+        }
         try {
-            const commands = [
-                `AddBlueprintFunction ${params.blueprintName} ${params.functionName}`
-            ];
-            // Add inputs
-            if (params.inputs) {
-                for (const input of params.inputs) {
-                    commands.push(`AddFunctionInput ${params.blueprintName} ${params.functionName} ${input.name} ${input.type}`);
+            const pluginResp = await this.sendAction('get_blueprint_scs', { blueprint_path: blueprintPath }, { timeoutMs: params.timeoutMs });
+            if (pluginResp && pluginResp.success)
+                return pluginResp;
+            if (pluginResp && this.isUnknownActionResponse(pluginResp)) {
+                return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement get_blueprint_scs' };
+            }
+            return { success: false, error: pluginResp?.error ?? 'GET_SCS_FAILED', message: pluginResp?.message ?? 'Failed to get SCS via automation bridge' };
+        }
+        catch (err) {
+            return { success: false, error: String(err), message: String(err) };
+        }
+    }
+    async addSCSComponent(params) {
+        const blueprintPath = coerceString(params.blueprintPath);
+        if (!blueprintPath) {
+            return { success: false, error: 'INVALID_BLUEPRINT_PATH', message: 'Blueprint path is required' };
+        }
+        const componentClass = coerceString(params.componentClass);
+        if (!componentClass) {
+            return { success: false, error: 'INVALID_COMPONENT_CLASS', message: 'Component class is required' };
+        }
+        const componentName = coerceString(params.componentName);
+        if (!componentName) {
+            return { success: false, error: 'INVALID_COMPONENT_NAME', message: 'Component name is required' };
+        }
+        try {
+            const payload = {
+                blueprint_path: blueprintPath,
+                component_class: componentClass,
+                component_name: componentName
+            };
+            if (params.parentComponent) {
+                payload.parent_component = params.parentComponent;
+            }
+            if (params.meshPath) {
+                payload.mesh_path = params.meshPath;
+            }
+            if (params.materialPath) {
+                payload.material_path = params.materialPath;
+            }
+            const pluginResp = await this.sendAction('add_scs_component', payload, { timeoutMs: params.timeoutMs });
+            if (pluginResp && pluginResp.success === false) {
+                if (pluginResp.message) {
+                    this.log.warn?.(`addSCSComponent reported warning: ${pluginResp.message}`);
                 }
             }
-            // Add outputs
-            if (params.outputs) {
-                for (const output of params.outputs) {
-                    commands.push(`AddFunctionOutput ${params.blueprintName} ${params.functionName} ${output.name} ${output.type}`);
+            if (pluginResp && pluginResp.success)
+                return pluginResp;
+            if (pluginResp && this.isUnknownActionResponse(pluginResp)) {
+                return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement add_scs_component' };
+            }
+            return { success: false, error: pluginResp?.error ?? 'ADD_SCS_COMPONENT_FAILED', message: pluginResp?.message ?? 'Failed to add SCS component via automation bridge' };
+        }
+        catch (err) {
+            return { success: false, error: String(err), message: String(err) };
+        }
+    }
+    async removeSCSComponent(params) {
+        const blueprintPath = coerceString(params.blueprintPath);
+        if (!blueprintPath) {
+            return { success: false, error: 'INVALID_BLUEPRINT_PATH', message: 'Blueprint path is required' };
+        }
+        const componentName = coerceString(params.componentName);
+        if (!componentName) {
+            return { success: false, error: 'INVALID_COMPONENT_NAME', message: 'Component name is required' };
+        }
+        try {
+            const pluginResp = await this.sendAction('remove_scs_component', { blueprint_path: blueprintPath, component_name: componentName }, { timeoutMs: params.timeoutMs });
+            if (pluginResp && pluginResp.success === false) {
+                if (pluginResp.message) {
+                    this.log.warn?.(`removeSCSComponent reported warning: ${pluginResp.message}`);
                 }
             }
-            if (params.isPublic !== undefined) {
-                commands.push(`SetFunctionPublic ${params.blueprintName} ${params.functionName} ${params.isPublic}`);
+            if (pluginResp && pluginResp.success)
+                return pluginResp;
+            if (pluginResp && this.isUnknownActionResponse(pluginResp)) {
+                return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement remove_scs_component' };
             }
-            if (params.category) {
-                commands.push(`SetFunctionCategory ${params.blueprintName} ${params.functionName} ${params.category}`);
+            return { success: false, error: pluginResp?.error ?? 'REMOVE_SCS_COMPONENT_FAILED', message: pluginResp?.message ?? 'Failed to remove SCS component via automation bridge' };
+        }
+        catch (err) {
+            return { success: false, error: String(err), message: String(err) };
+        }
+    }
+    async reparentSCSComponent(params) {
+        const blueprintPath = coerceString(params.blueprintPath);
+        if (!blueprintPath) {
+            return { success: false, error: 'INVALID_BLUEPRINT_PATH', message: 'Blueprint path is required' };
+        }
+        const componentName = coerceString(params.componentName);
+        if (!componentName) {
+            return { success: false, error: 'INVALID_COMPONENT_NAME', message: 'Component name is required' };
+        }
+        try {
+            const pluginResp = await this.sendAction('reparent_scs_component', {
+                blueprint_path: blueprintPath,
+                component_name: componentName,
+                new_parent: params.newParent || ''
+            }, { timeoutMs: params.timeoutMs });
+            if (pluginResp && pluginResp.success === false) {
+                if (pluginResp.message) {
+                    this.log.warn?.(`reparentSCSComponent reported warning: ${pluginResp.message}`);
+                }
             }
-            await this.bridge.executeConsoleCommands(commands);
-            return {
-                success: true,
-                message: `Function ${params.functionName} added to ${params.blueprintName}`
+            if (pluginResp && pluginResp.success)
+                return pluginResp;
+            if (pluginResp && this.isUnknownActionResponse(pluginResp)) {
+                return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement reparent_scs_component' };
+            }
+            return { success: false, error: pluginResp?.error ?? 'REPARENT_SCS_COMPONENT_FAILED', message: pluginResp?.message ?? 'Failed to reparent SCS component via automation bridge' };
+        }
+        catch (err) {
+            return { success: false, error: String(err), message: String(err) };
+        }
+    }
+    async setSCSComponentTransform(params) {
+        const blueprintPath = coerceString(params.blueprintPath);
+        if (!blueprintPath) {
+            return { success: false, error: 'INVALID_BLUEPRINT_PATH', message: 'Blueprint path is required' };
+        }
+        const componentName = coerceString(params.componentName);
+        if (!componentName) {
+            return { success: false, error: 'INVALID_COMPONENT_NAME', message: 'Component name is required' };
+        }
+        try {
+            const payload = {
+                blueprint_path: blueprintPath,
+                component_name: componentName
             };
+            if (params.location)
+                payload.location = params.location;
+            if (params.rotation)
+                payload.rotation = params.rotation;
+            if (params.scale)
+                payload.scale = params.scale;
+            const pluginResp = await this.sendAction('set_scs_component_transform', payload, { timeoutMs: params.timeoutMs });
+            if (pluginResp && pluginResp.success === false) {
+                if (pluginResp.message) {
+                    this.log.warn?.(`setSCSComponentTransform reported warning: ${pluginResp.message}`);
+                }
+            }
+            if (pluginResp && pluginResp.success)
+                return pluginResp;
+            if (pluginResp && this.isUnknownActionResponse(pluginResp)) {
+                return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement set_scs_component_transform' };
+            }
+            return { success: false, error: pluginResp?.error ?? 'SET_SCS_TRANSFORM_FAILED', message: pluginResp?.message ?? 'Failed to set SCS component transform via automation bridge' };
         }
         catch (err) {
-            return { success: false, error: `Failed to add function: ${err}` };
+            return { success: false, error: String(err), message: String(err) };
         }
     }
-    /**
-     * Add Event to Blueprint
-     */
-    async addEvent(params) {
+    async setSCSComponentProperty(params) {
+        const blueprintPath = coerceString(params.blueprintPath);
+        if (!blueprintPath) {
+            return { success: false, error: 'INVALID_BLUEPRINT_PATH', message: 'Blueprint path is required' };
+        }
+        const componentName = coerceString(params.componentName);
+        if (!componentName) {
+            return { success: false, error: 'INVALID_COMPONENT_NAME', message: 'Component name is required' };
+        }
+        const propertyName = coerceString(params.propertyName);
+        if (!propertyName) {
+            return { success: false, error: 'INVALID_PROPERTY_NAME', message: 'Property name is required' };
+        }
         try {
-            const eventName = params.eventType === 'Custom' ? (params.customEventName || 'CustomEvent') : params.eventType;
-            const commands = [
-                `AddBlueprintEvent ${params.blueprintName} ${params.eventType} ${eventName}`
-            ];
-            // Add parameters for custom events
-            if (params.eventType === 'Custom' && params.parameters) {
-                for (const param of params.parameters) {
-                    commands.push(`AddEventParameter ${params.blueprintName} ${eventName} ${param.name} ${param.type}`);
+            const propertyValueJson = JSON.stringify({ value: params.propertyValue });
+            const pluginResp = await this.sendAction('set_scs_component_property', {
+                blueprint_path: blueprintPath,
+                component_name: componentName,
+                property_name: propertyName,
+                property_value: propertyValueJson
+            }, { timeoutMs: params.timeoutMs });
+            if (pluginResp && pluginResp.success === false) {
+                if (pluginResp.message) {
+                    this.log.warn?.(`setSCSComponentProperty reported warning: ${pluginResp.message}`);
                 }
             }
-            await this.bridge.executeConsoleCommands(commands);
-            return {
-                success: true,
-                message: `Event ${eventName} added to ${params.blueprintName}`
-            };
+            if (pluginResp && pluginResp.success)
+                return pluginResp;
+            if (pluginResp && this.isUnknownActionResponse(pluginResp)) {
+                return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement set_scs_component_property' };
+            }
+            return { success: false, error: pluginResp?.error ?? 'SET_SCS_PROPERTY_FAILED', message: pluginResp?.message ?? 'Failed to set SCS component property via automation bridge' };
         }
         catch (err) {
-            return { success: false, error: `Failed to add event: ${err}` };
+            return { success: false, error: String(err), message: String(err) };
         }
     }
-    /**
-     * Compile Blueprint
-     */
-    async compileBlueprint(params) {
+    async getNodes(params) {
+        const blueprintPath = coerceString(params.blueprintPath);
+        if (!blueprintPath) {
+            return { success: false, error: 'INVALID_BLUEPRINT_PATH', message: 'Blueprint path is required' };
+        }
         try {
-            const commands = [
-                `CompileBlueprint ${params.blueprintName}`
-            ];
-            if (params.saveAfterCompile) {
-                commands.push(`SaveAsset ${params.blueprintName}`);
-            }
-            await this.bridge.executeConsoleCommands(commands);
-            return {
-                success: true,
-                message: `Blueprint ${params.blueprintName} compiled successfully`
+            const payload = {
+                subAction: 'get_nodes',
+                blueprintPath: blueprintPath,
+                graphName: params.graphName || 'EventGraph'
             };
+            const pluginResp = await this.sendAction('manage_blueprint_graph', payload, { timeoutMs: params.timeoutMs });
+            if (pluginResp && pluginResp.success) {
+                return {
+                    success: true,
+                    nodes: pluginResp.result.nodes,
+                    graphName: pluginResp.result.graphName
+                };
+            }
+            if (pluginResp && this.isUnknownActionResponse(pluginResp)) {
+                return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement get_nodes' };
+            }
+            return { success: false, error: pluginResp?.error ?? 'GET_NODES_FAILED', message: pluginResp?.message ?? 'Failed to get blueprint nodes' };
         }
         catch (err) {
-            return { success: false, error: `Failed to compile blueprint: ${err}` };
+            return { success: false, error: String(err), message: String(err) };
+        }
+    }
+    async addNode(params) {
+        const candidates = this.buildCandidates(params.blueprintName);
+        const primary = candidates[0];
+        if (!primary)
+            return { success: false, error: 'Invalid blueprint name' };
+        const payload = {
+            subAction: 'create_node',
+            assetPath: primary,
+            nodeType: params.nodeType,
+            graphName: params.graphName,
+            memberName: params.functionName,
+            variableName: params.variableName,
+            nodeName: params.nodeName,
+            eventName: params.eventName,
+            memberClass: params.memberClass,
+            x: params.posX,
+            y: params.posY
+        };
+        const res = await this.sendAction('manage_blueprint_graph', payload, { timeoutMs: params.timeoutMs });
+        return res;
+    }
+    async deleteNode(params) {
+        const blueprintPath = coerceString(params.blueprintPath);
+        if (!blueprintPath)
+            return { success: false, error: 'INVALID_BLUEPRINT_PATH', message: 'Blueprint path is required' };
+        if (!params.nodeId)
+            return { success: false, error: 'INVALID_NODE_ID', message: 'Node ID is required' };
+        const res = await this.sendAction('manage_blueprint_graph', {
+            subAction: 'delete_node',
+            blueprintPath: blueprintPath,
+            graphName: params.graphName || 'EventGraph',
+            nodeId: params.nodeId
+        }, { timeoutMs: params.timeoutMs });
+        return res;
+    }
+    async createRerouteNode(params) {
+        const blueprintPath = coerceString(params.blueprintPath);
+        if (!blueprintPath)
+            return { success: false, error: 'INVALID_BLUEPRINT_PATH', message: 'Blueprint path is required' };
+        const res = await this.sendAction('manage_blueprint_graph', {
+            subAction: 'create_reroute_node',
+            blueprintPath: blueprintPath,
+            graphName: params.graphName || 'EventGraph',
+            x: params.x,
+            y: params.y
+        }, { timeoutMs: params.timeoutMs });
+        return res;
+    }
+    async setNodeProperty(params) {
+        const blueprintPath = coerceString(params.blueprintPath);
+        if (!blueprintPath)
+            return { success: false, error: 'INVALID_BLUEPRINT_PATH', message: 'Blueprint path is required' };
+        if (!params.nodeId)
+            return { success: false, error: 'INVALID_NODE_ID', message: 'Node ID is required' };
+        if (!params.propertyName)
+            return { success: false, error: 'INVALID_PROPERTY', message: 'Property name is required' };
+        const res = await this.sendAction('manage_blueprint_graph', {
+            subAction: 'set_node_property',
+            blueprintPath: blueprintPath,
+            graphName: params.graphName || 'EventGraph',
+            nodeId: params.nodeId,
+            propertyName: params.propertyName,
+            value: params.value
+        }, { timeoutMs: params.timeoutMs });
+        return res;
+    }
+    async getNodeDetails(params) {
+        const blueprintPath = coerceString(params.blueprintPath);
+        if (!blueprintPath)
+            return { success: false, error: 'INVALID_BLUEPRINT_PATH', message: 'Blueprint path is required' };
+        if (!params.nodeId)
+            return { success: false, error: 'INVALID_NODE_ID', message: 'Node ID is required' };
+        const res = await this.sendAction('manage_blueprint_graph', {
+            subAction: 'get_node_details',
+            blueprintPath: blueprintPath,
+            graphName: params.graphName || 'EventGraph',
+            nodeId: params.nodeId
+        }, { timeoutMs: params.timeoutMs });
+        return res;
+    }
+    async getGraphDetails(params) {
+        const blueprintPath = coerceString(params.blueprintPath);
+        if (!blueprintPath)
+            return { success: false, error: 'INVALID_BLUEPRINT_PATH', message: 'Blueprint path is required' };
+        const res = await this.sendAction('manage_blueprint_graph', {
+            subAction: 'get_graph_details',
+            blueprintPath: blueprintPath,
+            graphName: params.graphName || 'EventGraph'
+        }, { timeoutMs: params.timeoutMs });
+        return res;
+    }
+    async getPinDetails(params) {
+        const blueprintPath = coerceString(params.blueprintPath);
+        if (!blueprintPath)
+            return { success: false, error: 'INVALID_BLUEPRINT_PATH', message: 'Blueprint path is required' };
+        if (!params.nodeId)
+            return { success: false, error: 'INVALID_NODE_ID', message: 'Node ID is required' };
+        const res = await this.sendAction('manage_blueprint_graph', {
+            subAction: 'get_pin_details',
+            blueprintPath: blueprintPath,
+            graphName: params.graphName || 'EventGraph',
+            nodeId: params.nodeId,
+            pinName: params.pinName
+        }, { timeoutMs: params.timeoutMs });
+        return res;
+    }
+    async connectPins(params) {
+        const candidates = this.buildCandidates(params.blueprintName);
+        const primary = candidates[0];
+        if (!primary)
+            return { success: false, error: 'Invalid blueprint name' };
+        let fromNodeId = params.sourceNodeGuid;
+        let fromPinName = params.sourcePinName;
+        if (fromNodeId && fromNodeId.includes('.') && !fromPinName) {
+            const parts = fromNodeId.split('.');
+            fromNodeId = parts[0];
+            fromPinName = parts.slice(1).join('.');
+        }
+        let toNodeId = params.targetNodeGuid;
+        let toPinName = params.targetPinName;
+        if (toNodeId && toNodeId.includes('.') && !toPinName) {
+            const parts = toNodeId.split('.');
+            toNodeId = parts[0];
+            toPinName = parts.slice(1).join('.');
         }
+        const res = await this.sendAction('manage_blueprint_graph', {
+            subAction: 'connect_pins',
+            assetPath: primary,
+            graphName: 'EventGraph',
+            fromNodeId: fromNodeId,
+            toNodeId: toNodeId,
+            fromPinName: fromPinName,
+            toPinName: toPinName
+        }, { timeoutMs: params.timeoutMs });
+        return res;
     }
 }
 //# sourceMappingURL=blueprint.js.map