unreal-engine-mcp-server 0.6.0-beta-e → 0.6.0

package/dist/server/mcp-primitives/progress/progress-token.d.ts

@@ -1,3 +0,0 @@
-export type ProgressToken = string | number;
-export declare function readProgressToken(meta: unknown): ProgressToken | undefined;
-//# sourceMappingURL=progress-token.d.ts.map

package/dist/server/mcp-primitives/progress/progress-token.js

@@ -1,12 +0,0 @@
-import { isRecord } from '../../../utils/validation/type-guards.js';
-export function readProgressToken(meta) {
-    if (!isRecord(meta))
-        return undefined;
-    const token = meta.progressToken;
-    if (typeof token === 'string')
-        return token;
-    if (typeof token === 'number' && Number.isFinite(token))
-        return token;
-    return undefined;
-}
-//# sourceMappingURL=progress-token.js.map

package/dist/server/mcp-primitives/prompts.d.ts

@@ -1,43 +0,0 @@
-interface PromptStep {
-    readonly summary: string;
-    readonly capabilityId: string;
-    readonly parentTool: string;
-    readonly action: string;
-    readonly resourceUri?: string;
-    readonly safety: string;
-}
-export interface WorkflowPrompt {
-    readonly id: string;
-    readonly title: string;
-    readonly description: string;
-    readonly arguments: readonly {
-        readonly name: string;
-        readonly description: string;
-        readonly required: boolean;
-        readonly allowed?: readonly string[];
-    }[];
-    readonly steps: readonly PromptStep[];
-}
-export declare const WORKFLOW_PROMPTS: readonly WorkflowPrompt[];
-export declare function listPrompts(): {
-    name: string;
-    title: string;
-    description: string;
-    arguments: {
-        name: string;
-        description: string;
-        required: boolean;
-    }[];
-}[];
-export declare function getPrompt(name: string, args: Readonly<Record<string, string>>): {
-    description: string;
-    messages: {
-        role: 'user';
-        content: {
-            type: 'text';
-            text: string;
-        };
-    }[];
-};
-export {};
-//# sourceMappingURL=prompts.d.ts.map

package/dist/server/mcp-primitives/prompts.js

