unreal-engine-mcp-server 0.5.0 → 0.5.1

package/src/graphql/resolvers.ts

@@ -129,6 +129,35 @@ interface Blueprint {
   scsHierarchy?: Record<string, any>;
 }
 
+import { Logger } from '../utils/logger.js';
+
+const log = new Logger('GraphQL:Resolvers');
+
+/**
+ * Creates a GraphQL-friendly error with proper extensions
+ */
+class GraphQLResolverError extends Error {
+  extensions: { code: string; originalError?: string };
+
+  constructor(message: string, code: string = 'UNREAL_ENGINE_ERROR', originalError?: Error) {
+    super(message);
+    this.name = 'GraphQLResolverError';
+    this.extensions = {
+      code,
+      originalError: originalError?.message
+    };
+  }
+}
+
+/**
+ * Helper to create resolver errors with proper logging
+ */
+function createResolverError(operation: string, error: unknown): GraphQLResolverError {
+  const message = error instanceof Error ? error.message : String(error);
+  log.error(`${operation} failed:`, message);
+  return new GraphQLResolverError(`${operation} failed: ${message}`, 'UNREAL_ENGINE_ERROR', error instanceof Error ? error : undefined);
+}
+
 function logAutomationFailure(source: string, response: any) {
   try {
     if (!response || response.success !== false) {
@@ -138,7 +167,7 @@ function logAutomationFailure(source: string, response: any) {
     if (errorText.length === 0) {
       return;
     }
-    console.error(`[GraphQL] ${source} automation failure:`, errorText);
+    log.error(`${source} automation failure:`, errorText);
   } catch {
   }
 }
@@ -158,7 +187,7 @@ async function getActorProperties(
     });
     return result.success ? result.value || {} : {};
   } catch (error) {
-    console.error('Failed to get actor properties:', error);
+    log.error('Failed to get actor properties:', error);
     return {};
   }
 }
@@ -190,11 +219,11 @@ async function listAssets(
     }
 
     logAutomationFailure('list_assets', response);
-    console.error('Failed to list assets:', response);
+    log.warn('Failed to list assets - returning empty set');
     return { assets: [], totalCount: 0 };
   } catch (error) {
-    console.error('Failed to list assets:', error);
-    return { assets: [], totalCount: 0 };
+    log.error('Failed to list assets:', error);
+    throw createResolverError('listAssets', error);
   }
 }
 
@@ -229,33 +258,7 @@ async function listActors(
   }
 }
 
