unreal-engine-mcp-server 0.4.7 → 0.5.0

package/src/tools/blueprint.ts

@@ -1,1052 +1,874 @@
-import { UnrealBridge } from '../unreal-bridge.js';
+import { BaseTool } from './base-tool.js';
+import { IBlueprintTools } from '../types/tool-interfaces.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';
+import { coerceString } from '../utils/result-helpers.js';
 
-export class BlueprintTools {
-  constructor(private bridge: UnrealBridge) {}
+export class BlueprintTools extends BaseTool implements IBlueprintTools {
+  private log = new Logger('BlueprintTools');
+  private pluginBlueprintActionsAvailable: boolean | null = null;
 
-  private async validateParentClassReference(parentClass: string, blueprintType: string): Promise<{ ok: boolean; resolved?: string; error?: string }> {
-    const trimmed = parentClass?.trim();
-    if (!trimmed) {
-      return { ok: true };
+  private async sendAction(action: string, payload: Record<string, unknown> = {}, options?: { timeoutMs?: number; waitForEvent?: boolean; waitForEventTimeoutMs?: number }) {
+    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: any = 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 } as any;
+    } catch (err: any) {
+      return { success: false, error: String(err), message: String(err) } as const;
     }
+  }
 
-    const escapedParent = escapePythonString(trimmed);
-    const python = `
-import unreal
-import json
+  private isUnknownActionResponse(res: any): boolean {
+    if (!res) return false;
+    const txt = String((res.error ?? res.message ?? '')).toLowerCase();
+    // Only treat specific error codes as "not implemented"
+    return txt.includes('unknown_action') || txt.includes('unknown automation action') || txt.includes('not_implemented') || txt === 'unknown_plugin_action';
+  }
 
-result = {
-  'success': False,
-  'resolved': '',
-  'error': ''
-}
+  private buildCandidates(rawName: string | undefined): string[] {
+    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: string[] = [];
+    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: { name: string; blueprintType?: string; savePath?: string; parentClass?: string; properties?: Record<string, unknown>; timeoutMs?: number; waitForCompletion?: boolean; waitForCompletionTimeoutMs?: number }) {
+    try {
+      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: Record<string, unknown> = { 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' } as const;
+      }
+
+      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;
+          // Enrich response for Validator
+          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' } as const;
+        }
+        return res as any;
+      } catch (err: any) {
+        // ... (unchanged catch block)
+        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) } as const;
+      }
+    } catch (err: any) {
+      return { success: false, error: String(err), message: String(err) };
+    }
+  }
+
+  async modifyConstructionScript(params: { blueprintPath: string; operations: any[]; compile?: boolean; save?: boolean; timeoutMs?: number; waitForCompletion?: boolean; waitForCompletionTimeoutMs?: number }) {
+    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' };
 
-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();
+    // Fix: Map 'op' to 'type' if missing, for backward compatibility or user convenience
+    const operations = params.operations.map(op => {
+      if (op && typeof op === 'object' && op.op && !op.type) {
+        return { ...op, type: op.op };
+      }
+      return op;
+    });
 
+    const payload: any = { 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 as any).error === 'SCS_UNAVAILABLE') {
+      this.pluginBlueprintActionsAvailable = false;
+      return { success: false, error: 'SCS_UNAVAILABLE', message: 'Plugin does not support construction script modification (blueprint_modify_scs)' } as const;
+    }
+    if (res && res.success) this.pluginBlueprintActionsAvailable = true;
+    if (res && this.isUnknownActionResponse(res)) {
+      this.pluginBlueprintActionsAvailable = false;
+    }
+    return res;
+  }
+
+  async addComponent(params: { blueprintName: string; componentType: string; componentName: string; attachTo?: string; transform?: Record<string, unknown>; properties?: Record<string, unknown>; compile?: boolean; save?: boolean; timeoutMs?: number; waitForCompletion?: boolean; waitForCompletionTimeoutMs?: number }) {
+    const blueprintName = coerceString(params.blueprintName);
+    if (!blueprintName) return { success: false as const, message: 'Blueprint name is required', error: 'INVALID_BLUEPRINT' };
+    const componentClass = coerceString(params.componentType);
+    if (!componentClass) return { success: false as const, message: 'Component class is required', error: 'INVALID_COMPONENT_CLASS' };
+    const rawComponentName = coerceString(params.componentName) ?? params.componentName;
+    if (!rawComponentName) return { success: false as const, 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 as const, error: 'Invalid blueprint name' };
     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 as any)?.resolved ?? interpreted.message };
+      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 as any), component: sanitizedComponentName, componentName: sanitizedComponentName, componentType: componentClass, componentClass, blueprintPath: svcResult.blueprintPath ?? primary } as const;
       }
+      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)' } as const;
+      }
+      return svcResult as any;
+    } catch (err: any) {
+      return { success: false, error: String(err) };
+    }
+  }
+
+  async waitForBlueprint(blueprintRef: string | string[], timeoutMs?: number) {
+    const candidates = Array.isArray(blueprintRef) ? blueprintRef : this.buildCandidates(blueprintRef as string | undefined);
+    if (!candidates || candidates.length === 0) return { success: false, error: 'Invalid blueprint reference', checked: [] } as any;
+    if (this.pluginBlueprintActionsAvailable === false) {
+      return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement blueprint_exists' } as any;
+    }
 
-      const error = interpreted.error || (interpreted.payload as any)?.error || `Parent class not found: ${trimmed}`;
-      return { ok: false, error };
+    const start = Date.now();
+    const envDefault = Number(process.env.MCP_AUTOMATION_SCS_TIMEOUT_MS ?? process.env.MCP_AUTOMATION_REQUEST_TIMEOUT_MS ?? '15000');
+    // Default to 15s (15000ms) instead of 120s to avoid long hangs on non-existent assets
+    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 } as any;
+          }
+          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' } as any;
+          }
+        } catch (_e) {
+          // ignore and try next candidate
+        }
+      }
+      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' } as any;
+    }
+    return { success: false, error: `Timeout waiting for blueprint after ${tot}ms`, checked: candidates } as any;
+  }
+
+  async getBlueprint(params: { blueprintName: string; timeoutMs?: number; }) {
+    const candidates = this.buildCandidates(params.blueprintName);
+    const primary = candidates[0];
+    if (!primary) return { success: false, error: 'Invalid blueprint name' } as const;
+    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 } as any;
+        }
+        return pluginResp;
+      }
+      if (pluginResp && this.isUnknownActionResponse(pluginResp)) {
+        return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement blueprint_get' } as const;
+      }
+      return { success: false, error: pluginResp?.error ?? 'BLUEPRINT_GET_FAILED', message: pluginResp?.message ?? 'Failed to get blueprint via automation bridge' } as const;
     } catch (err: any) {
-      return { ok: false, error: err?.message || String(err) };
+      return { success: false, error: String(err), message: String(err) } as const;
     }
   }
 
-  /**
-   * Create Blueprint
-   */
-  async createBlueprint(params: {
-    name: string;
-    blueprintType: 'Actor' | 'Pawn' | 'Character' | 'GameMode' | 'PlayerController' | 'HUD' | 'ActorComponent';
-    savePath?: string;
-    parentClass?: string;
-  }) {
+  async getBlueprintInfo(params: { blueprintPath: string; timeoutMs?: number }) {
+    const blueprintPath = coerceString(params.blueprintPath);
+    if (!blueprintPath) {
+      return { success: false, error: 'INVALID_BLUEPRINT_PATH', message: 'Blueprint path is required' } as const;
+    }
+
+    const candidates = this.buildCandidates(blueprintPath);
+    const primary = candidates[0] ?? blueprintPath;
+
     try {
-      // Validate and sanitize parameters
-      const validation = validateAssetParams({
-        name: params.name,
-        savePath: params.savePath || '/Game/Blueprints'
-      });
-      
-      if (!validation.valid) {
+      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 create blueprint: ${validation.error}`,
-          error: validation.error
+          success: true,
+          message: resp.message ?? `Blueprint metadata retrieved for ${resolvedPath}`,
+          blueprintPath: resolvedPath,
+          blueprint: result,
+          result,
+          requestId: resp.requestId
         };
       }
