unreal-engine-mcp-server 0.5.0 → 0.5.1

package/src/tools/editor.ts

@@ -1,7 +1,9 @@
 import { BaseTool } from './base-tool.js';
-import { IEditorTools } from '../types/tool-interfaces.js';
+import { IEditorTools, StandardActionResponse } from '../types/tool-interfaces.js';
 import { toVec3Object, toRotObject } from '../utils/normalize.js';
 import { DEFAULT_SCREENSHOT_RESOLUTION } from '../constants.js';
+import { EditorResponse } from '../types/automation-responses.js';
+import { wasmIntegration } from '../wasm/index.js';
 
 export class EditorTools extends BaseTool implements IEditorTools {
   private cameraBookmarks = new Map<string, { location: [number, number, number]; rotation: [number, number, number]; savedAt: number }>();
@@ -10,14 +12,14 @@ export class EditorTools extends BaseTool implements IEditorTools {
 
   async isInPIE(): Promise<boolean> {
     try {
-      const response = await this.sendAutomationRequest(
+      const response = await this.sendAutomationRequest<EditorResponse>(
         'check_pie_state',
         {},
         { timeoutMs: 5000 }
       );
 
       if (response && response.success !== false) {
-        return response.isInPIE === true || response.result?.isInPIE === true;
+        return response.isInPIE === true || (response.result as any)?.isInPIE === true;
       }
 
       return false;
@@ -34,10 +36,10 @@ export class EditorTools extends BaseTool implements IEditorTools {
     }
   }
 
-  async playInEditor(timeoutMs: number = 30000) {
+  async playInEditor(timeoutMs: number = 30000): Promise<StandardActionResponse> {
     try {
       try {
-        const response = await this.sendAutomationRequest(
+        const response = await this.sendAutomationRequest<EditorResponse>(
           'control_editor',
           { action: 'play' },
           { timeoutMs }
@@ -62,10 +64,10 @@ export class EditorTools extends BaseTool implements IEditorTools {
     }
   }
 
-  async stopPlayInEditor() {
+  async stopPlayInEditor(): Promise<StandardActionResponse> {
     try {
       try {
-        const response = await this.sendAutomationRequest(
+        const response = await this.sendAutomationRequest<EditorResponse>(
           'control_editor',
           { action: 'stop' },
           { timeoutMs: 30000 }
@@ -92,7 +94,7 @@ export class EditorTools extends BaseTool implements IEditorTools {
     }
   }
 
-  async pausePlayInEditor() {
+  async pausePlayInEditor(): Promise<StandardActionResponse> {
     try {
       // Pause/Resume PIE
       await this.bridge.executeConsoleCommand('pause');
@@ -103,11 +105,11 @@ export class EditorTools extends BaseTool implements IEditorTools {
   }
 
   // Alias for consistency with naming convention
-  async pauseInEditor() {
+  async pauseInEditor(): Promise<StandardActionResponse> {
     return this.pausePlayInEditor();
   }
 
-  async buildLighting() {
+  async buildLighting(): Promise<StandardActionResponse> {
     try {
       // Use console command to build lighting
       await this.bridge.executeConsoleCommand('BuildLighting');
@@ -125,12 +127,12 @@ export class EditorTools extends BaseTool implements IEditorTools {
     message?: string;
   }> {
     try {
-      const resp = await this.sendAutomationRequest(
+      const resp = await this.sendAutomationRequest<EditorResponse>(
         'control_editor',
         { action: 'get_camera' },
         { timeoutMs: 3000 }
       );
-      const result = resp?.result ?? resp;
+      const result: any = resp?.result ?? resp;
       const loc = result?.location ?? result?.camera?.location;
       const rot = result?.rotation ?? result?.camera?.rotation;
       const locArr: [number, number, number] | undefined = Array.isArray(loc) && loc.length === 3 ? [Number(loc[0]) || 0, Number(loc[1]) || 0, Number(loc[2]) || 0] : undefined;
@@ -144,7 +146,7 @@ export class EditorTools extends BaseTool implements IEditorTools {
     }
   }
 
-  async setViewportCamera(location?: { x: number; y: number; z: number } | [number, number, number] | null | undefined, rotation?: { pitch: number; yaw: number; roll: number } | [number, number, number] | null | undefined) {
+  async setViewportCamera(location?: { x: number; y: number; z: number } | [number, number, number] | null | undefined, rotation?: { pitch: number; yaw: number; roll: number } | [number, number, number] | null | undefined): Promise<StandardActionResponse> {
     // Special handling for when both location and rotation are missing/invalid
     // Allow rotation-only updates
     if (location === null) {
@@ -182,7 +184,18 @@ export class EditorTools extends BaseTool implements IEditorTools {
 
     // Use native control_editor.set_camera when available
     try {
-      const resp = await this.sendAutomationRequest('control_editor', {
+      // Use WASM composeTransform for camera transform calculation
+      const locArray: [number, number, number] = location
+        ? [((location as any).x ?? (location as any)[0] ?? 0), ((location as any).y ?? (location as any)[1] ?? 0), ((location as any).z ?? (location as any)[2] ?? 0)]
+        : [0, 0, 0];
+      const rotArray: [number, number, number] = rotation
+        ? [((rotation as any).pitch ?? (rotation as any)[0] ?? 0), ((rotation as any).yaw ?? (rotation as any)[1] ?? 0), ((rotation as any).roll ?? (rotation as any)[2] ?? 0)]
+        : [0, 0, 0];
+      // Compose transform to validate and process camera positioning via WASM
+      wasmIntegration.composeTransform(locArray, rotArray, [1, 1, 1]);
+      // console.error('[WASM] Using composeTransform for camera positioning');
+
+      const resp = await this.sendAutomationRequest<EditorResponse>('control_editor', {
         action: 'set_camera',
         location: location as any,
         rotation: rotation as any
@@ -196,7 +209,7 @@ export class EditorTools extends BaseTool implements IEditorTools {
     }
   }
 
-  async setCameraSpeed(speed: number) {
+  async setCameraSpeed(speed: number): Promise<StandardActionResponse> {
     try {
       await this.bridge.executeConsoleCommand(`camspeed ${speed}`);
       return { success: true, message: `Camera speed set to ${speed}` };
@@ -205,7 +218,7 @@ export class EditorTools extends BaseTool implements IEditorTools {
     }
   }
 
-  async setFOV(fov: number) {
+  async setFOV(fov: number): Promise<StandardActionResponse> {
     try {
       await this.bridge.executeConsoleCommand(`fov ${fov}`);
       return { success: true, message: `FOV set to ${fov}` };
@@ -214,7 +227,7 @@ export class EditorTools extends BaseTool implements IEditorTools {
     }
   }
 
-  async takeScreenshot(filename?: string, resolution?: string) {
+  async takeScreenshot(filename?: string, resolution?: string): Promise<StandardActionResponse> {
     try {
       if (resolution && !/^\d+x\d+$/.test(resolution)) {
         return { success: false, error: 'Invalid resolution format. Use WxH (e.g. 1920x1080)' };
@@ -237,7 +250,7 @@ export class EditorTools extends BaseTool implements IEditorTools {
     }
   }
 
-  async resumePlayInEditor() {
+  async resumePlayInEditor(): Promise<StandardActionResponse> {
     try {
       // Use console command to toggle pause (resumes if paused)
       await this.bridge.executeConsoleCommand('pause');
@@ -250,7 +263,7 @@ export class EditorTools extends BaseTool implements IEditorTools {
     }
   }
 
-  async stepPIEFrame(steps: number = 1) {
+  async stepPIEFrame(steps: number = 1): Promise<StandardActionResponse> {
     const clampedSteps = Number.isFinite(steps) ? Math.max(1, Math.floor(steps)) : 1;
     try {
       // Use console command to step frames
@@ -267,7 +280,7 @@ export class EditorTools extends BaseTool implements IEditorTools {
     }
   }
 
-  async startRecording(options?: { filename?: string; frameRate?: number; durationSeconds?: number; metadata?: Record<string, unknown> }) {
+  async startRecording(options?: { filename?: string; frameRate?: number; durationSeconds?: number; metadata?: Record<string, unknown> }): Promise<StandardActionResponse> {
     const startedAt = Date.now();
     this.activeRecording = {
       name: typeof options?.filename === 'string' ? options.filename.trim() : undefined,
@@ -286,7 +299,7 @@ export class EditorTools extends BaseTool implements IEditorTools {
     };
   }
 
-  async stopRecording() {
+  async stopRecording(): Promise<StandardActionResponse> {
     if (!this.activeRecording) {
       return {
         success: true as const,
@@ -304,7 +317,7 @@ export class EditorTools extends BaseTool implements IEditorTools {
     };
   }
 
-  async createCameraBookmark(name: string) {
+  async createCameraBookmark(name: string): Promise<StandardActionResponse> {
     const trimmedName = name.trim();
     if (!trimmedName) {
       return { success: false as const, error: 'bookmarkName is required' };
@@ -335,7 +348,7 @@ export class EditorTools extends BaseTool implements IEditorTools {
     };
   }
 
-  async jumpToCameraBookmark(name: string) {
+  async jumpToCameraBookmark(name: string): Promise<StandardActionResponse> {
     const trimmedName = name.trim();
     if (!trimmedName) {
       return { success: false as const, error: 'bookmarkName is required' };
@@ -360,7 +373,7 @@ export class EditorTools extends BaseTool implements IEditorTools {
     };
   }
 
-  async setEditorPreferences(category: string | undefined, preferences: Record<string, unknown>) {
+  async setEditorPreferences(category: string | undefined, preferences: Record<string, unknown>): Promise<StandardActionResponse> {
     const resolvedCategory = typeof category === 'string' && category.trim().length > 0 ? category.trim() : 'General';
     const existing = this.editorPreferences.get(resolvedCategory) ?? {};
     this.editorPreferences.set(resolvedCategory, { ...existing, ...preferences });
@@ -372,7 +385,7 @@ export class EditorTools extends BaseTool implements IEditorTools {
     };
   }
 
-  async setViewportResolution(width: number, height: number) {
+  async setViewportResolution(width: number, height: number): Promise<StandardActionResponse> {
     try {
       // Clamp to reasonable limits
       const clampedWidth = Math.max(320, Math.min(7680, width));
@@ -393,7 +406,7 @@ export class EditorTools extends BaseTool implements IEditorTools {
     }
   }
 
-  async executeConsoleCommand(command: string) {
+  async executeConsoleCommand(command: string): Promise<StandardActionResponse> {
     try {
       // Sanitize and validate command
       if (!command || typeof command !== 'string') {

package/src/tools/environment.ts

@@ -3,15 +3,9 @@ import path from 'node:path';
 import { AutomationBridge } from '../automation/index.js';
 import { UnrealBridge } from '../unreal-bridge.js';
 import { DEFAULT_SKYLIGHT_INTENSITY, DEFAULT_SUN_INTENSITY, DEFAULT_TIME_OF_DAY } from '../constants.js';
+import { IEnvironmentTools, StandardActionResponse } from '../types/tool-interfaces.js';
 
-interface EnvironmentResult {
-  success: boolean;
-  message?: string;
-  error?: string;
-  details?: Record<string, unknown>;
-}
-
-export class EnvironmentTools {
+export class EnvironmentTools implements IEnvironmentTools {
   constructor(_bridge: UnrealBridge, private automationBridge?: AutomationBridge) { }
 
   setAutomationBridge(automationBridge?: AutomationBridge) {
@@ -69,7 +63,7 @@ export class EnvironmentTools {
     return num;
   }
 
-  private async invoke(action: string, payload: Record<string, unknown>): Promise<EnvironmentResult> {
+  private async invoke(action: string, payload: Record<string, unknown>): Promise<StandardActionResponse> {
     try {
       const bridge = this.ensureAutomationBridge();
       const response = await bridge.sendAutomationRequest(action, payload, { timeoutMs: 40000 });
@@ -79,42 +73,42 @@ export class EnvironmentTools {
           error: typeof response.error === 'string' && response.error.length > 0 ? response.error : 'ENVIRONMENT_CONTROL_FAILED',
           message: typeof response.message === 'string' ? response.message : undefined,
           details: typeof response.result === 'object' && response.result ? response.result as Record<string, unknown> : undefined
-        };
+        } as StandardActionResponse;
       }
       const resultPayload = typeof response.result === 'object' && response.result ? response.result as Record<string, unknown> : undefined;
       return {
         success: true,
         message: typeof response.message === 'string' ? response.message : 'Environment control action succeeded',
         details: resultPayload
-      };
+      } as StandardActionResponse;
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       return {
         success: false,
         error: message || 'ENVIRONMENT_CONTROL_FAILED'
-      };
+      } as StandardActionResponse;
     }
   }
 
-  async setTimeOfDay(hour: unknown): Promise<EnvironmentResult> {
+  async setTimeOfDay(hour: unknown): Promise<StandardActionResponse> {
     const normalizedHour = this.normalizeNumber(hour, 'hour', this.getDefaultTimeOfDay());
     const clampedHour = Math.min(Math.max(normalizedHour, 0), 24);
     return this.invoke('set_time_of_day', { hour: clampedHour });
   }
 
-  async setSunIntensity(intensity: unknown): Promise<EnvironmentResult> {
+  async setSunIntensity(intensity: unknown): Promise<StandardActionResponse> {
     const normalized = this.normalizeNumber(intensity, 'intensity', this.getDefaultSunIntensity());
     const finalValue = Math.max(normalized, 0);
     return this.invoke('set_sun_intensity', { intensity: finalValue });
   }
 
-  async setSkylightIntensity(intensity: unknown): Promise<EnvironmentResult> {
+  async setSkylightIntensity(intensity: unknown): Promise<StandardActionResponse> {
     const normalized = this.normalizeNumber(intensity, 'intensity', this.getDefaultSkylightIntensity());
     const finalValue = Math.max(normalized, 0);
     return this.invoke('set_skylight_intensity', { intensity: finalValue });
   }
 
-  async exportSnapshot(params: { path?: unknown; filename?: unknown }): Promise<EnvironmentResult> {
+  async exportSnapshot(params: { path?: unknown; filename?: unknown }): Promise<StandardActionResponse> {
     try {
       const rawPath = typeof params?.path === 'string' && params.path.trim().length > 0
         ? params.path.trim()
@@ -157,17 +151,17 @@ export class EnvironmentTools {
         success: true,
         message: `Environment snapshot exported to ${targetPath}`,
         details: { path: targetPath }
-      };
+      } as StandardActionResponse;
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       return {
         success: false,
         error: `Failed to export environment snapshot: ${message}`
-      };
+      } as StandardActionResponse;
     }
   }
 
-  async importSnapshot(params: { path?: unknown; filename?: unknown }): Promise<EnvironmentResult> {
+  async importSnapshot(params: { path?: unknown; filename?: unknown }): Promise<StandardActionResponse> {
     const rawPath = typeof params?.path === 'string' && params.path.trim().length > 0
       ? params.path.trim()
       : './tests/reports/env_snapshot.json';
@@ -210,7 +204,7 @@ export class EnvironmentTools {
           return {
             success: true,
             message: `Environment snapshot file not found at ${targetPath}; import treated as no-op`
-          };
+          } as StandardActionResponse;
         }
         throw err;
       }
@@ -219,17 +213,17 @@ export class EnvironmentTools {
         success: true,
         message: `Environment snapshot import handled from ${targetPath}`,
         details: parsed && typeof parsed === 'object' ? parsed as Record<string, unknown> : undefined
-      };
+      } as StandardActionResponse;
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       return {
         success: false,
         error: `Failed to import environment snapshot: ${message}`
-      };
+      } as StandardActionResponse;
     }
   }
 
-  async cleanup(params?: { names?: unknown; name?: unknown }): Promise<EnvironmentResult> {
+  async cleanup(params?: { names?: unknown; name?: unknown }): Promise<StandardActionResponse> {
     try {
       const rawNames = Array.isArray(params?.names) ? params.names : [];
       if (typeof params?.name === 'string' && params.name.trim().length > 0) {
@@ -244,7 +238,7 @@ export class EnvironmentTools {
         return {
           success: true,
           message: 'No environment actor names provided for cleanup; no-op'
-        };
+        } as StandardActionResponse;
       }
 
       const bridge = this.ensureAutomationBridge();
@@ -264,7 +258,7 @@ export class EnvironmentTools {
               : 'Failed to delete environment actors'),
           message: typeof resp?.message === 'string' ? resp.message : undefined,
           details: result
-        };
+        } as StandardActionResponse;
       }
 
       const result = resp && typeof resp.result === 'object' ? resp.result as Record<string, unknown> : undefined;
@@ -275,13 +269,13 @@ export class EnvironmentTools {
           ? resp.message
           : `Environment actors deleted: ${cleaned.join(', ')}`,
         details: result ?? { names: cleaned }
-      };
+      } as StandardActionResponse;
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       return {
         success: false,
         error: `Failed to cleanup environment actors: ${message}`
-      };
+      } as StandardActionResponse;
     }
   }
 }

package/src/tools/foliage.ts

@@ -2,8 +2,9 @@
 import { UnrealBridge } from '../unreal-bridge.js';
 import { AutomationBridge } from '../automation/index.js';
 import { coerceBoolean, coerceNumber, coerceString } from '../utils/result-helpers.js';
+import { IFoliageTools, StandardActionResponse } from '../types/tool-interfaces.js';
 
-export class FoliageTools {
+export class FoliageTools implements IFoliageTools {
   constructor(private bridge: UnrealBridge, private automationBridge?: AutomationBridge) { }
 
   setAutomationBridge(automationBridge?: AutomationBridge) { this.automationBridge = automationBridge; }
@@ -24,7 +25,7 @@ export class FoliageTools {
     alignToNormal?: boolean;
     randomYaw?: boolean;
     groundSlope?: number;
-  }) {
+  }): Promise<StandardActionResponse> {
     // Basic validation to prevent bad inputs like 'undefined' and empty strings
     const errors: string[] = [];
     const name = String(params?.name ?? '').trim();
@@ -99,7 +100,7 @@ export class FoliageTools {
         message: exists
           ? `Foliage type '${name}' ready (${method})`
           : `Created foliage '${name}' but verification did not find it yet`
-      };
+      } as StandardActionResponse;
     } catch (error) {
       return {
         success: false,
@@ -115,7 +116,7 @@ export class FoliageTools {
     brushSize?: number;
     paintDensity?: number;
     eraseMode?: boolean;
-  }) {
+  }): Promise<StandardActionResponse> {
     const errors: string[] = [];
     const foliageType = String(params?.foliageType ?? '').trim();
     const pos = Array.isArray(params?.position) ? params.position : [0, 0, 0];
@@ -174,7 +175,7 @@ export class FoliageTools {
         added,
         note,
         message: `Painted ${added} instances for '${foliageType}' around (${pos[0]}, ${pos[1]}, ${pos[2]})`
-      };
+      } as StandardActionResponse;
     } catch (error) {
       return {
         success: false,
@@ -184,7 +185,7 @@ export class FoliageTools {
   }
 
   // Query foliage instances (plugin-native)
-  async getFoliageInstances(params: { foliageType?: string }) {
+  async getFoliageInstances(params: { foliageType?: string }): Promise<StandardActionResponse> {
     if (!this.automationBridge) {
       throw new Error('Automation Bridge not available. Foliage operations require plugin support.');
     }
@@ -200,15 +201,16 @@ export class FoliageTools {
       return {
         success: true,
         count: coerceNumber(payload.count) ?? 0,
-        instances: (payload.instances as any[]) ?? []
-      };
+        instances: (payload.instances as any[]) ?? [],
+        message: 'Foliage instances retrieved'
+      } as StandardActionResponse;
     } catch (error) {
       return { success: false, error: `Failed to get foliage instances: ${error instanceof Error ? error.message : String(error)}` };
     }
   }
 
   // Remove foliage (plugin-native)
-  async removeFoliage(params: { foliageType?: string; removeAll?: boolean }) {
+  async removeFoliage(params: { foliageType?: string; removeAll?: boolean }): Promise<StandardActionResponse> {
     if (!this.automationBridge) {
       throw new Error('Automation Bridge not available. Foliage operations require plugin support.');
     }
@@ -224,8 +226,9 @@ export class FoliageTools {
       const payload = response.result as Record<string, unknown>;
       return {
         success: true,
-        instancesRemoved: coerceNumber(payload.instancesRemoved) ?? 0
-      };
+        instancesRemoved: coerceNumber(payload.instancesRemoved) ?? 0,
+        message: 'Foliage removed'
+      } as StandardActionResponse;
     } catch (error) {
       return { success: false, error: `Failed to remove foliage: ${error instanceof Error ? error.message : String(error)}` };
     }
@@ -242,7 +245,7 @@ export class FoliageTools {
     }>;
     enableCulling?: boolean;
     cullDistance?: number;
-  }) {
+  }): Promise<StandardActionResponse> {
     const commands: string[] = [];
 
     commands.push(`CreateInstancedStaticMesh ${params.name} ${params.meshPath}`);
@@ -271,7 +274,7 @@ export class FoliageTools {
     foliageType: string;
     lodDistances?: number[];
     screenSize?: number[];
-  }) {
+  }): Promise<StandardActionResponse> {
     const commands: string[] = [];
 
     if (params.lodDistances) {
@@ -288,7 +291,7 @@ export class FoliageTools {
   }
 
   // Alias for addFoliageType to match interface/handler usage
-  async addFoliage(params: { foliageType: string; locations: Array<{ x: number; y: number; z: number }> }) {
+  async addFoliage(params: { foliageType: string; locations: Array<{ x: number; y: number; z: number }> }): Promise<StandardActionResponse> {
     // Delegate to paintFoliage which handles placing instances at locations
     if (params.locations && params.locations.length > 0) {
       if (!this.automationBridge) {
@@ -331,7 +334,7 @@ export class FoliageTools {
     size?: [number, number, number];
     seed?: number;
     tileSize?: number;
-  }) {
+  }): Promise<StandardActionResponse> {
     if (!this.automationBridge) {
       throw new Error('Automation Bridge not available.');
     }
@@ -376,7 +379,7 @@ export class FoliageTools {
       volumeActor: result?.volume_actor,
       spawnerPath: result?.spawner_path,
       foliageTypesCount: result?.foliage_types_count
-    };
+    } as StandardActionResponse;
   }
 
   /**
@@ -390,7 +393,7 @@ export class FoliageTools {
       rotation?: [number, number, number];
       scale?: [number, number, number];
     }>;
-  }) {
+  }): Promise<StandardActionResponse> {
     if (!this.automationBridge) {
       throw new Error('Automation Bridge not available. Foliage instance placement requires plugin support.');
     }
@@ -417,7 +420,7 @@ export class FoliageTools {
         success: true,
         message: response.message || `Added ${result?.instances_count || params.transforms.length} foliage instances`,
         instancesCount: result?.instances_count
-      };
+      } as StandardActionResponse;
     } catch (error) {
       return {
         success: false,
@@ -432,7 +435,7 @@ export class FoliageTools {
     collisionEnabled?: boolean;
     collisionProfile?: string;
     generateOverlapEvents?: boolean;
-  }) {
+  }): Promise<StandardActionResponse> {
     const commands: string[] = [];
 
     if (params.collisionEnabled !== undefined) {
@@ -463,7 +466,7 @@ export class FoliageTools {
     }>;
     windStrength?: number;
     windSpeed?: number;
-  }) {
+  }): Promise<StandardActionResponse> {
     const commands: string[] = [];
 
     commands.push(`CreateGrassSystem ${params.name}`);
@@ -492,7 +495,7 @@ export class FoliageTools {
     foliageType: string;
     position: [number, number, number];
     radius: number;
-  }) {
+  }): Promise<StandardActionResponse> {
     const command = `RemoveFoliageInRadius ${params.foliageType} ${params.position.join(' ')} ${params.radius}`;
     return this.bridge.executeConsoleCommand(command);
   }
@@ -503,7 +506,7 @@ export class FoliageTools {
     position?: [number, number, number];
     radius?: number;
     selectAll?: boolean;
-  }) {
+  }): Promise<StandardActionResponse> {
     let command: string;
 
     if (params.selectAll) {
@@ -523,7 +526,7 @@ export class FoliageTools {
     updateTransforms?: boolean;
     updateMesh?: boolean;
     newMeshPath?: string;
-  }) {
+  }): Promise<StandardActionResponse> {
     const commands: string[] = [];
 
     if (params.updateTransforms) {
@@ -546,7 +549,7 @@ export class FoliageTools {
     name: string;
     spawnArea: 'Landscape' | 'StaticMesh' | 'BSP' | 'Foliage' | 'All';
     excludeAreas?: Array<[number, number, number, number]>; // [x, y, z, radius]
-  }) {
+  }): Promise<StandardActionResponse> {
     const commands: string[] = [];
 
     commands.push(`CreateFoliageSpawner ${params.name} ${params.spawnArea}`);
@@ -568,7 +571,7 @@ export class FoliageTools {
     generateClusters?: boolean;
     clusterSize?: number;
     reduceDrawCalls?: boolean;
-  }) {
+  }): Promise<StandardActionResponse> {
     const commands = [];
 
     if (params.mergeInstances) {

package/src/tools/handlers/actor-handlers.ts

@@ -1,13 +1,10 @@
 import { cleanObject } from '../../utils/safe-json.js';
 import { ITools } from '../../types/tool-interfaces.js';
 import { executeAutomationRequest } from './common-handlers.js';
-import { Logger } from '../../utils/logger.js';
 import { normalizeArgs } from './argument-helper.js';
 
 type ActorActionHandler = (args: any, tools: ITools) => Promise<any>;
 
-const logger = new Logger('ActorHandlers');
-
 const handlers: Record<string, ActorActionHandler> = {
     spawn: async (args, tools) => {
         // Class name aliases for user-friendly names
@@ -35,7 +32,7 @@ const handlers: Record<string, ActorActionHandler> = {
             { key: 'actorName', aliases: ['name'] },
             { key: 'timeoutMs', default: undefined }
         ]);
-        
+
         const timeoutMs = typeof params.timeoutMs === 'number' ? params.timeoutMs : undefined;
 
         // Extremely small timeouts are treated as an immediate timeout-style
@@ -113,7 +110,6 @@ const handlers: Record<string, ActorActionHandler> = {
                     // Auto-enable physics logic
                     const compsResult = await tools.actorTools.getComponents(params.actorName);
                     if (compsResult && compsResult.success && Array.isArray(compsResult.components)) {
-                        logger.debug('Components found:', JSON.stringify(compsResult.components));
                         const meshComp = compsResult.components.find((c: any) => {
                             const name = c.name || c;
                             const match = typeof name === 'string' && (
@@ -121,13 +117,11 @@ const handlers: Record<string, ActorActionHandler> = {
                                 name.toLowerCase().includes('mesh') ||
                                 name.toLowerCase().includes('primitive')
                             );
-                            logger.debug(`Checking component '${name}' matches? ${match}`);
                             return match;
                         });
 
                         if (meshComp) {
                             const compName = meshComp.name || meshComp;
-                            logger.debug(`Auto-enabling physics for component: ${compName}`); // Debug log
                             await tools.actorTools.setComponentProperties({
                                 actorName: params.actorName,
                                 componentName: compName,
@@ -253,7 +247,7 @@ const handlers: Record<string, ActorActionHandler> = {
         const params = normalizeArgs(args, [
             { key: 'name', aliases: ['actorName', 'query'], required: true }
         ]);
-        
+
         // Use the plugin's fuzzy query endpoint (contains-match) instead of the
         // exact lookup endpoint. This improves "spawn then find" reliability.
         return tools.actorTools.findByName(params.name);