unreal-engine-mcp-server 0.5.0 → 0.5.2

package/dist/tools/consolidated-tool-handlers.js

@@ -1,6 +1,7 @@
 import { cleanObject } from '../utils/safe-json.js';
 import { Logger } from '../utils/logger.js';
 import { ResponseFactory } from '../utils/response-factory.js';
+import { toolRegistry } from './dynamic-handler-registry.js';
 import { executeAutomationRequest, requireAction } from './handlers/common-handlers.js';
 import { handleAssetTools } from './handlers/asset-handlers.js';
 import { handleActorTools } from './handlers/actor-handlers.js';
@@ -19,8 +20,6 @@ import { handleAudioTools } from './handlers/audio-handlers.js';
 import { handleLightingTools } from './handlers/lighting-handlers.js';
 import { handlePerformanceTools } from './handlers/performance-handlers.js';
 import { handleInputTools } from './handlers/input-handlers.js';
-import { getDynamicHandlerForTool } from './dynamic-handler-registry.js';
-import { consolidatedToolDefinitions } from './consolidated-tool-definitions.js';
 const MATERIAL_GRAPH_ACTION_MAP = {
     add_material_node: 'add_node',
     connect_material_pins: 'connect_pins',
@@ -92,105 +91,103 @@ function normalizeToolCall(name, args) {
         args
     };
 }