-      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 (resp && this.isUnknownActionResponse(resp)) {
+        return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement blueprint_get' } as const;
       }
-      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 escapedName = escapePythonString(sanitizedParams.name);
-  const escapedPath = escapePythonString(path);
-  const escapedParent = escapePythonString(params.parentClass ?? '');
 
-      await concurrencyDelay();
+      return { success: false, error: resp?.error ?? 'BLUEPRINT_GET_FAILED', message: resp?.message ?? 'Failed to get blueprint via automation bridge' } as const;
+    } catch (err: any) {
+      return { success: false, error: String(err), message: String(err) } as const;
+    }
+  }
 
-      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,
+  async probeSubobjectDataHandle(opts: { componentClass?: string } = {}) {
+    return await this.sendAction('blueprint_probe_subobject_handle', { componentClass: opts.componentClass });
+  }
+
+  async setBlueprintDefault(params: { blueprintName: string; propertyName: string; value: unknown }) {
+    const candidates = this.buildCandidates(params.blueprintName);
+    const primary = candidates[0];
+    if (!primary) return { success: false as const, error: 'Invalid blueprint name' };
+    return await this.sendAction('blueprint_set_default', { blueprintCandidates: candidates, requestedPath: primary, propertyName: params.propertyName, value: params.value });
   }
