unreal-engine-mcp-server 0.5.0 → 0.5.2

package/dist/tools/handlers/sequence-handlers.d.ts

@@ -1,3 +1,3 @@
 import { ITools } from '../../types/tool-interfaces.js';
-export declare function handleSequenceTools(action: string, args: any, tools: ITools): Promise<any>;
+export declare function handleSequenceTools(action: string, args: Record<string, unknown>, tools: ITools): Promise<any>;
 //# sourceMappingURL=sequence-handlers.d.ts.map

package/dist/tools/handlers/sequence-handlers.js

@@ -20,7 +20,17 @@ function markSequenceDeleted(path) {
     if (!norm)
         return;
     managedSequences.delete(norm);
-    deletedSequences.add(norm);
+    deletedSequences.delete(norm);
+}
+function getErrorString(res) {
+    if (!res)
+        return '';
+    return typeof res.error === 'string' ? res.error : '';
+}
+function getMessageString(res) {
+    if (!res)
+        return '';
+    return typeof res.message === 'string' ? res.message : '';
 }
 export async function handleSequenceTools(action, args, tools) {
     const seqAction = String(action || '').trim();
@@ -39,8 +49,8 @@ export async function handleSequenceTools(action, args, tools) {
             if (sequencePath && res && res.success !== false) {
                 markSequenceCreated(sequencePath);
             }
-            const errorCode = String((res && res.error) || '').toUpperCase();
-            const msgLower = String((res && res.message) || '').toLowerCase();
+            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({
@@ -75,8 +85,8 @@ export async function handleSequenceTools(action, args, tools) {
                 subAction: 'add_actor'
             };
             const res = await executeAutomationRequest(tools, 'manage_sequence', payload);
-            const errorCode = String((res && res.error) || '').toUpperCase();
-            const msgLower = String((res && res.message) || '').toLowerCase();
+            const errorCode = getErrorString(res).toUpperCase();
+            const msgLower = getMessageString(res).toLowerCase();
             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) {
@@ -114,8 +124,8 @@ export async function handleSequenceTools(action, args, tools) {
         case 'add_actors': {
             const actorNames = Array.isArray(args.actorNames) ? args.actorNames : [];
             const res = await tools.sequenceTools.addActors({ actorNames, path: args.path });
-            const errorCode = String((res && res.error) || '').toUpperCase();
-            const msgLower = String((res && res.message) || '').toLowerCase();
+            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,
@@ -172,8 +182,8 @@ export async function handleSequenceTools(action, args, tools) {
                 payload.value = { scale: args.value };
             }
             const res = await executeAutomationRequest(tools, 'manage_sequence', payload);
-            const errorCode = String((res && res.error) || '').toUpperCase();
-            const msgLower = String((res && res.message) || '').toLowerCase();
+            const errorCode = getErrorString(res).toUpperCase();
+            const msgLower = getMessageString(res).toLowerCase();
             if (errorCode === 'INVALID_ARGUMENT' || msgLower.includes('frame number is required')) {
                 return cleanObject(res);
             }
@@ -237,7 +247,7 @@ export async function handleSequenceTools(action, args, tools) {
                 throw new Error('Invalid speed: must be a positive number');
             }
             let res = await tools.sequenceTools.setPlaybackSpeed({ speed, path: args.path });
-            const errorCode = String((res && res.error) || '').toUpperCase();
+            const errorCode = getErrorString(res).toUpperCase();
             if ((!res || res.success === false) && errorCode === 'EDITOR_NOT_OPEN' && args.path) {
                 await tools.sequenceTools.open({ path: args.path });
                 await new Promise(resolve => setTimeout(resolve, 1000));
@@ -252,7 +262,8 @@ export async function handleSequenceTools(action, args, tools) {
         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 });
@@ -262,8 +273,8 @@ export async function handleSequenceTools(action, args, tools) {
             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.error) || '').toUpperCase();
-            const msgLower = String((res && res.message) || '').toLowerCase();
+            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 cleanObject({
                     success: false,

package/dist/tools/introspection.d.ts

@@ -31,7 +31,7 @@ export interface PropertyInfo {
     type: string;
     value?: any;
     flags?: string[];
-    metadata?: Record<string, any>;
+    metadata?: Record<string, unknown>;
     category?: string;
     tooltip?: string;
     description?: string;

package/dist/tools/introspection.js

@@ -339,7 +339,7 @@ export class IntrospectionTools {
                 return res;
             }
             catch (err) {
-                const errorMsg = err?.message || String(err);
+                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/dist/tools/landscape.d.ts

@@ -1,6 +1,7 @@
 import { UnrealBridge } from '../unreal-bridge.js';
 import { AutomationBridge } from '../automation/index.js';
-export declare class LandscapeTools {
+import { ILandscapeTools, StandardActionResponse } from '../types/tool-interfaces.js';
+export declare class LandscapeTools implements ILandscapeTools {
     private bridge;
     private automationBridge?;
     constructor(bridge: UnrealBridge, automationBridge?: AutomationBridge | undefined);
@@ -18,7 +19,7 @@ export declare class LandscapeTools {
         runtimeGrid?: string;
         isSpatiallyLoaded?: boolean;
         dataLayers?: string[];
-    }): Promise<Record<string, unknown>>;
+    }): Promise<StandardActionResponse>;
     sculptLandscape(params: {
         landscapeName: string;
         tool: string;
@@ -27,17 +28,7 @@ export declare class LandscapeTools {
         strength?: number;
         location?: [number, number, number];
         radius?: number;
-    }): Promise<{
-        success: boolean;
-        error: string;
-        message?: undefined;
-        details?: undefined;
-    } | {
-        success: boolean;
-        message: string;
-        details: import("../automation/types.js").AutomationBridgeResponseMessage;
-        error?: undefined;
-    }>;
+    }): Promise<StandardActionResponse>;
     paintLandscape(params: {
         landscapeName: string;
         layerName: string;
@@ -47,17 +38,7 @@ export declare class LandscapeTools {
         targetValue?: number;
         radius?: number;
         density?: number;
-    }): Promise<{
-        success: boolean;
-        error: string;
-        message?: undefined;
-        details?: undefined;
-    } | {
-        success: boolean;
-        message: string;
-        details: import("../automation/types.js").AutomationBridgeResponseMessage;
-        error?: undefined;
-    }>;
+    }): Promise<StandardActionResponse>;
     createProceduralTerrain(params: {
         name: string;
         location?: [number, number, number];
@@ -67,37 +48,7 @@ export declare class LandscapeTools {
         heightFunction?: string;
         material?: string;
         settings?: Record<string, unknown>;
-    }): Promise<{
-        success: boolean;
-        error: string;
-        message: string;
-        actorName?: undefined;
-        vertices?: undefined;
-        triangles?: undefined;
-        size?: undefined;
-        subdivisions?: undefined;
-        details?: undefined;
-    } | {
-        success: boolean;
-        message: string;
-        actorName: any;
-        vertices: any;
-        triangles: any;
-        size: any;
-        subdivisions: any;
-        details: any;
-        error?: undefined;
-    } | {
-        success: boolean;
-        error: string;
-        message?: undefined;
-        actorName?: undefined;
-        vertices?: undefined;
-        triangles?: undefined;
-        size?: undefined;
-        subdivisions?: undefined;
-        details?: undefined;
-    }>;
+    }): Promise<StandardActionResponse>;
     createLandscapeGrassType(params: {
         name: string;
         meshPath: string;
@@ -106,11 +57,11 @@ export declare class LandscapeTools {
         maxScale?: number;
         path?: string;
         staticMesh?: string;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
     setLandscapeMaterial(params: {
         landscapeName: string;
         materialPath: string;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
     createLandscapeGrass(params: {
         landscapeName: string;
         grassType: string;
@@ -118,85 +69,42 @@ export declare class LandscapeTools {
         minScale?: number;
         maxScale?: number;
         randomRotation?: boolean;
-    }): Promise<{
-        success: boolean;
-        message: string;
-    }>;
+    }): Promise<StandardActionResponse>;
     updateLandscapeCollision(params: {
         landscapeName: string;
         collisionMipLevel?: number;
         simpleCollision?: boolean;
-    }): Promise<{
-        success: boolean;
-        message: string;
-    }>;
+    }): Promise<StandardActionResponse>;
     retopologizeLandscape(params: {
         landscapeName: string;
         targetTriangleCount?: number;
         preserveDetails?: boolean;
-    }): Promise<{
-        success: boolean;
-        message: string;
-    }>;
+    }): Promise<StandardActionResponse>;
     createWaterBody(params: {
         type: 'Ocean' | 'Lake' | 'River' | 'Stream';
         name: string;
         location?: [number, number, number];
         size?: [number, number];
         depth?: number;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
     configureWorldPartition(params: {
         landscapeName: string;
         enableSpatialLoading?: boolean;
         runtimeGrid?: string;
         dataLayers?: string[];
         streamingDistance?: number;
-    }): Promise<{
-        success: boolean;
-        error: string;
-        message?: undefined;
-        changes?: undefined;
-    } | {
-        success: boolean;
-        message: string;
-        changes: unknown;
-        error?: undefined;
-    }>;
+    }): Promise<StandardActionResponse>;
     setDataLayers(params: {
         landscapeName: string;
         dataLayerNames: string[];
         operation: 'add' | 'remove' | 'set';
-    }): Promise<{
-        success: boolean;
-        message: string;
-        layers: string[];
-        error?: undefined;
-    } | {
-        success: boolean;
-        error: string;
-        message?: undefined;
-        layers?: undefined;
-    }>;
+    }): Promise<StandardActionResponse>;
     configureStreamingCells(params: {
         landscapeName: string;
         cellSize?: number;
         loadingRange?: number;
         enableHLOD?: boolean;
-    }): Promise<{
-        success: boolean;
-        message: string;
-        settings: {
-            cellSize: number | undefined;
-            loadingRange: number | undefined;
-            hlod: boolean | undefined;
-        };
-        error?: undefined;
-    } | {
-        success: boolean;
-        error: string;
-        message?: undefined;
-        settings?: undefined;
-    }>;
+    }): Promise<StandardActionResponse>;
     modifyHeightmap(params: {
         landscapeName: string;
         heightData: number[];
@@ -205,14 +113,6 @@ export declare class LandscapeTools {
         maxX: number;
         maxY: number;
         updateNormals?: boolean;
-    }): Promise<{
-        success: boolean;
-        error: string;
-        message?: undefined;
-    } | {
-        success: boolean;
-        message: string;
-        error?: undefined;
-    }>;
+    }): Promise<StandardActionResponse>;
 }
 //# sourceMappingURL=landscape.d.ts.map