@@ -1,142 +0,0 @@
-import { ErrorCode, McpError } from '@modelcontextprotocol/sdk/types.js';
-export const WORKFLOW_PROMPTS = [
-    {
-        id: 'inspect-fix',
-        title: 'Inspect and fix an object property',
-        description: 'Walk through inspecting a UObject and correcting a single property, one reviewed call at a time.',
-        arguments: [
-            { name: 'objectPath', description: 'Content path of the object to inspect', required: true },
-            { name: 'propertyName', description: 'Name of the property to review', required: false },
-            { name: 'newValue', description: 'Value you intend to set, for your reference', required: false },
-        ],
-        steps: [
-            { summary: 'Read the current editor selection to confirm the target.', capabilityId: 'inspect.get_selected_actors', parentTool: 'inspect', action: 'get_selected_actors', resourceUri: 'ue://selection', safety: 'Confirm the selected actor is the intended target before reading or changing anything.' },
-            { summary: 'Introspect the object and its components.', capabilityId: 'inspect.inspect_object', parentTool: 'inspect', action: 'inspect_object', resourceUri: 'ue://asset/{assetPath}', safety: 'Inspection is read-only; use it to understand the object before any edit.' },
-            { summary: 'Read the specific property you plan to change.', capabilityId: 'inspect.get_property', parentTool: 'inspect', action: 'get_property', safety: 'Note the current value so you can revert the change by hand if needed.' },
-            { summary: 'Apply the fix to a single property.', capabilityId: 'inspect.set_property', parentTool: 'inspect', action: 'set_property', safety: 'Review the new value; this edits editor state only when you run the call yourself.' },
-        ],
-    },
-    {
-        id: 'asset-import',
-        title: 'Import an asset into the project',
-        description: 'Check the destination, import from a source you supply, then validate the result.',
-        arguments: [
-            { name: 'destinationPath', description: 'Content folder to import into', required: true },
-            { name: 'sourceFormat', description: 'Source file format', required: false, allowed: ['fbx', 'obj', 'gltf', 'png', 'wav'] },
-        ],
-        steps: [
-            { summary: 'List the destination folder contents.', capabilityId: 'asset.list', parentTool: 'manage_asset', action: 'list', resourceUri: 'ue://project', safety: 'Confirm the destination path is correct so you do not overwrite existing assets.' },
-            { summary: 'Check whether the target asset already exists.', capabilityId: 'asset.exists', parentTool: 'manage_asset', action: 'exists', resourceUri: 'ue://asset/{assetPath}', safety: 'If it already exists, decide whether replacing it is intended before importing.' },
-            { summary: 'Import the asset from your chosen source.', capabilityId: 'asset.import', parentTool: 'manage_asset', action: 'import', safety: 'Supply your own source path when you run this; the import applies only on execute.' },
-            { summary: 'Validate the imported asset.', capabilityId: 'asset.validate', parentTool: 'manage_asset', action: 'validate', safety: 'Review the validation report before using the asset in a level.' },
-        ],
-    },
-    {
-        id: 'level-build',
-        title: 'Create and build a level',
-        description: 'Create a working level, build its lighting, and save it, reviewing each step.',
-        arguments: [
-            { name: 'levelPath', description: 'Content path for the level', required: true },
-        ],
-        steps: [
-            { summary: 'Read the current level.', capabilityId: 'manage_level.get_current_level', parentTool: 'manage_level', action: 'get_current_level', resourceUri: 'ue://editor', safety: 'Confirm which level is active before creating or building anything.' },
-            { summary: 'Create the working level.', capabilityId: 'manage_level.create_level', parentTool: 'manage_level', action: 'create_level', resourceUri: 'ue://editor', safety: 'Creating a level does not save it; the file is written only when you save.' },
-            { summary: 'Build lighting for the level.', capabilityId: 'manage_level.build_lighting', parentTool: 'manage_level', action: 'build_lighting', safety: 'Lighting builds can be slow; start the build yourself when the scene is ready.' },
-            { summary: 'Save the level.', capabilityId: 'manage_level.save', parentTool: 'manage_level', action: 'save', safety: 'Saving routes through the safe save wrapper; review the scene before you save.' },
-        ],
-    },
-    {
-        id: 'blueprint-edit',
-        title: 'Edit a Blueprint',
-        description: 'Read a Blueprint, add a variable and an SCS component, then compile it.',
-        arguments: [
-            { name: 'blueprintPath', description: 'Content path of the Blueprint', required: true },
-            { name: 'variableName', description: 'Name of a variable to add', required: false },
-        ],
-        steps: [
-            { summary: 'Read the Blueprint definition.', capabilityId: 'blueprint.get', parentTool: 'manage_blueprint', action: 'get', resourceUri: 'ue://asset/{assetPath}', safety: 'Understand the current Blueprint before editing it.' },
-            { summary: 'Add a variable to the Blueprint.', capabilityId: 'blueprint.add_variable', parentTool: 'manage_blueprint', action: 'add_variable', safety: 'Pick a clear variable name; the change applies only when you run the call.' },
-            { summary: 'Add a component through the SCS.', capabilityId: 'blueprint.add_scs_component', parentTool: 'manage_blueprint', action: 'add_scs_component', safety: 'Components are owned by the Simple Construction Script; review the component setup.' },
-            { summary: 'Compile the Blueprint.', capabilityId: 'blueprint.compile', parentTool: 'manage_blueprint', action: 'compile', safety: 'Compile to surface errors; read the compile result yourself before using the Blueprint.' },
-        ],
-    },
-    {
-        id: 'validation',
-        title: 'Validate project assets and level',
-        description: 'Run read-only validation across the project, a specific asset, and the current level.',
-        arguments: [
-            { name: 'assetPath', description: 'Content path of an asset to focus on', required: false },
-        ],
-        steps: [
-            { summary: 'Read the project context.', capabilityId: 'inspect.get_project_settings', parentTool: 'inspect', action: 'get_project_settings', resourceUri: 'ue://project', safety: 'Confirm the project and engine version before running validation.' },
-            { summary: "Run data validation across the project's assets.", capabilityId: 'system_control.validate_assets', parentTool: 'system_control', action: 'validate_assets', resourceUri: 'ue://capability/catalog', safety: 'Validation is read-only; review each reported issue yourself.' },
-            { summary: 'Validate a specific asset.', capabilityId: 'asset.validate', parentTool: 'manage_asset', action: 'validate', resourceUri: 'ue://asset/{assetPath}', safety: 'Use this to focus on one asset flagged by the project scan.' },
-            { summary: 'Validate the current level.', capabilityId: 'manage_level.validate_level', parentTool: 'manage_level', action: 'validate_level', safety: 'Level validation makes no changes; it only reports issues to review.' },
-        ],
-    },
-    {
-        id: 'sequence-render',
-        title: 'Render a level sequence',
-        description: 'Prepare and run a Movie Render Queue job for a level sequence, reviewing each step.',
-        arguments: [
-            { name: 'sequencePath', description: 'Content path of the level sequence', required: true },
-            { name: 'outputFormat', description: 'Render output image format', required: false, allowed: ['png', 'jpeg', 'exr', 'custom'] },
-        ],
-        steps: [
-            { summary: 'Read the sequence properties.', capabilityId: 'sequence.get_properties', parentTool: 'manage_sequence', action: 'get_properties', resourceUri: 'ue://project', safety: 'Confirm the sequence, frame range, and resolution before rendering.' },
-            { summary: 'Create a Movie Render Queue job.', capabilityId: 'sequence.mrq.create_render_job', parentTool: 'manage_sequence', action: 'create_render_job', safety: 'Creating a job does not render; it only prepares the queue entry.' },
-            { summary: 'Configure the render output settings.', capabilityId: 'sequence.mrq.configure_output_settings', parentTool: 'manage_sequence', action: 'configure_output_settings', resourceUri: 'ue://editor', safety: 'Confirm the output directory and format yourself before rendering.' },
-            { summary: 'Queue the render job.', capabilityId: 'sequence.mrq.queue_render', parentTool: 'manage_sequence', action: 'queue_render', safety: 'Queuing stages the job; nothing is written until you start the render.' },
-            { summary: 'Start the render.', capabilityId: 'sequence.mrq.start_render', parentTool: 'manage_sequence', action: 'start_render', safety: 'Rendering can be long-running and writes files; you start it explicitly.' },
-        ],
-    },
-];
-const MAX_ARGUMENT_LENGTH = 512;
-const DISCLAIMER = 'Guidance only. Nothing here runs on its own, no conversation state is kept, and you decide '
-    + 'whether to run each call. Discover exact parameters with the gateway `describe` operation, '
-    + 'then run one `execute` call at a time and review each receipt yourself.';
-export function listPrompts() {
-    return WORKFLOW_PROMPTS.map((prompt) => ({
-        name: prompt.id,
-        title: prompt.title,
-        description: prompt.description,
-        arguments: prompt.arguments.map(({ name, description, required }) => ({ name, description, required })),
-    }));
-}
-export function getPrompt(name, args) {
-    const prompt = WORKFLOW_PROMPTS.find((candidate) => candidate.id === name);
-    if (prompt === undefined)
-        throw new McpError(ErrorCode.InvalidParams, `Unknown workflow prompt: ${name}`);
-    const declared = new Set(prompt.arguments.map((argument) => argument.name));
-    for (const argName of Object.keys(args)) {
-        if (!declared.has(argName))
-            throw new McpError(ErrorCode.InvalidParams, `Unknown argument: ${argName}`);
-    }
-    for (const spec of prompt.arguments) {
-        const value = args[spec.name];
-        if (value === undefined) {
-            if (spec.required)
-                throw new McpError(ErrorCode.InvalidParams, `Missing required argument: ${spec.name}`);
-            continue;
-        }
-        if (value.length > MAX_ARGUMENT_LENGTH)
-            throw new McpError(ErrorCode.InvalidParams, `Argument ${spec.name} is longer than ${String(MAX_ARGUMENT_LENGTH)} characters`);
-        if (spec.allowed !== undefined && !spec.allowed.includes(value)) {
-            throw new McpError(ErrorCode.InvalidParams, `Argument ${spec.name} must be one of: ${spec.allowed.join(', ')}`);
-        }
-    }
-    const provided = prompt.arguments.filter((spec) => args[spec.name] !== undefined).map((spec) => `- ${spec.name}: ${args[spec.name] ?? ''}`);
-    const lines = [`# ${prompt.title}  (prompt ${prompt.id})`, '', DISCLAIMER, '', 'Your inputs:', ...(provided.length > 0 ? provided : ['- (none provided)']), '', 'Steps:'];
-    prompt.steps.forEach((step, index) => {
-        lines.push(`${String(index + 1)}. ${step.summary}`);
-        lines.push(`   describe: unreal { "operation": "describe", "tool": "${step.parentTool}", "action": "${step.action}" }`);
-        lines.push(`   execute:  unreal { "operation": "execute", "capability": "${step.capabilityId}", "params": { } }`);
-        if (step.resourceUri !== undefined)
-            lines.push(`   read:     ${step.resourceUri}`);
-        lines.push(`   safety:   ${step.safety}`);
-    });
-    lines.push('', 'Finish: re-read the relevant resource and confirm the outcome before moving on.');
-    lines.push('Nothing above is executed for you; run each call yourself.');
-    return { description: prompt.description, messages: [{ role: 'user', content: { type: 'text', text: lines.join('\n') } }] };
-}
-//# sourceMappingURL=prompts.js.map

