unreal-engine-mcp-server 0.5.0 → 0.5.1

package/src/tools/niagara.ts

@@ -1,6 +1,7 @@
 import { UnrealBridge } from '../unreal-bridge.js';
 import { AutomationBridge } from '../automation/index.js';
 import { sanitizeAssetName, validateAssetParams } from '../utils/validation.js';
+import { wasmIntegration } from '../wasm/index.js';
 
 type Vector3 = [number, number, number];
 
@@ -30,6 +31,18 @@ export class NiagaraTools {
         throw new Error('Automation Bridge not available. Niagara system creation requires plugin support.');
       }
 
+      // Process emitter params with WASM
+      if (params.emitters) {
+        for (const emitter of params.emitters) {
+          if (emitter.shapeSize) {
+            const zeroVector: [number, number, number] = [0, 0, 0];
+            const processedSize = wasmIntegration.vectorAdd(zeroVector, emitter.shapeSize);
+            console.error('[WASM] Using vectorAdd for Niagara emitter shape size');
+            emitter.shapeSize = [processedSize[0], processedSize[1], processedSize[2]];
+          }
+        }
+      }
+
       const path = params.savePath || '/Game/Effects/Niagara';
       const response: any = await this.automationBridge.sendAutomationRequest(
         'create_niagara_system',
@@ -118,8 +131,22 @@ export class NiagaraTools {
     };
 
     const requestPayload: Record<string, unknown> = { systemPath: params.systemPath };
-    const start = toVector(params.start);
-    const end = toVector(params.end);
+    let start = toVector(params.start);
+    let end = toVector(params.end);
+
+    // Use WASM for vector processing if available
+    const zeroVector: [number, number, number] = [0, 0, 0];
+    if (start) {
+      const processed = wasmIntegration.vectorAdd(zeroVector, start);
+      console.error('[WASM] Using vectorAdd for Niagara ribbon start');
+      start = [processed[0], processed[1], processed[2]];
+    }
+    if (end) {
+      const processed = wasmIntegration.vectorAdd(zeroVector, end);
+      console.error('[WASM] Using vectorAdd for Niagara ribbon end');
+      end = [processed[0], processed[1], processed[2]];
+    }
+
     if (start) requestPayload.start = start;
     if (end) requestPayload.end = end;
     if (params.color) requestPayload.color = params.color;
@@ -202,6 +229,21 @@ export class NiagaraTools {
       return { success: false, error: 'AUTOMATION_BRIDGE_UNAVAILABLE', message: 'addEmitter requires automation bridge' } as const;
     }
 
+    // Use WASM for velocity processing
+    if (params.properties) {
+      const zeroVector: [number, number, number] = [0, 0, 0];
+      if (params.properties.velocityMin) {
+        const processed = wasmIntegration.vectorAdd(zeroVector, params.properties.velocityMin);
+        console.error('[WASM] Using vectorAdd for Niagara velocity min');
+        params.properties.velocityMin = [processed[0], processed[1], processed[2]];
+      }
+      if (params.properties.velocityMax) {
+        const processed = wasmIntegration.vectorAdd(zeroVector, params.properties.velocityMax);
+        console.error('[WASM] Using vectorAdd for Niagara velocity max');
+        params.properties.velocityMax = [processed[0], processed[1], processed[2]];
+      }
+    }
+
     try {
       const resp: any = await this.automationBridge.sendAutomationRequest('manage_niagara_graph', {
         subAction: 'add_emitter',

package/src/tools/performance.ts

@@ -474,7 +474,7 @@ export class PerformanceTools {
   // Draw call optimization
   async optimizeDrawCalls(params: {
     enableInstancing?: boolean;
-    enableBatching?: boolean; // no-op (deprecated internal toggle)
+
     mergeActors?: boolean;
     actors?: string[];
   }) {
@@ -495,7 +495,6 @@ export class PerformanceTools {
 
           const payload: any = {
             enableInstancing: params.enableInstancing,
-            enableBatching: params.enableBatching,
             mergeActors: params.mergeActors,
             actors: actors
           };

package/src/tools/physics.ts

@@ -3,6 +3,7 @@ import { UnrealBridge } from '../unreal-bridge.js';
 import { AutomationBridge } from '../automation/index.js';
 import { validateAssetParams, resolveSkeletalMeshPath, concurrencyDelay } from '../utils/validation.js';
 import { coerceString, coerceStringArray } from '../utils/result-helpers.js';
+import { wasmIntegration } from '../wasm/index.js';
 
 export class PhysicsTools {
   constructor(private bridge: UnrealBridge, private automationBridge?: AutomationBridge) { }
@@ -485,10 +486,15 @@ export class PhysicsTools {
     }
 
     try {
+      // Use WASM for vector normalization/validation
+      const zeroVector: [number, number, number] = [0, 0, 0];
+      const normalizedVector = wasmIntegration.vectorAdd(zeroVector, params.vector);
+      console.error('[WASM] Using vectorAdd for physics force vector processing');
+
       const response = await this.automationBridge.sendAutomationRequest('apply_force', {
         actorName: params.actorName,
         forceType: params.forceType,
-        vector: params.vector,
+        vector: normalizedVector,
         boneName: params.boneName,
         isLocal: params.isLocal
       }, {

package/src/tools/sequence.ts

@@ -1,5 +1,7 @@
 import { BaseTool } from './base-tool.js';
-import { ISequenceTools } from '../types/tool-interfaces.js';
+import { ISequenceTools, StandardActionResponse } from '../types/tool-interfaces.js';
+import { SequenceResponse } from '../types/automation-responses.js';
+import { wasmIntegration } from '../wasm/index.js';
 
 export interface LevelSequence {
   path: string;
@@ -39,7 +41,7 @@ export class SequenceTools extends BaseTool implements ISequenceTools {
     const finalTimeout = typeof timeoutMs === 'number' && timeoutMs > 0 ? timeoutMs : defaultTimeout;
 
     try {
-      const response = await this.sendAutomationRequest(
+      const response = await this.sendAutomationRequest<SequenceResponse>(
         action,
         payload,
         { timeoutMs: finalTimeout, waitForEvent: false }
@@ -61,7 +63,7 @@ export class SequenceTools extends BaseTool implements ISequenceTools {
     return txt.includes('unknown_action') || txt.includes('unknown automation action') || txt.includes('not_implemented') || txt === 'unknown_plugin_action';
   }
 
-  async create(params: { name: string; path?: string; timeoutMs?: number }) {
+  async create(params: { name: string; path?: string; timeoutMs?: number }): Promise<StandardActionResponse> {
     const name = params.name?.trim();
     const base = (params.path || '/Game/Sequences').replace(/\/$/, '');
     if (!name) return { success: false, error: 'name is required' };
@@ -79,7 +81,7 @@ export class SequenceTools extends BaseTool implements ISequenceTools {
     return resp;
   }
 
-  async open(params: { path: string }) {
+  async open(params: { path: string }): Promise<StandardActionResponse> {
     const path = params.path?.trim();
     const resp = await this.sendAction('sequence_open', { path });
     if (!resp.success && this.isUnknownActionResponse(resp)) {
@@ -91,7 +93,7 @@ export class SequenceTools extends BaseTool implements ISequenceTools {
     return resp;
   }
 
-  async addCamera(params: { spawnable?: boolean; path?: string }) {
+  async addCamera(params: { spawnable?: boolean; path?: string }): Promise<StandardActionResponse> {
     const path = this.resolveSequencePath(params.path);
     const resp = await this.sendAction('sequence_add_camera', { path, spawnable: params.spawnable !== false });
     if (!resp.success && this.isUnknownActionResponse(resp)) {
@@ -100,7 +102,7 @@ export class SequenceTools extends BaseTool implements ISequenceTools {
     return resp;
   }
 
-  async addActor(params: { actorName: string; createBinding?: boolean; path?: string }) {
+  async addActor(params: { actorName: string; createBinding?: boolean; path?: string }): Promise<StandardActionResponse> {
     const path = this.resolveSequencePath(params.path);
     const resp = await this.sendAction('sequence_add_actor', { path, actorName: params.actorName, createBinding: params.createBinding });
     if (!resp.success && this.isUnknownActionResponse(resp)) {
@@ -112,7 +114,7 @@ export class SequenceTools extends BaseTool implements ISequenceTools {
   /**
    * Play the current level sequence
    */
-  async play(params?: { path?: string; startTime?: number; loopMode?: 'once' | 'loop' | 'pingpong' }) {
+  async play(params?: { path?: string; startTime?: number; loopMode?: 'once' | 'loop' | 'pingpong' }): Promise<StandardActionResponse> {
     const path = this.resolveSequencePath(params?.path);
     const resp = await this.sendAction('sequence_play', { path, startTime: params?.startTime, loopMode: params?.loopMode });
     if (!resp.success && this.isUnknownActionResponse(resp)) {
@@ -124,7 +126,7 @@ export class SequenceTools extends BaseTool implements ISequenceTools {
   /**
    * Pause the current level sequence
    */
-  async pause(params?: { path?: string }) {
+  async pause(params?: { path?: string }): Promise<StandardActionResponse> {
     const path = this.resolveSequencePath(params?.path);
     const resp = await this.sendAction('sequence_pause', { path });
     if (!resp.success && this.isUnknownActionResponse(resp)) {
@@ -136,7 +138,7 @@ export class SequenceTools extends BaseTool implements ISequenceTools {
   /**
    * Stop/close the current level sequence
    */
-  async stop(params?: { path?: string }) {
+  async stop(params?: { path?: string }): Promise<StandardActionResponse> {
     const path = this.resolveSequencePath(params?.path);
     const resp = await this.sendAction('sequence_stop', { path });
     if (!resp.success && this.isUnknownActionResponse(resp)) {
@@ -154,7 +156,7 @@ export class SequenceTools extends BaseTool implements ISequenceTools {
     lengthInFrames?: number;
     playbackStart?: number;
     playbackEnd?: number;
-  }) {
+  }): Promise<StandardActionResponse> {
     const payload: Record<string, unknown> = {
       path: params.path,
       frameRate: params.frameRate,
@@ -172,7 +174,7 @@ export class SequenceTools extends BaseTool implements ISequenceTools {
   /**
    * Set display rate (fps)
    */
-  async setDisplayRate(params: { path?: string; frameRate: string | number }) {
+  async setDisplayRate(params: { path?: string; frameRate: string | number }): Promise<StandardActionResponse> {
     const resp = await this.sendAction('sequence_set_display_rate', { path: params.path, frameRate: params.frameRate });
     if (!resp.success && this.isUnknownActionResponse(resp)) {
       return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement sequence_set_display_rate' } as const;
@@ -183,7 +185,7 @@ export class SequenceTools extends BaseTool implements ISequenceTools {
   /**
    * Get sequence properties
    */
-  async getSequenceProperties(params: { path?: string }) {
+  async getSequenceProperties(params: { path?: string }): Promise<StandardActionResponse> {
     const resp = await this.sendAction('sequence_get_properties', { path: params.path });
     if (!resp.success && this.isUnknownActionResponse(resp)) {
       return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement sequence_get_properties' } as const;
@@ -194,7 +196,7 @@ export class SequenceTools extends BaseTool implements ISequenceTools {
   /**
    * Set playback speed/rate
    */
-  async setPlaybackSpeed(params: { speed: number; path?: string }) {
+  async setPlaybackSpeed(params: { speed: number; path?: string }): Promise<StandardActionResponse> {
     const path = this.resolveSequencePath(params.path);
     const resp = await this.sendAction('sequence_set_playback_speed', { path, speed: params.speed });
     if (!resp.success && this.isUnknownActionResponse(resp)) {
@@ -206,7 +208,7 @@ export class SequenceTools extends BaseTool implements ISequenceTools {
   /**
    * Get all bindings in the current sequence
    */
-  async getBindings(params?: { path?: string }) {
+  async getBindings(params?: { path?: string }): Promise<StandardActionResponse> {
     const resp = await this.sendAction('sequence_get_bindings', { path: params?.path });
     if (!resp.success && this.isUnknownActionResponse(resp)) {
       return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement sequence_get_bindings' } as const;
@@ -217,7 +219,7 @@ export class SequenceTools extends BaseTool implements ISequenceTools {
   /**
    * Add multiple actors to sequence at once
    */
-  async addActors(params: { actorNames: string[]; path?: string }) {
+  async addActors(params: { actorNames: string[]; path?: string }): Promise<StandardActionResponse> {
     const path = this.resolveSequencePath(params.path);
     const resp = await this.sendAction('sequence_add_actors', { path, actorNames: params.actorNames });
     if (!resp.success && this.isUnknownActionResponse(resp)) {
@@ -229,7 +231,7 @@ export class SequenceTools extends BaseTool implements ISequenceTools {
   /**
    * Remove actors from binding
    */
-  async removeActors(params: { actorNames: string[]; path?: string }) {
+  async removeActors(params: { actorNames: string[]; path?: string }): Promise<StandardActionResponse> {
     const path = this.resolveSequencePath(params.path);
     const resp = await this.sendAction('sequence_remove_actors', { path, actorNames: params.actorNames });
     if (!resp.success && this.isUnknownActionResponse(resp)) {
@@ -241,7 +243,7 @@ export class SequenceTools extends BaseTool implements ISequenceTools {
   /**
    * Create a spawnable from an actor class
    */
-  async addSpawnableFromClass(params: { className: string; path?: string }) {
+  async addSpawnableFromClass(params: { className: string; path?: string }): Promise<StandardActionResponse> {
     const resp = await this.sendAction('sequence_add_spawnable_from_class', { className: params.className, path: params.path });
     if (!resp.success && this.isUnknownActionResponse(resp)) {
       return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement sequence_add_spawnable_from_class' } as const;
@@ -249,7 +251,7 @@ export class SequenceTools extends BaseTool implements ISequenceTools {
     return resp;
   }
 
-  async list(params?: { path?: string }) {
+  async list(params?: { path?: string }): Promise<StandardActionResponse> {
     const resp = await this.sendAction('sequence_list', { path: params?.path });
     if (!resp.success && this.isUnknownActionResponse(resp)) {
       return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement sequence_list' } as const;
@@ -265,7 +267,7 @@ export class SequenceTools extends BaseTool implements ISequenceTools {
     return resp;
   }
 
-  async duplicate(params: { path: string; destinationPath: string }) {
+  async duplicate(params: { path: string; destinationPath: string }): Promise<StandardActionResponse> {
     const resp = await this.sendAction('sequence_duplicate', { path: params.path, destinationPath: params.destinationPath });
     if (!resp.success && this.isUnknownActionResponse(resp)) {
       return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement sequence_duplicate' } as const;
@@ -273,7 +275,7 @@ export class SequenceTools extends BaseTool implements ISequenceTools {
     return resp;
   }
 
-  async rename(params: { path: string; newName: string }) {
+  async rename(params: { path: string; newName: string }): Promise<StandardActionResponse> {
     const resp = await this.sendAction('sequence_rename', { path: params.path, newName: params.newName });
     if (!resp.success && this.isUnknownActionResponse(resp)) {
       return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement sequence_rename' } as const;
@@ -281,7 +283,7 @@ export class SequenceTools extends BaseTool implements ISequenceTools {
     return resp;
   }
 
-  async deleteSequence(params: { path: string }) {
+  async deleteSequence(params: { path: string }): Promise<StandardActionResponse> {
     const resp = await this.sendAction('sequence_delete', { path: params.path });
     if (!resp.success && this.isUnknownActionResponse(resp)) {
       return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement sequence_delete' } as const;
@@ -289,7 +291,7 @@ export class SequenceTools extends BaseTool implements ISequenceTools {
     return resp;
   }
 
-  async getMetadata(params: { path?: string }) {
+  async getMetadata(params: { path?: string }): Promise<StandardActionResponse> {
     const resp = await this.sendAction('sequence_get_metadata', { path: params.path });
     if (!resp.success && this.isUnknownActionResponse(resp)) {
       return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement sequence_get_metadata' } as const;
@@ -311,7 +313,7 @@ export class SequenceTools extends BaseTool implements ISequenceTools {
       rotation?: { roll: number; pitch: number; yaw: number };
       scale?: { x: number; y: number; z: number };
     };
-  }) {
+  }): Promise<StandardActionResponse> {
     const resp = await this.sendAction('sequence_add_keyframe', {
       path: params.path,
       bindingId: params.bindingId,
@@ -320,6 +322,20 @@ export class SequenceTools extends BaseTool implements ISequenceTools {
       frame: params.frame,
       value: params.value
     });
+
+    // Use WASM for transform processing
+    if (params.property === 'Transform' && params.value) {
+      const loc = params.value.location;
+      const rot = params.value.rotation;
+      const scale = params.value.scale;
+      if (loc && rot && scale) {
+        const locArr: [number, number, number] = [loc.x, loc.y, loc.z];
+        const rotArr: [number, number, number] = [rot.pitch, rot.yaw, rot.roll];
+        const scaleArr: [number, number, number] = [scale.x, scale.y, scale.z];
+        wasmIntegration.composeTransform(locArr, rotArr, scaleArr);
+        console.error('[WASM] Using composeTransform for keyframe validation');
+      }
+    }
     if (!resp.success && this.isUnknownActionResponse(resp)) {
       return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement sequence_add_keyframe' } as const;
     }
@@ -329,7 +345,7 @@ export class SequenceTools extends BaseTool implements ISequenceTools {
   /**
    * List tracks in a sequence
    */
-  async listTracks(params: { path: string }) {
+  async listTracks(params: { path: string }): Promise<StandardActionResponse> {
     const resp = await this.sendAction('sequence_list_tracks', { path: params.path });
     if (!resp.success && this.isUnknownActionResponse(resp)) {
       return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement sequence_list_tracks' } as const;
@@ -348,7 +364,7 @@ export class SequenceTools extends BaseTool implements ISequenceTools {
   /**
    * Set playback work range
    */
-  async setWorkRange(params: { path?: string; start: number; end: number }) {
+  async setWorkRange(params: { path?: string; start: number; end: number }): Promise<StandardActionResponse> {
     const resp = await this.sendAction('sequence_set_work_range', { path: params.path, start: params.start, end: params.end });
     if (!resp.success && this.isUnknownActionResponse(resp)) {
       return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement sequence_set_work_range' } as const;

package/src/tools/ui.ts

@@ -123,7 +123,6 @@ export class UITools {
   async setWidgetText(_params: {
     key: string; // The widget name to find
     value: string; // The text to set
-    componentName?: string; // Legacy/Unused in new impl
   }) {
     if (!this.automationBridge) {
       throw new Error('Automation bridge required for setting widget text');
@@ -149,7 +148,6 @@ export class UITools {
   async setWidgetImage(_params: {
     key: string;
     texturePath: string;
-    componentName?: string; // Unused
   }) {
     if (!this.automationBridge) {
       throw new Error('Automation bridge required for setting widget images');

package/src/types/automation-responses.ts

@@ -0,0 +1,119 @@
+/**
+ * Common type definitions for automation bridge responses
+ * Used to provide type safety for sendAutomationRequest calls
+ */
+
+/**
+ * Base response structure from the Automation Bridge
+ * Most responses follow this pattern with optional additional fields
+ */
+export interface AutomationResponse {
+    success: boolean;
+    message?: string;
+    error?: string | { message: string; code?: string };
+    result?: unknown;
+    // Common additional fields
+    warnings?: string[];
+    details?: unknown;
+    data?: unknown;
+    [key: string]: unknown;
+}
+
+/**
+ * Level-related response fields
+ */
+export interface LevelResponse extends AutomationResponse {
+    levelPath?: string;
+    level?: string;
+    path?: string;
+    packagePath?: string;
+    objectPath?: string;
+    currentMap?: string;
+    currentMapPath?: string;
+    currentWorldLevels?: unknown[];
+    allMaps?: unknown[];
+    partitioned?: boolean;
+    streaming?: boolean;
+    loaded?: boolean;
+    visible?: boolean;
+    skipped?: boolean;
+    reason?: string;
+}
+
+/**
+ * Actor-related response fields
+ */
+export interface ActorResponse extends AutomationResponse {
+    actorName?: string;
+    actorLabel?: string;
+    actorPath?: string;
+    actors?: unknown[];
+    components?: unknown[];
+    location?: { x: number; y: number; z: number };
+    rotation?: { pitch: number; yaw: number; roll: number };
+    scale?: { x: number; y: number; z: number };
+    transform?: unknown;
+    tags?: string[];
+    properties?: Record<string, unknown>;
+    deleted?: boolean;
+    deletedCount?: number;
+}
+
+/**
+ * Asset-related response fields
+ */
+export interface AssetResponse extends AutomationResponse {
+    assetPath?: string;
+    asset?: string;
+    assets?: unknown[];
+    source?: string;
+    saved?: boolean;
+    metadata?: Record<string, unknown>;
+    tags?: string[];
+    graph?: Record<string, unknown[]>;
+}
+
+/**
+ * Editor-related response fields
+ */
+export interface EditorResponse extends AutomationResponse {
+    viewMode?: string;
+    fov?: number;
+    location?: { x: number; y: number; z: number };
+    rotation?: { pitch: number; yaw: number; roll: number };
+    cameraSettings?: unknown;
+    camera?: { location?: unknown; rotation?: unknown };
+    resolution?: { width: number; height: number };
+    filename?: string;
+    filePath?: string;
+    isPlaying?: boolean;
+    isPaused?: boolean;
+    isInPIE?: boolean;
+    playSessionId?: string;
+    bookmarkName?: string;
+    bookmarks?: unknown[];
+    realtime?: boolean;
+}
+
+/**
+ * Sequence/Animation-related response fields
+ */
+export interface SequenceResponse extends AutomationResponse {
+    sequencePath?: string;
+    sequence?: string;
+    bindingId?: string;
+    trackName?: string;
+    keyframe?: unknown;
+    frameNumber?: number;
+    length?: number;
+    playbackPosition?: number;
+    requestId?: string;
+}
+
+/**
+ * Console command response
+ */
+export interface ConsoleResponse extends AutomationResponse {
+    output?: string;
+    command?: string;
+}