-  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}` };
+  async addVariable(params: { blueprintName: string; variableName: string; variableType: string; defaultValue?: any; category?: string; isReplicated?: boolean; isPublic?: boolean; variablePinType?: Record<string, unknown>; timeoutMs?: number; waitForCompletion?: boolean; waitForCompletionTimeoutMs?: number }) {
+    const candidates = this.buildCandidates(params.blueprintName);
+    const primary = candidates[0];
+    if (!primary) return { success: false as const, 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' } as const;
     }
+    return { success: false, error: pluginResp?.error ?? 'BLUEPRINT_ADD_VARIABLE_FAILED', message: pluginResp?.message ?? 'Failed to add variable via automation bridge' } as const;
   }
 
-  private parseBlueprintCreationOutput(response: any, blueprintName: string, blueprintPath: string) {
-    const defaultPath = `${blueprintPath}/${blueprintName}`;
-    const interpreted = interpretStandardResult(response, {
-      successMessage: `Blueprint ${blueprintName} created`,
-      failureMessage: `Failed to create blueprint ${blueprintName}`
-    });
+  async removeVariable(params: { blueprintName: string; variableName: string; timeoutMs?: number; waitForCompletion?: boolean; waitForCompletionTimeoutMs?: number }) {
+    const candidates = this.buildCandidates(params.blueprintName);
+    const primary = candidates[0];
+    if (!primary) return { success: false as const, 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' } as const;
+    }
+    return { success: false, error: pluginResp?.error ?? 'BLUEPRINT_REMOVE_VARIABLE_FAILED', message: pluginResp?.message ?? 'Failed to remove variable via automation bridge' } as const;
+  }
 
-    const payload = interpreted.payload ?? {};
-    const hasPayload = Object.keys(payload).length > 0;
-    const warnings = interpreted.warnings ?? coerceStringArray((payload as any).warnings) ?? undefined;
-    const details = interpreted.details ?? coerceStringArray((payload as any).details) ?? undefined;
-    const path = coerceString((payload as any).path) ?? defaultPath;
-    const parent = coerceString((payload as any).parent);
-    const verifyError = coerceString((payload as any).verifyError);
-    const exists = coerceBoolean((payload as any).exists);
-    const errorValue = coerceString((payload as any).error) ?? interpreted.error;
-
-    if (hasPayload) {
-      if (interpreted.success) {
-        const outcome: {
-          success: true;
-          message: string;
-          path: string;
-          exists?: boolean;
-          parent?: string;
-          verifyError?: string;
-          warnings?: string[];
-          details?: string[];
-        } = {
-          success: true,
-          message: interpreted.message,
-          path
-        };
+  async renameVariable(params: { blueprintName: string; oldName: string; newName: string; timeoutMs?: number; waitForCompletion?: boolean; waitForCompletionTimeoutMs?: number }) {
+    const candidates = this.buildCandidates(params.blueprintName);
+    const primary = candidates[0];
+    if (!primary) return { success: false as const, 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' } as const;
+    }
+    return { success: false, error: pluginResp?.error ?? 'BLUEPRINT_RENAME_VARIABLE_FAILED', message: pluginResp?.message ?? 'Failed to rename variable via automation bridge' } as const;
+  }
 
-        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: string;
-        error: string;
-        path: string;
-        exists?: boolean;
-        parent?: string;
-        verifyError?: string;
-        warnings?: string[];
-        details?: string[];
-      } = {
-        success: false,
-        message: `Failed to create blueprint: ${fallbackMessage}`,
-        error: fallbackMessage,
-        path
-      };
+  async addEvent(params: { blueprintName: string; eventType: string; customEventName?: string; parameters?: Array<{ name: string; type: string }>; timeoutMs?: number; waitForCompletion?: boolean; waitForCompletionTimeoutMs?: number }) {
+    const candidates = this.buildCandidates(params.blueprintName);
+    const primary = candidates[0];
+    if (!primary) return { success: false as const, 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' } as const;
+    }
+    return { success: false, error: pluginResp?.error ?? 'BLUEPRINT_ADD_EVENT_FAILED', message: pluginResp?.message ?? 'Failed to add event via automation bridge' } as const;
+  }
 
-      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;
+  async removeEvent(params: { blueprintName: string; eventName: string; customEventName?: string; timeoutMs?: number; waitForCompletion?: boolean; waitForCompletionTimeoutMs?: number }) {
+    const candidates = this.buildCandidates(params.blueprintName);
+    const primary = candidates[0];
+    if (!primary) return { success: false as const, error: 'Invalid blueprint name' };
+
+    // Fix: Allow customEventName as alias for eventName
+    const finalEventName = params.eventName || params.customEventName;
+    if (!finalEventName) return { success: false, error: 'INVALID_ARGUMENT', message: 'eventName is required' } as const;
+
+    try {
+      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 (details && details.length > 0) {
-        failureOutcome.details = details;
+      if (pluginResp && this.isUnknownActionResponse(pluginResp)) {
+        return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement blueprint_remove_event' } as const;
       }
+      return { success: false, error: pluginResp?.error ?? 'BLUEPRINT_REMOVE_EVENT_FAILED', message: pluginResp?.message ?? 'Failed to remove event via automation bridge' } as const;
+    } catch (err: any) {
+      return { success: false, error: String(err), message: String(err) } as const;
+    }
+  }
 
-      return failureOutcome;
+  async addFunction(params: { blueprintName: string; functionName: string; inputs?: Array<{ name: string; type: string }>; outputs?: Array<{ name: string; type: string }>; isPublic?: boolean; category?: string; timeoutMs?: number; waitForCompletion?: boolean; waitForCompletionTimeoutMs?: number }) {
+    const candidates = this.buildCandidates(params.blueprintName);
+    const primary = candidates[0];
+    if (!primary) return { success: false as const, 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' } as const;
     }
+    return { success: false, error: pluginResp?.error ?? 'BLUEPRINT_ADD_FUNCTION_FAILED', message: pluginResp?.message ?? 'Failed to add function via automation bridge' } as const;
+  }
 
-  const cleanedText = bestEffortInterpretedText(interpreted) ?? '';
-  const failureMessage = extractTaggedLine(cleanedText, 'FAILED:');
-    if (failureMessage) {
-      return {
-        success: false,
-        message: `Failed to create blueprint: ${failureMessage}`,
-        error: failureMessage,
-        path: defaultPath
-      };
+  async setVariableMetadata(params: { blueprintName: string; variableName: string; metadata: Record<string, unknown>; timeoutMs?: number }) {
+    const candidates = this.buildCandidates(params.blueprintName);
+    const primary = candidates[0];
+    if (!primary) return { success: false as const, 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' } as const;
+    }
+    return { success: false, error: pluginResp?.error ?? 'SET_VARIABLE_METADATA_FAILED', message: pluginResp?.message ?? 'Failed to set variable metadata via automation bridge' } as const;
+  }
 
-  if (cleanedText.includes('SUCCESS')) {
-      return {
-        success: true,
-        message: `Blueprint ${blueprintName} created`,
-        path: defaultPath
-      };
+  async addConstructionScript(params: { blueprintName: string; scriptName: string; timeoutMs?: number; waitForCompletion?: boolean; waitForCompletionTimeoutMs?: number }) {
+    const candidates = this.buildCandidates(params.blueprintName);
+    const primary = candidates[0];
+    if (!primary) return { success: false as const, 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' } as const;
     }
+    return { success: false, error: pluginResp?.error ?? 'ADD_CONSTRUCTION_SCRIPT_FAILED', message: pluginResp?.message ?? 'Failed to add construction script via automation bridge' } as const;
+  }
 
-    return {
-      success: false,
-      message: interpreted.message,
-  error: interpreted.error ?? (cleanedText || JSON.stringify(response)),
-      path: defaultPath
-    };
+  async compileBlueprint(params: { blueprintName: string; saveAfterCompile?: boolean; }) {
+    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 (pluginResp && this.isUnknownActionResponse(pluginResp)) {
+        this.pluginBlueprintActionsAvailable = false;
+        return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement blueprint_compile' } as const;
+      }
+      return { success: false, error: pluginResp?.error ?? 'BLUEPRINT_COMPILE_FAILED', message: pluginResp?.message ?? 'Failed to compile blueprint via automation bridge' } as const;
+    } catch (err: any) {
+      return { success: false, error: String(err) };
+    }
   }
 
-  /**
-   * Add Component to Blueprint
-   */
-  async addComponent(params: {
-    blueprintName: string;
-    componentType: string;
+  async getBlueprintSCS(params: { blueprintPath: string; timeoutMs?: number }) {
+    const blueprintPath = coerceString(params.blueprintPath);
+    if (!blueprintPath) {
+      return { success: false, error: 'INVALID_BLUEPRINT_PATH', message: 'Blueprint path is required' } as const;
+    }
+
+    try {
+      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' } as const;
+      }
+      return { success: false, error: pluginResp?.error ?? 'GET_SCS_FAILED', message: pluginResp?.message ?? 'Failed to get SCS via automation bridge' } as const;
+    } catch (err: any) {
+      return { success: false, error: String(err), message: String(err) } as const;
+    }
+  }
+
+  async addSCSComponent(params: {
+    blueprintPath: string;
+    componentClass: string;
     componentName: string;
-    attachTo?: string;
-    transform?: {
-      location?: [number, number, number];
-      rotation?: [number, number, number];
-      scale?: [number, number, number];
-    };
+    parentComponent?: string;
+    meshPath?: string;
+    materialPath?: string;
+    timeoutMs?: number;
   }) {
+    const blueprintPath = coerceString(params.blueprintPath);
+    if (!blueprintPath) {
+      return { success: false, error: 'INVALID_BLUEPRINT_PATH', message: 'Blueprint path is required' } as const;
+    }
+
+    const componentClass = coerceString(params.componentClass);
+    if (!componentClass) {
+      return { success: false, error: 'INVALID_COMPONENT_CLASS', message: 'Component class is required' } as const;
+    }
+
+    const componentName = coerceString(params.componentName);
+    if (!componentName) {
+      return { success: false, error: 'INVALID_COMPONENT_NAME', message: 'Component name is required' } as const;
+    }
+
     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": []
-}
+      const payload: Record<string, unknown> = {
+        blueprint_path: blueprintPath,
+        component_class: componentClass,
+        component_name: componentName
+      };
 
-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 as any).warnings) ?? undefined;
-        const details = interpreted.details ?? coerceStringArray((payload as any).details) ?? undefined;
-        const blueprintPath = coerceString((payload as any).blueprintPath) ?? params.blueprintName;
-        const componentName = coerceString((payload as any).component) ?? sanitizedComponentName;
-        const componentType = coerceString((payload as any).componentType) ?? params.componentType;
-        const errorMessage = coerceString((payload as any).error) ?? interpreted.error ?? 'Unknown error';
-
-        if (interpreted.success) {
-          const outcome: {
-            success: true;
-            message: string;
-            blueprintPath: string;
-            component: string;
-            componentType: string;
-            warnings?: string[];
-            details?: string[];
-          } = {
-            success: true,
-            message: interpreted.message,
-            blueprintPath,
-            component: componentName,
-            componentType
-          };
+      if (params.parentComponent) {
+        payload.parent_component = params.parentComponent;
+      }
+      if (params.meshPath) {
+        payload.mesh_path = params.meshPath;
+      }
+      if (params.materialPath) {
+        payload.material_path = params.materialPath;
+      }
 
-          if (warnings && warnings.length > 0) {
-            outcome.warnings = warnings;
-          }
-          if (details && details.length > 0) {
-            outcome.details = details;
-          }
+      const pluginResp = await this.sendAction('add_scs_component', payload, { timeoutMs: params.timeoutMs });
 
-          return outcome;
+      if (pluginResp && pluginResp.success === false) {
+        if ((pluginResp as any).message) {
+          this.log.warn?.(`addSCSComponent reported warning: ${(pluginResp as any).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 add_scs_component' } as const;
+      }
+      return { success: false, error: pluginResp?.error ?? 'ADD_SCS_COMPONENT_FAILED', message: pluginResp?.message ?? 'Failed to add SCS component via automation bridge' } as const;
+    } catch (err: any) {
+      return { success: false, error: String(err), message: String(err) } as const;
+    }
+  }
 
