unreal-engine-mcp-server 0.5.0 → 0.5.2

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

@@ -1,7 +1,18 @@
 import { cleanObject } from '../../utils/safe-json.js';
-import { ITools } from '../../types/tool-interfaces.js';
+import { ITools, StandardActionResponse } from '../../types/tool-interfaces.js';
 import { executeAutomationRequest, requireNonEmptyString } from './common-handlers.js';
 
+/** Extended response with common sequence fields */
+interface SequenceActionResponse extends StandardActionResponse {
+  result?: {
+    sequencePath?: string;
+    results?: Array<{ success?: boolean; error?: string }>;
+    [key: string]: unknown;
+  };
+  bindings?: Array<{ name?: string;[key: string]: unknown }>;
+  message?: string;
+}
+
 const managedSequences = new Set<string>();
 const deletedSequences = new Set<string>();
 
@@ -22,37 +33,48 @@ function markSequenceDeleted(path: unknown) {
   const norm = normalizeSequencePath(path);
   if (!norm) return;
   managedSequences.delete(norm);
-  deletedSequences.add(norm);
+  deletedSequences.delete(norm);
+}
+
+/** Helper to safely get string from error/message */
+function getErrorString(res: SequenceActionResponse | null | undefined): string {
+  if (!res) return '';
+  return typeof res.error === 'string' ? res.error : '';
+}
+
+function getMessageString(res: SequenceActionResponse | null | undefined): string {
+  if (!res) return '';
+  return typeof res.message === 'string' ? res.message : '';
 }
 
 
 