package/dist/server/mcp-primitives/resource-revision.d.ts

@@ -1,15 +0,0 @@
-export type ResourceRevision = number & {
-    readonly __brand: 'ResourceRevision';
-};
-export declare const INITIAL_REVISION: ResourceRevision;
-export interface RevisionedResource<T> {
-    readonly uri: string;
-    readonly revision: ResourceRevision;
-    readonly data: T;
-}
-export type RevisionedUri = 'ue://capability/catalog' | 'ue://project' | 'ue://selection' | 'ue://pie' | 'ue://asset-registry';
-export interface RevisionProvider {
-    currentRevision(uri: RevisionedUri): ResourceRevision;
-}
-export declare function sharedRevisionProvider(): RevisionProvider;
-//# sourceMappingURL=resource-revision.d.ts.map

package/dist/server/mcp-primitives/resource-revision.js

@@ -1,11 +0,0 @@
-import { dynamicToolManager } from '../../tools/dynamic/dynamic-tool-manager.js';
-export const INITIAL_REVISION = 1;
-const shared = {
-    currentRevision: (uri) => (uri === 'ue://capability/catalog'
-        ? (dynamicToolManager.getCatalogStateRevision() + INITIAL_REVISION)
-        : INITIAL_REVISION),
-};
-export function sharedRevisionProvider() {
-    return shared;
-}
-//# sourceMappingURL=resource-revision.js.map