-        const normalizedBlueprint = (blueprintPath || params.blueprintName || '').toLowerCase();
-        const expectingStaticMeshSuccess = params.componentType === 'StaticMeshComponent' && normalizedBlueprint.endsWith('bp_test');
-        if (expectingStaticMeshSuccess) {
-          const fallbackSuccess: {
-            success: true;
-            message: string;
-            blueprintPath: string;
-            component: string;
-            componentType: string;
-            warnings?: string[];
-            details?: string[];
-            note?: string;
-          } = {
-            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;
-          }
-          if (details && details.length > 0) {
-            fallbackSuccess.details = details;
-          }
-          return fallbackSuccess;
-        }
+  async removeSCSComponent(params: { blueprintPath: string; componentName: string; timeoutMs?: number }) {
+    const blueprintPath = coerceString(params.blueprintPath);
+    if (!blueprintPath) {
+      return { success: false, error: 'INVALID_BLUEPRINT_PATH', message: 'Blueprint path is required' } as const;
+    }
 
-        const failureOutcome: {
-          success: false;
-          message: string;
-          error: string;
-          blueprintPath: string;
-          component: string;
-          componentType: string;
-          warnings?: string[];
-          details?: string[];
-        } = {
-          success: false,
-          message: `Failed to add component: ${errorMessage}`,
-          error: errorMessage,
-          blueprintPath,
-          component: componentName,
-          componentType
-        };
+    const componentName = coerceString(params.componentName);
+    if (!componentName) {
+      return { success: false, error: 'INVALID_COMPONENT_NAME', message: 'Component name is required' } as const;
+    }
 
-        if (warnings && warnings.length > 0) {
-          failureOutcome.warnings = warnings;
-        }
-        if (details && details.length > 0) {
-          failureOutcome.details = details;
-        }
+    try {
+      const pluginResp = await this.sendAction('remove_scs_component',
+        { blueprint_path: blueprintPath, component_name: componentName },
+        { timeoutMs: params.timeoutMs });
 
-        return failureOutcome;
-      } catch (error) {
-        return {
-          success: false,
-          message: 'Failed to add component',
-          error: String(error)
-        };
+      if (pluginResp && pluginResp.success === false) {
+        if ((pluginResp as any).message) {
+          this.log.warn?.(`removeSCSComponent reported warning: ${(pluginResp as any).message}`);
+        }
       }
-    } catch (err) {
-      return { success: false, error: `Failed to add component: ${err}` };
+      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' } as const;
+      }
+      return { success: false, error: pluginResp?.error ?? 'REMOVE_SCS_COMPONENT_FAILED', message: pluginResp?.message ?? 'Failed to remove SCS component via automation bridge' } as const;
+    } catch (err: any) {
+      return { success: false, error: String(err), message: String(err) } as const;
     }
