unreal-engine-mcp-server 0.5.21 → 0.6.0-a

package/dist/server/tool-registry.js

@@ -1,47 +1,20 @@
 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 { BlueprintTools } from '../tools/blueprint.js';
-import { LevelTools } from '../tools/level.js';
-import { LandscapeTools } from '../tools/landscape.js';
-import { FoliageTools } from '../tools/foliage.js';
-import { EnvironmentTools } from '../tools/environment.js';
-import { SequenceTools } from '../tools/sequence.js';
-import { LogTools } from '../tools/logs.js';
-import { getProjectSetting } from '../utils/ini-reader.js';
-import { config } from '../config.js';
-import { mcpClients } from 'mcp-client-capabilities';
-import { dynamicToolManager } from '../tools/dynamic-tool-manager.js';
-function parseDefaultCategories() {
-    const raw = config.MCP_DEFAULT_CATEGORIES || 'core';
-    const cats = raw.split(',').map(c => c.trim().toLowerCase()).filter(c => c.length > 0);
-    return cats.length > 0 ? cats : ['core'];
-}
-function clientSupportsListChanged(clientName) {
-    if (!clientName)
-        return false;
-    const normalizedName = clientName.toLowerCase().trim();
-    for (const [key, clientInfo] of Object.entries(mcpClients)) {
-        if (key.toLowerCase() === normalizedName ||
-            (clientInfo.title && clientInfo.title.toLowerCase() === normalizedName)) {
-            const tools = clientInfo.tools;
-            return Boolean(tools?.listChanged);
-        }
-    }
-    const knownDynamicClients = ['cursor', 'cline', 'windsurf', 'kilo', 'opencode', 'vscode', 'visual studio code'];
-    for (const known of knownDynamicClients) {
-        if (normalizedName.includes(known))
-            return true;
-    }
-    return false;
-}
+import { actionClassForGatewayArgs, failureClassForError } from '../services/telemetry-observation.js';
+import { responseValidator } from '../utils/responses/response-validator.js';
+import { ErrorHandler } from '../utils/responses/error-handler.js';
+import { cleanObject } from '../utils/serialization/safe-json.js';
+import { isRecord } from '../utils/validation/type-guards.js';
+import { redactImagePayloadForLog } from '../utils/logging/log-redaction.js';
+import { createElicitationHelper } from '../utils/interaction/elicitation.js';
+import { getProjectSetting } from '../utils/config/ini-reader.js';
+import { canonicalizeMcpRequestId, runWithMcpRequestContext } from '../automation/request-context.js';
+import { readProgressToken } from './mcp-primitives/progress/progress-token.js';
+import { createProgressReporter } from './mcp-primitives/progress/progress-reporter.js';
+import { ProgressSinkRegistry } from './mcp-primitives/progress/progress-sink-registry.js';
+import { runTaskCheckpoint, taskCheckpointRefusal } from './mcp-primitives/task-checkpoint.js';
+import { handleUnrealGatewayCall } from './tool-registry-gateway.js';
+import { buildGatewayToolDefinition } from './tool-registry-listing.js';
+import { buildDirectCallMigration } from './gateway/direct-call-migration.js';
 export class ToolRegistry {
     server;
     bridge;
@@ -53,7 +26,7 @@ export class ToolRegistry {
     levelResources;
     ensureConnected;
     defaultElicitationTimeoutMs = 60000;
-    currentCategories = parseDefaultCategories();
+    progressSinks = new ProgressSinkRegistry();
     constructor(server, bridge, automationBridge, logger, healthMonitor, assetResources, actorResources, levelResources, ensureConnected) {
         this.server = server;
         this.bridge = bridge;
@@ -65,522 +38,199 @@ export class ToolRegistry {
         this.levelResources = levelResources;
         this.ensureConnected = ensureConnected;
     }
-    async handlePipelineCall(args) {
-        const action = args.action;
-        if (action === 'set_categories') {
-            const newCats = Array.isArray(args.categories) ? args.categories : [];
-            this.currentCategories = newCats.length > 0 ? newCats : ['all'];
-            this.logger.info(`MCP Categories updated to: ${this.currentCategories.join(', ')}`);
-            this.server.notification({
-                method: 'notifications/tools/list_changed',
-                params: {}
-            }).catch(err => this.logger.error('Failed to send list_changed notification', err));
-            return { success: true, message: `Categories updated to ${this.currentCategories.join(', ')}`, categories: this.currentCategories };
-        }
-        else if (action === 'list_categories') {
-            const categories = dynamicToolManager.listCategories();
+    async readProjectSettingsFromDisk(category) {
+        if (!process.env.UE_PROJECT_PATH)
+            return undefined;
+        try {
+            const settings = await getProjectSetting(process.env.UE_PROJECT_PATH, category, '');
             return {
                 success: true,
-                categories: this.currentCategories,
-                available: ['core', 'world', 'authoring', 'gameplay', 'utility', 'all'],
-                categoryDetails: categories.map(c => ({
-                    name: c.name,
-                    enabled: c.enabled,
-                    toolCount: c.toolCount,
-                    enabledCount: c.enabledCount
-                }))
+                section: category,
+                settings: settings || {},
+                source: 'disk'
             };
         }
-        else if (action === 'get_status') {
-            const status = dynamicToolManager.getStatus();
-            return {
-                success: true,
-                categories: this.currentCategories,
-                toolCount: status.totalTools,
-                enabledCount: status.enabledTools,
-                disabledCount: status.disabledTools,
-                filteredCount: dynamicToolManager.getEnabledToolDefinitions().length
-            };
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.logger.debug('Disk project settings fallback failed', { error: message, section: category });
+            return undefined;
         }
-        return { _delegateToHandler: true, action, args };
     }
-    async handleManageToolsCall(args) {
-        const action = args.action;
-        const getStringArray = (key) => {
-            const val = args[key];
-            if (Array.isArray(val)) {
-                return val.filter((v) => typeof v === 'string');
-            }
-            return [];
-        };
-        const getString = (key) => {
-            const val = args[key];
-            return typeof val === 'string' ? val : undefined;
-        };
-        switch (action) {
-            case 'list_tools': {
-                const toolStates = dynamicToolManager.listTools();
-                const tools = toolStates.map(state => ({
-                    name: state.name,
-                    enabled: state.enabled,
-                    category: state.category,
-                    description: state.description.substring(0, 100) + (state.description.length > 100 ? '...' : '')
-                }));
-                const status = dynamicToolManager.getStatus();
-                return {
-                    success: true,
-                    tools,
-                    totalTools: status.totalTools,
-                    enabledCount: status.enabledTools,
-                    disabledCount: status.disabledTools,
-                    message: `Listed ${tools.length} tools (${status.enabledTools} enabled, ${status.disabledTools} disabled)`
-                };
-            }
-            case 'list_categories': {
-                const categories = dynamicToolManager.listCategories();
-                return {
-                    success: true,
-                    categories: categories.map(cat => ({
-                        name: cat.name,
-                        enabled: cat.enabled,
-                        toolCount: cat.toolCount,
-                        enabledCount: cat.enabledCount
-                    })),
-                    totalCategories: categories.length,
-                    message: `Listed ${categories.length} categories`
-                };
-            }
-            case 'enable_tools': {
-                const toolNames = getStringArray('tools').length > 0
-                    ? getStringArray('tools')
-                    : getStringArray('toolNames');
-                if (toolNames.length === 0) {
-                    return { success: false, error: 'No tools specified. Provide tools array.', errorCode: 'MISSING_TOOLS' };
-                }
-                const result = dynamicToolManager.enableTools(toolNames);
-                return {
-                    success: true,
-                    enabled: result.enabled,
-                    notFound: result.notFound,
-                    message: result.notFound.length > 0
-                        ? `Enabled ${result.enabled.length} tools. ${result.notFound.length} not found.`
-                        : `Enabled ${result.enabled.length} tools`
-                };
-            }
-            case 'disable_tools': {
-                const toolNames = getStringArray('tools').length > 0
-                    ? getStringArray('tools')
-                    : getStringArray('toolNames');
-                if (toolNames.length === 0) {
-                    return { success: false, error: 'No tools specified. Provide tools array.', errorCode: 'MISSING_TOOLS' };
-                }
-                const result = dynamicToolManager.disableTools(toolNames);
-                if (result.protected.length > 0 && result.disabled.length === 0) {
-                    return {
-                        success: false,
-                        error: `Cannot disable protected tools: ${result.protected.join(', ')}`,
-                        errorCode: 'PROTECTED_TOOLS'
-                    };
-                }
-                const messages = [];
-                if (result.disabled.length > 0)
-                    messages.push(`Disabled ${result.disabled.length} tools`);
-                if (result.notFound.length > 0)
-                    messages.push(`${result.notFound.length} not found`);
-                if (result.protected.length > 0)
-                    messages.push(`${result.protected.length} protected`);
-                return {
-                    success: true,
-                    disabled: result.disabled,
-                    notFound: result.notFound,
-                    protected: result.protected,
-                    message: messages.join('. ')
-                };
-            }
-            case 'enable_category': {
-                const category = getString('category');
-                if (!category) {
-                    return { success: false, error: 'No category specified.', errorCode: 'MISSING_CATEGORY' };
-                }
-                const validCategories = ['core', 'world', 'authoring', 'gameplay', 'utility'];
-                if (!validCategories.includes(category)) {
-                    return {
-                        success: false,
-                        error: `Invalid category '${category}'. Valid: ${validCategories.join(', ')}`,
-                        errorCode: 'INVALID_CATEGORY'
-                    };
-                }
-                const result = dynamicToolManager.enableCategory(category);
-                if (result.notFound) {
-                    return { success: false, error: `Category '${category}' not found`, errorCode: 'CATEGORY_NOT_FOUND' };
-                }
-                return {
-                    success: true,
-                    category,
-                    enabled: result.enabled,
-                    message: `Enabled category '${category}' (${result.enabled.length} tools)`
-                };
-            }
-            case 'disable_category': {
-                const category = getString('category');
-                if (!category) {
-                    return { success: false, error: 'No category specified.', errorCode: 'MISSING_CATEGORY' };
-                }
-                const validCategories = ['core', 'world', 'authoring', 'gameplay', 'utility'];
-                if (!validCategories.includes(category)) {
-                    return {
-                        success: false,
-                        error: `Invalid category '${category}'. Valid: ${validCategories.join(', ')}`,
-                        errorCode: 'INVALID_CATEGORY'
-                    };
-                }
-                const result = dynamicToolManager.disableCategory(category);
-                if (result.notFound) {
-                    return { success: false, error: `Category '${category}' not found`, errorCode: 'CATEGORY_NOT_FOUND' };
-                }
-                if (result.protected.length > 0 && result.disabled.length === 0) {
-                    return {
-                        success: false,
-                        error: `Cannot fully disable protected category '${category}'. Protected tools: ${result.protected.join(', ')}`,
-                        errorCode: 'PROTECTED_CATEGORY'
-                    };
-                }
-                return {
-                    success: true,
-                    category,
-                    disabled: result.disabled,
-                    protected: result.protected,
-                    message: `Disabled category '${category}' (${result.disabled.length} tools disabled)`
-                };
-            }
-            case 'get_status': {
-                const status = dynamicToolManager.getStatus();
-                return {
-                    success: true,
-                    totalTools: status.totalTools,
-                    enabledTools: status.enabledTools,
-                    disabledTools: status.disabledTools,
-                    categories: status.categories.map(cat => ({
-                        name: cat.name,
-                        enabled: cat.enabled,
-                        toolCount: cat.toolCount,
-                        enabledCount: cat.enabledCount
-                    })),
-                    message: `${status.enabledTools}/${status.totalTools} tools enabled`
-                };
-            }
-            case 'reset': {
-                const result = dynamicToolManager.reset();
-                return {
-                    success: true,
-                    enabled: result.enabled,
-                    message: `Reset complete. ${result.enabled} tools re-enabled.`
-                };
-            }
-            default:
-                return {
-                    success: false,
-                    error: `Unknown action: ${action}. Available: list_tools, list_categories, enable_tools, disable_tools, enable_category, disable_category, get_status, reset`,
-                    errorCode: 'UNKNOWN_ACTION'
-                };
-        }
-    }
-    register() {
-        const actorTools = new ActorTools(this.bridge);
-        const assetTools = new AssetTools(this.bridge);
-        const editorTools = new EditorTools(this.bridge);
-        const blueprintTools = new BlueprintTools(this.bridge);
-        const levelTools = new LevelTools(this.bridge);
-        const landscapeTools = new LandscapeTools(this.bridge);
-        const foliageTools = new FoliageTools(this.bridge);
-        const environmentTools = new EnvironmentTools(this.bridge);
-        const sequenceTools = new SequenceTools(this.bridge);
-        const logTools = new LogTools(this.bridge);
-        environmentTools.setAutomationBridge(this.automationBridge);
-        const systemTools = {
+    buildSystemTools() {
+        return {
             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 };
+                    const diskSettings = await this.readProjectSettingsFromDisk(category);
+                    if (diskSettings)
+                        return diskSettings;
+                    const error = process.env.UE_PROJECT_PATH
+                        ? 'Automation bridge not connected and disk read failed'
+                        : 'Automation bridge not connected';
+                    return { success: false, error, section: category };
                 }
                 try {
                     const resp = await this.automationBridge.sendAutomationRequest('system_control', {
-                        action: 'get_project_settings',
-                        category
+                        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.'
-                                }
-                            };
+                            const diskSettings = await this.readProjectSettingsFromDisk(category);
+                            if (diskSettings)
+                                return diskSettings;
+                            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
-                        };
+                        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
-                    };
+                    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 diskSettings = await this.readProjectSettingsFromDisk(category);
+                    if (diskSettings)
+                        return diskSettings;
+                    return { success: false, error: `Failed to get project settings: ${e instanceof Error ? e.message : String(e)}`, section: category };
                 }
             }
         };
+    }
+    register() {
+        const systemTools = this.buildSystemTools();
         const elicitation = createElicitationHelper(this.server, this.logger);
+        const tools = {
+            systemTools,
+            elicit: elicitation.elicit,
+            supportsElicitation: elicitation.supports,
+            elicitationTimeoutMs: this.defaultElicitationTimeoutMs,
+            assetResources: this.assetResources,
+            actorResources: this.actorResources,
+            levelResources: this.levelResources,
+            bridge: this.bridge,
+            automationBridge: this.automationBridge
+        };
         this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-            let supportsListChanged = false;
-            let clientName;
-            try {
-                const serverObj = this.server;
-                const clientInfo = serverObj._clientVersion;
-                clientName = clientInfo?.name;
-                supportsListChanged = clientSupportsListChanged(clientName);
-                this.logger.debug(`Client detection: name=${clientName}, supportsListChanged=${supportsListChanged}`);
-            }
-            catch (_e) {
-                supportsListChanged = false;
-            }
-            const effectiveCategories = (!supportsListChanged || this.currentCategories.includes('all'))
-                ? ['all']
-                : this.currentCategories;
-            this.logger.info(`Serving tools for categories: ${effectiveCategories.join(', ')} (client=${clientName || 'unknown'}, supportsListChanged=${supportsListChanged})`);
-            const allTools = dynamicToolManager.getAllToolDefinitions();
-            const status = dynamicToolManager.getStatus();
-            const filtered = allTools
-                .filter((t) => {
-                if (!dynamicToolManager.isToolEnabled(t.name))
-                    return false;
-                const category = t.category;
-                if (category && !effectiveCategories.includes(category) && !effectiveCategories.includes('all')) {
-                    return false;
-                }
-                if (!supportsListChanged && t.name === 'manage_pipeline')
-                    return false;
-                return true;
-            });
-            this.logger.debug(`Tool filtering: ${status.enabledTools}/${status.totalTools} enabled, ${filtered.length} visible`);
-            const sanitized = filtered.map((t) => {
-                try {
-                    const copy = JSON.parse(JSON.stringify(t));
-                    delete copy.outputSchema;
-                    return copy;
-                }
-                catch (_e) {
-                    return t;
-                }
-            });
-            return { tools: sanitized };
+            this.logger.debug('Serving gateway tool list (static single-tool mode)');
+            return { tools: [buildGatewayToolDefinition()] };
         });
-        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        this.automationBridge.setRequestProgressListener((mcpRequestId, update) => this.progressSinks.report(mcpRequestId, update));
+        this.automationBridge.setRequestCancelledListener((mcpRequestId) => this.progressSinks.close(mcpRequestId));
+        const previousOnClose = this.server.onclose;
+        this.server.onclose = () => {
+            this.progressSinks.clear();
+            previousOnClose?.();
+        };
+        this.server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
             const { name } = request.params;
-            let args = request.params.arguments || {};
-            if (name === 'manage_pipeline') {
-                const result = await this.handlePipelineCall(args);
-                if (result._delegateToHandler) {
-                }
-                else {
-                    return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-                }
-            }
-            if (name === 'manage_tools') {
-                const result = await this.handleManageToolsCall(args);
-                const action = args.action;
-                if (['enable_tools', 'disable_tools', 'enable_category', 'disable_category', 'reset'].includes(action || '')) {
-                    this.server.notification({
-                        method: 'notifications/tools/list_changed',
-                        params: {}
-                    }).catch(err => this.logger.error('Failed to send list_changed notification', err));
-                }
-                return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-            }
+            const 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 {
-                    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, editorTools, blueprintTools, levelTools,
-                landscapeTools, foliageTools, environmentTools, sequenceTools, logTools,
-                systemTools,
-                elicit: elicitation.elicit,
-                supportsElicitation: elicitation.supports,
-                elicitationTimeoutMs: this.defaultElicitationTimeoutMs,
-                assetResources: this.assetResources,
-                actorResources: this.actorResources,
-                levelResources: this.levelResources,
-                bridge: this.bridge,
-                automationBridge: this.automationBridge
+            const actionClass = actionClassForGatewayArgs(args);
+            const mcpRequestId = extra.requestId !== undefined
+                ? canonicalizeMcpRequestId(extra.requestId)
+                : undefined;
+            const progress = createProgressReporter({
+                token: readProgressToken(extra._meta),
+                notify: (notification) => extra.sendNotification(notification),
+                onError: (error) => this.logger.debug('Progress notification dropped', {
+                    error: error instanceof Error ? error.message : String(error)
+                })
+            });
+            if (mcpRequestId)
+                this.progressSinks.register(mcpRequestId, progress);
+            let progressEnded = false;
+            const endProgress = () => {
+                if (progressEnded)
+                    return;
+                progressEnded = true;
+                progress.close();
+                if (mcpRequestId)
+                    this.progressSinks.unregister(mcpRequestId);
             };
-            try {
-                this.logger.debug(`Executing tool: ${name}`);
+            if (mcpRequestId && extra.signal) {
+                extra.signal.addEventListener('abort', () => {
+                    endProgress();
+                    this.automationBridge.cancelMcpRequest(mcpRequestId, 'Client aborted request');
+                }, { once: true });
+            }
+            const withRequestContext = (fn) => mcpRequestId
+                ? runWithMcpRequestContext({ requestId: mcpRequestId, signal: extra.signal }, fn)
+                : fn();
+            const taskCreation = request.params.task;
+            if (taskCreation !== undefined) {
+                const refusal = taskCheckpointRefusal(name, args, extra.taskStore);
+                if (refusal) {
+                    endProgress();
+                    this.healthMonitor.trackPerformance(startTime, false, { actionClass, failureClass: 'validation' });
+                    throw refusal;
+                }
+            }
+            if (name !== 'unreal') {
+                endProgress();
+                this.healthMonitor.trackPerformance(startTime, false, { actionClass, failureClass: 'validation' });
+                const migration = buildDirectCallMigration(name, args);
+                return responseValidator.wrapResponse('unreal', migration);
+            }
+            const runGateway = async () => {
                 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) {
-                                const schemaType = (isEnum ? 'string' : t);
-                                primitiveProps[k] = {
-                                    type: schemaType,
-                                    title: typeof p.title === 'string' ? p.title : undefined,
-                                    description: typeof p.description === 'string' ? p.description : undefined,
-                                    enum: Array.isArray(p.enum) ? p.enum : undefined,
-                                    enumNames: Array.isArray(p.enumNames) ? p.enumNames : undefined,
-                                    minimum: typeof p.minimum === 'number' ? p.minimum : undefined,
-                                    maximum: typeof p.maximum === 'number' ? p.maximum : undefined,
-                                    minLength: typeof p.minLength === 'number' ? p.minLength : undefined,
-                                    maxLength: typeof p.maxLength === 'number' ? p.maxLength : undefined,
-                                    pattern: typeof p.pattern === 'string' ? p.pattern : undefined,
-                                    format: typeof p.format === 'string' ? p.format : undefined,
-                                    default: (typeof p.default === 'string' || typeof p.default === 'number' || typeof p.default === 'boolean') ? p.default : undefined
-                                };
-                            }
-                        }
-                        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 };
-                            }
-                        }
+                    const context = { tools, logger: this.logger, elicitationTimeoutMs: this.defaultElicitationTimeoutMs, ensureConnected: this.ensureConnected };
+                    const gatewayResult = cleanObject(await withRequestContext(() => handleUnrealGatewayCall(args, context)));
+                    const wrapped = await responseValidator.wrapResponse('unreal', gatewayResult);
+                    const resultObj = gatewayResult;
+                    const explicitSuccess = typeof resultObj?.success === 'boolean' ? Boolean(resultObj.success) : undefined;
+                    let wrappedSuccess = undefined;
+                    if (isRecord(wrapped.structuredContent)) {
+                        const sc = wrapped.structuredContent;
+                        if (sc && typeof sc.success === 'boolean')
+                            wrappedSuccess = Boolean(sc.success);
                     }
