unreal-engine-mcp-server 0.5.0 → 0.5.2

package/src/tools/blueprint.ts

@@ -1,30 +1,60 @@
 import { BaseTool } from './base-tool.js';
-import { IBlueprintTools } from '../types/tool-interfaces.js';
+import { IBlueprintTools, StandardActionResponse } from '../types/tool-interfaces.js';
 import { Logger } from '../utils/logger.js';
 import { validateAssetParams, concurrencyDelay } from '../utils/validation.js';
 import { coerceString } from '../utils/result-helpers.js';
 
+/** Response from automation actions */
+interface ActionResponse extends StandardActionResponse {
+  result?: Record<string, unknown>;
+  requestId?: string;
+  blueprint?: string;
+  blueprintPath?: string;
+  component?: string;
+  componentName?: string;
+  componentType?: string;
+  componentClass?: string;
+  found?: string;
+  checked?: string[];
+  path?: string;
+  nodes?: unknown[];
+  graphName?: string;
+}
+
+/** Response type guard */
+interface ActionResponseInput {
+  success?: boolean;
+  message?: string;
+  error?: string;
+  result?: unknown;
+  requestId?: string;
+  [key: string]: unknown;
+}
+
 export class BlueprintTools extends BaseTool implements IBlueprintTools {
   private log = new Logger('BlueprintTools');
   private pluginBlueprintActionsAvailable: boolean | null = null;
 
-  private async sendAction(action: string, payload: Record<string, unknown> = {}, options?: { timeoutMs?: number; waitForEvent?: boolean; waitForEventTimeoutMs?: number }) {
+  private async sendAction(action: string, payload: Record<string, unknown> = {}, options?: { timeoutMs?: number; waitForEvent?: boolean; waitForEventTimeoutMs?: number }): Promise<ActionResponse> {
     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 response = await this.sendAutomationRequest(action, payload, { timeoutMs: finalTimeout, waitForEvent: !!options?.waitForEvent, waitForEventTimeoutMs: options?.waitForEventTimeoutMs }) as ActionResponseInput;
       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 result = (response.result ?? response) as Record<string, unknown>;
+      return { success, message: response.message ?? undefined, error: response.success === false ? (response.error ?? response.message) : undefined, result, requestId: response.requestId };
+    } catch (err: unknown) {
+      const errMsg = err instanceof Error ? err.message : String(err);
+      return { success: false, error: errMsg, message: errMsg };
     }
   }
 
-  private isUnknownActionResponse(res: any): boolean {
+  private isUnknownActionResponse(res: ActionResponse | StandardActionResponse | null | undefined): boolean {
     if (!res) return false;
-    const txt = String((res.error ?? res.message ?? '')).toLowerCase();
+    const errStr = typeof res.error === 'string' ? res.error : '';
+    const msgStr = typeof res.message === 'string' ? res.message : '';
+    const txt = (errStr || msgStr).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';
   }
@@ -54,7 +84,7 @@ export class BlueprintTools extends BaseTool implements IBlueprintTools {
     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 }) {
+  async createBlueprint(params: { name: string; blueprintType?: string; savePath?: string; parentClass?: string; properties?: Record<string, unknown>; timeoutMs?: number; waitForCompletion?: boolean; waitForCompletionTimeoutMs?: number }): Promise<StandardActionResponse> {
     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 };
@@ -84,8 +114,8 @@ export class BlueprintTools extends BaseTool implements IBlueprintTools {
           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) {
+        return res;
+      } catch (err: unknown) {
         // ... (unchanged catch block)
         const errTxt = String(err ?? '');
         const isTimeout = errTxt.includes('Request timed out') || errTxt.includes('-32001') || errTxt.toLowerCase().includes('timeout');
@@ -94,12 +124,12 @@ export class BlueprintTools extends BaseTool implements IBlueprintTools {
         }
         return { success: false, error: String(err), message: String(err) } as const;
       }
-    } catch (err: any) {
+    } catch (err: unknown) {
       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 }) {
+  async modifyConstructionScript(params: { blueprintPath: string; operations: any[]; compile?: boolean; save?: boolean; timeoutMs?: number; waitForCompletion?: boolean; waitForCompletionTimeoutMs?: number }): Promise<StandardActionResponse> {
     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' };
@@ -112,12 +142,12 @@ export class BlueprintTools extends BaseTool implements IBlueprintTools {
       return op;
     });
 
-    const payload: any = { blueprintPath, operations };
+    const payload: Record<string, unknown> = { 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') {
+    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)' } as const;
     }