-
   }
-  /**
-   * Add Variable to Blueprint
-   */
-  async addVariable(params: {
-    blueprintName: string;
-    variableName: string;
-    variableType: string;
-    defaultValue?: any;
-    category?: string;
-    isReplicated?: boolean;
-    isPublic?: boolean;
+
+  async reparentSCSComponent(params: {
+    blueprintPath: string;
+    componentName: string;
+    newParent: string;
+    timeoutMs?: number;
   }) {
+    const blueprintPath = coerceString(params.blueprintPath);
+    if (!blueprintPath) {
+      return { success: false, error: 'INVALID_BLUEPRINT_PATH', message: 'Blueprint path is required' } as const;
+    }
+
+    const componentName = coerceString(params.componentName);
+    if (!componentName) {
+      return { success: false, error: 'INVALID_COMPONENT_NAME', message: 'Component name is required' } as const;
+    }
+
     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)}`
-        );
-      }
-      
-      if (params.category) {
-        commands.push(
-          `SetVariableCategory ${params.blueprintName} ${params.variableName} ${params.category}`
-        );
-      }
-      
-      if (params.isReplicated) {
-        commands.push(
-          `SetVariableReplicated ${params.blueprintName} ${params.variableName} true`
-        );
+      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 as any).message) {
+          this.log.warn?.(`reparentSCSComponent reported warning: ${(pluginResp as any).message}`);
+        }
       }
-      
-      if (params.isPublic !== undefined) {
-        commands.push(
-          `SetVariablePublic ${params.blueprintName} ${params.variableName} ${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 reparent_scs_component' } as const;
       }
-      
-      await this.bridge.executeConsoleCommands(commands);
-      
-      return { 
-        success: true, 
-        message: `Variable ${params.variableName} added to ${params.blueprintName}` 
-      };
-    } catch (err) {
-      return { success: false, error: `Failed to add variable: ${err}` };
+      return { success: false, error: pluginResp?.error ?? 'REPARENT_SCS_COMPONENT_FAILED', message: pluginResp?.message ?? 'Failed to reparent SCS component via automation bridge' } as const;
+    } catch (err: any) {
+      return { success: false, error: String(err), message: String(err) } as const;
     }
   }
 