package/dist/server/server-factory.d.ts

@@ -1,47 +0,0 @@
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { AutomationBridge } from '../automation/index.js';
-import { AutomationLogger } from '../automation/log-redaction.js';
-import { HealthMonitor } from '../services/health-monitor.js';
-import { UnrealBridge } from '../unreal-bridge.js';
-export declare const log: AutomationLogger;
-export declare function routeStdoutLogsToStderr(): void;
-export declare function createServer(): {
-    server: Server<{
-        method: string;
-        params?: {
-            [x: string]: unknown;
-            _meta?: {
-                [x: string]: unknown;
-                progressToken?: string | number | undefined;
-                "io.modelcontextprotocol/related-task"?: {
-                    taskId: string;
-                } | undefined;
-            } | undefined;
-        } | undefined;
-    }, {
-        method: string;
-        params?: {
-            [x: string]: unknown;
-            _meta?: {
-                [x: string]: unknown;
-                progressToken?: string | number | undefined;
-                "io.modelcontextprotocol/related-task"?: {
-                    taskId: string;
-                } | undefined;
-            } | undefined;
-        } | undefined;
-    }, {
-        [x: string]: unknown;
-        _meta?: {
-            [x: string]: unknown;
-            progressToken?: string | number | undefined;
-            "io.modelcontextprotocol/related-task"?: {
-                taskId: string;
-            } | undefined;
-        } | undefined;
-    }>;
-    bridge: UnrealBridge;
-    automationBridge: AutomationBridge;
-    healthMonitor: HealthMonitor;
-};
-//# sourceMappingURL=server-factory.d.ts.map