package/dist/tools/landscape.js

@@ -1,4 +1,5 @@
 import { ensureVector3 } from '../utils/validation.js';
+import { wasmIntegration } from '../wasm/index.js';
 export class LandscapeTools {
     bridge;
     automationBridge;
@@ -28,6 +29,9 @@ export class LandscapeTools {
             throw new Error('Automation Bridge not available. Landscape operations require plugin support.');
         }
         const [locX, locY, locZ] = ensureVector3(params.location ?? [0, 0, 0], 'landscape location');
+        const zeroVector = [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));
         try {
@@ -36,9 +40,9 @@ export class LandscapeTools {
             const quadsPerComponent = quadsPerSection;
             const payload = {
                 name,
-                x: locX,
-                y: locY,
-                z: locZ,
+                x: processedLocation[0],
+                y: processedLocation[1],
+                z: processedLocation[2],
                 componentsX,
                 componentsY,
                 quadsPerComponent,

package/dist/tools/level.d.ts

@@ -1,5 +1,5 @@
 import { BaseTool } from './base-tool.js';
-import { ILevelTools } from '../types/tool-interfaces.js';
+import { ILevelTools, StandardActionResponse } from '../types/tool-interfaces.js';
 export declare class LevelTools extends BaseTool implements ILevelTools {
     private managedLevels;
     private listCache?;
@@ -15,13 +15,8 @@ export declare class LevelTools extends BaseTool implements ILevelTools {
     private listManagedLevels;
     private summarizeLevel;
     private setCurrentLevel;
-    listLevels(): Promise<Record<string, unknown> | {
-        success: true;
-        message: string;
-        count: number;
-        levels: Array<Record<string, unknown>>;
-    }>;
-    getLevelSummary(levelPath?: string): Promise<Record<string, unknown>>;
+    listLevels(): Promise<StandardActionResponse>;
+    getLevelSummary(levelPath?: string): Promise<StandardActionResponse>;
     registerLight(levelPath: string | undefined, info: {
         name: string;
         type: string;
@@ -32,122 +27,52 @@ export declare class LevelTools extends BaseTool implements ILevelTools {
         exportPath: string;
         note?: string;
         timeoutMs?: number;
-    }): Promise<{
-        success: boolean;
-        error: string;
-        levelPath?: undefined;
-        exportPath?: undefined;
-        details?: undefined;
-        message?: undefined;
-    } | {
-        success: boolean;
-        error: any;
-        levelPath: string;
-        exportPath: string;
-        details: any;
-        message?: undefined;
-    } | {
-        success: boolean;
-        message: string;
-        levelPath: string;
-        exportPath: string;
-        details: any;
-        error?: undefined;
-    }>;
+    }): Promise<StandardActionResponse>;
     importLevel(params: {
         packagePath: string;
         destinationPath?: string;
         streaming?: boolean;
         timeoutMs?: number;
-    }): Promise<{
-        success: boolean;
-        error: any;
-        levelPath: string;
-        details: any;
-        message?: undefined;
-        partitioned?: undefined;
-        streaming?: undefined;
-    } | {
-        success: boolean;
-        message: string;
-        levelPath: string;
-        partitioned: boolean;
-        streaming: boolean;
-        details: any;
-        error?: undefined;
-    } | {
-        success: boolean;
-        error: string;
-        levelPath?: undefined;
-        details?: undefined;
-        message?: undefined;
-        partitioned?: undefined;
-        streaming?: undefined;
-    }>;
+    }): Promise<StandardActionResponse>;
     saveLevelAs(params: {
         sourcePath?: string;
         targetPath: string;
-    }): Promise<{
-        success: boolean;
-        error: any;
-        message?: undefined;
-        levelPath?: undefined;
-    } | {
-        success: boolean;
-        message: any;
-        levelPath: string;
-        error?: undefined;
-    }>;
+    }): Promise<StandardActionResponse>;
     deleteLevels(params: {
         levelPaths: string[];
-    }): Promise<{
-        success: boolean;
-        message: string;
-        removed: string[];
-    }>;
+    }): Promise<StandardActionResponse>;
     loadLevel(params: {
         levelPath: string;
         streaming?: boolean;
         position?: [number, number, number];
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
     saveLevel(params: {
         levelName?: string;
         savePath?: string;
-    }): Promise<Record<string, unknown> | {
-        success: boolean;
-        error: any;
-    }>;
+    }): Promise<StandardActionResponse>;
     createLevel(params: {
         levelName: string;
         template?: 'Empty' | 'Default' | 'VR' | 'TimeOfDay';
         savePath?: string;
-    }): Promise<Record<string, unknown> | {
-        success: boolean;
-        error: any;
-        path: string;
-        partitioned: boolean;
-    }>;
+    }): Promise<StandardActionResponse>;
     addSubLevel(params: {
         parentLevel?: string;
         subLevelPath: string;
         streamingMethod?: 'Blueprint' | 'AlwaysLoaded';
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
     streamLevel(params: {
         levelPath?: string;
         levelName?: string;
         shouldBeLoaded: boolean;
         shouldBeVisible?: boolean;
         position?: [number, number, number];
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
     setupWorldComposition(params: {
         enableComposition: boolean;
         tileSize?: number;
         distanceStreaming?: boolean;
         streamingDistance?: number;
-    }): Promise<{
-        success: boolean;
-        message: string;
-    }>;
+    }): Promise<StandardActionResponse>;
     editLevelBlueprint(params: {
         eventType: 'BeginPlay' | 'EndPlay' | 'Tick' | 'Custom';
         customEventName?: string;
@@ -156,50 +81,44 @@ export declare class LevelTools extends BaseTool implements ILevelTools {
             position: [number, number];
             connections?: string[];
         }>;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
     createSubLevel(params: {
         name: string;
         type: 'Persistent' | 'Streaming' | 'Lighting' | 'Gameplay';
         parent?: string;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
     setWorldSettings(params: {
         gravity?: number;
         worldScale?: number;
         gameMode?: string;
         defaultPawn?: string;
         killZ?: number;
-    }): Promise<{
-        success: boolean;
-        message: string;
-    }>;
+    }): Promise<StandardActionResponse>;
     setLevelBounds(params: {
         min: [number, number, number];
         max: [number, number, number];
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
     buildNavMesh(params: {
         rebuildAll?: boolean;
         selectedOnly?: boolean;
-    }): Promise<Record<string, unknown> | {
-        success: boolean;
-        error: any;
-    }>;
+    }): Promise<StandardActionResponse>;
     setLevelVisibility(params: {
         levelName: string;
         visible: boolean;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
     setWorldOrigin(params: {
         location: [number, number, number];
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
     createStreamingVolume(params: {
         levelName: string;
         position: [number, number, number];
         size: [number, number, number];
         streamingDistance?: number;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
     setLevelLOD(params: {
         levelName: string;
         lodLevel: number;
         distance: number;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
 }
 //# sourceMappingURL=level.d.ts.map