-  /**
-   * Add Function to Blueprint
-   */
-  async addFunction(params: {
-    blueprintName: string;
-    functionName: string;
-    inputs?: Array<{ name: string; type: string }>;
-    outputs?: Array<{ name: string; type: string }>;
-    isPublic?: boolean;
-    category?: string;
+  async setSCSComponentTransform(params: {
+    blueprintPath: string;
+    componentName: string;
+    location?: [number, number, number];
+    rotation?: [number, number, number];
+    scale?: [number, number, number];
+    timeoutMs?: number;
   }) {
+    const blueprintPath = coerceString(params.blueprintPath);
+    if (!blueprintPath) {
+      return { success: false, error: 'INVALID_BLUEPRINT_PATH', message: 'Blueprint path is required' } as const;
+    }
+
+    const componentName = coerceString(params.componentName);
+    if (!componentName) {
+      return { success: false, error: 'INVALID_COMPONENT_NAME', message: 'Component name is required' } as const;
+    }
+
     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}`
-          );
-        }
-      }
-      
-      // Add outputs
-      if (params.outputs) {
-        for (const output of params.outputs) {
-          commands.push(
-            `AddFunctionOutput ${params.blueprintName} ${params.functionName} ${output.name} ${output.type}`
-          );
+      const payload: Record<string, unknown> = {
+        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 as any).message) {
+          this.log.warn?.(`setSCSComponentTransform reported warning: ${(pluginResp as any).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 set_scs_component_transform' } as const;
       }
-      
-      if (params.category) {
-        commands.push(
-          `SetFunctionCategory ${params.blueprintName} ${params.functionName} ${params.category}`
-        );
-      }
-      
-      await this.bridge.executeConsoleCommands(commands);
-      
-      return { 
-        success: true, 
-        message: `Function ${params.functionName} added to ${params.blueprintName}` 
-      };
-    } catch (err) {
-      return { success: false, error: `Failed to add function: ${err}` };
+      return { success: false, error: pluginResp?.error ?? 'SET_SCS_TRANSFORM_FAILED', message: pluginResp?.message ?? 'Failed to set SCS component transform via automation bridge' } as const;
+    } catch (err: any) {
+      return { success: false, error: String(err), message: String(err) } as const;
     }
   }
 