package/dist/server/server-factory.js

@@ -1,84 +0,0 @@
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { CancelledNotificationSchema } from '@modelcontextprotocol/sdk/types.js';
-import { AutomationBridge } from '../automation/index.js';
-import { AutomationLogger } from '../automation/log-redaction.js';
-import { PACKAGE } from '../constants.js';
-import { ServerSetup } from '../server-setup.js';
-import { HealthMonitor } from '../services/health-monitor.js';
-import { UNREAL_GATEWAY_INSTRUCTIONS } from '../tools/catalog/unreal-gateway-definition.js';
-import { UnrealBridge } from '../unreal-bridge.js';
-import { canonicalizeMcpRequestId } from '../automation/request-context.js';
-import { SERVER_CAPABILITIES, wirePrimitives } from './mcp-primitives/primitive-wiring.js';
-const { name: SERVER_NAME, version: SERVER_VERSION } = PACKAGE;
-const AUTOMATION_HEARTBEAT_MS = 15_000;
-export const log = new AutomationLogger('UE-MCP');
-export function routeStdoutLogsToStderr() {
-    const writeToStderr = (...args) => {
-        const line = args
-            .map((argument) => typeof argument === 'string' ? argument : JSON.stringify(argument))
-            .join(' ');
-        process.stderr.write(`${line}\n`);
-    };
-    console.log = writeToStderr;
-    console.info = writeToStderr;
-    console.debug = writeToStderr;
-}
-export function createServer() {
-    const bridge = new UnrealBridge();
-    const healthMonitor = new HealthMonitor(log);
-    const automationBridge = new AutomationBridge({
-        serverName: SERVER_NAME,
-        serverVersion: SERVER_VERSION,
-        heartbeatIntervalMs: AUTOMATION_HEARTBEAT_MS,
-    });
-    bridge.setAutomationBridge(automationBridge);
-    automationBridge.on('connected', ({ metadata, port, protocol }) => {
-        log.info(`Automation bridge connected (port=${port}, protocol=${protocol ?? 'none'})`, metadata);
-    });
-    automationBridge.on('disconnected', ({ code, reason, port, protocol }) => {
-        log.info(`Automation bridge disconnected (code=${code}, reason=${reason || 'n/a'}, port=${port}, protocol=${protocol ?? 'none'})`);
-    });
-    automationBridge.on('handshakeFailed', ({ reason, port }) => {
-        log.warn(`Automation bridge handshake failed (port=${port}): ${reason}`);
-    });
-    automationBridge.on('message', (message) => {
-        log.debug('Automation bridge inbound message', message);
-    });
-    automationBridge.on('error', (error) => {
-        log.error('Automation bridge error', error);
-    });
-    log.debug('Server starting without connecting to Unreal Engine');
-    healthMonitor.metrics.connectionStatus = 'disconnected';
-    const server = new Server({
-        name: SERVER_NAME,
-        version: SERVER_VERSION,
-    }, {
-        capabilities: SERVER_CAPABILITIES,
-        instructions: UNREAL_GATEWAY_INSTRUCTIONS,
-    });
-    automationBridge.on('automationEvent', (event) => {
-        server.notification({
-            method: 'notifications/unreal/automation_event',
-            params: event,
-        }).catch((error) => {
-            log.error('Failed to forward Unreal automation event notification', error instanceof Error ? error : String(error));
-        });
-    });
-    const serverSetup = new ServerSetup(server, bridge, automationBridge, log, healthMonitor);
-    serverSetup.setup();
-    wirePrimitives(server, { name: SERVER_NAME, version: SERVER_VERSION }, UNREAL_GATEWAY_INSTRUCTIONS);
-    server.setNotificationHandler(CancelledNotificationSchema, (notification) => {
-        const rawId = notification.params.requestId;
-        if (rawId === undefined)
-            return;
-        const requestId = canonicalizeMcpRequestId(rawId);
-        automationBridge.cancelMcpRequest(requestId, 'Client cancelled request');
-    });
-    return {
-        server,
-        bridge,
-        automationBridge,
-        healthMonitor,
-    };
-}
-//# sourceMappingURL=server-factory.js.map