-async function invokeNamedTool(name, action, args, tools) {
-    switch (name) {
-        case 'manage_asset': {
-            if (['create_render_target', 'nanite_rebuild_mesh'].includes(action)) {
-                const payload = { ...args, subAction: action };
-                return cleanObject(await executeAutomationRequest(tools, 'manage_render', payload, `Automation bridge not available for ${action}`));
-            }
-            if (isMaterialGraphAction(action)) {
-                const subAction = MATERIAL_GRAPH_ACTION_MAP[action] || action;
-                return await handleGraphTools('manage_material_graph', subAction, args, tools);
-            }
-            if (isBehaviorTreeGraphAction(action)) {
-                const subAction = BEHAVIOR_TREE_ACTION_MAP[action] || action;
-                return await handleGraphTools('manage_behavior_tree', subAction, args, tools);
-            }
-            return await handleAssetTools(action, args, tools);
+function registerDefaultHandlers() {
+    toolRegistry.register('manage_asset', async (args, tools) => {
+        const action = args.subAction || args.action || requireAction(args);
+        if (['create_render_target', 'nanite_rebuild_mesh'].includes(action)) {
+            const payload = { ...args, subAction: action };
+            return cleanObject(await executeAutomationRequest(tools, 'manage_render', payload, `Automation bridge not available for ${action}`));
         }
-        case 'manage_blueprint': {
-            if (action === 'get_blueprint') {
-                return await handleBlueprintGet(args, tools);
-            }
-            const graphActions = ['create_node', 'delete_node', 'connect_pins', 'break_pin_links', 'set_node_property', 'create_reroute_node', 'get_node_details', 'get_graph_details', 'get_pin_details'];
-            if (graphActions.includes(action)) {
-                return await handleGraphTools('manage_blueprint_graph', action, args, tools);
-            }
-            return await handleBlueprintTools(action, args, tools);
+        if (isMaterialGraphAction(action)) {
+            const subAction = MATERIAL_GRAPH_ACTION_MAP[action] || action;
+            return await handleGraphTools('manage_material_graph', subAction, args, tools);
         }
-        case 'control_actor':
-            return await handleActorTools(action, args, tools);
-        case 'control_editor': {
-            if (action === 'simulate_input') {
-                const payload = { ...args, subAction: action };
-                return cleanObject(await executeAutomationRequest(tools, 'manage_ui', payload, 'Automation bridge not available'));
-            }
-            return await handleEditorTools(action, args, tools);
+        if (isBehaviorTreeGraphAction(action)) {
+            const subAction = BEHAVIOR_TREE_ACTION_MAP[action] || action;
+            return await handleGraphTools('manage_behavior_tree', subAction, args, tools);
         }
-        case 'manage_level': {
-            if (['load_cells', 'set_datalayer'].includes(action)) {
-                const payload = { ...args, subAction: action };
-                return cleanObject(await executeAutomationRequest(tools, 'manage_world_partition', payload, 'Automation bridge not available'));
-            }
-            return await handleLevelTools(action, args, tools);
+        return await handleAssetTools(action, args, tools);
+    });
+    toolRegistry.register('manage_blueprint', async (args, tools) => {
+        const action = args.action || requireAction(args);
+        if (action === 'get_blueprint') {
+            return await handleBlueprintGet(args, tools);
         }
-        case 'animation_physics':
-            return await handleAnimationTools(action, args, tools);
-        case 'manage_effect': {
-            if (isNiagaraGraphAction(action)) {
-                const isInstanceOp = action === 'set_niagara_parameter' && (args.actorName || (args.systemName && !args.assetPath && !args.systemPath));
-                if (isInstanceOp) {
-                    return await handleEffectTools(action, args, tools);
-                }
-                const subAction = NIAGARA_GRAPH_ACTION_MAP[action] || action;
-                return await handleGraphTools('manage_niagara_graph', subAction, args, tools);
-            }
-            return await handleEffectTools(action, args, tools);
+        const graphActions = ['create_node', 'delete_node', 'connect_pins', 'break_pin_links', 'set_node_property', 'create_reroute_node', 'get_node_details', 'get_graph_details', 'get_pin_details'];
+        if (graphActions.includes(action)) {
+            return await handleGraphTools('manage_blueprint_graph', action, args, tools);
         }
-        case 'build_environment':
-            return await handleEnvironmentTools(action, args, tools);
-        case 'system_control': {
-            if (action === 'console_command')
-                return await handleConsoleCommand(args, tools);
-            if (action === 'run_ubt')
-                return await handlePipelineTools(action, args, tools);
-            if (action === 'run_tests')
-                return cleanObject(await executeAutomationRequest(tools, 'manage_tests', { ...args, subAction: action }, 'Bridge unavailable'));
-            if (action === 'subscribe' || action === 'unsubscribe')
-                return cleanObject(await executeAutomationRequest(tools, 'manage_logs', { ...args, subAction: action }, 'Bridge unavailable'));
-            if (action === 'spawn_category')
-                return cleanObject(await executeAutomationRequest(tools, 'manage_debug', { ...args, subAction: action }, 'Bridge unavailable'));
-            if (action === 'start_session')
-                return cleanObject(await executeAutomationRequest(tools, 'manage_insights', { ...args, subAction: action }, 'Bridge unavailable'));
-            if (action === 'lumen_update_scene')
-                return cleanObject(await executeAutomationRequest(tools, 'manage_render', { ...args, subAction: action }, 'Bridge unavailable'));
-            return await handleSystemTools(action, args, tools);
+        return await handleBlueprintTools(action, args, tools);
+    });
+    toolRegistry.register('control_actor', async (args, tools) => {
+        return await handleActorTools(args.action || requireAction(args), args, tools);
+    });
+    toolRegistry.register('control_editor', async (args, tools) => {
+        const action = args.action || requireAction(args);
+        if (action === 'simulate_input') {
+            const payload = { ...args, subAction: action };
+            return cleanObject(await executeAutomationRequest(tools, 'manage_ui', payload, 'Automation bridge not available'));
         }
-        case 'manage_sequence':
-            return await handleSequenceTools(action, args, tools);
-        case 'inspect':
-            return await handleInspectTools(action, args, tools);
-        case 'manage_audio':
-            return await handleAudioTools(action, args, tools);
-        case 'manage_behavior_tree':
-            return await handleGraphTools('manage_behavior_tree', action, args, tools);
-        case 'manage_blueprint_graph':
-            return await handleGraphTools('manage_blueprint_graph', action, args, tools);
-        case 'manage_render':
+        return await handleEditorTools(action, args, tools);
+    });
+    toolRegistry.register('manage_level', async (args, tools) => {
+        const action = args.action || requireAction(args);
+        if (['load_cells', 'set_datalayer'].includes(action)) {
+            const payload = { ...args, subAction: action };
+            return cleanObject(await executeAutomationRequest(tools, 'manage_world_partition', payload, 'Automation bridge not available'));
+        }
+        return await handleLevelTools(action, args, tools);
+    });
+    toolRegistry.register('animation_physics', async (args, tools) => await handleAnimationTools(args.action || requireAction(args), args, tools));
+    toolRegistry.register('manage_effect', async (args, tools) => {
+        const action = args.action || requireAction(args);
+        if (isNiagaraGraphAction(action)) {
+            const isInstanceOp = action === 'set_niagara_parameter' && (args.actorName || (args.systemName && !args.assetPath && !args.systemPath));
+            if (isInstanceOp) {
+                return await handleEffectTools(action, args, tools);
+            }
+            const subAction = NIAGARA_GRAPH_ACTION_MAP[action] || action;
+            return await handleGraphTools('manage_niagara_graph', subAction, args, tools);
+        }
+        return await handleEffectTools(action, args, tools);
+    });
+    toolRegistry.register('build_environment', async (args, tools) => await handleEnvironmentTools(args.action || requireAction(args), args, tools));
+    toolRegistry.register('system_control', async (args, tools) => {
+        const action = args.action || requireAction(args);
+        if (action === 'console_command')
+            return await handleConsoleCommand(args, tools);
+        if (action === 'run_ubt')
+            return await handlePipelineTools(action, args, tools);
+        if (action === 'run_tests')
+            return cleanObject(await executeAutomationRequest(tools, 'manage_tests', { ...args, subAction: action }, 'Bridge unavailable'));
+        if (action === 'subscribe' || action === 'unsubscribe')
+            return cleanObject(await executeAutomationRequest(tools, 'manage_logs', { ...args, subAction: action }, 'Bridge unavailable'));
+        if (action === 'spawn_category')
+            return cleanObject(await executeAutomationRequest(tools, 'manage_debug', { ...args, subAction: action }, 'Bridge unavailable'));
+        if (action === 'start_session')
+            return cleanObject(await executeAutomationRequest(tools, 'manage_insights', { ...args, subAction: action }, 'Bridge unavailable'));
+        if (action === 'lumen_update_scene')
             return cleanObject(await executeAutomationRequest(tools, 'manage_render', { ...args, subAction: action }, 'Bridge unavailable'));
-        case 'manage_world_partition':
-            return cleanObject(await executeAutomationRequest(tools, 'manage_world_partition', { ...args, subAction: action }, 'Bridge unavailable'));
-        case 'manage_lighting':
-            return await handleLightingTools(action, args, tools);
-        case 'manage_performance':
-            return await handlePerformanceTools(action, args, tools);
-        case 'manage_input':
-            return await handleInputTools(action, args, tools);
-        default:
-            return cleanObject({ success: false, error: 'UNKNOWN_TOOL', message: `Unknown consolidated tool: ${name}` });
-    }
+        return await handleSystemTools(action, args, tools);
+    });
+    toolRegistry.register('manage_sequence', async (args, tools) => await handleSequenceTools(args.action || requireAction(args), args, tools));
+    toolRegistry.register('inspect', async (args, tools) => await handleInspectTools(args.action || requireAction(args), args, tools));
+    toolRegistry.register('manage_audio', async (args, tools) => await handleAudioTools(args.action || requireAction(args), args, tools));
+    toolRegistry.register('manage_behavior_tree', async (args, tools) => await handleGraphTools('manage_behavior_tree', args.action || requireAction(args), args, tools));
+    toolRegistry.register('manage_blueprint_graph', async (args, tools) => await handleGraphTools('manage_blueprint_graph', args.action || requireAction(args), args, tools));
+    toolRegistry.register('manage_render', async (args, tools) => {
+        const action = args.action || requireAction(args);
+        return cleanObject(await executeAutomationRequest(tools, 'manage_render', { ...args, subAction: action }, 'Bridge unavailable'));
+    });
+    toolRegistry.register('manage_world_partition', async (args, tools) => {
+        const action = args.action || requireAction(args);
+        return cleanObject(await executeAutomationRequest(tools, 'manage_world_partition', { ...args, subAction: action }, 'Bridge unavailable'));
+    });
+    toolRegistry.register('manage_lighting', async (args, tools) => await handleLightingTools(args.action || requireAction(args), args, tools));
+    toolRegistry.register('manage_performance', async (args, tools) => await handlePerformanceTools(args.action || requireAction(args), args, tools));
+    toolRegistry.register('manage_input', async (args, tools) => await handleInputTools(args.action || requireAction(args), args, tools));
 }
+registerDefaultHandlers();
 export async function handleConsolidatedToolCall(name, args, tools) {
     const logger = new Logger('ConsolidatedToolHandler');
     const startTime = Date.now();
@@ -198,26 +195,15 @@ export async function handleConsolidatedToolCall(name, args, tools) {
     try {
         const normalized = normalizeToolCall(name, args);
         const normalizedName = normalized.name;
-        const action = normalized.action;
         const normalizedArgs = normalized.args;
-        const toolDef = consolidatedToolDefinitions.find(t => t.name === normalizedName);
-        const dynamicHandler = await getDynamicHandlerForTool(normalizedName, action);
-        if (!dynamicHandler && toolDef && toolDef.inputSchema && toolDef.inputSchema.properties && toolDef.inputSchema.properties.action) {
-            const actionProp = toolDef.inputSchema.properties.action;
-            const allowed = Array.isArray(actionProp.enum) ? actionProp.enum : undefined;
-            if (allowed && !allowed.includes(action)) {
-                return cleanObject({
-                    success: false,
-                    error: 'UNKNOWN_ACTION',
-                    message: `Unknown action '${action}' for consolidated tool '${normalizedName}'.`
-                });
-            }
+        if (normalized.action && !normalizedArgs.action) {
+            normalizedArgs.action = normalized.action;
         }
-        const defaultHandler = async () => invokeNamedTool(normalizedName, action, normalizedArgs, tools);
-        if (dynamicHandler) {
-            return await dynamicHandler({ name: normalizedName, action, args: normalizedArgs, tools, defaultHandler });
+        const handler = toolRegistry.getHandler(normalizedName);
+        if (handler) {
+            return await handler(normalizedArgs, tools);
         }
-        return await defaultHandler();
+        return cleanObject({ success: false, error: 'UNKNOWN_TOOL', message: `Unknown consolidated tool: ${name}` });
     }
     catch (err) {
         const duration = Date.now() - startTime;

package/dist/tools/dynamic-handler-registry.d.ts

@@ -1,11 +1,13 @@
-import type { ITools } from '../types/tool-interfaces.js';
-export interface DynamicHandlerContext {
-    name: string;
-    action: string;
-    args: any;
-    tools: ITools;
-    defaultHandler: () => Promise<any>;
+import { ITools } from '../types/tool-interfaces.js';
+type ToolHandler = (args: any, tools: ITools) => Promise<any>;
+export declare class DynamicHandlerRegistry {
+    private handlers;
+    register(toolName: string, handler: ToolHandler): void;
+    getHandler(toolName: string): ToolHandler | undefined;
+    hasHandler(toolName: string): boolean;
+    removeHandler(toolName: string): boolean;
+    getAllRegisteredTools(): string[];
 }
-export type DynamicHandlerFn = (ctx: DynamicHandlerContext) => Promise<any>;
-export declare function getDynamicHandlerForTool(toolName: string, action?: string): Promise<DynamicHandlerFn | null>;
+export declare const toolRegistry: DynamicHandlerRegistry;
+export {};
 //# sourceMappingURL=dynamic-handler-registry.d.ts.map

package/dist/tools/dynamic-handler-registry.js

@@ -1,101 +1,23 @@
-import { Logger } from '../utils/logger.js';
-import fs from 'fs/promises';
-import path from 'node:path';
-import { pathToFileURL } from 'node:url';
-const log = new Logger('DynamicHandlerRegistry');
-let registryLoaded = false;
-const loadedHandlers = [];
-async function loadRegistryIfNeeded() {
-    if (registryLoaded)
-        return;
-    registryLoaded = true;
-    const rootUrl = new URL('../..', import.meta.url);
-    const envPath = (process.env.MCP_HANDLER_REGISTRY || '').trim();
-    let configUrl = null;
-    try {
-        if (envPath) {
-            if (envPath.startsWith('file:')) {
-                configUrl = new URL(envPath);
-            }
-            else if (path.isAbsolute(envPath)) {
-                configUrl = pathToFileURL(envPath);
-            }
-            else {
-                configUrl = new URL(envPath, rootUrl);
-            }
-        }
-        else {
-            configUrl = new URL('handler-registry.json', rootUrl);
-        }
-        let jsonText;
-        try {
-            jsonText = await fs.readFile(configUrl, 'utf8');
-        }
-        catch (err) {
-            if (err && (err.code === 'ENOENT' || err.code === 'ERR_MODULE_NOT_FOUND')) {
-                log.debug(`Handler registry not found at ${configUrl.href}; dynamic handlers disabled.`);
-                return;
-            }
-            log.warn(`Failed to read handler registry from ${configUrl.href}:`, err);
-            return;
-        }
-        let raw;
-        try {
-            raw = JSON.parse(jsonText);
-        }
-        catch (err) {
-            log.warn(`Invalid JSON in handler registry at ${configUrl.href}:`, err);
-            return;
-        }
-        if (!raw.handlers || !Array.isArray(raw.handlers)) {
-            log.debug('Handler registry contains no handlers.');
-            return;
-        }
-        for (const entry of raw.handlers) {
-            if (!entry || typeof entry.tool !== 'string' || typeof entry.module !== 'string') {
-                continue;
-            }
-            try {
-                const modUrl = new URL(entry.module, rootUrl);
-                const mod = await import(modUrl.href);
-                const exportName = entry.function && entry.function.trim().length > 0
-                    ? entry.function.trim()
-                    : 'default';
-                const fnExport = mod[exportName];
-                if (typeof fnExport !== 'function') {
-                    log.warn(`Dynamic handler module ${modUrl.href} for tool '${entry.tool}' does not export a callable '${exportName}'.`);
-                    continue;
-                }
-                const wrapped = fnExport;
-                loadedHandlers.push({
-                    tool: entry.tool,
-                    actions: Array.isArray(entry.actions) ? entry.actions.slice() : undefined,
-                    fn: wrapped
-                });
-                log.info(`Registered dynamic handler for tool '${entry.tool}' from ${modUrl.href}`);
-            }
-            catch (err) {
-                log.warn(`Failed to load dynamic handler for tool '${entry.tool}' from module spec '${entry.module}':`, err);
-            }
+export class DynamicHandlerRegistry {
+    handlers = new Map();
+    register(toolName, handler) {
+        if (this.handlers.has(toolName)) {
+            console.warn(`Handler for tool '${toolName}' is being overwritten.`);
         }
+        this.handlers.set(toolName, handler);
     }
-    catch (err) {
-        log.warn('Unexpected error while loading handler registry:', err);
+    getHandler(toolName) {
+        return this.handlers.get(toolName);
     }
-}
-export async function getDynamicHandlerForTool(toolName, action) {
-    await loadRegistryIfNeeded();
-    if (!loadedHandlers.length)
-        return null;
-    const name = toolName;
-    const act = action;
-    for (const handler of loadedHandlers) {
-        if (handler.tool !== name)
-            continue;
-        if (handler.actions && act && !handler.actions.includes(act))
-            continue;
-        return handler.fn;
+    hasHandler(toolName) {
+        return this.handlers.has(toolName);
+    }
+    removeHandler(toolName) {
+        return this.handlers.delete(toolName);
+    }
+    getAllRegisteredTools() {
+        return Array.from(this.handlers.keys());
     }
-    return null;
 }
+export const toolRegistry = new DynamicHandlerRegistry();
 //# sourceMappingURL=dynamic-handler-registry.js.map

package/dist/tools/editor.d.ts

@@ -1,56 +1,16 @@
 import { BaseTool } from './base-tool.js';
-import { IEditorTools } from '../types/tool-interfaces.js';
+import { IEditorTools, StandardActionResponse } from '../types/tool-interfaces.js';
 export declare class EditorTools extends BaseTool implements IEditorTools {
     private cameraBookmarks;
     private editorPreferences;
     private activeRecording?;
     isInPIE(): Promise<boolean>;
     ensureNotInPIE(): Promise<void>;
-    playInEditor(timeoutMs?: number): Promise<{
-        success: boolean;
-        message: any;
-        error?: undefined;
-    } | {
-        success: boolean;
-        error: any;
-        message?: undefined;
-    }>;
-    stopPlayInEditor(): Promise<{
-        success: boolean;
-        message: any;
-        error?: undefined;
-    } | {
-        success: boolean;
-        error: any;
-        message?: undefined;
-    }>;
-    pausePlayInEditor(): Promise<{
-        success: boolean;
-        message: string;
-        error?: undefined;
-    } | {
-        success: boolean;
-        error: string;
-        message?: undefined;
-    }>;
-    pauseInEditor(): Promise<{
-        success: boolean;
-        message: string;
-        error?: undefined;
-    } | {
-        success: boolean;
-        error: string;
-        message?: undefined;
-    }>;
-    buildLighting(): Promise<{
-        success: boolean;
-        message: string;
-        error?: undefined;
-    } | {
-        success: boolean;
-        error: string;
-        message?: undefined;
-    }>;
+    playInEditor(timeoutMs?: number): Promise<StandardActionResponse>;
+    stopPlayInEditor(): Promise<StandardActionResponse>;
+    pausePlayInEditor(): Promise<StandardActionResponse>;
+    pauseInEditor(): Promise<StandardActionResponse>;
+    buildLighting(): Promise<StandardActionResponse>;
     private getViewportCameraInfo;
     setViewportCamera(location?: {
         x: number;
@@ -60,157 +20,23 @@ export declare class EditorTools extends BaseTool implements IEditorTools {
         pitch: number;
         yaw: number;
         roll: number;
-    } | [number, number, number] | null | undefined): Promise<{
-        success: boolean;
-        message: any;
-        location: [number, number, number] | {
-            x: number;
-            y: number;
-            z: number;
-        } | null | undefined;
-        rotation: [number, number, number] | {
-            pitch: number;
-            yaw: number;
-            roll: number;
-        } | null | undefined;
-        error?: undefined;
-    } | {
-        success: boolean;
-        error: any;
-        message?: undefined;
-        location?: undefined;
-        rotation?: undefined;
-    }>;
-    setCameraSpeed(speed: number): Promise<{
-        success: boolean;
-        message: string;
-        error?: undefined;
-    } | {
-        success: boolean;
-        error: string;
-        message?: undefined;
-    }>;
-    setFOV(fov: number): Promise<{
-        success: boolean;
-        message: string;
-        error?: undefined;
-    } | {
-        success: boolean;
-        error: string;
-        message?: undefined;
-    }>;
-    takeScreenshot(filename?: string, resolution?: string): Promise<{
-        success: boolean;
-        error: string;
-        message?: undefined;
-        filename?: undefined;
-        command?: undefined;
-    } | {
-        success: boolean;
-        message: string;
-        filename: string;
-        command: string;
-        error?: undefined;
-    }>;
-    resumePlayInEditor(): Promise<{
-        success: boolean;
-        message: string;
-        error?: undefined;
-    } | {
-        success: boolean;
-        error: string;
-        message?: undefined;
-    }>;
-    stepPIEFrame(steps?: number): Promise<{
-        success: boolean;
-        message: string;
-        steps: number;
-        error?: undefined;
-    } | {
-        success: boolean;
-        error: string;
-        message?: undefined;
-        steps?: undefined;
-    }>;
+    } | [number, number, number] | null | undefined): Promise<StandardActionResponse>;
+    setCameraSpeed(speed: number): Promise<StandardActionResponse>;
+    setFOV(fov: number): Promise<StandardActionResponse>;
+    takeScreenshot(filename?: string, resolution?: string): Promise<StandardActionResponse>;
+    resumePlayInEditor(): Promise<StandardActionResponse>;
+    stepPIEFrame(steps?: number): Promise<StandardActionResponse>;
     startRecording(options?: {
         filename?: string;
         frameRate?: number;
         durationSeconds?: number;
         metadata?: Record<string, unknown>;
-    }): Promise<{
-        success: true;
-        message: string;
-        recording: {
-            name: string | undefined;
-            startedAt: number;
-            options: Record<string, unknown> | undefined;
-        };
-    }>;
-    stopRecording(): Promise<{
-        success: true;
-        message: string;
-        recording?: undefined;
-    } | {
-        success: true;
-        message: string;
-        recording: {
-            name?: string;
-            options?: Record<string, unknown>;
-            startedAt: number;
-        };
-    }>;
-    createCameraBookmark(name: string): Promise<{
-        success: false;
-        error: string;
-        message?: undefined;
-        bookmark?: undefined;
-    } | {
-        success: true;
-        message: string;
-        bookmark: {
-            name: string;
-            location: [number, number, number];
-            rotation: [number, number, number];
-        };
-        error?: undefined;
-    }>;
-    jumpToCameraBookmark(name: string): Promise<{
-        success: false;
-        error: string;
-        message?: undefined;
-    } | {
-        success: true;
-        message: string;
-        error?: undefined;
-    }>;
-    setEditorPreferences(category: string | undefined, preferences: Record<string, unknown>): Promise<{
-        success: true;
-        message: string;
-        preferences: Record<string, unknown> | undefined;
-    }>;
-    setViewportResolution(width: number, height: number): Promise<{
-        success: boolean;
-        message: string;
-        width: number;
-        height: number;
-        error?: undefined;
-    } | {
-        success: boolean;
-        error: string;
-        message?: undefined;
-        width?: undefined;
-        height?: undefined;
-    }>;
-    executeConsoleCommand(command: string): Promise<{
-        success: boolean;
-        error: string;
-        message?: undefined;
-        output?: undefined;
-    } | {
-        success: boolean;
-        message: string;
-        output: any;
-        error?: undefined;
-    }>;
+    }): Promise<StandardActionResponse>;
+    stopRecording(): Promise<StandardActionResponse>;
+    createCameraBookmark(name: string): Promise<StandardActionResponse>;
+    jumpToCameraBookmark(name: string): Promise<StandardActionResponse>;
+    setEditorPreferences(category: string | undefined, preferences: Record<string, unknown>): Promise<StandardActionResponse>;
+    setViewportResolution(width: number, height: number): Promise<StandardActionResponse>;
+    executeConsoleCommand(command: string): Promise<StandardActionResponse>;
 }
 //# sourceMappingURL=editor.d.ts.map

package/dist/tools/editor.js

@@ -1,6 +1,7 @@
 import { BaseTool } from './base-tool.js';
 import { toVec3Object, toRotObject } from '../utils/normalize.js';
 import { DEFAULT_SCREENSHOT_RESOLUTION } from '../constants.js';
+import { wasmIntegration } from '../wasm/index.js';
 export class EditorTools extends BaseTool {
     cameraBookmarks = new Map();
     editorPreferences = new Map();
@@ -33,8 +34,9 @@ export class EditorTools extends BaseTool {
                 return { success: false, error: response?.error || response?.message || 'Failed to start PIE' };
             }
             catch (err) {
-                if (err.message && /time.*out/i.test(err.message)) {
-                    return { success: false, error: `Timeout waiting for PIE to start: ${err.message}` };
+                const errMsg = err instanceof Error ? err.message : String(err);
+                if (errMsg && /time.*out/i.test(errMsg)) {
+                    return { success: false, error: `Timeout waiting for PIE to start: ${errMsg}` };
                 }
                 await this.bridge.executeConsoleCommand('t.MaxFPS 60');
                 await this.bridge.executeConsoleCommand('PlayInViewport');
@@ -136,6 +138,13 @@ export class EditorTools extends BaseTool {
             rotation = rotObj;
         }
         try {
+            const locArray = location
+                ? [(location.x ?? location[0] ?? 0), (location.y ?? location[1] ?? 0), (location.z ?? location[2] ?? 0)]
+                : [0, 0, 0];
+            const rotArray = rotation
+                ? [(rotation.pitch ?? rotation[0] ?? 0), (rotation.yaw ?? rotation[1] ?? 0), (rotation.roll ?? rotation[2] ?? 0)]
+                : [0, 0, 0];
+            wasmIntegration.composeTransform(locArray, rotArray, [1, 1, 1]);
             const resp = await this.sendAutomationRequest('control_editor', {
                 action: 'set_camera',
                 location: location,