-export async function handleSequenceTools(action: string, args: any, tools: ITools) {
+export async function handleSequenceTools(action: string, args: Record<string, unknown>, tools: ITools) {
   const seqAction = String(action || '').trim();
   switch (seqAction) {
     case 'create': {
       const name = requireNonEmptyString(args.name, 'name', 'Missing required parameter: name');
-      const res = await tools.sequenceTools.create({ name, path: args.path });
+      const res = await tools.sequenceTools.create({ name, path: args.path as string | undefined }) as SequenceActionResponse;
 
       let sequencePath: string | undefined;
-      if (res && (res as any).result && typeof (res as any).result.sequencePath === 'string') {
-        sequencePath = (res as any).result.sequencePath;
+      if (res && res.result && typeof res.result.sequencePath === 'string') {
+        sequencePath = res.result.sequencePath;
       } else if (typeof args.path === 'string' && args.path.trim().length > 0) {
         const basePath = args.path.trim().replace(/\/$/, '');
         sequencePath = `${basePath}/${name}`;
       }
-      if (sequencePath && res && (res as any).success !== false) {
+      if (sequencePath && res && res.success !== false) {
         markSequenceCreated(sequencePath);
       }
 
-      const errorCode = String((res && (res as any).error) || '').toUpperCase();
-      const msgLower = String((res && (res as any).message) || '').toLowerCase();
-      if (res && (res as any).success === false && (errorCode === 'FACTORY_NOT_AVAILABLE' || msgLower.includes('ulevelsequencefactorynew not available'))) {
+      const errorCode = getErrorString(res).toUpperCase();
+      const msgLower = getMessageString(res).toLowerCase();
+      if (res && res.success === false && (errorCode === 'FACTORY_NOT_AVAILABLE' || msgLower.includes('ulevelsequencefactorynew not available'))) {
         const path = sequencePath || (typeof args.path === 'string' ? args.path : undefined);
         return cleanObject({
           success: false,
           error: 'FACTORY_NOT_AVAILABLE',
-          message: (res as any).message || 'Sequence creation failed: factory not available',
+          message: res.message || 'Sequence creation failed: factory not available',
           action: 'create',
           name,
           path,
@@ -69,7 +91,7 @@ export async function handleSequenceTools(action: string, args: any, tools: IToo
       return cleanObject(res);
     }
     case 'add_camera': {
-      const res = await tools.sequenceTools.addCamera({ spawnable: args.spawnable, path: args.path });
+      const res = await tools.sequenceTools.addCamera({ spawnable: args.spawnable as boolean | undefined, path: args.path as string | undefined });
       return cleanObject(res);
     }
     case 'add_actor': {
@@ -82,18 +104,18 @@ export async function handleSequenceTools(action: string, args: any, tools: IToo
         subAction: 'add_actor'
       };
 
-      const res = await executeAutomationRequest(tools, 'manage_sequence', payload);
+      const res = await executeAutomationRequest(tools, 'manage_sequence', payload) as SequenceActionResponse;
 
-      const errorCode = String((res && (res as any).error) || '').toUpperCase();
-      const msgLower = String((res && (res as any).message) || '').toLowerCase();
+      const errorCode = getErrorString(res).toUpperCase();
+      const msgLower = getMessageString(res).toLowerCase();
 
-      if (res && (res as any).success === false && path) {
+      if (res && res.success === false && path) {
         const isInvalidSequence = errorCode === 'INVALID_SEQUENCE' || msgLower.includes('sequence_add_actor requires a sequence path') || msgLower.includes('sequence not found');
         if (isInvalidSequence) {
           return cleanObject({
             success: false,
             error: 'NOT_FOUND',
-            message: (res as any).message || 'Sequence not found',
+            message: res.message || 'Sequence not found',
             action: 'add_actor',
             path,
             actorName
@@ -101,8 +123,8 @@ export async function handleSequenceTools(action: string, args: any, tools: IToo
         }
       }
 
-      const results = res && (res as any).result && Array.isArray((res as any).result.results)
-        ? (res as any).result.results as any[]
+      const results = res && res.result && Array.isArray(res.result.results)
+        ? res.result.results
         : undefined;
       if (results && results.length) {
         const failed = results.find((item) => item && item.success === false && typeof item.error === 'string');
@@ -124,24 +146,24 @@ export async function handleSequenceTools(action: string, args: any, tools: IToo
       return cleanObject(res);
     }
     case 'add_actors': {
-      const actorNames: string[] = Array.isArray(args.actorNames) ? args.actorNames : [];
-      const res = await tools.sequenceTools.addActors({ actorNames, path: args.path });
-      const errorCode = String((res && (res as any).error) || '').toUpperCase();
-      const msgLower = String((res && (res as any).message) || '').toLowerCase();
-      if (actorNames.length === 0 && res && (res as any).success === false && errorCode === 'INVALID_ARGUMENT') {
+      const actorNames: string[] = Array.isArray(args.actorNames) ? args.actorNames as string[] : [];
+      const res = await tools.sequenceTools.addActors({ actorNames, path: args.path as string | undefined }) as SequenceActionResponse;
+      const errorCode = getErrorString(res).toUpperCase();
+      const msgLower = getMessageString(res).toLowerCase();
+      if (actorNames.length === 0 && res && res.success === false && errorCode === 'INVALID_ARGUMENT') {
         return cleanObject({
           success: false,
           error: 'INVALID_ARGUMENT',
-          message: (res as any).message || 'Invalid argument: actorNames required',
+          message: res.message || 'Invalid argument: actorNames required',
           action: 'add_actors',
           actorNames
         });
       }
-      if (res && (res as any).success === false && msgLower.includes('actor not found')) {
+      if (res && res.success === false && msgLower.includes('actor not found')) {
         return cleanObject({
           success: false,
           error: 'NOT_FOUND',
-          message: (res as any).message || 'Actor not found',
+          message: res.message || 'Actor not found',
           action: 'add_actors',
           actorNames
         });
@@ -149,8 +171,8 @@ export async function handleSequenceTools(action: string, args: any, tools: IToo
       return cleanObject(res);
     }
     case 'remove_actors': {
-      const actorNames: string[] = Array.isArray(args.actorNames) ? args.actorNames : [];
-      const res = await tools.sequenceTools.removeActors({ actorNames, path: args.path });
+      const actorNames: string[] = Array.isArray(args.actorNames) ? args.actorNames as string[] : [];
+      const res = await tools.sequenceTools.removeActors({ actorNames, path: args.path as string | undefined });
       return cleanObject(res);
     }
     case 'get_bindings': {
@@ -164,7 +186,7 @@ export async function handleSequenceTools(action: string, args: any, tools: IToo
       const property = typeof args.property === 'string' ? args.property : undefined;
       const frame = typeof args.frame === 'number' ? args.frame : Number(args.frame);
 
-      const payload = {
+      const payload: Record<string, unknown> = {
         ...args,
         path: path || args.path,
         actorName,
@@ -185,16 +207,16 @@ export async function handleSequenceTools(action: string, args: any, tools: IToo
         payload.value = { scale: args.value };
       }
 
-      const res = await executeAutomationRequest(tools, 'manage_sequence', payload);
-      const errorCode = String((res && (res as any).error) || '').toUpperCase();
-      const msgLower = String((res && (res as any).message) || '').toLowerCase();
+      const res = await executeAutomationRequest(tools, 'manage_sequence', payload) as SequenceActionResponse;
+      const errorCode = getErrorString(res).toUpperCase();
+      const msgLower = getMessageString(res).toLowerCase();
 
       // Keep explicit INVALID_ARGUMENT for missing frame as a real error
       if (errorCode === 'INVALID_ARGUMENT' || msgLower.includes('frame number is required')) {
         return cleanObject(res);
       }
 
-      if (res && (res as any).success === false) {
+      if (res && res.success === false) {
         const isBindingIssue = errorCode === 'BINDING_NOT_FOUND' || msgLower.includes('binding not found');
         const isUnsupported = errorCode === 'UNSUPPORTED_PROPERTY' || msgLower.includes('unsupported property') || msgLower.includes('invalid_sequence_type');
         const isInvalidSeq = errorCode === 'INVALID_SEQUENCE' || msgLower.includes('sequence not found') || msgLower.includes('requires a sequence path');
@@ -203,7 +225,7 @@ export async function handleSequenceTools(action: string, args: any, tools: IToo
           return cleanObject({
             success: false,
             error: 'NOT_FOUND',
-            message: (res as any).message || 'Sequence not found',
+            message: res.message || 'Sequence not found',
             action: 'add_keyframe',
             path,
             actorName,
@@ -222,28 +244,28 @@ export async function handleSequenceTools(action: string, args: any, tools: IToo
     }
     case 'add_spawnable_from_class': {
       const className = requireNonEmptyString(args.className, 'className', 'Missing required parameter: className');
-      const res = await tools.sequenceTools.addSpawnableFromClass({ className, path: args.path });
+      const res = await tools.sequenceTools.addSpawnableFromClass({ className, path: args.path as string | undefined });
       return cleanObject(res);
     }
     case 'play': {
-      const res = await tools.sequenceTools.play({ path: args.path, startTime: args.startTime, loopMode: args.loopMode });
+      const res = await tools.sequenceTools.play({ path: args.path as string | undefined, startTime: args.startTime as number | undefined, loopMode: args.loopMode as 'once' | 'loop' | 'pingpong' | undefined });
       return cleanObject(res);
     }
     case 'pause': {
-      const res = await tools.sequenceTools.pause({ path: args.path });
+      const res = await tools.sequenceTools.pause({ path: args.path as string | undefined });
       return cleanObject(res);
     }
     case 'stop': {
-      const res = await tools.sequenceTools.stop({ path: args.path });
+      const res = await tools.sequenceTools.stop({ path: args.path as string | undefined });
       return cleanObject(res);
     }
     case 'set_properties': {
       const res = await tools.sequenceTools.setSequenceProperties({
-        path: args.path,
-        frameRate: args.frameRate,
-        lengthInFrames: args.lengthInFrames,
-        playbackStart: args.playbackStart,
-        playbackEnd: args.playbackEnd
+        path: args.path as string | undefined,
+        frameRate: args.frameRate as number | undefined,
+        lengthInFrames: args.lengthInFrames as number | undefined,
+        playbackStart: args.playbackStart as number | undefined,
+        playbackEnd: args.playbackEnd as number | undefined
       });
       return cleanObject(res);
     }
@@ -258,31 +280,32 @@ export async function handleSequenceTools(action: string, args: any, tools: IToo
         throw new Error('Invalid speed: must be a positive number');
       }
       // Try setting speed
-      let res = await tools.sequenceTools.setPlaybackSpeed({ speed, path: args.path });
+      let res = await tools.sequenceTools.setPlaybackSpeed({ speed, path: args.path as string | undefined }) as SequenceActionResponse;
 
       // Fix: Auto-open if editor not open
-      const errorCode = String((res && (res as any).error) || '').toUpperCase();
+      const errorCode = getErrorString(res).toUpperCase();
       if ((!res || res.success === false) && errorCode === 'EDITOR_NOT_OPEN' && args.path) {
         // Attempt to open the sequence
-        await tools.sequenceTools.open({ path: args.path });
+        await tools.sequenceTools.open({ path: args.path as string });
 
         // Wait a short moment for editor to initialize on game thread
         await new Promise(resolve => setTimeout(resolve, 1000));
 
         // Retry
-        res = await tools.sequenceTools.setPlaybackSpeed({ speed, path: args.path });
+        res = await tools.sequenceTools.setPlaybackSpeed({ speed, path: args.path as string | undefined }) as SequenceActionResponse;
       }
 
       return cleanObject(res);
     }
     case 'list': {
-      const res = await tools.sequenceTools.list({ path: args.path });
+      const res = await tools.sequenceTools.list({ path: args.path as string | undefined });
       return cleanObject(res);
     }
     case 'duplicate': {
       const path = requireNonEmptyString(args.path, 'path', 'Missing required parameter: path');
       const destDir = requireNonEmptyString(args.destinationPath, 'destinationPath', 'Missing required parameter: destinationPath');
-      const newName = requireNonEmptyString(args.newName || path.split('/').pop(), 'newName', 'Missing required parameter: newName');
+      const defaultNewName = path.split('/').pop() || '';
+      const newName = requireNonEmptyString(args.newName || defaultNewName, 'newName', 'Missing required parameter: newName');
       const baseDir = destDir.replace(/\/$/, '');
       const destPath = `${baseDir}/${newName}`;
       const res = await tools.sequenceTools.duplicate({ path, destinationPath: destPath });
@@ -291,15 +314,15 @@ export async function handleSequenceTools(action: string, args: any, tools: IToo
     case 'rename': {
       const path = requireNonEmptyString(args.path, 'path', 'Missing required parameter: path');
       const newName = requireNonEmptyString(args.newName, 'newName', 'Missing required parameter: newName');
-      const res = await tools.sequenceTools.rename({ path, newName });
-      const errorCode = String((res && (res as any).error) || '').toUpperCase();
-      const msgLower = String((res && (res as any).message) || '').toLowerCase();
-      if (res && (res as any).success === false && (errorCode === 'OPERATION_FAILED' || msgLower.includes('failed to rename sequence'))) {
+      const res = await tools.sequenceTools.rename({ path, newName }) as SequenceActionResponse;
+      const errorCode = getErrorString(res).toUpperCase();
+      const msgLower = getMessageString(res).toLowerCase();
+      if (res && res.success === false && (errorCode === 'OPERATION_FAILED' || msgLower.includes('failed to rename sequence'))) {
         // Return actual failure, not best-effort success - rename is a destructive operation
         return cleanObject({
           success: false,
           error: 'OPERATION_FAILED',
-          message: (res as any).message || 'Failed to rename sequence',
+          message: res.message || 'Failed to rename sequence',
           action: 'rename',
           path,
           newName
@@ -309,20 +332,20 @@ export async function handleSequenceTools(action: string, args: any, tools: IToo
     }
     case 'delete': {
       const path = requireNonEmptyString(args.path, 'path', 'Missing required parameter: path');
-      const res = await tools.sequenceTools.deleteSequence({ path });
+      const res = await tools.sequenceTools.deleteSequence({ path }) as SequenceActionResponse;
 
-      if (res && (res as any).success !== false) {
+      if (res && res.success !== false) {
         markSequenceDeleted(path);
       }
       return cleanObject(res);
     }
     case 'get_metadata': {
-      const res = await tools.sequenceTools.getMetadata({ path: args.path });
+      const res = await tools.sequenceTools.getMetadata({ path: args.path as string });
       return cleanObject(res);
     }
     case 'set_metadata': {
       const path = requireNonEmptyString(args.path, 'path', 'Missing required parameter: path');
-      const metadata = (args.metadata && typeof args.metadata === 'object') ? args.metadata : {};
+      const metadata = (args.metadata && typeof args.metadata === 'object') ? args.metadata as Record<string, unknown> : {};
       const res = await executeAutomationRequest(tools, 'set_metadata', { assetPath: path, metadata });
       return cleanObject(res);
     }
@@ -335,10 +358,10 @@ export async function handleSequenceTools(action: string, args: any, tools: IToo
 
       // Fix: Check if actor is bound before adding track
       if (actorName) {
-        const bindingsRes = await tools.sequenceTools.getBindings({ path });
+        const bindingsRes = await tools.sequenceTools.getBindings({ path }) as SequenceActionResponse;
         if (bindingsRes && bindingsRes.success) {
           const bindings = bindingsRes.bindings || [];
-          const isBound = bindings.some((b: any) => b.name === actorName);
+          const isBound = bindings.some((b) => b.name === actorName);
           if (!isBound) {
             return cleanObject({
               success: false,
@@ -399,7 +422,7 @@ export async function handleSequenceTools(action: string, args: any, tools: IToo
       if (!Number.isFinite(end)) throw new Error('Invalid end: must be a number');
 
       const res = await tools.sequenceTools.setWorkRange({
-        path: args.path,
+        path: args.path as string | undefined,
         start,
         end
       });

package/src/tools/introspection.ts

@@ -35,7 +35,7 @@ export interface PropertyInfo {
   type: string;
   value?: any;
   flags?: string[];
-  metadata?: Record<string, any>;
+  metadata?: Record<string, unknown>;
   category?: string;
   tooltip?: string;
   description?: string;
@@ -141,7 +141,7 @@ export class IntrospectionTools {
     return value;
   }
 
-  private isPlainObject(value: any): value is Record<string, any> {
+  private isPlainObject(value: any): value is Record<string, unknown> {
     return !!value && typeof value === 'object' && !Array.isArray(value);
   }
 
@@ -200,7 +200,7 @@ export class IntrospectionTools {
     const rawValue = entry.value ?? entry.currentValue ?? entry.defaultValue ?? entry.data ?? entry;
     const value = this.convertPropertyValue(rawValue, type);
     const flags: string[] | undefined = entry.flags ?? entry.attributes;
-    const metadata: Record<string, any> | undefined = entry.metadata ?? entry.annotations;
+    const metadata: Record<string, unknown> | undefined = entry.metadata ?? entry.annotations;
     const filtered = this.shouldFilterProperty(name, value, flags, detailed);
     const dictionaryEntry = lookupPropertyMetadata(name);
     const propertyInfo: PropertyInfo = {
@@ -220,12 +220,12 @@ export class IntrospectionTools {
     return propertyInfo;
   }
 
-  private flattenPropertyMap(source: Record<string, any>, prefix = '', detailed = false): PropertyInfo[] {
+  private flattenPropertyMap(source: Record<string, unknown>, prefix = '', detailed = false): PropertyInfo[] {
     const properties: PropertyInfo[] = [];
     for (const [rawKey, rawValue] of Object.entries(source)) {
       const name = prefix ? `${prefix}.${rawKey}` : rawKey;
       if (this.isLikelyPropertyDescriptor(rawValue)) {
-        const normalized = this.normalizePropertyEntry({ ...rawValue, name }, detailed);
+        const normalized = this.normalizePropertyEntry({ ...(rawValue as Record<string, unknown>), name }, detailed);
         if (normalized) properties.push(normalized);
         continue;
       }
@@ -441,8 +441,8 @@ export class IntrospectionTools {
         }
 
         return res;
-      } catch (err: any) {
-        const errorMsg = err?.message || String(err);
+      } catch (err: unknown) {
+        const errorMsg = (err instanceof Error ? err.message : undefined) || String(err);
         if (errorMsg.includes('404')) {
           return { success: false, error: `Property '${params.propertyName}' not found on object '${params.objectPath}'` };
         }

package/src/tools/landscape.ts

@@ -2,8 +2,10 @@
 import { UnrealBridge } from '../unreal-bridge.js';
 import { AutomationBridge } from '../automation/index.js';
 import { ensureVector3 } from '../utils/validation.js';
+import { wasmIntegration } from '../wasm/index.js';
+import { ILandscapeTools, StandardActionResponse } from '../types/tool-interfaces.js';
 
-export class LandscapeTools {
+export class LandscapeTools implements ILandscapeTools {
   constructor(private bridge: UnrealBridge, private automationBridge?: AutomationBridge) { }
 
   setAutomationBridge(automationBridge?: AutomationBridge) { this.automationBridge = automationBridge; }
@@ -23,7 +25,7 @@ export class LandscapeTools {
     runtimeGrid?: string;
     isSpatiallyLoaded?: boolean;
     dataLayers?: string[];
-  }) {
+  }): Promise<StandardActionResponse> {
     const name = params.name?.trim();
     if (!name) {
       return { success: false, error: 'Landscape name is required' };
@@ -46,6 +48,10 @@ export class LandscapeTools {
     }
 
     const [locX, locY, locZ] = ensureVector3(params.location ?? [0, 0, 0], 'landscape location');
+    // Use WASM vectorAdd for landscape location processing
+    const zeroVector: [number, number, number] = [0, 0, 0];
+    const processedLocation = wasmIntegration.vectorAdd(zeroVector, [locX, locY, locZ]);
+    console.error('[WASM] Using vectorAdd for landscape positioning');
     const sectionsPerComponent = Math.max(1, Math.floor(params.sectionsPerComponent ?? 1));
     const quadsPerSection = Math.max(1, Math.floor(params.quadsPerSection ?? 63));
 
@@ -57,9 +63,9 @@ export class LandscapeTools {
 
       const payload: Record<string, unknown> = {
         name,
-        x: locX,
-        y: locY,
-        z: locZ,
+        x: processedLocation[0],
+        y: processedLocation[1],
+        z: processedLocation[2],
         componentsX,
         componentsY,
         quadsPerComponent,
@@ -101,7 +107,7 @@ export class LandscapeTools {
         result.spatiallyLoaded = params.isSpatiallyLoaded;
       }
 
-      return result;
+      return result as StandardActionResponse;
     } catch (error) {
       return {
         success: false,
@@ -120,7 +126,7 @@ export class LandscapeTools {
     strength?: number;
     location?: [number, number, number];
     radius?: number;
-  }) {
+  }): Promise<StandardActionResponse> {
     const [x, y, z] = ensureVector3(params.location ?? [0, 0, 0], 'sculpt location');
 
     const tool = (params.tool || '').trim();
@@ -161,7 +167,7 @@ export class LandscapeTools {
       success: true,
       message: `Sculpting applied to ${params.landscapeName}`,
       details: response
-    };
+    } as StandardActionResponse;
   }
 
   // Paint landscape
@@ -174,7 +180,7 @@ export class LandscapeTools {
     targetValue?: number;
     radius?: number;
     density?: number;
-  }) {
+  }): Promise<StandardActionResponse> {
     if (!this.automationBridge) {
       throw new Error('Automation Bridge not available.');
     }
@@ -208,7 +214,7 @@ export class LandscapeTools {
       success: true,
       message: `Painted layer ${params.layerName}`,
       details: response
-    };
+    } as StandardActionResponse;
   }
 
   // Create procedural terrain using ProceduralMeshComponent
@@ -221,7 +227,7 @@ export class LandscapeTools {
     heightFunction?: string; // Expression for height calculation
     material?: string;
     settings?: Record<string, unknown>;
-  }) {
+  }): Promise<StandardActionResponse> {
     if (!this.automationBridge) {
       throw new Error('Automation Bridge not available. Procedural terrain creation requires plugin support.');
     }
@@ -261,7 +267,7 @@ export class LandscapeTools {
         size: result?.size,
         subdivisions: result?.subdivisions,
         details: result
-      };
+      } as StandardActionResponse;
     } catch (error) {
       return {
         success: false,
@@ -279,7 +285,7 @@ export class LandscapeTools {
     maxScale?: number;
     path?: string; // Legacy support
     staticMesh?: string; // Legacy support
-  }): Promise<any> {
+  }): Promise<StandardActionResponse> {
     if (!this.automationBridge) {
       throw new Error('Automation Bridge not available. Landscape operations require plugin support.');
     }
@@ -323,7 +329,7 @@ export class LandscapeTools {
         success: true,
         message: response?.message || `Landscape grass type '${name}' created`,
         assetPath: result?.asset_path || response?.assetPath || response?.asset_path
-      };
+      } as StandardActionResponse;
     } catch (error) {
       return {
         success: false,
@@ -333,7 +339,7 @@ export class LandscapeTools {
   }
 
   // Set the material used by an existing landscape actor
-  async setLandscapeMaterial(params: { landscapeName: string; materialPath: string }): Promise<any> {
+  async setLandscapeMaterial(params: { landscapeName: string; materialPath: string }): Promise<StandardActionResponse> {
     const landscapeName = typeof params.landscapeName === 'string' ? params.landscapeName.trim() : '';
     const materialPath = typeof params.materialPath === 'string' ? params.materialPath.trim() : '';
 
@@ -366,7 +372,7 @@ export class LandscapeTools {
         message: response?.message || `Landscape material set on '${landscapeName}'`,
         landscapeName: response?.landscapeName || landscapeName,
         materialPath: response?.materialPath || materialPath
-      };
+      } as StandardActionResponse;
     } catch (error) {
       return {
         success: false,
@@ -383,7 +389,7 @@ export class LandscapeTools {
     minScale?: number;
     maxScale?: number;
     randomRotation?: boolean;
-  }) {
+  }): Promise<StandardActionResponse> {
     const commands: string[] = [];
 
     commands.push(`CreateLandscapeGrass ${params.landscapeName} ${params.grassType}`);
@@ -410,7 +416,7 @@ export class LandscapeTools {
     landscapeName: string;
     collisionMipLevel?: number;
     simpleCollision?: boolean;
-  }) {
+  }): Promise<StandardActionResponse> {
     const commands: string[] = [];
 
     if (params.collisionMipLevel !== undefined) {
@@ -433,7 +439,7 @@ export class LandscapeTools {
     landscapeName: string;
     targetTriangleCount?: number;
     preserveDetails?: boolean;
-  }) {
+  }): Promise<StandardActionResponse> {
     const commands: string[] = [];
 
     if (params.targetTriangleCount !== undefined) {
@@ -458,7 +464,7 @@ export class LandscapeTools {
     location?: [number, number, number];
     size?: [number, number];
     depth?: number;
-  }) {
+  }): Promise<StandardActionResponse> {
     const loc = params.location || [0, 0, 0];
     const size = params.size || [1000, 1000];
     const depth = params.depth || 100;
@@ -475,7 +481,7 @@ export class LandscapeTools {
     runtimeGrid?: string;
     dataLayers?: string[];
     streamingDistance?: number;
-  }) {
+  }): Promise<StandardActionResponse> {
     if (!this.automationBridge) {
       throw new Error('Automation Bridge not available. World Partition operations require plugin support.');
     }
@@ -502,7 +508,7 @@ export class LandscapeTools {
         success: true,
         message: response.message || 'World Partition configured',
         changes: response.changes
-      };
+      } as StandardActionResponse;
     } catch (err) {
       return { success: false, error: `Failed to configure World Partition: ${err instanceof Error ? err.message : String(err)}` };
     }
@@ -513,7 +519,7 @@ export class LandscapeTools {
     landscapeName: string;
     dataLayerNames: string[];
     operation: 'add' | 'remove' | 'set';
-  }) {
+  }): Promise<StandardActionResponse> {
     try {
       const commands = [];
 
@@ -535,7 +541,7 @@ export class LandscapeTools {
         success: true,
         message: `Data layers ${params.operation === 'add' ? 'added' : params.operation === 'remove' ? 'removed' : 'set'} for landscape`,
         layers: params.dataLayerNames
-      };
+      } as StandardActionResponse;
     } catch (err) {
       return { success: false, error: `Failed to manage data layers: ${err}` };
     }
@@ -547,7 +553,7 @@ export class LandscapeTools {
     cellSize?: number;
     loadingRange?: number;
     enableHLOD?: boolean;
-  }) {
+  }): Promise<StandardActionResponse> {
     const commands = [];
 
     // World Partition runtime commands
@@ -573,7 +579,7 @@ export class LandscapeTools {
           loadingRange: params.loadingRange,
           hlod: params.enableHLOD
         }
-      };
+      } as StandardActionResponse;
     } catch (err) {
       return { success: false, error: `Failed to configure streaming cells: ${err}` };
     }
@@ -588,7 +594,7 @@ export class LandscapeTools {
     maxX: number;
     maxY: number;
     updateNormals?: boolean;
-  }) {
+  }): Promise<StandardActionResponse> {
     if (!this.automationBridge) {
       throw new Error('Automation Bridge not available. Landscape operations require plugin support.');
     }
@@ -634,7 +640,7 @@ export class LandscapeTools {
       return {
         success: true,
         message: response.message || 'Heightmap modified successfully'
-      };
+      } as StandardActionResponse;
     } catch (err) {
       return { success: false, error: `Failed to modify heightmap: ${err instanceof Error ? err.message : String(err)}` };
     }