package/dist/server/stdio-lifecycle.d.ts

@@ -1,2 +0,0 @@
-export declare function startStdioServer(): Promise<void>;
-//# sourceMappingURL=stdio-lifecycle.d.ts.map

package/dist/server/stdio-lifecycle.js

@@ -1,57 +0,0 @@
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { createServer, log, } from './server-factory.js';
-export async function startStdioServer() {
-    const { server, automationBridge, healthMonitor, } = createServer();
-    const transport = new StdioServerTransport();
-    let shuttingDown = false;
-    const stopServices = () => {
-        for (const [what, stop] of [
-            ['stop health checks', () => healthMonitor.stopHealthChecks()],
-            ['stop automation bridge', () => automationBridge.stop()],
-        ]) {
-            try {
-                stop();
-            }
-            catch (error) {
-                log.warn(`Failed to ${what} cleanly`, error instanceof Error ? error : String(error));
-            }
-        }
-    };
-    const handleShutdown = async (signal) => {
-        if (shuttingDown) {
-            return;
-        }
-        shuttingDown = true;
-        log.info(`Shutting down MCP server${signal ? ` due to ${signal}` : ''}`);
-        stopServices();
-        try {
-            await server.close();
-        }
-        catch (error) {
-            log.warn('Failed to close MCP server transport cleanly', error instanceof Error ? error : String(error));
-        }
-        if (signal) {
-            process.exit(0);
-        }
-    };
-    for (const signal of ['SIGINT', 'SIGTERM']) {
-        process.once(signal, () => {
-            void handleShutdown(signal);
-        });
-    }
-    process.stdin.once('end', () => {
-        void handleShutdown();
-    });
-    process.stdin.once('close', () => {
-        void handleShutdown();
-    });
-    process.stdin.once('error', (error) => {
-        log.warn('Stdio input closed with an error', error);
-        void handleShutdown();
-    });
-    process.once('beforeExit', stopServices);
-    process.once('exit', stopServices);
-    await server.connect(transport);
-    log.info('Unreal Engine MCP Server started on stdio');
-}
-//# sourceMappingURL=stdio-lifecycle.js.map

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

@@ -1,4 +0,0 @@
-import { type GatewayContext } from './gateway/gateway-execute.js';
-export type { GatewayContext };
-export declare function handleUnrealGatewayCall(args: Record<string, unknown>, context: GatewayContext): Promise<Record<string, unknown>>;
-//# sourceMappingURL=tool-registry-gateway.d.ts.map

package/dist/server/tool-registry-gateway.js