@@ -128,7 +158,7 @@ export class BlueprintTools extends BaseTool implements IBlueprintTools {
     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 }) {
+  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 }): Promise<StandardActionResponse> {
     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);
@@ -144,23 +174,23 @@ export class BlueprintTools extends BaseTool implements IBlueprintTools {
       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;
+        return { ...svcResult, 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 svcResult;
+    } catch (err: unknown) {
       return { success: false, error: String(err) };
     }
   }
 
-  async waitForBlueprint(blueprintRef: string | string[], timeoutMs?: number) {
+  async waitForBlueprint(blueprintRef: string | string[], timeoutMs?: number): Promise<StandardActionResponse> {
     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 (!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' } as any;
+      return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement blueprint_exists' };
     }
 
     const start = Date.now();
@@ -175,11 +205,11 @@ export class BlueprintTools extends BaseTool implements IBlueprintTools {
           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;
+            return { success: true, found: r.result.found ?? candidate };
           }
           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;
+            return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement blueprint_exists' };
           }
         } catch (_e) {
           // ignore and try next candidate
@@ -188,12 +218,12 @@ export class BlueprintTools extends BaseTool implements IBlueprintTools {
       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: '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 } as any;
+    return { success: false, error: `Timeout waiting for blueprint after ${tot}ms`, checked: candidates };
   }
 
-  async getBlueprint(params: { blueprintName: string; timeoutMs?: number; }) {
+  async getBlueprint(params: { blueprintName: string; timeoutMs?: number; }): Promise<StandardActionResponse> {
     const candidates = this.buildCandidates(params.blueprintName);
     const primary = candidates[0];
     if (!primary) return { success: false, error: 'Invalid blueprint name' } as const;
@@ -201,7 +231,7 @@ export class BlueprintTools extends BaseTool implements IBlueprintTools {
       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, blueprint: pluginResp.result, blueprintPath: primary };
         }
         return pluginResp;
       }
@@ -209,12 +239,12 @@ export class BlueprintTools extends BaseTool implements IBlueprintTools {
         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) {
+    } catch (err: unknown) {
       return { success: false, error: String(err), message: String(err) } as const;
     }
   }
 
