unreal-engine-mcp-server 0.5.0 → 0.5.1

package/src/tools/consolidated-tool-handlers.ts

@@ -2,6 +2,7 @@ import { cleanObject } from '../utils/safe-json.js';
 import { Logger } from '../utils/logger.js';
 import { ResponseFactory } from '../utils/response-factory.js';
 import { ITools } from '../types/tool-interfaces.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';
@@ -20,8 +21,8 @@ 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';
+// import { getDynamicHandlerForTool } from './dynamic-handler-registry.js';
+// import { consolidatedToolDefinitions } from './consolidated-tool-definitions.js';
 
 type NormalizedToolCall = {
   name: string;
@@ -116,157 +117,141 @@ function normalizeToolCall(
   };
 }
 
-async function invokeNamedTool(
-  name: string,
-  action: string,
-  args: any,
-  tools: ITools
-) {
-  switch (name) {
-    // 1. ASSET MANAGER
-    case 'manage_asset': {
-      // Reroute merged functionality
-      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)) {
-        // Map new action names to legacy subActions if needed, or just pass through if plugin supports them.
-        // The plugin expects 'manage_material_graph' for these.
-        // We need to map 'add_material_node' -> 'add_node' etc if the plugin is strict, 
-        // or we assume we updated the plugin. 
-        // For now, let's assume we map them to the old tool 'manage_material_graph' with the old action names.
-        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);
+// Registration of default handlers
+function registerDefaultHandlers() {
+  // 1. ASSET MANAGER
+  toolRegistry.register('manage_asset', async (args, tools) => {
+    const action = args.subAction || args.action || requireAction(args); // Fallback assumption
+    // Reroute merged functionality
+    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}`));
     }
-
-    // 2. BLUEPRINT MANAGER
-
-    case 'manage_blueprint': {
-      if (action === 'get_blueprint') {
-        return await handleBlueprintGet(args, tools);
-      }
-      // Graph actions
-      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);
     }
-
-    // 3. ACTOR CONTROL
-    case 'control_actor':
-      return await handleActorTools(action, args, tools);
-
-    // 4. EDITOR CONTROL
-    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);
     }
-
-    // 5. LEVEL MANAGER
-    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);
+  });
+
+  // 2. BLUEPRINT MANAGER
+  toolRegistry.register('manage_blueprint', async (args, tools) => {
+    const action = args.action || requireAction(args);
+    if (action === 'get_blueprint') {
+      return await handleBlueprintGet(args, tools);
     }
-
-    // 6. ANIMATION & PHYSICS
-    case 'animation_physics':
-      return await handleAnimationTools(action, args, tools);
-
-    // 7. EFFECTS MANAGER (Renamed from create_effect)
-    case 'manage_effect': {
-      if (isNiagaraGraphAction(action)) {
-        // Special case: set_niagara_parameter can be for actor (Effect Tool) or asset (Graph Tool)
-        // If actorName is present, or systemName is present but no path, it's an instance operation -> handleEffectTools
-        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);
+    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);
+  });
+
+  // 3. ACTOR CONTROL
+  toolRegistry.register('control_actor', async (args, tools) => {
+    return await handleActorTools(args.action || requireAction(args), args, tools);
+  });
+
+  // 4. EDITOR CONTROL
+  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'));
+    }
+    return await handleEditorTools(action, args, tools);
+  });
+
+  // 5. LEVEL MANAGER
+  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);
+  });
+
+  // 6. ANIMATION & PHYSICS
+  toolRegistry.register('animation_physics', async (args, tools) => await handleAnimationTools(args.action || requireAction(args), args, tools));
+
+  // 7. EFFECTS MANAGER
+  toolRegistry.register('manage_effect', async (args, tools) => {
+    const action = args.action || requireAction(args);
+    if (isNiagaraGraphAction(action)) {
+      // Instance check
+      const isInstanceOp = action === 'set_niagara_parameter' && (args.actorName || (args.systemName && !args.assetPath && !args.systemPath));
+      if (isInstanceOp) {
+        return await handleEffectTools(action, args, tools);
       }
-      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);
+  });
 
-    // 8. ENVIRONMENT BUILDER
-    case 'build_environment':
-      return await handleEnvironmentTools(action, args, tools);
+  // 8. ENVIRONMENT BUILDER
+  toolRegistry.register('build_environment', async (args, tools) => await handleEnvironmentTools(args.action || requireAction(args), args, tools));
 
-    // 9. SYSTEM CONTROL
-    case 'system_control': {
-      if (action === 'console_command') return await handleConsoleCommand(args, tools);
-      if (action === 'run_ubt') return await handlePipelineTools(action, args, tools);
+  // 9. SYSTEM CONTROL
+  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);
 
-      // Bridge forwards
-      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'));
+    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 handleSystemTools(action, args, tools);
+  });
 
-    // 10. SEQUENCER
-    case 'manage_sequence':
-      return await handleSequenceTools(action, args, tools);
+  // 10. SEQUENCER
+  toolRegistry.register('manage_sequence', async (args, tools) => await handleSequenceTools(args.action || requireAction(args), args, tools));
 
-    // 11. INTROSPECTION
-    case 'inspect':
-      return await handleInspectTools(action, args, tools);
+  // 11. INTROSPECTION
+  toolRegistry.register('inspect', async (args, tools) => await handleInspectTools(args.action || requireAction(args), args, tools));
 
-    // 12. AUDIO
-    case 'manage_audio':
-      return await handleAudioTools(action, args, tools);
+  // 12. AUDIO
+  toolRegistry.register('manage_audio', async (args, tools) => await handleAudioTools(args.action || requireAction(args), args, tools));
 
-    // 13. BEHAVIOR TREE
-    case 'manage_behavior_tree':
-      return await handleGraphTools('manage_behavior_tree', action, args, tools);
+  // 13. BEHAVIOR TREE
+  toolRegistry.register('manage_behavior_tree', async (args, tools) => await handleGraphTools('manage_behavior_tree', args.action || requireAction(args), args, tools));
 
-    // 14. BLUEPRINT GRAPH DIRECT
-    case 'manage_blueprint_graph':
-      return await handleGraphTools('manage_blueprint_graph', action, args, tools);
+  // 14. BLUEPRINT GRAPH DIRECT
+  toolRegistry.register('manage_blueprint_graph', async (args, tools) => await handleGraphTools('manage_blueprint_graph', args.action || requireAction(args), args, tools));
 
-    // 15. RENDER TOOLS
-    case 'manage_render':
-      return cleanObject(await executeAutomationRequest(tools, 'manage_render', { ...args, subAction: action }, 'Bridge unavailable'));
+  // 15. RENDER 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'));
+  });
 
-    // 16. WORLD PARTITION
-    case 'manage_world_partition':
-      return cleanObject(await executeAutomationRequest(tools, 'manage_world_partition', { ...args, subAction: action }, 'Bridge unavailable'));
+  // 16. WORLD PARTITION
+  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'));
+  });
 
-    // 17. LIGHTING
-    case 'manage_lighting':
-      return await handleLightingTools(action, args, tools);
+  // 17. LIGHTING
+  toolRegistry.register('manage_lighting', async (args, tools) => await handleLightingTools(args.action || requireAction(args), args, tools));
 
-    // 18. PERFORMANCE
-    case 'manage_performance':
-      return await handlePerformanceTools(action, args, tools);
+  // 18. PERFORMANCE
+  toolRegistry.register('manage_performance', async (args, tools) => await handlePerformanceTools(args.action || requireAction(args), args, tools));
 
-    // 19. INPUT
-    case 'manage_input':
-      return await handleInputTools(action, args, tools);
-
-    default:
-      return cleanObject({ success: false, error: 'UNKNOWN_TOOL', message: `Unknown consolidated tool: ${name}` });
-  }
+  // 19. INPUT
+  toolRegistry.register('manage_input', async (args, tools) => await handleInputTools(args.action || requireAction(args), args, tools));
 }
 
+// Initialize default handlers immediately
+registerDefaultHandlers();
+
 // Export the main consolidated tool call handler
 export async function handleConsolidatedToolCall(
   name: string,
@@ -280,30 +265,24 @@ export async function handleConsolidatedToolCall(
   try {
     const normalized = normalizeToolCall(name, args);
     const normalizedName = normalized.name;
-    const action = normalized.action;
     const normalizedArgs = normalized.args;
-
-    const toolDef: any = (consolidatedToolDefinitions as any[]).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: any = toolDef.inputSchema.properties.action;
-      const allowed: string[] | undefined = Array.isArray(actionProp.enum) ? actionProp.enum as string[] : undefined;
-      if (allowed && !allowed.includes(action)) {
-        return cleanObject({
-          success: false,
-          error: 'UNKNOWN_ACTION',
-          message: `Unknown action '${action}' for consolidated tool '${normalizedName}'.`
-        });
-      }
+    // Note: action extracted inside handler usually, but here we might pass it if needed.
+    // The handlers above re-extract or use normalizedArgs.action. 
+    // `normalizeToolCall` puts `action` into `normalized.action` but does NOT necessarily put it into `normalized.args.action`.
+    // Let's ensure args has action if we relied on it above.
+    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();
+    // Fallback or Unknown
+    return cleanObject({ success: false, error: 'UNKNOWN_TOOL', message: `Unknown consolidated tool: ${name}` });
+
   } catch (err: any) {
     const duration = Date.now() - startTime;
     logger.error(`Failed execution of ${name} after ${duration}ms: ${err?.message || String(err)}`);

package/src/tools/dynamic-handler-registry.ts

@@ -1,151 +1,33 @@
-import { Logger } from '../utils/logger.js';
-import type { ITools } from '../types/tool-interfaces.js';
-import fs from 'fs/promises';
-import path from 'node:path';
-import { pathToFileURL } from 'node:url';
+import { ITools } from '../types/tool-interfaces.js';
 
-const log = new Logger('DynamicHandlerRegistry');
+type ToolHandler = (args: any, tools: ITools) => Promise<any>;
 
-export interface DynamicHandlerContext {
-  name: string;
-  action: string;
-  args: any;
-  tools: ITools;
-  defaultHandler: () => Promise<any>;
-}
-
-export type DynamicHandlerFn = (ctx: DynamicHandlerContext) => Promise<any>;
-
-interface RawHandlerEntry {
-  tool: string;
-  module: string;
-  function?: string;
-  actions?: string[];
-}
-
-interface RawRegistry {
-  handlers?: RawHandlerEntry[];
-}
-
-interface LoadedHandler {
-  tool: string;
-  actions?: string[];
-  fn: DynamicHandlerFn;
-}
+export class DynamicHandlerRegistry {
+  private handlers = new Map<string, ToolHandler>();
 
-let registryLoaded = false;
-const loadedHandlers: LoadedHandler[] = [];
-
-async function loadRegistryIfNeeded(): Promise<void> {
-  if (registryLoaded) return;
-  registryLoaded = true;
-
-  // Project root (works for both src/ and dist/ builds)
-  const rootUrl = new URL('../..', import.meta.url);
-
-  const envPath = (process.env.MCP_HANDLER_REGISTRY || '').trim();
-  let configUrl: URL | null = null;
-
-  try {
-    if (envPath) {
-      // Allow absolute paths, file:// URLs, or paths relative to project root
-      if (envPath.startsWith('file:')) {
-        configUrl = new URL(envPath);
-      } else if (path.isAbsolute(envPath)) {
-        configUrl = pathToFileURL(envPath);
-      } else {
-        configUrl = new URL(envPath, rootUrl);
-      }
-    } else {
-      // Default: handler-registry.json at project root
-      configUrl = new URL('handler-registry.json', rootUrl);
+  register(toolName: string, handler: ToolHandler) {
+    if (this.handlers.has(toolName)) {
+      console.warn(`Handler for tool '${toolName}' is being overwritten.`);
     }
-
-    let jsonText: string;
-    try {
-      jsonText = await fs.readFile(configUrl, 'utf8');
-    } catch (err: any) {
-      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: RawRegistry;
-    try {
-      raw = JSON.parse(jsonText) as RawRegistry;
-    } 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 {
-        // Resolve module relative to project root by default
-        const modUrl = new URL(entry.module, rootUrl);
-        const mod: any = 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: DynamicHandlerFn = 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 as any
-        );
-      }
-    }
-  } catch (err) {
-    log.warn('Unexpected error while loading handler registry:', err as any);
+    this.handlers.set(toolName, handler);
   }
-}
 
-/**
- * Resolve a dynamic handler for a given tool/action pair.
- * Returns null when no handler is configured.
- */
-export async function getDynamicHandlerForTool(
-  toolName: string,
-  action?: string
-): Promise<DynamicHandlerFn | null> {
-  await loadRegistryIfNeeded();
-  if (!loadedHandlers.length) return null;
+  getHandler(toolName: string): ToolHandler | undefined {
+    return this.handlers.get(toolName);
+  }
 
-  const name = toolName;
-  const act = action;
+  hasHandler(toolName: string): boolean {
+    return this.handlers.has(toolName);
+  }
 
-  for (const handler of loadedHandlers) {
-    if (handler.tool !== name) continue;
-    if (handler.actions && act && !handler.actions.includes(act)) continue;
-    return handler.fn;
+  removeHandler(toolName: string): boolean {
+    return this.handlers.delete(toolName);
   }
 
-  return null;
+  getAllRegisteredTools(): string[] {
+    return Array.from(this.handlers.keys());
+  }
 }
+
+// Global registry instance
+export const toolRegistry = new DynamicHandlerRegistry();