@@ -1,80 +0,0 @@
-import { isRecord } from '../utils/validation/type-guards.js';
-import { handleManageToolsCall } from './tool-registry-manage-tools.js';
-import { findTool, getString, gatewayError, isGatewayFailure, nextGatewayCorrelationId } from './gateway/gateway-shared.js';
-import { describeGatewayCapability } from './gateway/gateway-describe.js';
-import { searchGatewayCapabilities } from './gateway/gateway-search.js';
-import { executeGatewayCall } from './gateway/gateway-execute.js';
-const CONFIGURE_TOOL = 'manage_tools';
-function configureAdmissionError(args, action) {
-    const tool = getString(args, 'tool');
-    if (tool !== undefined && tool !== CONFIGURE_TOOL) {
-        return gatewayError('configure', 'UNKNOWN_TOOL', `configure routes only to ${CONFIGURE_TOOL}; '${tool}' cannot be configured.`);
-    }
-    if (action === undefined)
-        return gatewayError('configure', 'MISSING_ACTION', 'configure requires a manage_tools action.');
-    if (!isRecord(args.params) && args.params !== undefined)
-        return gatewayError('configure', 'INVALID_PARAMS', 'params must be an object.');
-    const params = isRecord(args.params) ? args.params : {};
-    if ('action' in params || 'subAction' in params) {
-        return gatewayError('configure', 'INVALID_PARAMS', 'action is an envelope field; remove it from params so one call cannot name two actions.');
-    }
-    const definition = findTool(CONFIGURE_TOOL);
-    const known = definition?.actions ?? [];
-    if (known.length > 0 && !known.includes(action)) {
-        return {
-            ...gatewayError('configure', 'UNKNOWN_ACTION', `Unknown action '${action}' for ${CONFIGURE_TOOL}.`),
-            availableActions: known
-        };
-    }
-    return undefined;
-}
-async function configureGateway(args) {
-    const action = getString(args, 'action');
-    const refusal = configureAdmissionError(args, action);
-    if (refusal !== undefined)
-        return refusal;
-    const result = await handleManageToolsCall({ ...(isRecord(args.params) ? args.params : {}), action: action });
-    const succeeded = result.success === true;
-    const envelope = { success: succeeded, operation: 'configure', action, result };
-    if (!succeeded) {
-        const reported = isRecord(result) && typeof result.errorCode === 'string' && result.errorCode.length > 0
-            ? result.errorCode
-            : 'CONFIGURE_FAILED';
-        const detail = isRecord(result) && typeof result.message === 'string' ? result.message : 'configure failed.';
-        envelope.errorCode = reported;
-        envelope.error = detail;
-        envelope.message = detail;
-    }
-    return envelope;
-}
-async function dispatchGatewayOperation(operation, args, context, correlationId) {
-    switch (operation) {
-        case 'search': return searchGatewayCapabilities(args);
-        case 'describe': return describeGatewayCapability(args);
-        case 'execute': return await executeGatewayCall(args, context, correlationId);
-        case 'configure': return await configureGateway(args);
-        default: return gatewayError(operation, 'UNKNOWN_OPERATION', 'operation must be search, describe, execute, or configure.');
-    }
-}
-export async function handleUnrealGatewayCall(args, context) {
-    const operation = getString(args, 'operation') ?? 'unknown';
-    const correlationId = nextGatewayCorrelationId();
-    const tool = getString(args, 'tool');
-    const action = getString(args, 'action');
-    context.logger.debug('gateway request received', { correlationId, operation, tool, action });
-    const result = await dispatchGatewayOperation(operation, args, context, correlationId);
-    if (isGatewayFailure(result)) {
-        context.logger.warn('gateway request failed', {
-            correlationId,
-            operation,
-            tool,
-            action,
-            errorCode: typeof result.errorCode === 'string' ? result.errorCode : undefined
-        });
-    }
-    else {
-        context.logger.debug('gateway request completed', { correlationId, operation, tool, action });
-    }
-    return result;
-}
-//# sourceMappingURL=tool-registry-gateway.js.map

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

@@ -1,2 +0,0 @@
-export declare function handleManageToolsCall(args: Record<string, unknown>): Promise<Record<string, unknown>>;
-//# sourceMappingURL=tool-registry-manage-tools.d.ts.map