-  async getBlueprintInfo(params: { blueprintPath: string; timeoutMs?: number }) {
+  async getBlueprintInfo(params: { blueprintPath: string; timeoutMs?: number }): Promise<StandardActionResponse> {
     const blueprintPath = coerceString(params.blueprintPath);
     if (!blueprintPath) {
       return { success: false, error: 'INVALID_BLUEPRINT_PATH', message: 'Blueprint path is required' } as const;
@@ -243,29 +273,29 @@ export class BlueprintTools extends BaseTool implements IBlueprintTools {
       }
 
       return { success: false, error: resp?.error ?? 'BLUEPRINT_GET_FAILED', message: resp?.message ?? 'Failed to get blueprint via automation bridge' } as const;
-    } catch (err: any) {
+    } catch (err: unknown) {
       return { success: false, error: String(err), message: String(err) } as const;
     }
   }
 
-  async probeSubobjectDataHandle(opts: { componentClass?: string } = {}) {
+  async probeSubobjectDataHandle(opts: { componentClass?: string } = {}): Promise<StandardActionResponse> {
     return await this.sendAction('blueprint_probe_subobject_handle', { componentClass: opts.componentClass });
   }
 
-  async setBlueprintDefault(params: { blueprintName: string; propertyName: string; value: unknown }) {
+  async setBlueprintDefault(params: { blueprintName: string; propertyName: string; value: unknown }): Promise<StandardActionResponse> {
     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 await this.sendAction('blueprint_set_default', { blueprintCandidates: candidates, requestedPath: primary, propertyName: params.propertyName, value: params.value }) as any;
   }
 
-  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 }) {
+  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 }): Promise<StandardActionResponse> {
     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;
+      return pluginResp as any;
     }
     if (pluginResp && this.isUnknownActionResponse(pluginResp)) {
       return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement blueprint_add_variable' } as const;
@@ -273,24 +303,24 @@ export class BlueprintTools extends BaseTool implements IBlueprintTools {
     return { success: false, error: pluginResp?.error ?? 'BLUEPRINT_ADD_VARIABLE_FAILED', message: pluginResp?.message ?? 'Failed to add variable via automation bridge' } as const;
   }
 
-  async removeVariable(params: { blueprintName: string; variableName: string; timeoutMs?: number; waitForCompletion?: boolean; waitForCompletionTimeoutMs?: number }) {
+  async removeVariable(params: { blueprintName: string; variableName: string; timeoutMs?: number; waitForCompletion?: boolean; waitForCompletionTimeoutMs?: number }): Promise<StandardActionResponse> {
     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 && pluginResp.success) return pluginResp as any;
     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;
   }
 
-  async renameVariable(params: { blueprintName: string; oldName: string; newName: string; timeoutMs?: number; waitForCompletion?: boolean; waitForCompletionTimeoutMs?: number }) {
+  async renameVariable(params: { blueprintName: string; oldName: string; newName: string; timeoutMs?: number; waitForCompletion?: boolean; waitForCompletionTimeoutMs?: number }): Promise<StandardActionResponse> {
     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 && pluginResp.success) return pluginResp as any;
     if (pluginResp && this.isUnknownActionResponse(pluginResp)) {
       return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement blueprint_rename_variable' } as const;
     }
@@ -299,13 +329,13 @@ export class BlueprintTools extends BaseTool implements IBlueprintTools {
 
 
 
-  async addEvent(params: { blueprintName: string; eventType: string; customEventName?: string; parameters?: Array<{ name: string; type: string }>; timeoutMs?: number; waitForCompletion?: boolean; waitForCompletionTimeoutMs?: number }) {
+  async addEvent(params: { blueprintName: string; eventType: string; customEventName?: string; parameters?: Array<{ name: string; type: string }>; timeoutMs?: number; waitForCompletion?: boolean; waitForCompletionTimeoutMs?: number }): Promise<StandardActionResponse> {
     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;
+      return pluginResp as any;
     }
     if (pluginResp && this.isUnknownActionResponse(pluginResp)) {
       return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement blueprint_add_event' } as const;
@@ -313,7 +343,7 @@ export class BlueprintTools extends BaseTool implements IBlueprintTools {
     return { success: false, error: pluginResp?.error ?? 'BLUEPRINT_ADD_EVENT_FAILED', message: pluginResp?.message ?? 'Failed to add event via automation bridge' } as const;
   }
 
-  async removeEvent(params: { blueprintName: string; eventName: string; customEventName?: string; timeoutMs?: number; waitForCompletion?: boolean; waitForCompletionTimeoutMs?: number }) {
+  async removeEvent(params: { blueprintName: string; eventName: string; customEventName?: string; timeoutMs?: number; waitForCompletion?: boolean; waitForCompletionTimeoutMs?: number }): Promise<StandardActionResponse> {
     const candidates = this.buildCandidates(params.blueprintName);
     const primary = candidates[0];
     if (!primary) return { success: false as const, error: 'Invalid blueprint name' };
@@ -325,24 +355,24 @@ export class BlueprintTools extends BaseTool implements IBlueprintTools {
     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;
+        return pluginResp as any;
       }
       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) {
+    } catch (err: unknown) {
       return { success: false, error: String(err), message: String(err) } as const;
     }
   }
 
-  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 }) {
+  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 }): Promise<StandardActionResponse> {
     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;
+      return pluginResp as any;
     }
     if (pluginResp && this.isUnknownActionResponse(pluginResp)) {
       return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement blueprint_add_function' } as const;
@@ -350,13 +380,13 @@ export class BlueprintTools extends BaseTool implements IBlueprintTools {
     return { success: false, error: pluginResp?.error ?? 'BLUEPRINT_ADD_FUNCTION_FAILED', message: pluginResp?.message ?? 'Failed to add function via automation bridge' } as const;
   }
 
-  async setVariableMetadata(params: { blueprintName: string; variableName: string; metadata: Record<string, unknown>; timeoutMs?: number }) {
+  async setVariableMetadata(params: { blueprintName: string; variableName: string; metadata: Record<string, unknown>; timeoutMs?: number }): Promise<StandardActionResponse> {
     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;
+      return pluginResp as any;
     }
     if (pluginResp && this.isUnknownActionResponse(pluginResp)) {
       return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement blueprint_set_variable_metadata' } as const;
@@ -364,19 +394,19 @@ export class BlueprintTools extends BaseTool implements IBlueprintTools {
     return { success: false, error: pluginResp?.error ?? 'SET_VARIABLE_METADATA_FAILED', message: pluginResp?.message ?? 'Failed to set variable metadata via automation bridge' } as const;
   }
 
-  async addConstructionScript(params: { blueprintName: string; scriptName: string; timeoutMs?: number; waitForCompletion?: boolean; waitForCompletionTimeoutMs?: number }) {
+  async addConstructionScript(params: { blueprintName: string; scriptName: string; timeoutMs?: number; waitForCompletion?: boolean; waitForCompletionTimeoutMs?: number }): Promise<StandardActionResponse> {
     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 && pluginResp.success) return pluginResp as any;
     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;
   }
 
-  async compileBlueprint(params: { blueprintName: string; saveAfterCompile?: boolean; }) {
+  async compileBlueprint(params: { blueprintName: string; saveAfterCompile?: boolean; }): Promise<StandardActionResponse> {
     try {
       const candidates = this.buildCandidates(params.blueprintName);
       const primary = candidates[0] ?? params.blueprintName;
@@ -386,19 +416,19 @@ export class BlueprintTools extends BaseTool implements IBlueprintTools {
           ...pluginResp,
           blueprint: primary,
           message: pluginResp.message || `Compiled ${primary}`
-        };
+        } as any;
       }
       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) {
+    } catch (err: unknown) {
       return { success: false, error: String(err) };
     }
   }
 
-  async getBlueprintSCS(params: { blueprintPath: string; timeoutMs?: number }) {
+  async getBlueprintSCS(params: { blueprintPath: string; timeoutMs?: number }): Promise<StandardActionResponse> {
     const blueprintPath = coerceString(params.blueprintPath);
     if (!blueprintPath) {
       return { success: false, error: 'INVALID_BLUEPRINT_PATH', message: 'Blueprint path is required' } as const;
@@ -409,12 +439,12 @@ export class BlueprintTools extends BaseTool implements IBlueprintTools {
         { blueprint_path: blueprintPath },
         { timeoutMs: params.timeoutMs });
 
-      if (pluginResp && pluginResp.success) return pluginResp;
+      if (pluginResp && pluginResp.success) return pluginResp as any;
       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) {
+    } catch (err: unknown) {
       return { success: false, error: String(err), message: String(err) } as const;
     }
   }
@@ -427,7 +457,7 @@ export class BlueprintTools extends BaseTool implements IBlueprintTools {
     meshPath?: string;
     materialPath?: string;
     timeoutMs?: number;
-  }) {
+  }): Promise<StandardActionResponse> {
     const blueprintPath = coerceString(params.blueprintPath);
     if (!blueprintPath) {
       return { success: false, error: 'INVALID_BLUEPRINT_PATH', message: 'Blueprint path is required' } as const;
@@ -463,21 +493,21 @@ export class BlueprintTools extends BaseTool implements IBlueprintTools {
       const pluginResp = await this.sendAction('add_scs_component', payload, { timeoutMs: params.timeoutMs });
 
       if (pluginResp && pluginResp.success === false) {
-        if ((pluginResp as any).message) {
-          this.log.warn?.(`addSCSComponent reported warning: ${(pluginResp as any).message}`);
+        if (pluginResp?.message) {
+          this.log.warn?.(`addSCSComponent reported warning: ${pluginResp?.message}`);
         }
       }
-      if (pluginResp && pluginResp.success) return pluginResp;
+      if (pluginResp && pluginResp.success) return pluginResp as any;
       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) {
+    } catch (err: unknown) {
       return { success: false, error: String(err), message: String(err) } as const;
     }
   }
 
-  async removeSCSComponent(params: { blueprintPath: string; componentName: string; timeoutMs?: number }) {
+  async removeSCSComponent(params: { blueprintPath: string; componentName: string; timeoutMs?: number }): Promise<StandardActionResponse> {
     const blueprintPath = coerceString(params.blueprintPath);
     if (!blueprintPath) {
       return { success: false, error: 'INVALID_BLUEPRINT_PATH', message: 'Blueprint path is required' } as const;
@@ -494,16 +524,16 @@ export class BlueprintTools extends BaseTool implements IBlueprintTools {
         { timeoutMs: params.timeoutMs });
 
       if (pluginResp && pluginResp.success === false) {
-        if ((pluginResp as any).message) {
-          this.log.warn?.(`removeSCSComponent reported warning: ${(pluginResp as any).message}`);
+        if (pluginResp?.message) {
+          this.log.warn?.(`removeSCSComponent reported warning: ${pluginResp?.message}`);
         }
       }
-      if (pluginResp && pluginResp.success) return pluginResp;
+      if (pluginResp && pluginResp.success) return pluginResp as any;
       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) {
+    } catch (err: unknown) {
       return { success: false, error: String(err), message: String(err) } as const;
     }
   }
@@ -513,7 +543,7 @@ export class BlueprintTools extends BaseTool implements IBlueprintTools {
     componentName: string;
     newParent: string;
     timeoutMs?: number;
-  }) {
+  }): Promise<StandardActionResponse> {
     const blueprintPath = coerceString(params.blueprintPath);
     if (!blueprintPath) {
       return { success: false, error: 'INVALID_BLUEPRINT_PATH', message: 'Blueprint path is required' } as const;
@@ -534,16 +564,16 @@ export class BlueprintTools extends BaseTool implements IBlueprintTools {
         { timeoutMs: params.timeoutMs });
 
       if (pluginResp && pluginResp.success === false) {
-        if ((pluginResp as any).message) {
-          this.log.warn?.(`reparentSCSComponent reported warning: ${(pluginResp as any).message}`);
+        if (pluginResp?.message) {
+          this.log.warn?.(`reparentSCSComponent reported warning: ${pluginResp?.message}`);
         }
       }
-      if (pluginResp && pluginResp.success) return pluginResp;
+      if (pluginResp && pluginResp.success) return pluginResp as any;
       if (pluginResp && this.isUnknownActionResponse(pluginResp)) {
         return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement reparent_scs_component' } as const;
       }
       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) {
+    } catch (err: unknown) {
       return { success: false, error: String(err), message: String(err) } as const;
     }
   }
@@ -555,7 +585,7 @@ export class BlueprintTools extends BaseTool implements IBlueprintTools {
     rotation?: [number, number, number];
     scale?: [number, number, number];
     timeoutMs?: number;
-  }) {
+  }): Promise<StandardActionResponse> {
     const blueprintPath = coerceString(params.blueprintPath);
     if (!blueprintPath) {
       return { success: false, error: 'INVALID_BLUEPRINT_PATH', message: 'Blueprint path is required' } as const;
@@ -579,16 +609,16 @@ export class BlueprintTools extends BaseTool implements IBlueprintTools {
       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 (pluginResp?.message) {
+          this.log.warn?.(`setSCSComponentTransform reported warning: ${pluginResp?.message}`);
         }
       }
-      if (pluginResp && pluginResp.success) return pluginResp;
+      if (pluginResp && pluginResp.success) return pluginResp as any;
       if (pluginResp && this.isUnknownActionResponse(pluginResp)) {
         return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement set_scs_component_transform' } as const;
       }
       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) {
+    } catch (err: unknown) {
       return { success: false, error: String(err), message: String(err) } as const;
     }
   }
@@ -599,7 +629,7 @@ export class BlueprintTools extends BaseTool implements IBlueprintTools {
     propertyName: string;
     propertyValue: any;
     timeoutMs?: number;
-  }) {
+  }): Promise<StandardActionResponse> {
     const blueprintPath = coerceString(params.blueprintPath);
     if (!blueprintPath) {
       return { success: false, error: 'INVALID_BLUEPRINT_PATH', message: 'Blueprint path is required' } as const;
@@ -628,16 +658,16 @@ export class BlueprintTools extends BaseTool implements IBlueprintTools {
         { timeoutMs: params.timeoutMs });
 
       if (pluginResp && pluginResp.success === false) {
-        if ((pluginResp as any).message) {
-          this.log.warn?.(`setSCSComponentProperty reported warning: ${(pluginResp as any).message}`);
+        if (pluginResp?.message) {
+          this.log.warn?.(`setSCSComponentProperty reported warning: ${pluginResp?.message}`);
         }
       }
-      if (pluginResp && pluginResp.success) return pluginResp;
+      if (pluginResp && pluginResp.success) return pluginResp as any;
       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) {
+    } catch (err: unknown) {
       return { success: false, error: String(err), message: String(err) } as const;
     }
   }
@@ -646,7 +676,7 @@ export class BlueprintTools extends BaseTool implements IBlueprintTools {
     blueprintPath: string;
     graphName?: string;
     timeoutMs?: number;
-  }) {
+  }): Promise<StandardActionResponse> {
     const blueprintPath = coerceString(params.blueprintPath);
     if (!blueprintPath) {
       return { success: false, error: 'INVALID_BLUEPRINT_PATH', message: 'Blueprint path is required' } as const;
@@ -662,15 +692,15 @@ export class BlueprintTools extends BaseTool implements IBlueprintTools {
       if (pluginResp && pluginResp.success) {
         return {
           success: true,
-          nodes: (pluginResp.result as any).nodes,
-          graphName: (pluginResp.result as any).graphName
+          nodes: (pluginResp.result as Record<string, unknown>).nodes,
+          graphName: (pluginResp.result as Record<string, unknown>).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) {
+    } catch (err: unknown) {
       return { success: false, error: String(err), message: String(err) } as const;
     }
   }
@@ -688,13 +718,13 @@ export class BlueprintTools extends BaseTool implements IBlueprintTools {
     posX?: number;
     posY?: number;
     timeoutMs?: number;
-  }) {
+  }): Promise<StandardActionResponse> {
     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 = {
+    const payload: Record<string, unknown> = {
       subAction: 'create_node',
       assetPath: primary,    // C++ expects 'assetPath' or 'blueprintPath'
       nodeType: params.nodeType,
@@ -708,7 +738,7 @@ export class BlueprintTools extends BaseTool implements IBlueprintTools {
       y: params.posY
     };
     const res = await this.sendAction('manage_blueprint_graph', payload, { timeoutMs: params.timeoutMs });
-    return res;
+    return res as any;
   }
 
   async deleteNode(params: {
@@ -716,7 +746,7 @@ export class BlueprintTools extends BaseTool implements IBlueprintTools {
     nodeId: string;
     graphName?: string;
     timeoutMs?: number;
-  }) {
+  }): Promise<StandardActionResponse> {
     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;
@@ -727,7 +757,7 @@ export class BlueprintTools extends BaseTool implements IBlueprintTools {
       graphName: params.graphName || 'EventGraph',
       nodeId: params.nodeId
     }, { timeoutMs: params.timeoutMs });
-    return res;
+    return res as any;
   }
 
   async createRerouteNode(params: {
@@ -736,7 +766,7 @@ export class BlueprintTools extends BaseTool implements IBlueprintTools {
     x: number;
     y: number;
     timeoutMs?: number;
-  }) {
+  }): Promise<StandardActionResponse> {
     const blueprintPath = coerceString(params.blueprintPath);
     if (!blueprintPath) return { success: false, error: 'INVALID_BLUEPRINT_PATH', message: 'Blueprint path is required' } as const;
 
@@ -747,7 +777,7 @@ export class BlueprintTools extends BaseTool implements IBlueprintTools {
       x: params.x,
       y: params.y
     }, { timeoutMs: params.timeoutMs });
-    return res;
+    return res as any;
   }
 
   async setNodeProperty(params: {
@@ -757,7 +787,7 @@ export class BlueprintTools extends BaseTool implements IBlueprintTools {
     value: string;
     graphName?: string;
     timeoutMs?: number;
-  }) {
+  }): Promise<StandardActionResponse> {
     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;
@@ -771,7 +801,7 @@ export class BlueprintTools extends BaseTool implements IBlueprintTools {
       propertyName: params.propertyName,
       value: params.value
     }, { timeoutMs: params.timeoutMs });
-    return res;
+    return res as any;
   }
 
   async getNodeDetails(params: {
@@ -779,7 +809,7 @@ export class BlueprintTools extends BaseTool implements IBlueprintTools {
     nodeId: string;
     graphName?: string;
     timeoutMs?: number;
-  }) {
+  }): Promise<StandardActionResponse> {
     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;
@@ -790,14 +820,14 @@ export class BlueprintTools extends BaseTool implements IBlueprintTools {
       graphName: params.graphName || 'EventGraph',
       nodeId: params.nodeId
     }, { timeoutMs: params.timeoutMs });
-    return res;
+    return res as any;
   }
 
   async getGraphDetails(params: {
     blueprintPath: string;
     graphName?: string;
     timeoutMs?: number;
-  }) {
+  }): Promise<StandardActionResponse> {
     const blueprintPath = coerceString(params.blueprintPath);
     if (!blueprintPath) return { success: false, error: 'INVALID_BLUEPRINT_PATH', message: 'Blueprint path is required' } as const;
 
@@ -806,7 +836,7 @@ export class BlueprintTools extends BaseTool implements IBlueprintTools {
       blueprintPath: blueprintPath,
       graphName: params.graphName || 'EventGraph'
     }, { timeoutMs: params.timeoutMs });