-  /**
-   * Add Event to Blueprint
-   */
-  async addEvent(params: {
-    blueprintName: string;
-    eventType: 'BeginPlay' | 'Tick' | 'EndPlay' | 'BeginOverlap' | 'EndOverlap' | 'Hit' | 'Custom';
-    customEventName?: string;
-    parameters?: Array<{ name: string; type: string }>;
+  async setSCSComponentProperty(params: {
+    blueprintPath: string;
+    componentName: string;
+    propertyName: string;
+    propertyValue: any;
+    timeoutMs?: number;
   }) {
+    const blueprintPath = coerceString(params.blueprintPath);
+    if (!blueprintPath) {
+      return { success: false, error: 'INVALID_BLUEPRINT_PATH', message: 'Blueprint path is required' } as const;
+    }
+
+    const componentName = coerceString(params.componentName);
+    if (!componentName) {
+      return { success: false, error: 'INVALID_COMPONENT_NAME', message: 'Component name is required' } as const;
+    }
+
+    const propertyName = coerceString(params.propertyName);
+    if (!propertyName) {
+      return { success: false, error: 'INVALID_PROPERTY_NAME', message: 'Property name is required' } as const;
+    }
+
     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 as any).message) {
+          this.log.warn?.(`setSCSComponentProperty reported warning: ${(pluginResp as any).message}`);
         }
       }
-      
-      await this.bridge.executeConsoleCommands(commands);
-      
-      return { 
-        success: true, 
-        message: `Event ${eventName} added to ${params.blueprintName}` 
-      };
-    } catch (err) {
-      return { success: false, error: `Failed to add event: ${err}` };
+      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' } as const;
+      }
+      return { success: false, error: pluginResp?.error ?? 'SET_SCS_PROPERTY_FAILED', message: pluginResp?.message ?? 'Failed to set SCS component property via automation bridge' } as const;
+    } catch (err: any) {
+      return { success: false, error: String(err), message: String(err) } as const;
     }
   }
 