+                    const isErrorResponse = Boolean(wrapped.isError === true);
+                    const finalSuccess = (explicitSuccess ?? wrappedSuccess) === true && !isErrorResponse;
+                    this.healthMonitor.trackPerformance(startTime, finalSuccess, {
+                        actionClass,
+                        ...(finalSuccess ? {} : { failureClass: failureClassForError(resultObj) })
+                    });
+                    if (this.logger.isEnabled('debug')) {
+                        const preview = JSON.stringify(redactImagePayloadForLog(wrapped)).substring(0, 100);
+                        this.logger.debug(`Returning gateway response to MCP client: ${preview}...`);
+                    }
+                    return wrapped;
+                }
+                catch (error) {
+                    this.healthMonitor.trackPerformance(startTime, false, { actionClass, failureClass: failureClassForError(error) });
+                    const normalizedError = error instanceof Error || isRecord(error) ? error : String(error);
+                    const errorResponse = ErrorHandler.createErrorResponse(normalizedError, 'unreal', { ...args, scope: 'tool-call/unreal' });
+                    this.logger.error('Gateway tool execution failed', errorResponse);
+                    if (isRecord(errorResponse))
+                        this.healthMonitor.recordError(errorResponse);
+                    const sanitizedError = cleanObject(errorResponse);
+                    if (isRecord(sanitizedError)) {
+                        sanitizedError.isError = true;
+                        return responseValidator.wrapResponse('unreal', sanitizedError);
+                    }
+                    return responseValidator.wrapResponse('unreal', { success: false, isError: true, operation: 'execute', error: 'UNKNOWN_ERROR', message: 'Failed to execute unreal gateway' });
                 }
