unreal-engine-mcp-server 0.4.7 → 0.5.1

package/dist/resources/levels.js

@@ -1,65 +1,56 @@
-import { coerceString, interpretStandardResult } from '../utils/result-helpers.js';
+import { coerceString } from '../utils/result-helpers.js';
 export class LevelResources {
-    bridge;
+    automationBridge;
     constructor(bridge) {
-        this.bridge = bridge;
+        this.automationBridge = bridge.automationBridge;
     }
     async getCurrentLevel() {
-        // Use UnrealEditorSubsystem instead of deprecated EditorLevelLibrary
         try {
-            const py = '\nimport unreal, json\ntry:\n    # Use UnrealEditorSubsystem instead of deprecated EditorLevelLibrary\n    editor_subsys = unreal.get_editor_subsystem(unreal.UnrealEditorSubsystem)\n    world = editor_subsys.get_editor_world()\n    name = world.get_name() if world else \'None\'\n    path = world.get_path_name() if world else \'None\'\n    print(\'RESULT:\' + json.dumps({\'success\': True, \'name\': name, \'path\': path}))\nexcept Exception as e:\n    print(\'RESULT:\' + json.dumps({\'success\': False, \'error\': str(e)}))\n'.trim();
-            const resp = await this.bridge.executePython(py);
-            const interpreted = interpretStandardResult(resp, {
-                successMessage: 'Retrieved current level',
-                failureMessage: 'Failed to get current level'
-            });
-            if (interpreted.success) {
+            if (!this.automationBridge || typeof this.automationBridge.sendAutomationRequest !== 'function') {
+                return { success: false, error: 'Automation bridge is not available' };
+            }
+            const resp = await this.automationBridge.sendAutomationRequest('get_level', { action: 'get_current' });
+            if (resp && resp.success !== false && resp.result) {
                 return {
                     success: true,
-                    name: coerceString(interpreted.payload.name) ?? coerceString(interpreted.payload.level_name) ?? 'None',
-                    path: coerceString(interpreted.payload.path) ?? 'None'
+                    name: coerceString(resp.result.name) ?? 'None',
+                    path: coerceString(resp.result.path) ?? 'None'
                 };
             }
-            return { success: false, error: interpreted.error ?? interpreted.message };
+            return { success: false, error: 'Failed to get current level' };
         }
         catch (err) {
             return { error: `Failed to get current level: ${err}`, success: false };
         }
     }
     async getLevelName() {
-        // Return camera/world info via Python first
         try {
-            const py = '\nimport unreal, json\ntry:\n    # Use UnrealEditorSubsystem instead of deprecated EditorLevelLibrary\n    editor_subsys = unreal.get_editor_subsystem(unreal.UnrealEditorSubsystem)\n    world = editor_subsys.get_editor_world()\n    path = world.get_path_name() if world else \'\'\n    print(\'RESULT:\' + json.dumps({\'success\': True, \'path\': path}))\nexcept Exception as e:\n    print(\'RESULT:\' + json.dumps({\'success\': False, \'error\': str(e)}))\n'.trim();
-            const resp = await this.bridge.executePython(py);
-            const interpreted = interpretStandardResult(resp, {
-                successMessage: 'Retrieved level path',
-                failureMessage: 'Failed to get level name'
-            });
-            if (interpreted.success) {
+            if (!this.automationBridge || typeof this.automationBridge.sendAutomationRequest !== 'function') {
+                return { success: false, error: 'Automation bridge is not available' };
+            }
+            const resp = await this.automationBridge.sendAutomationRequest('get_level', { action: 'get_name' });
+            if (resp && resp.success !== false && resp.result) {
                 return {
                     success: true,
-                    path: coerceString(interpreted.payload.path) ?? ''
+                    path: coerceString(resp.result.path) ?? ''
                 };
             }
-            return { success: false, error: interpreted.error ?? interpreted.message };
+            return { success: false, error: 'Failed to get level name' };
         }
         catch (err) {
             return { error: `Failed to get level name: ${err}`, success: false };
         }
     }
     async saveCurrentLevel() {
-        // Strict modern API: require LevelEditorSubsystem
         try {
-            const py = '\nimport unreal, json\ntry:\n    les = unreal.get_editor_subsystem(unreal.LevelEditorSubsystem)\n    if not les:\n        print(\'RESULT:\' + json.dumps({\'success\': False, \'error\': \'LevelEditorSubsystem not available\'}))\n    else:\n        les.save_current_level()\n        print(\'RESULT:\' + json.dumps({\'success\': True}))\nexcept Exception as e:\n    print(\'RESULT:\' + json.dumps({\'success\': False, \'error\': str(e)}))\n'.trim();
-            const resp = await this.bridge.executePython(py);
-            const interpreted = interpretStandardResult(resp, {
-                successMessage: 'Level saved',
-                failureMessage: 'Failed to save level'
-            });
-            if (interpreted.success) {
-                return { success: true, message: interpreted.message };
+            if (!this.automationBridge || typeof this.automationBridge.sendAutomationRequest !== 'function') {
+                return { success: false, error: 'Automation bridge is not available' };
+            }
+            const resp = await this.automationBridge.sendAutomationRequest('save_level', {});
+            if (resp && resp.success !== false) {
+                return { success: true, message: 'Level saved' };
             }
-            return { success: false, error: interpreted.error ?? interpreted.message };
+            return { success: false, error: 'Failed to save level' };
         }
         catch (err) {
             return { error: `Failed to save level: ${err}`, success: false };

package/dist/server/resource-registry.d.ts

@@ -0,0 +1,20 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { UnrealBridge } from '../unreal-bridge.js';
+import { AutomationBridge } from '../automation/index.js';
+import { HealthMonitor } from '../services/health-monitor.js';
+import { AssetResources } from '../resources/assets.js';
+import { ActorResources } from '../resources/actors.js';
+import { LevelResources } from '../resources/levels.js';
+export declare class ResourceRegistry {
+    private server;
+    private bridge;
+    private automationBridge;
+    private assetResources;
+    private actorResources;
+    private levelResources;
+    private healthMonitor;
+    private ensureConnected;
+    constructor(server: Server, bridge: UnrealBridge, automationBridge: AutomationBridge, assetResources: AssetResources, actorResources: ActorResources, levelResources: LevelResources, healthMonitor: HealthMonitor, ensureConnected: () => Promise<boolean>);
+    register(): void;
+}
+//# sourceMappingURL=resource-registry.d.ts.map

package/dist/server/resource-registry.js

@@ -0,0 +1,37 @@
+import { ListResourcesRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { ResourceHandler } from '../handlers/resource-handlers.js';
+export class ResourceRegistry {
+    server;
+    bridge;
+    automationBridge;
+    assetResources;
+    actorResources;
+    levelResources;
+    healthMonitor;
+    ensureConnected;
+    constructor(server, bridge, automationBridge, assetResources, actorResources, levelResources, healthMonitor, ensureConnected) {
+        this.server = server;
+        this.bridge = bridge;
+        this.automationBridge = automationBridge;
+        this.assetResources = assetResources;
+        this.actorResources = actorResources;
+        this.levelResources = levelResources;
+        this.healthMonitor = healthMonitor;
+        this.ensureConnected = ensureConnected;
+    }
+    register() {
+        this.server.setRequestHandler(ListResourcesRequestSchema, async () => {
+            return {
+                resources: [
+                    { uri: 'ue://assets', name: 'Assets', description: 'Project assets', mimeType: 'application/json' },
+                    { uri: 'ue://health', name: 'Health Status', description: 'Server health and performance metrics', mimeType: 'application/json' },
+                    { uri: 'ue://automation-bridge', name: 'Automation Bridge', description: 'Automation bridge diagnostics and recent activity', mimeType: 'application/json' },
+                    { uri: 'ue://version', name: 'Engine Version', description: 'Unreal Engine version and compatibility info', mimeType: 'application/json' }
+                ]
+            };
+        });
+        const resourceHandler = new ResourceHandler(this.server, this.bridge, this.automationBridge, this.assetResources, this.actorResources, this.levelResources, this.healthMonitor, this.ensureConnected);
+        resourceHandler.registerHandlers();
+    }
+}
+//# sourceMappingURL=resource-registry.js.map

package/dist/server/tool-registry.d.ts

@@ -0,0 +1,23 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.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 { AssetResources } from '../resources/assets.js';
+import { ActorResources } from '../resources/actors.js';
+import { LevelResources } from '../resources/levels.js';
+export declare class ToolRegistry {
+    private server;
+    private bridge;
+    private automationBridge;
+    private logger;
+    private healthMonitor;
+    private assetResources;
+    private actorResources;
+    private levelResources;
+    private ensureConnected;
+    private defaultElicitationTimeoutMs;
+    constructor(server: Server, bridge: UnrealBridge, automationBridge: AutomationBridge, logger: Logger, healthMonitor: HealthMonitor, assetResources: AssetResources, actorResources: ActorResources, levelResources: LevelResources, ensureConnected: () => Promise<boolean>);
+    register(): void;
+}
+//# sourceMappingURL=tool-registry.d.ts.map

package/dist/server/tool-registry.js

@@ -0,0 +1,322 @@
+import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { consolidatedToolDefinitions } from '../tools/consolidated-tool-definitions.js';
+import { handleConsolidatedToolCall } from '../tools/consolidated-tool-handlers.js';
+import { responseValidator } from '../utils/response-validator.js';
+import { ErrorHandler } from '../utils/error-handler.js';
+import { cleanObject } from '../utils/safe-json.js';
+import { createElicitationHelper } from '../utils/elicitation.js';
+import { ActorTools } from '../tools/actors.js';
+import { AssetTools } from '../tools/assets.js';
+import { EditorTools } from '../tools/editor.js';
+import { MaterialTools } from '../tools/materials.js';
+import { AnimationTools } from '../tools/animation.js';
+import { PhysicsTools } from '../tools/physics.js';
+import { NiagaraTools } from '../tools/niagara.js';
+import { BlueprintTools } from '../tools/blueprint.js';
+import { LevelTools } from '../tools/level.js';
+import { LightingTools } from '../tools/lighting.js';
+import { LandscapeTools } from '../tools/landscape.js';
+import { FoliageTools } from '../tools/foliage.js';
+import { EnvironmentTools } from '../tools/environment.js';
+import { DebugVisualizationTools } from '../tools/debug.js';
+import { PerformanceTools } from '../tools/performance.js';
+import { AudioTools } from '../tools/audio.js';
+import { UITools } from '../tools/ui.js';
+import { SequenceTools } from '../tools/sequence.js';
+import { IntrospectionTools } from '../tools/introspection.js';
+import { EngineTools } from '../tools/engine.js';
+import { BehaviorTreeTools } from '../tools/behavior-tree.js';
+import { InputTools } from '../tools/input.js';
+import { LogTools } from '../tools/logs.js';
+import { getProjectSetting } from '../utils/ini-reader.js';
+export class ToolRegistry {
+    server;
+    bridge;
+    automationBridge;
+    logger;
+    healthMonitor;
+    assetResources;
+    actorResources;
+    levelResources;
+    ensureConnected;
+    defaultElicitationTimeoutMs = 60000;
+    constructor(server, bridge, automationBridge, logger, healthMonitor, assetResources, actorResources, levelResources, ensureConnected) {
+        this.server = server;
+        this.bridge = bridge;
+        this.automationBridge = automationBridge;
+        this.logger = logger;
+        this.healthMonitor = healthMonitor;
+        this.assetResources = assetResources;
+        this.actorResources = actorResources;
+        this.levelResources = levelResources;
+        this.ensureConnected = ensureConnected;
+    }
+    register() {
+        const actorTools = new ActorTools(this.bridge);
+        const assetTools = new AssetTools(this.bridge);
+        const editorTools = new EditorTools(this.bridge);
+        const materialTools = new MaterialTools(this.bridge);
+        const animationTools = new AnimationTools(this.bridge);
+        const physicsTools = new PhysicsTools(this.bridge);
+        const niagaraTools = new NiagaraTools(this.bridge);
+        const blueprintTools = new BlueprintTools(this.bridge);
+        const levelTools = new LevelTools(this.bridge);
+        const lightingTools = new LightingTools(this.bridge);
+        const landscapeTools = new LandscapeTools(this.bridge);
+        const foliageTools = new FoliageTools(this.bridge);
+        const environmentTools = new EnvironmentTools(this.bridge);
+        const debugTools = new DebugVisualizationTools(this.bridge);
+        const performanceTools = new PerformanceTools(this.bridge);
+        const audioTools = new AudioTools(this.bridge);
+        const uiTools = new UITools(this.bridge);
+        const sequenceTools = new SequenceTools(this.bridge);
+        const introspectionTools = new IntrospectionTools(this.bridge);
+        const engineTools = new EngineTools(this.bridge);
+        const behaviorTreeTools = new BehaviorTreeTools(this.bridge);
+        const inputTools = new InputTools();
+        const logTools = new LogTools(this.bridge);
+        const toolsWithAutomation = [
+            materialTools, animationTools, physicsTools, niagaraTools,
+            lightingTools, landscapeTools, foliageTools, debugTools,
+            performanceTools, audioTools, uiTools, introspectionTools,
+            engineTools, environmentTools, inputTools
+        ];
+        toolsWithAutomation.forEach(t => t.setAutomationBridge(this.automationBridge));
+        const systemTools = {
+            executeConsoleCommand: (command) => this.bridge.executeConsoleCommand(command),
+            getProjectSettings: async (section) => {
+                const category = typeof section === 'string' && section.trim().length > 0 ? section.trim() : 'Project';
+                if (!this.automationBridge || !this.automationBridge.isConnected()) {
+                    if (process.env.UE_PROJECT_PATH) {
+                        try {
+                            const settings = await getProjectSetting(process.env.UE_PROJECT_PATH, category, '');
+                            return {
+                                success: true,
+                                section: category,
+                                settings: settings || {},
+                                source: 'disk'
+                            };
+                        }
+                        catch (_diskErr) {
+                            return { success: false, error: 'Automation bridge not connected and disk read failed', section: category };
+                        }
+                    }
+                    return { success: false, error: 'Automation bridge not connected', section: category };
+                }
+                try {
+                    const resp = await this.automationBridge.sendAutomationRequest('system_control', {
+                        action: 'get_project_settings',
+                        category
+                    }, { timeoutMs: 30000 });
+                    const rawError = (resp?.error || '').toString();
+                    const msgLower = (resp?.message || '').toString().toLowerCase();
+                    const isNotImplemented = rawError.toUpperCase() === 'NOT_IMPLEMENTED' || msgLower.includes('not implemented');
+                    if (!resp || resp.success === false) {
+                        if (isNotImplemented) {
+                            if (process.env.UE_PROJECT_PATH) {
+                                try {
+                                    const settings = await getProjectSetting(process.env.UE_PROJECT_PATH, category, '');
+                                    return {
+                                        success: true,
+                                        section: category,
+                                        settings: settings || {},
+                                        source: 'disk'
+                                    };
+                                }
+                                catch (_diskErr) {
+                                }
+                            }
+                            return {
+                                success: true,
+                                section: category,
+                                settings: {
+                                    category,
+                                    available: false,
+                                    note: 'Project settings are not exposed by the current runtime but validation can proceed.'
+                                }
+                            };
+                        }
+                        return {
+                            success: false,
+                            error: rawError || resp?.message || 'Failed to get project settings',
+                            section: category,
+                            settings: resp?.result
+                        };
+                    }
+                    const result = resp.result && typeof resp.result === 'object' ? resp.result : {};
+                    const settings = (result.settings && typeof result.settings === 'object') ? result.settings : result;
+                    return {
+                        success: true,
+                        section: category,
+                        settings
+                    };
+                }
+                catch (e) {
+                    if (process.env.UE_PROJECT_PATH) {
+                        try {
+                            const settings = await getProjectSetting(process.env.UE_PROJECT_PATH, category, '');
+                            return {
+                                success: true,
+                                section: category,
+                                settings: settings || {},
+                                source: 'disk'
+                            };
+                        }
+                        catch (_diskErr) {
+                        }
+                    }
+                    return {
+                        success: false,
+                        error: `Failed to get project settings: ${e instanceof Error ? e.message : String(e)}`,
+                        section: category
+                    };
+                }
+            }
+        };
+        const elicitation = createElicitationHelper(this.server, this.logger);
+        this.server.setRequestHandler(ListToolsRequestSchema, async () => {
+            this.logger.info('Serving consolidated tools');
+            const sanitized = consolidatedToolDefinitions.map((t) => {
+                try {
+                    const copy = JSON.parse(JSON.stringify(t));
+                    delete copy.outputSchema;
+                    return copy;
+                }
+                catch (_e) {
+                    return t;
+                }
+            });
+            return { tools: sanitized };
+        });
+        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+            const { name } = request.params;
+            let args = request.params.arguments || {};
+            const startTime = Date.now();
+            const connected = await this.ensureConnected();
+            if (!connected) {
+                if (name === 'system_control' && args.action === 'get_project_settings') {
+                }
+                else if (name === 'manage_pipeline') {
+                }
+                else {
+                    this.healthMonitor.trackPerformance(startTime, false);
+                    return {
+                        content: [{ type: 'text', text: `Cannot execute tool '${name}': Unreal Engine is not connected.` }],
+                        isError: true
+                    };
+                }
+            }
+            const tools = {
+                actorTools, assetTools, materialTools, editorTools, animationTools,
+                physicsTools, niagaraTools, blueprintTools, levelTools, lightingTools,
+                landscapeTools, foliageTools, environmentTools, debugTools, performanceTools,
+                audioTools, systemTools, uiTools, sequenceTools, introspectionTools,
+                engineTools, behaviorTreeTools, inputTools, logTools,
+                elicit: elicitation.elicit,
+                supportsElicitation: elicitation.supports,
+                elicitationTimeoutMs: this.defaultElicitationTimeoutMs,
+                assetResources: this.assetResources,
+                actorResources: this.actorResources,
+                levelResources: this.levelResources,
+                bridge: this.bridge,
+                automationBridge: this.automationBridge
+            };
+            try {
+                this.logger.debug(`Executing tool: ${name}`);
+                try {
+                    const toolDef = consolidatedToolDefinitions.find(t => t.name === name);
+                    const inputSchema = toolDef?.inputSchema;
+                    const elicitFn = tools.elicit;
+                    if (inputSchema && typeof elicitFn === 'function') {
+                        const props = inputSchema.properties || {};
+                        const required = Array.isArray(inputSchema.required) ? inputSchema.required : [];
+                        const missing = required.filter((k) => {
+                            const v = args[k];
+                            if (v === undefined || v === null)
+                                return true;
+                            if (typeof v === 'string' && v.trim() === '')
+                                return true;
+                            return false;
+                        });
+                        const primitiveProps = {};
+                        for (const k of missing) {
+                            const p = props[k];
+                            if (!p || typeof p !== 'object')
+                                continue;
+                            const t = (p.type || '').toString();
+                            const isEnum = Array.isArray(p.enum);
+                            if (t === 'string' || t === 'number' || t === 'integer' || t === 'boolean' || isEnum) {
+                                primitiveProps[k] = {
+                                    type: t || (isEnum ? 'string' : undefined),
+                                    title: p.title,
+                                    description: p.description,
+                                    enum: p.enum,
+                                    enumNames: p.enumNames,
+                                    minimum: p.minimum,
+                                    maximum: p.maximum,
+                                    minLength: p.minLength,
+                                    maxLength: p.maxLength,
+                                    pattern: p.pattern,
+                                    format: p.format,
+                                    default: p.default
+                                };
+                            }
+                        }
+                        if (Object.keys(primitiveProps).length > 0) {
+                            const elicitOptions = { fallback: async () => ({ ok: false, error: 'missing-params' }) };
+                            if (typeof tools.elicitationTimeoutMs === 'number' && Number.isFinite(tools.elicitationTimeoutMs)) {
+                                elicitOptions.timeoutMs = tools.elicitationTimeoutMs;
+                            }
+                            const elicitRes = await elicitFn(`Provide missing parameters for ${name}`, { type: 'object', properties: primitiveProps, required: Object.keys(primitiveProps) }, elicitOptions);
+                            if (elicitRes && elicitRes.ok && elicitRes.value) {
+                                args = { ...args, ...elicitRes.value };
+                            }
+                        }
+                    }
+                }
+                catch (e) {
+                    this.logger.debug('Generic elicitation prefill skipped', { err: e?.message || String(e) });
+                }
+                let result = await handleConsolidatedToolCall(name, args, tools);
+                this.logger.debug(`Tool ${name} returned result`);
+                result = cleanObject(result);
+                const explicitSuccess = typeof result?.success === 'boolean' ? Boolean(result.success) : undefined;
+                const wrappedResult = await responseValidator.wrapResponse(name, result);
+                let wrappedSuccess = undefined;
+                try {
+                    const sc = wrappedResult.structuredContent;
+                    if (sc && typeof sc.success === 'boolean')
+                        wrappedSuccess = Boolean(sc.success);
+                }
+                catch { }
+                const isErrorResponse = Boolean(wrappedResult?.isError === true);
+                const tentative = explicitSuccess ?? wrappedSuccess;
+                const finalSuccess = tentative === true && !isErrorResponse;
+                this.healthMonitor.trackPerformance(startTime, finalSuccess);
+                const durationMs = Date.now() - startTime;
+                if (finalSuccess) {
+                    this.logger.info(`Tool ${name} completed successfully in ${durationMs}ms`);
+                }
+                else {
+                    this.logger.warn(`Tool ${name} completed with errors in ${durationMs}ms`);
+                }
+                const responsePreview = JSON.stringify(wrappedResult).substring(0, 100);
+                this.logger.debug(`Returning response to MCP client: ${responsePreview}...`);
+                return wrappedResult;
+            }
+            catch (error) {
+                this.healthMonitor.trackPerformance(startTime, false);
+                const errorResponse = ErrorHandler.createErrorResponse(error, name, { ...args, scope: `tool-call/${name}` });
+                this.logger.error(`Tool execution failed: ${name}`, errorResponse);
+                this.healthMonitor.recordError(errorResponse);
+                const sanitizedError = cleanObject(errorResponse);
+                try {
+                    sanitizedError.isError = true;
+                }
+                catch { }
+                return responseValidator.wrapResponse(name, sanitizedError);
+            }
+        });
+    }
+}
+//# sourceMappingURL=tool-registry.js.map

package/dist/server-setup.d.ts

@@ -0,0 +1,20 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.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';
+export declare class ServerSetup {
+    private server;
+    private bridge;
+    private automationBridge;
+    private logger;
+    private healthMonitor;
+    private assetResources;
+    private actorResources;
+    private levelResources;
+    constructor(server: Server, bridge: UnrealBridge, automationBridge: AutomationBridge, logger: Logger, healthMonitor: HealthMonitor);
+    setup(): Promise<void>;
+    private validateEnvironment;
+    private ensureConnectedOnDemand;
+}
+//# sourceMappingURL=server-setup.d.ts.map

package/dist/server-setup.js

@@ -0,0 +1,71 @@
+import { AssetResources } from './resources/assets.js';
+import { ActorResources } from './resources/actors.js';
+import { LevelResources } from './resources/levels.js';
+import { ResourceRegistry } from './server/resource-registry.js';
+import { ToolRegistry } from './server/tool-registry.js';
+import fs from 'fs';
+export class ServerSetup {
+    server;
+    bridge;
+    automationBridge;
+    logger;
+    healthMonitor;
+    assetResources;
+    actorResources;
+    levelResources;
+    constructor(server, bridge, automationBridge, logger, healthMonitor) {
+        this.server = server;
+        this.bridge = bridge;
+        this.automationBridge = automationBridge;
+        this.logger = logger;
+        this.healthMonitor = healthMonitor;
+        this.assetResources = new AssetResources(bridge);
+        this.actorResources = new ActorResources(bridge);
+        this.levelResources = new LevelResources(bridge);
+    }
+    async setup() {
+        this.validateEnvironment();
+        const ensureConnected = this.ensureConnectedOnDemand.bind(this);
+        const resourceRegistry = new ResourceRegistry(this.server, this.bridge, this.automationBridge, this.assetResources, this.actorResources, this.levelResources, this.healthMonitor, ensureConnected);
+        resourceRegistry.register();
+        const toolRegistry = new ToolRegistry(this.server, this.bridge, this.automationBridge, this.logger, this.healthMonitor, this.assetResources, this.actorResources, this.levelResources, ensureConnected);
+        toolRegistry.register();
+    }
+    validateEnvironment() {
+        const projectPath = process.env.UE_PROJECT_PATH;
+        if (projectPath) {
+            if (!fs.existsSync(projectPath)) {
+                this.logger.warn(`UE_PROJECT_PATH is set to '${projectPath}' but the path does not exist.`);
+            }
+            else {
+                this.logger.info(`UE_PROJECT_PATH validated: ${projectPath}`);
+            }
+        }
+        else {
+            this.logger.info('UE_PROJECT_PATH is not set. Offline project settings fallback will be disabled.');
+        }
+        const enginePath = process.env.UE_ENGINE_PATH || process.env.UNREAL_ENGINE_PATH;
+        if (enginePath) {
+            if (!fs.existsSync(enginePath)) {
+                this.logger.warn(`UE_ENGINE_PATH is set to '${enginePath}' but the path does not exist.`);
+            }
+            else {
+                this.logger.info(`UE_ENGINE_PATH validated: ${enginePath}`);
+            }
+        }
+    }
+    async ensureConnectedOnDemand() {
+        if (this.bridge.isConnected)
+            return true;
+        const ok = await this.bridge.tryConnect(3, 5000, 1000);
+        if (ok) {
+            this.healthMonitor.metrics.connectionStatus = 'connected';
+            this.healthMonitor.startHealthChecks(this.bridge);
+        }
+        else {
+            this.healthMonitor.metrics.connectionStatus = 'disconnected';
+        }
+        return ok;
+    }
+}
+//# sourceMappingURL=server-setup.js.map

package/dist/services/health-monitor.d.ts

@@ -0,0 +1,34 @@
+import { UnrealBridge } from '../unreal-bridge.js';
+import { Logger } from '../utils/logger.js';
+export interface PerformanceMetrics {
+    totalRequests: number;
+    successfulRequests: number;
+    failedRequests: number;
+    averageResponseTime: number;
+    responseTimes: number[];
+    connectionStatus: 'connected' | 'disconnected' | 'error';
+    lastHealthCheck: Date;
+    uptime: number;
+    recentErrors: Array<{
+        time: string;
+        scope: string;
+        type: string;
+        message: string;
+        retriable: boolean;
+    }>;
+}
+export declare class HealthMonitor {
+    private logger;
+    metrics: PerformanceMetrics;
+    private healthCheckTimer;
+    private lastHealthSuccessAt;
+    private readonly HEALTH_CHECK_INTERVAL_MS;
+    constructor(logger: Logger);
+    trackPerformance(startTime: number, success: boolean): void;
+    recordError(errorResponse: any): void;
+    performHealthCheck(bridge: UnrealBridge): Promise<boolean>;
+    startHealthChecks(bridge: UnrealBridge): void;
+    stopHealthChecks(): void;
+    setLastHealthSuccessAt(time: number): void;
+}
+//# sourceMappingURL=health-monitor.d.ts.map