-  /**
-   * Compile Blueprint
-   */
-  async compileBlueprint(params: {
-    blueprintName: string;
-    saveAfterCompile?: boolean;
+  async getNodes(params: {
+    blueprintPath: string;
+    graphName?: string;
+    timeoutMs?: number;
   }) {
+    const blueprintPath = coerceString(params.blueprintPath);
+    if (!blueprintPath) {
+      return { success: false, error: 'INVALID_BLUEPRINT_PATH', message: 'Blueprint path is required' } as const;
+    }
+
     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: Record<string, unknown> = {
+        subAction: 'get_nodes',
+        blueprintPath: blueprintPath,
+        graphName: params.graphName || 'EventGraph'
       };
-    } catch (err) {
-      return { success: false, error: `Failed to compile blueprint: ${err}` };
+      const pluginResp = await this.sendAction('manage_blueprint_graph', payload, { timeoutMs: params.timeoutMs });
+      if (pluginResp && pluginResp.success) {
+        return {
+          success: true,
+          nodes: (pluginResp.result as any).nodes,
+          graphName: (pluginResp.result as any).graphName
+        };
+      }
+      if (pluginResp && this.isUnknownActionResponse(pluginResp)) {
+        return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement get_nodes' } as const;
+      }
+      return { success: false, error: pluginResp?.error ?? 'GET_NODES_FAILED', message: pluginResp?.message ?? 'Failed to get blueprint nodes' } as const;
+    } catch (err: any) {
+      return { success: false, error: String(err), message: String(err) } as const;
     }
   }
 
+
+  async addNode(params: {
+    blueprintName: string;
+    nodeType: string;
+    graphName?: string;
+    functionName?: string;
+    variableName?: string;
+    nodeName?: string;
+    eventName?: string;
+    memberClass?: string;
+    posX?: number;
+    posY?: number;
+    timeoutMs?: number;
+  }) {
+    const candidates = this.buildCandidates(params.blueprintName);
+    const primary = candidates[0];
+    if (!primary) return { success: false as const, error: 'Invalid blueprint name' };
+
+    // Fix: C++ expects 'manage_blueprint_graph' with 'subAction' = 'create_node'
+    const payload: any = {
+      subAction: 'create_node',
+      assetPath: primary,    // C++ expects 'assetPath' or 'blueprintPath'
+      nodeType: params.nodeType,
+      graphName: params.graphName,
+      memberName: params.functionName, // C++ maps 'memberName' to 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: {
+    blueprintPath: string;
+    nodeId: string;
+    graphName?: string;
+    timeoutMs?: number;
+  }) {
+    const blueprintPath = coerceString(params.blueprintPath);
+    if (!blueprintPath) return { success: false, error: 'INVALID_BLUEPRINT_PATH', message: 'Blueprint path is required' } as const;
+    if (!params.nodeId) return { success: false, error: 'INVALID_NODE_ID', message: 'Node ID is required' } as const;
+
+    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: {
+    blueprintPath: string;
+    graphName?: string;
+    x: number;
+    y: number;
+    timeoutMs?: number;
+  }) {
+    const blueprintPath = coerceString(params.blueprintPath);
+    if (!blueprintPath) return { success: false, error: 'INVALID_BLUEPRINT_PATH', message: 'Blueprint path is required' } as const;
+
+    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: {
+    blueprintPath: string;
+    nodeId: string;
+    propertyName: string;
+    value: string;
+    graphName?: string;
+    timeoutMs?: number;
+  }) {
+    const blueprintPath = coerceString(params.blueprintPath);
+    if (!blueprintPath) return { success: false, error: 'INVALID_BLUEPRINT_PATH', message: 'Blueprint path is required' } as const;
+    if (!params.nodeId) return { success: false, error: 'INVALID_NODE_ID', message: 'Node ID is required' } as const;
+    if (!params.propertyName) return { success: false, error: 'INVALID_PROPERTY', message: 'Property name is required' } as const;
+
+    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: {
+    blueprintPath: string;
+    nodeId: string;
+    graphName?: string;
+    timeoutMs?: number;
+  }) {
+    const blueprintPath = coerceString(params.blueprintPath);
+    if (!blueprintPath) return { success: false, error: 'INVALID_BLUEPRINT_PATH', message: 'Blueprint path is required' } as const;
+    if (!params.nodeId) return { success: false, error: 'INVALID_NODE_ID', message: 'Node ID is required' } as const;
+
+    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: {
+    blueprintPath: string;
+    graphName?: string;
+    timeoutMs?: number;
+  }) {
+    const blueprintPath = coerceString(params.blueprintPath);
+    if (!blueprintPath) return { success: false, error: 'INVALID_BLUEPRINT_PATH', message: 'Blueprint path is required' } as const;
+
+    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: {
+    blueprintPath: string;
+    nodeId: string;
+    pinName?: string;
+    graphName?: string;
+    timeoutMs?: number;
+  }) {
+    const blueprintPath = coerceString(params.blueprintPath);
+    if (!blueprintPath) return { success: false, error: 'INVALID_BLUEPRINT_PATH', message: 'Blueprint path is required' } as const;
+    if (!params.nodeId) return { success: false, error: 'INVALID_NODE_ID', message: 'Node ID is required' } as const;
+
+    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: {
+    blueprintName: string;
+    sourceNodeGuid: string;
+    targetNodeGuid: string;
+    sourcePinName?: string;
+    targetPinName?: string;
+    timeoutMs?: number;
+  }) {
+    const candidates = this.buildCandidates(params.blueprintName);
+    const primary = candidates[0];
+    if (!primary) return { success: false as const, error: 'Invalid blueprint name' };
+
+    // Fix: C++ expects 'manage_blueprint_graph' with 'subAction' = 'connect_pins'
+    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;
+  }
 }