-                catch (e) {
-                    const errObj = e;
-                    this.logger.debug('Generic elicitation prefill skipped', { err: errObj?.message ? String(errObj.message) : String(e) });
+                finally {
+                    endProgress();
                 }
-                let result = await handleConsolidatedToolCall(name, args, tools);
-                this.logger.debug(`Tool ${name} returned result`);
-                result = cleanObject(result);
-                const resultObj = result;
-                const explicitSuccess = typeof resultObj?.success === 'boolean' ? Boolean(resultObj.success) : undefined;
-                const wrappedResult = await responseValidator.wrapResponse(name, result);
-                let wrappedSuccess = undefined;
+            };
+            if (taskCreation !== undefined && extra.taskStore !== undefined) {
                 try {
-                    const wrappedObj = wrappedResult;
-                    const sc = wrappedObj.structuredContent;
-                    if (sc && typeof sc.success === 'boolean')
-                        wrappedSuccess = Boolean(sc.success);
+                    return await runTaskCheckpoint({
+                        taskStore: extra.taskStore,
+                        taskCreation,
+                        run: runGateway
+                    });
                 }
-                catch { }
-                const wrappedResultObj = wrappedResult;
-                const isErrorResponse = Boolean(wrappedResultObj?.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 (error) {
+                    endProgress();
+                    throw error;
                 }
-                catch { }
-                return responseValidator.wrapResponse(name, sanitizedError);
             }
+            return await runGateway();
         });
     }
 }