-/**
- * Helper to get blueprint details
- */
-async function getBlueprint(
-  automationBridge: AutomationBridge,
-  blueprintPath: string
-): Promise<Blueprint | null> {
-  try {
-    const response = await automationBridge.sendAutomationRequest(
-      'get_blueprint',
-      {
-        blueprintPath
-      },
-      { timeoutMs: 30000 }
-    );
 
-    if (response.success && response.result) {
-      return response.result as Blueprint;
-    }
-
-    logAutomationFailure('get_blueprint', response);
-    return null;
-  } catch (error) {
-    console.error('Failed to get blueprint:', error);
-    return null;
-  }
-}
 
 /**
  * GraphQL Resolvers Implementation
@@ -291,17 +294,10 @@ export const resolvers = {
 
     asset: async (_: any, { path }: { path: string }, context: GraphQLContext) => {
       try {
-        const response = await context.automationBridge.sendAutomationRequest(
-          'get_asset',
-          { assetPath: path },
-          { timeoutMs: 10000 }
-        );
-
-        if (response.success && response.result) {
-          return response.result;
+        if (!context.loaders) {
+          throw new Error('Loaders not initialized');
         }
-
-        return null;
+        return await context.loaders.assetLoader.load(path);
       } catch (error) {
         console.error('Failed to get asset:', error);
         return null;
@@ -336,11 +332,10 @@ export const resolvers = {
 
     actor: async (_: any, { name }: { name: string }, context: GraphQLContext) => {
       try {
-        const actors = await listActors(context.automationBridge, { tag: name });
-        if (actors.actors.length > 0) {
-          return actors.actors[0];
+        if (!context.loaders) {
+          throw new Error('Loaders not initialized');
         }
-        return null;
+        return await context.loaders.actorLoader.load(name);
       } catch (error) {
         console.error('Failed to get actor:', error);
         return null;
@@ -394,7 +389,10 @@ export const resolvers = {
     },
 
     blueprint: async (_: any, { path }: { path: string }, context: GraphQLContext) => {
-      return await getBlueprint(context.automationBridge, path);
+      if (!context.loaders) {
+        throw new Error('Loaders not initialized');
+      }
+      return await context.loaders.blueprintLoader.load(path);
     },
 
     levels: async (_: any, __: any, context: GraphQLContext) => {
@@ -524,9 +522,9 @@ export const resolvers = {
           { subAction: 'get_cells' },
           { timeoutMs: 10000 }
         );
-        
+
         if (response.success && response.result) {
-            return (response.result as any).cells || [];
+          return (response.result as any).cells || [];
         }
         return [];
       } catch (error) {
@@ -550,7 +548,7 @@ export const resolvers = {
         const edges = assets.map((asset, index) => ({
           node: {
             ...asset,
-            emitters: [], 
+            emitters: [],
             parameters: []
           },
           cursor: Buffer.from(`${asset.path}:${offset + index}`).toString('base64')

package/src/graphql/server.ts

@@ -5,6 +5,7 @@ import { createGraphQLSchema } from './schema.js';
 import type { GraphQLContext } from './types.js';
 import type { UnrealBridge } from '../unreal-bridge.js';
 import { AutomationBridge } from '../automation/index.js';
+import { createLoaders } from './loaders.js';
 
 export interface GraphQLServerConfig {
   enabled?: boolean;
@@ -65,7 +66,8 @@ export class GraphQLServer {
         },
         context: (): GraphQLContext => ({
           bridge: this.bridge,
-          automationBridge: this.automationBridge
+          automationBridge: this.automationBridge,
+          loaders: createLoaders(this.automationBridge)
         }),
         logging: {
           debug: (...args) => this.log.debug('[GraphQL]', ...args),

package/src/graphql/types.ts

@@ -1,7 +1,10 @@
 import type { UnrealBridge } from '../unreal-bridge.js';
 import { AutomationBridge } from '../automation/index.js';
+import type { GraphQLLoaders } from './loaders.js';
 
 export interface GraphQLContext {
     bridge: UnrealBridge;
     automationBridge: AutomationBridge;
+    /** DataLoaders for batching and caching - solves N+1 query problem */
+    loaders?: GraphQLLoaders;
 }

package/src/index.ts

@@ -13,6 +13,7 @@ import { HealthMonitor } from './services/health-monitor.js';
 import { ServerSetup } from './server-setup.js';
 import { startMetricsServer } from './services/metrics-server.js';
 import { config } from './config.js';