-    return res;
+    return res as any;
   }
 
   async getPinDetails(params: {
@@ -815,7 +845,7 @@ export class BlueprintTools extends BaseTool implements IBlueprintTools {
     pinName?: string;
     graphName?: string;
     timeoutMs?: number;
-  }) {
+  }): Promise<StandardActionResponse> {
     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;
@@ -827,7 +857,43 @@ export class BlueprintTools extends BaseTool implements IBlueprintTools {
       nodeId: params.nodeId,
       pinName: params.pinName
     }, { timeoutMs: params.timeoutMs });
-    return res;
+    return res as any;
+  }
+
+  async listNodeTypes(params: {
+    blueprintPath?: string;
+    timeoutMs?: number;
+  } = {}): Promise<StandardActionResponse> {
+    const res = await this.sendAction('manage_blueprint_graph', {
+      subAction: 'list_node_types',
+      blueprintPath: params.blueprintPath || '/Game/Temp',
+      graphName: 'EventGraph'
+    }, { timeoutMs: params.timeoutMs });
+    return res as any;
+  }
+
+  async setPinDefaultValue(params: {
+    blueprintPath: string;
+    nodeId: string;
+    pinName: string;
+    value: string;
+    graphName?: string;
+    timeoutMs?: number;
+  }): Promise<StandardActionResponse> {
+    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.pinName) return { success: false, error: 'INVALID_PIN_NAME', message: 'Pin name is required' } as const;
+
+    const res = await this.sendAction('manage_blueprint_graph', {
+      subAction: 'set_pin_default_value',
+      blueprintPath: blueprintPath,
+      graphName: params.graphName || 'EventGraph',
+      nodeId: params.nodeId,
+      pinName: params.pinName,
+      value: params.value
+    }, { timeoutMs: params.timeoutMs });
+    return res as any;
   }
 
 
@@ -838,7 +904,7 @@ export class BlueprintTools extends BaseTool implements IBlueprintTools {
     sourcePinName?: string;
     targetPinName?: string;
     timeoutMs?: number;
-  }) {
+  }): Promise<StandardActionResponse> {
     const candidates = this.buildCandidates(params.blueprintName);
     const primary = candidates[0];
     if (!primary) return { success: false as const, error: 'Invalid blueprint name' };
@@ -869,6 +935,6 @@ export class BlueprintTools extends BaseTool implements IBlueprintTools {
       fromPinName: fromPinName,
       toPinName: toPinName
     }, { timeoutMs: params.timeoutMs });
-    return res;
+    return res as any;
   }
 }