+import { GraphQLServer } from './graphql/server.js';
 
 const require = createRequire(import.meta.url);
 const packageInfo: { name?: string; version?: string } = (() => {
@@ -106,6 +107,12 @@ export function createServer() {
   // Optionally expose Prometheus-style metrics via /metrics
   startMetricsServer({ healthMonitor, automationBridge, logger: log });
 
+  // Initialize GraphQL server (controlled by GRAPHQL_ENABLED env var)
+  const graphqlServer = new GraphQLServer(bridge, automationBridge);
+  graphqlServer.start().catch((error) => {
+    log.warn('GraphQL server failed to start:', error);
+  });
+
   // Initialize WebAssembly module for high-performance operations (5-8x faster)
   log.debug('Initializing WebAssembly integration...');
   initializeWASM().then(() => {
@@ -145,7 +152,7 @@ export function createServer() {
   const serverSetup = new ServerSetup(server, bridge, automationBridge, log, healthMonitor);
   serverSetup.setup(); // Register tools, resources, and prompts
 
-  return { server, bridge, automationBridge };
+  return { server, bridge, automationBridge, graphqlServer };
 }
 
 // Export configuration schema for session UI and runtime validation
@@ -170,7 +177,7 @@ export default function createServerDefault({ config }: { config?: any } = {}) {
 }
 
 export async function startStdioServer() {
-  const { server, automationBridge } = createServer();
+  const { server, automationBridge, graphqlServer } = createServer();
   const transport = new StdioServerTransport();
   let shuttingDown = false;
 
@@ -187,6 +194,12 @@ export async function startStdioServer() {
       log.warn('Failed to stop automation bridge cleanly', error);
     }
 
+    try {
+      await graphqlServer.stop();
+    } catch (error) {
+      log.warn('Failed to stop GraphQL server cleanly', error);
+    }
+
     try {
       if (typeof (server as any).close === 'function') {
         await (server as any).close();

package/src/resources/assets.ts

@@ -1,6 +1,7 @@
 import { BaseTool } from '../tools/base-tool.js';
 import { IAssetResources } from '../types/tool-interfaces.js';
 import { coerceString } from '../utils/result-helpers.js';
+import { AutomationResponse } from '../types/automation-responses.js';
 
 export class AssetResources extends BaseTool implements IAssetResources {
   // Simple in-memory cache for asset listing
@@ -175,14 +176,14 @@ export class AssetResources extends BaseTool implements IAssetResources {
       // Use the native C++ plugin's list action instead of Python
       try {
         const normalizedDir = this.normalizeDir(dir);
-        const response = await this.sendAutomationRequest(
+        const response = await this.sendAutomationRequest<AutomationResponse>(
           'list',
           { directory: normalizedDir, limit, recursive: false },
           { timeoutMs: 30000 }
         );
 
         if (response.success !== false && response.result) {
-          const payload = response.result;
+          const payload = response.result as any;
 
           const foldersArr = Array.isArray(payload.folders_list)
             ? payload.folders_list.map((f: any) => ({
@@ -257,12 +258,12 @@ export class AssetResources extends BaseTool implements IAssetResources {
 
     try {
       const normalizedPath = this.normalizeDir(assetPath);
-      const response = await this.sendAutomationRequest(
+      const response = await this.sendAutomationRequest<AutomationResponse>(
         'asset_exists',
         { asset_path: normalizedPath }
       );
 
-      return response?.success !== false && response?.result?.exists === true;
+      return response?.success !== false && (response?.result as any)?.exists === true;
     } catch {
       return false;
     }

package/src/server-setup.ts

@@ -1,10 +1,10 @@
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { ListPromptsRequestSchema, GetPromptRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+// import { ListPromptsRequestSchema, GetPromptRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import { UnrealBridge } from './unreal-bridge.js';
 import { AutomationBridge } from './automation/index.js';
 import { Logger } from './utils/logger.js';
 import { HealthMonitor } from './services/health-monitor.js';
-import { prompts } from './prompts/index.js';
+// import { prompts } from './prompts/index.js';
 import { AssetResources } from './resources/assets.js';
 import { ActorResources } from './resources/actors.js';
 import { LevelResources } from './resources/levels.js';
@@ -73,7 +73,7 @@ export class ServerSetup {
     );
     toolRegistry.register();
 
-    this.registerPrompts();
+    // this.registerPrompts();
   }
 
   private validateEnvironment() {
@@ -110,39 +110,5 @@ export class ServerSetup {
     return ok;
   }
 
-  private registerPrompts() {
-    this.server.setRequestHandler(ListPromptsRequestSchema, async () => {
-      return {
-        prompts: prompts.map(p => ({
-          name: p.name,
-          description: p.description,
-          arguments: Object.entries(p.arguments || {}).map(([name, schema]) => {
-            const meta: Record<string, unknown> = {};
-            if (schema.type) meta.type = schema.type;
-            if (schema.enum) meta.enum = schema.enum;
-            if (schema.default !== undefined) meta.default = schema.default;
-            return {
-              name,
-              description: schema.description,
-              required: schema.required ?? false,
-              ...(Object.keys(meta).length ? { _meta: meta } : {})
-            };
-          })
-        }))
-      };
-    });
 
-    this.server.setRequestHandler(GetPromptRequestSchema, async (request) => {
-      const prompt = prompts.find(p => p.name === request.params.name);
-      if (!prompt) {
-        throw new Error(`Unknown prompt: ${request.params.name}`);
-      }
-      const args = (request.params.arguments || {}) as Record<string, unknown>;
-      const messages = prompt.build(args);
-      return {
-        description: prompt.description,
-        messages
-      };
-    });
-  }
 }

package/src/tools/actors.ts

@@ -2,6 +2,8 @@ import { UnrealBridge } from '../unreal-bridge.js';
 import { ensureRotation, ensureVector3 } from '../utils/validation.js';
 import { BaseTool } from './base-tool.js';
 import { IActorTools, StandardActionResponse } from '../types/tool-interfaces.js';
+import { ActorResponse } from '../types/automation-responses.js';
+import { wasmIntegration } from '../wasm/index.js';
 
 export class ActorTools extends BaseTool implements IActorTools {
   constructor(bridge: UnrealBridge) {
@@ -44,7 +46,7 @@ export class ActorTools extends BaseTool implements IActorTools {
     try {
       const bridge = this.getAutomationBridge();
       const timeoutMs = typeof params.timeoutMs === 'number' && params.timeoutMs > 0 ? params.timeoutMs : undefined;
-      const response = await bridge.sendAutomationRequest(
+      const response = await bridge.sendAutomationRequest<ActorResponse>(
         'control_actor',
         {
           action: 'spawn',
@@ -58,7 +60,9 @@ export class ActorTools extends BaseTool implements IActorTools {
       );
 
       if (!response || !response.success) {
-        throw new Error(response?.error || response?.message || 'Failed to spawn actor');
+        const error = response?.error;
+        const errorMsg = typeof error === 'string' ? error : (error as any)?.message || response?.message || 'Failed to spawn actor';
+        throw new Error(errorMsg);
       }
 
       const data = (response as any).data || {};
@@ -117,7 +121,7 @@ export class ActorTools extends BaseTool implements IActorTools {
       // DELETE_PARTIAL as a handled, partial-success cleanup instead
       // of surfacing it as a hard error to the consolidated handler.
       const bridge = this.getAutomationBridge();
-      const response: any = await bridge.sendAutomationRequest('control_actor', {
+      const response: any = await bridge.sendAutomationRequest<ActorResponse>('control_actor', {
         action: 'delete',
         actorNames: names
       });
@@ -158,7 +162,7 @@ export class ActorTools extends BaseTool implements IActorTools {
       throw new Error('Invalid actorName');
     }
 
-    return this.sendRequest('delete', { actorName: params.actorName }, 'control_actor');
+    return this.sendRequest<StandardActionResponse>('delete', { actorName: params.actorName }, 'control_actor');
   }
 
   async applyForce(params: { actorName: string; force: { x: number; y: number; z: number } }) {
@@ -183,7 +187,7 @@ export class ActorTools extends BaseTool implements IActorTools {
       };
     }
 
-    return this.sendRequest('apply_force', {
+    return this.sendRequest<StandardActionResponse>('apply_force', {
       actorName: params.actorName,
       force: { x: forceX, y: forceY, z: forceZ }
     }, 'control_actor');
@@ -259,7 +263,7 @@ export class ActorTools extends BaseTool implements IActorTools {
     if (location) payload.location = { x: location[0], y: location[1], z: location[2] };
     if (rotation) payload.rotation = { pitch: rotation[0], yaw: rotation[1], roll: rotation[2] };
 
-    return this.sendRequest('spawn_blueprint', payload, 'control_actor');
+    return this.sendRequest<StandardActionResponse>('spawn_blueprint', payload, 'control_actor');
   }
 
   async setTransform(params: { actorName: string; location?: { x: number; y: number; z: number }; rotation?: { pitch: number; yaw: number; roll: number }; scale?: { x: number; y: number; z: number } }) {
@@ -282,14 +286,14 @@ export class ActorTools extends BaseTool implements IActorTools {
       payload.scale = { x: scl[0], y: scl[1], z: scl[2] };
     }
 
-    return this.sendRequest('set_transform', payload, 'control_actor');
+    return this.sendRequest<StandardActionResponse>('set_transform', payload, 'control_actor');
   }
 
   async getTransform(actorName: string) {
     if (typeof actorName !== 'string' || actorName.trim().length === 0) {
       throw new Error('Invalid actorName');
     }
-    return this.sendRequest('get_transform', { actorName }, 'control_actor')
+    return this.sendRequest<StandardActionResponse>('get_transform', { actorName }, 'control_actor')
       .then(response => {
         // If response is standardized, extract data or return as is.
         // For now, return the full response which includes data.
@@ -302,7 +306,7 @@ export class ActorTools extends BaseTool implements IActorTools {
     if (!actorName) {
       throw new Error('Invalid actorName');
     }
-    return this.sendRequest('set_visibility', { actorName, visible: Boolean(params.visible) }, 'control_actor');
+    return this.sendRequest<StandardActionResponse>('set_visibility', { actorName, visible: Boolean(params.visible) }, 'control_actor');
   }
 
   async addComponent(params: { actorName: string; componentType: string; componentName?: string; properties?: Record<string, unknown> }) {
@@ -311,7 +315,7 @@ export class ActorTools extends BaseTool implements IActorTools {
     if (!actorName) throw new Error('Invalid actorName');
     if (!componentType) throw new Error('Invalid componentType');
 
-    return this.sendRequest('add_component', {
+    return this.sendRequest<StandardActionResponse>('add_component', {
       actorName,
       componentType,
       componentName: typeof params.componentName === 'string' ? params.componentName : undefined,
@@ -325,7 +329,7 @@ export class ActorTools extends BaseTool implements IActorTools {
     if (!actorName) throw new Error('Invalid actorName');
     if (!componentName) throw new Error('Invalid componentName');
 
-    return this.sendRequest('set_component_properties', {
+    return this.sendRequest<StandardActionResponse>('set_component_properties', {
       actorName,
       componentName,
       properties: params.properties ?? {}
@@ -336,7 +340,7 @@ export class ActorTools extends BaseTool implements IActorTools {
     if (typeof actorName !== 'string' || actorName.trim().length === 0) {
       throw new Error('Invalid actorName');
     }
-    const response = await this.sendRequest('get_components', { actorName }, 'control_actor');
+    const response = await this.sendRequest<StandardActionResponse>('get_components', { actorName }, 'control_actor');
     if (!response.success) {
       return { success: false, error: response.error || `Failed to get components for actor ${actorName}` };
     }
@@ -365,10 +369,14 @@ export class ActorTools extends BaseTool implements IActorTools {
     }
     if (params.offset) {
       const offs = ensureVector3(params.offset, 'duplicate offset');
-      payload.offset = { x: offs[0], y: offs[1], z: offs[2] };
+      // Use WASM vectorAdd for offset calculation (origin + offset)
+      const origin: [number, number, number] = [0, 0, 0];
+      const calculatedOffset = wasmIntegration.vectorAdd(origin, offs);
+      console.error('[WASM] Using vectorAdd for duplicate offset calculation');
+      payload.offset = { x: calculatedOffset[0], y: calculatedOffset[1], z: calculatedOffset[2] };
     }
 
-    return this.sendRequest('duplicate', payload, 'control_actor');
+    return this.sendRequest<StandardActionResponse>('duplicate', payload, 'control_actor');
   }
 
   async addTag(params: { actorName: string; tag: string }) {
@@ -377,7 +385,7 @@ export class ActorTools extends BaseTool implements IActorTools {
     if (!actorName) throw new Error('Invalid actorName');
     if (!tag) throw new Error('Invalid tag');
 
-    return this.sendRequest('add_tag', { actorName, tag }, 'control_actor');
+    return this.sendRequest<StandardActionResponse>('add_tag', { actorName, tag }, 'control_actor');
   }
 
   async removeTag(params: { actorName: string; tag: string }) {
@@ -386,7 +394,7 @@ export class ActorTools extends BaseTool implements IActorTools {
     if (!actorName) throw new Error('Invalid actorName');
     if (!tag) throw new Error('Invalid tag');
 
-    return this.sendRequest('remove_tag', { actorName, tag }, 'control_actor');
+    return this.sendRequest<StandardActionResponse>('remove_tag', { actorName, tag }, 'control_actor');
   }
 
   async findByTag(params: { tag: string; matchType?: string }) {
@@ -404,7 +412,7 @@ export class ActorTools extends BaseTool implements IActorTools {
       };
     }
 
-    return this.sendRequest('find_by_tag', {
+    return this.sendRequest<StandardActionResponse>('find_by_tag', {
       tag,
       matchType: typeof params.matchType === 'string' ? params.matchType : undefined
     }, 'control_actor');
@@ -414,7 +422,7 @@ export class ActorTools extends BaseTool implements IActorTools {
     if (typeof name !== 'string' || name.trim().length === 0) {
       throw new Error('Invalid actor name query');
     }
-    return this.sendRequest('find_by_name', { name: name.trim() }, 'control_actor');
+    return this.sendRequest<StandardActionResponse>('find_by_name', { name: name.trim() }, 'control_actor');
   }
 
   async detach(actorName: string) {
@@ -428,7 +436,7 @@ export class ActorTools extends BaseTool implements IActorTools {
     if (typeof actorName !== 'string' || actorName.trim().length === 0) {
       throw new Error('Invalid actorName');
     }
-    return this.sendRequest('detach', { actorName }, 'control_actor');
+    return this.sendRequest<StandardActionResponse>('detach', { actorName }, 'control_actor');
   }
 
   async attach(params: { childActor: string; parentActor: string }) {
@@ -437,20 +445,20 @@ export class ActorTools extends BaseTool implements IActorTools {
     if (!child) throw new Error('Invalid childActor');
     if (!parent) throw new Error('Invalid parentActor');
 
-    return this.sendRequest('attach', { childActor: child, parentActor: parent }, 'control_actor');
+    return this.sendRequest<StandardActionResponse>('attach', { childActor: child, parentActor: parent }, 'control_actor');
   }
 
   async deleteByTag(tag: string) {
     if (typeof tag !== 'string' || tag.trim().length === 0) {
       throw new Error('Invalid tag');
     }
-    return this.sendRequest('delete_by_tag', { tag: tag.trim() }, 'control_actor');
+    return this.sendRequest<StandardActionResponse>('delete_by_tag', { tag: tag.trim() }, 'control_actor');
   }
 
   async setBlueprintVariables(params: { actorName: string; variables: Record<string, unknown> }) {
     const actorName = typeof params.actorName === 'string' ? params.actorName.trim() : '';
     if (!actorName) throw new Error('Invalid actorName');
-    return this.sendRequest('set_blueprint_variables', { actorName, variables: params.variables ?? {} }, 'control_actor');
+    return this.sendRequest<StandardActionResponse>('set_blueprint_variables', { actorName, variables: params.variables ?? {} }, 'control_actor');
   }
 
   async createSnapshot(params: { actorName: string; snapshotName: string }) {
@@ -458,7 +466,7 @@ export class ActorTools extends BaseTool implements IActorTools {
     const snapshotName = typeof params.snapshotName === 'string' ? params.snapshotName.trim() : '';
     if (!actorName) throw new Error('Invalid actorName');
     if (!snapshotName) throw new Error('Invalid snapshotName');
-    return this.sendRequest('create_snapshot', { actorName, snapshotName }, 'control_actor');
+    return this.sendRequest<StandardActionResponse>('create_snapshot', { actorName, snapshotName }, 'control_actor');
   }
 
   async restoreSnapshot(params: { actorName: string; snapshotName: string }) {
@@ -466,12 +474,12 @@ export class ActorTools extends BaseTool implements IActorTools {
     const snapshotName = typeof params.snapshotName === 'string' ? params.snapshotName.trim() : '';
     if (!actorName) throw new Error('Invalid actorName');
     if (!snapshotName) throw new Error('Invalid snapshotName');
-    return this.sendRequest('restore_snapshot', { actorName, snapshotName }, 'control_actor');
+    return this.sendRequest<StandardActionResponse>('restore_snapshot', { actorName, snapshotName }, 'control_actor');
   }
   async exportActor(params: { actorName: string; destinationPath?: string }) {
     const actorName = typeof params.actorName === 'string' ? params.actorName.trim() : '';
     if (!actorName) throw new Error('Invalid actorName');
-    return this.sendRequest('export', {
+    return this.sendRequest<StandardActionResponse>('export', {
       actorName,
       destinationPath: params.destinationPath
     }, 'control_actor');
@@ -481,7 +489,7 @@ export class ActorTools extends BaseTool implements IActorTools {
     if (typeof actorName !== 'string' || actorName.trim().length === 0) {
       throw new Error('Invalid actorName');
     }
-    const response = await this.sendRequest('get_bounding_box', { actorName }, 'control_actor');
+    const response = await this.sendRequest<StandardActionResponse>('get_bounding_box', { actorName }, 'control_actor');
     if (!response.success) {
       return { success: false, error: response.error || `Failed to get bounding box for actor ${actorName}` };
     }
@@ -496,7 +504,7 @@ export class ActorTools extends BaseTool implements IActorTools {
     if (typeof actorName !== 'string' || actorName.trim().length === 0) {
       throw new Error('Invalid actorName');
     }
-    const response = await this.sendRequest('get_metadata', { actorName }, 'control_actor');
+    const response = await this.sendRequest<StandardActionResponse>('get_metadata', { actorName }, 'control_actor');
     if (!response.success) {
       return { success: false, error: response.error || `Failed to get metadata for actor ${actorName}` };
     }
@@ -512,7 +520,7 @@ export class ActorTools extends BaseTool implements IActorTools {
     if (params?.filter) {
       payload.filter = params.filter;
     }
-    const response = await this.sendRequest('list_actors', payload, 'control_actor');
+    const response = await this.sendRequest<StandardActionResponse>('list_actors', payload, 'control_actor');
     if (!response.success) {
       return { success: false, error: response.error || 'Failed to list actors' };
     }

package/src/tools/animation.ts

@@ -2,6 +2,7 @@ import { UnrealBridge } from '../unreal-bridge.js';
 import { AutomationBridge } from '../automation/index.js';
 import { cleanObject } from '../utils/safe-json.js';
 import { validateAssetParams } from '../utils/validation.js';
+import { wasmIntegration as _wasmIntegration } from '../wasm/index.js';
 
 type CreateAnimationBlueprintSuccess = {
   success: true;