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

package/dist/server/tool-registry-manage-tools.js

@@ -1,160 +0,0 @@
-import { CATALOG_REVISION } from '../tools/catalog/capabilities/generated/canonical-registry.generated.js';
-import { dynamicToolManager } from '../tools/dynamic/dynamic-tool-manager.js';
-import { getString } from './gateway/gateway-shared.js';
-import { describeTask } from './gateway/gateway-task-results.js';
-const VALID_TOOL_CATEGORIES = ['core', 'world', 'gameplay', 'utility', 'all'];
-function getStringArray(args, key) {
-    const val = args[key];
-    if (Array.isArray(val)) {
-        return val.filter((v) => typeof v === 'string');
-    }
-    return [];
-}
-function getToolNames(args) {
-    return getStringArray(args, 'tools');
-}
-export async function handleManageToolsCall(args) {
-    const action = args.action;
-    switch (action) {
-        case 'list_tools':
-            return listTools();
-        case 'list_categories':
-            return listCategories();
-        case 'enable_tools':
-            return enableTools(args);
-        case 'disable_tools':
-            return disableTools(args);
-        case 'enable_category':
-            return setCategoryEnabled(args, true);
-        case 'disable_category':
-            return setCategoryEnabled(args, false);
-        case 'get_status':
-            return getStatus();
-        case 'get_task_result':
-            return describeTask(getString(args, 'taskId') ?? '');
-        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, get_task_result, reset`,
-                errorCode: 'UNKNOWN_ACTION'
-            };
-    }
-}
-function listTools() {
-    const tools = dynamicToolManager.listTools();
-    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)`
-    };
-}
-function listCategories() {
-    const categories = dynamicToolManager.listCategories();
-    return {
-        success: true,
-        categories,
-        totalCategories: categories.length,
-        message: `Listed ${categories.length} categories`
-    };
-}
-function enableTools(args) {
-    const toolNames = getToolNames(args);
-    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`
-    };
-}
-function disableTools(args) {
-    const toolNames = getToolNames(args);
-    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('. ')
-    };
-}
-function setCategoryEnabled(args, enabled) {
-    const category = getString(args, 'category');
-    if (!category) {
-        return { success: false, error: 'No category specified.', errorCode: 'MISSING_CATEGORY' };
-    }
-    if (!VALID_TOOL_CATEGORIES.includes(category)) {
-        return {
-            success: false,
-            error: `Invalid category '${category}'. Valid: ${VALID_TOOL_CATEGORIES.join(', ')}`,
-            errorCode: 'INVALID_CATEGORY'
-        };
-    }
-    if (enabled) {
-        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)` };
-    }
-    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)` };
-}
-function getStatus() {
-    const status = dynamicToolManager.getStatus();
-    return {
-        success: true,
-        totalTools: status.totalTools,
-        enabledTools: status.enabledTools,
-        disabledTools: status.disabledTools,
-        categories: status.categories,
-        catalogRevision: CATALOG_REVISION,
-        catalogStateRevision: status.catalogStateRevision,
-        message: `${status.enabledTools}/${status.totalTools} tools enabled`
-    };
-}
-//# sourceMappingURL=tool-registry-manage-tools.js.map

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

@@ -1,15 +0,0 @@
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { AutomationBridge } from '../automation/index.js';
-import { Logger } from '../utils/logging/logger.js';
-import { HealthMonitor } from '../services/health-monitor.js';
-export declare class ToolRegistry {
-    private server;
-    private automationBridge;
-    private logger;
-    private healthMonitor;
-    private ensureConnected;
-    private readonly progressSinks;
-    constructor(server: Server, automationBridge: AutomationBridge, logger: Logger, healthMonitor: HealthMonitor, ensureConnected: () => Promise<boolean>);
-    register(): void;
-}
-//# sourceMappingURL=tool-registry.d.ts.map

package/dist/server/tool-registry.js

@@ -1,110 +0,0 @@
-import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
-import { actionClassForGatewayArgs, failureClassForError } from '../services/telemetry-observation.js';
-import { wrapGatewayResponse } from '../utils/responses/response-validator.js';
-import { cleanObject } from '../utils/serialization/safe-json.js';
-import { redactImagePayloadForLog } from '../utils/logging/log-redaction.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 { handleUnrealGatewayCall } from './tool-registry-gateway.js';
-import { unrealGatewayToolDefinition } from '../tools/catalog/unreal-gateway-definition.js';
-import { buildDirectCallMigration } from './gateway/direct-call-migration.js';
-export class ToolRegistry {
-    server;
-    automationBridge;
-    logger;
-    healthMonitor;
-    ensureConnected;
-    progressSinks = new ProgressSinkRegistry();
-    constructor(server, automationBridge, logger, healthMonitor, ensureConnected) {
-        this.server = server;
-        this.automationBridge = automationBridge;
-        this.logger = logger;
-        this.healthMonitor = healthMonitor;
-        this.ensureConnected = ensureConnected;
-    }
-    register() {
-        const tools = { automationBridge: this.automationBridge };
-        this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-            this.logger.debug('Serving gateway tool list (static single-tool mode)');
-            return { tools: [unrealGatewayToolDefinition] };
-        });
-        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;
-            const args = (request.params.arguments || {});
-            const startTime = Date.now();
-            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);
-            };
-            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();
-            if (name !== 'unreal') {
-                endProgress();
-                this.healthMonitor.trackPerformance(startTime, false, { actionClass, failureClass: 'validation' });
-                const migration = buildDirectCallMigration(name, args);
-                return wrapGatewayResponse(migration);
-            }
-            try {
-                const context = { tools, logger: this.logger, ensureConnected: this.ensureConnected };
-                const gatewayResult = cleanObject(await withRequestContext(() => handleUnrealGatewayCall(args, context)));
-                const wrapped = wrapGatewayResponse(gatewayResult);
-                const finalSuccess = wrapped.isError !== true;
-                this.healthMonitor.trackPerformance(startTime, finalSuccess, {
-                    actionClass,
-                    ...(finalSuccess ? {} : { failureClass: failureClassForError(gatewayResult) })
-                });
-                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 detail = error instanceof Error ? error.message : String(error);
-                const errorResponse = { success: false, isError: true, error: detail, message: `Failed to execute unreal: ${detail}`, scope: 'tool-call/unreal' };
-                this.logger.error('Gateway tool execution failed', errorResponse);
-                this.healthMonitor.recordError(errorResponse);
-                return wrapGatewayResponse(errorResponse);
-            }
-            finally {
-                endProgress();
-            }
-        });
-    }
-}
-//# sourceMappingURL=tool-registry.js.map

package/dist/server-setup.d.ts

@@ -1,21 +0,0 @@
-import { UnrealBridge } from './unreal-bridge.js';
-import { AutomationBridge } from './automation/index.js';
-import { Logger } from './utils/logging/logger.js';
-import { HealthMonitor } from './services/health-monitor.js';
-import { ToolRegistry } from './server/tool-registry.js';
-type McpServer = ConstructorParameters<typeof ToolRegistry>[0];
-export declare class ServerSetup {
-    private server;
-    private bridge;
-    private automationBridge;
-    private logger;
-    private healthMonitor;
-    private assetResources;
-    constructor(server: McpServer, bridge: UnrealBridge, automationBridge: AutomationBridge, logger: Logger, healthMonitor: HealthMonitor);
-    setup(): Promise<void>;
-    private validateEnvironment;
-    private validateConfiguredPath;
-    private ensureConnectedOnDemand;
-}
-export {};
-//# sourceMappingURL=server-setup.d.ts.map

package/dist/server-setup.js

@@ -1,60 +0,0 @@
-import { AssetResources } from './resources/assets.js';
-import { ResourceHandler } from './handlers/resource-handlers.js';
-import { ToolRegistry } from './server/tool-registry.js';
-import fs from 'node:fs';
-export class ServerSetup {
-    server;
-    bridge;
-    automationBridge;
-    logger;
-    healthMonitor;
-    assetResources;
-    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);
-    }
-    async setup() {
-        this.validateEnvironment();
-        const ensureConnected = this.ensureConnectedOnDemand.bind(this);
-        new ResourceHandler(this.server, this.bridge, this.automationBridge, this.assetResources, this.healthMonitor, ensureConnected).registerHandlers();
-        const toolRegistry = new ToolRegistry(this.server, this.automationBridge, this.logger, this.healthMonitor, ensureConnected);
-        toolRegistry.register();
-    }
-    validateEnvironment() {
-        const enginePath = process.env.UE_ENGINE_PATH || process.env.UNREAL_ENGINE_PATH;
-        this.validateConfiguredPath('UE_PROJECT_PATH', process.env.UE_PROJECT_PATH, 'UE_PROJECT_PATH is not set; the bridge port is read from MCP_AUTOMATION_PORT or the default.');
-        this.validateConfiguredPath('UE_ENGINE_PATH', enginePath);
-    }
-    validateConfiguredPath(envName, configuredPath, notSetMessage) {
-        const pathToValidate = configuredPath?.trim();
-        if (!pathToValidate) {
-            if (notSetMessage) {
-                this.logger.info(notSetMessage);
-            }
-            return;
-        }
-        if (!fs.existsSync(pathToValidate)) {
-            this.logger.warn(`${envName} is set to '${pathToValidate}' but the path does not exist.`);
-            return;
-        }
-        this.logger.info(`${envName} validated: ${pathToValidate}`);
-    }
-    async ensureConnectedOnDemand() {
-        if (this.bridge.isConnected)
-            return true;
-        const ok = await this.bridge.tryConnect();
-        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

@@ -1,42 +0,0 @@
-import { Logger } from '../utils/logging/logger.js';
-import { TelemetryRegistry } from './telemetry-registry.js';
-export interface PerformanceDimensions {
-    readonly actionClass?: unknown;
-    readonly failureClass?: unknown;
-    readonly queueWaitMs?: number;
-}
-export interface PerformanceMetrics {
-    connectionStatus: 'connected' | 'disconnected' | 'error';
-    lastHealthCheck: Date;
-    uptime: number;
-    recentErrors: Array<{
-        time: string;
-        scope: string;
-        type: string;
-        message: string;
-        retriable: boolean;
-    }>;
-}
-interface HealthCheckBridge {
-    readonly isConnected: boolean;
-    executeConsoleCommand(command: string): Promise<unknown>;
-}
-export declare class HealthMonitor {
-    private logger;
-    metrics: PerformanceMetrics;
-    readonly telemetry: TelemetryRegistry;
-    private healthCheckTimer;
-    private lastHealthSuccessAt;
-    private readonly HEALTH_CHECK_INTERVAL_MS;
-    private readonly HEALTH_CHECK_PAUSE_AFTER_MS;
-    constructor(logger: Logger);
-    trackPerformance(startTime: number, success: boolean, dimensions: PerformanceDimensions): void;
-    recordError(errorResponse: Record<string, unknown>): void;
-    performHealthCheck(bridge: HealthCheckBridge): Promise<boolean>;
-    startHealthChecks(bridge: HealthCheckBridge): void;
-    stopHealthChecks(): void;
-    setLastHealthSuccessAt(time: number): void;
-    private markDisconnected;
-}
-export {};
-//# sourceMappingURL=health-monitor.d.ts.map

package/dist/services/health-monitor.js

@@ -1,103 +0,0 @@
-import { TelemetryRegistry } from './telemetry-registry.js';
-const RECENT_ERROR_LIMIT = 20;
-function elapsedSince(startTime) {
-    if (!Number.isFinite(startTime)) {
-        return 0;
-    }
-    return Math.max(0, Date.now() - startTime);
-}
-export class HealthMonitor {
-    logger;
-    metrics;
-    telemetry = new TelemetryRegistry({ surface: 'typescript' });
-    healthCheckTimer;
-    lastHealthSuccessAt = 0;
-    HEALTH_CHECK_INTERVAL_MS = 30000;
-    HEALTH_CHECK_PAUSE_AFTER_MS = 5 * 60 * 1000;
-    constructor(logger) {
-        this.logger = logger;
-        this.metrics = {
-            connectionStatus: 'disconnected',
-            lastHealthCheck: new Date(),
-            uptime: Date.now(),
-            recentErrors: []
-        };
-    }
-    trackPerformance(startTime, success, dimensions) {
-        const responseTime = elapsedSince(startTime);
-        this.telemetry.observeRequest({
-            actionClass: dimensions.actionClass,
-            outcome: success ? 'success' : 'failure',
-            failureClass: dimensions.failureClass,
-            durationSeconds: responseTime / 1000,
-            ...(typeof dimensions.queueWaitMs === 'number'
-                ? { queueWaitSeconds: Math.max(0, dimensions.queueWaitMs) / 1000 }
-                : {})
-        });
-    }
-    recordError(errorResponse) {
-        try {
-            const debugObj = errorResponse._debug;
-            this.metrics.recentErrors.push({
-                time: new Date().toISOString(),
-                scope: typeof errorResponse.scope === 'string' ? errorResponse.scope : 'unknown',
-                type: typeof debugObj?.errorType === 'string' ? debugObj.errorType : 'UNKNOWN',
-                message: typeof errorResponse.error === 'string' ? errorResponse.error : (typeof errorResponse.message === 'string' ? errorResponse.message : 'Unknown error'),
-                retriable: Boolean(errorResponse.retriable)
-            });
-            if (this.metrics.recentErrors.length > RECENT_ERROR_LIMIT)
-                this.metrics.recentErrors.splice(0, this.metrics.recentErrors.length - RECENT_ERROR_LIMIT);
-        }
-        catch (error) {
-            this.logger.debug('Failed to record health monitor error response', error instanceof Error ? error : String(error));
-        }
-    }
-    async performHealthCheck(bridge) {
-        if (!bridge.isConnected) {
-            this.markDisconnected();
-            return false;
-        }
-        try {
-            await bridge.executeConsoleCommand('stat none');
-            this.metrics.connectionStatus = 'connected';
-            this.metrics.lastHealthCheck = new Date();
-            this.lastHealthSuccessAt = Date.now();
-            return true;
-        }
-        catch (err1) {
-            this.metrics.connectionStatus = 'error';
-            this.metrics.lastHealthCheck = new Date();
-            this.logger.debug('Health check failed (console):', err1 instanceof Error ? err1 : String(err1));
-            return false;
-        }
-    }
-    startHealthChecks(bridge) {
-        if (this.healthCheckTimer)
-            return;
-        this.lastHealthSuccessAt = Date.now();
-        this.healthCheckTimer = setInterval(async () => {
-            if (bridge.isConnected)
-                await this.performHealthCheck(bridge);
-            else
-                this.markDisconnected();
-            if (this.healthCheckTimer && Date.now() - (this.lastHealthSuccessAt ?? 0) > this.HEALTH_CHECK_PAUSE_AFTER_MS) {
-                this.stopHealthChecks();
-                this.logger.info('Health checks paused after 5 minutes without a successful response');
-            }
-        }, this.HEALTH_CHECK_INTERVAL_MS);
-    }
-    stopHealthChecks() {
-        if (this.healthCheckTimer) {
-            clearInterval(this.healthCheckTimer);
-            this.healthCheckTimer = undefined;
-        }
-    }
-    setLastHealthSuccessAt(time) {
-        this.lastHealthSuccessAt = time;
-    }
-    markDisconnected() {
-        this.metrics.connectionStatus = 'disconnected';
-        this.metrics.lastHealthCheck = new Date();
-    }
-}
-//# sourceMappingURL=health-monitor.js.map

package/dist/services/readiness.d.ts

@@ -1,35 +0,0 @@
-import { type TelemetryReadinessComponent } from './telemetry-schema.js';
-export declare const READINESS_REASONS: readonly ["editor_error", "editor_unavailable", "registry_empty", "registry_load_failed", "transport_disconnected"];
-export type ReadinessReason = (typeof READINESS_REASONS)[number];
-export interface ReadinessProbeResult {
-    readonly ok: boolean;
-    readonly reason?: ReadinessReason;
-}
-export type ReadinessProbe = () => ReadinessProbeResult;
-export type ReadinessProbes = Readonly<Record<TelemetryReadinessComponent, ReadinessProbe>>;
-export interface ReadinessReport {
-    readonly ready: boolean;
-    readonly components: Readonly<Record<TelemetryReadinessComponent, boolean>>;
-    readonly notReady: readonly ReadinessReason[];
-}
-export declare function evaluateReadiness(probes: ReadinessProbes): ReadinessReport;
-export declare function createRegistryProbe(load?: () => readonly unknown[]): ReadinessProbe;
-export interface TransportStatusSource {
-    getStatus(): {
-        connected: boolean;
-    };
-}
-export declare function createTransportProbe(source: TransportStatusSource): ReadinessProbe;
-export interface EditorStatusSource {
-    readonly metrics: {
-        readonly connectionStatus: 'connected' | 'disconnected' | 'error';
-    };
-}
-export declare function createEditorProbe(source: EditorStatusSource): ReadinessProbe;
-export interface DefaultReadinessDependencies {
-    readonly automationBridge: TransportStatusSource;
-    readonly healthMonitor: EditorStatusSource;
-    readonly loadRegistry?: () => readonly unknown[];
-}
-export declare function createDefaultReadinessProbes(deps: DefaultReadinessDependencies): ReadinessProbes;
-//# sourceMappingURL=readiness.d.ts.map

package/dist/services/readiness.js

@@ -1,77 +0,0 @@
-import { getGatewayManifestTools } from '../gateway/gateway-manifest.js';
-import { TELEMETRY_READINESS_COMPONENTS } from './telemetry-schema.js';
-export const READINESS_REASONS = [
-    'editor_error',
-    'editor_unavailable',
-    'registry_empty',
-    'registry_load_failed',
-    'transport_disconnected',
-];
-const READY = { ok: true };
-export function evaluateReadiness(probes) {
-    const components = {
-        editor: false,
-        registry: false,
-        transport: false,
-    };
-    const notReady = [];
-    for (const component of TELEMETRY_READINESS_COMPONENTS) {
-        let result;
-        try {
-            result = probes[component]();
-        }
-        catch {
-            result = { ok: false, reason: defaultReasonFor(component) };
-        }
-        components[component] = result.ok === true;
-        if (!components[component]) {
-            notReady.push(result.reason ?? defaultReasonFor(component));
-        }
-    }
-    return {
-        ready: TELEMETRY_READINESS_COMPONENTS.every((component) => components[component]),
-        components,
-        notReady,
-    };
-}
-function defaultReasonFor(component) {
-    if (component === 'registry')
-        return 'registry_load_failed';
-    if (component === 'transport')
-        return 'transport_disconnected';
-    return 'editor_unavailable';
-}
-export function createRegistryProbe(load = getGatewayManifestTools) {
-    return () => {
-        let tools;
-        try {
-            tools = load();
-        }
-        catch {
-            return { ok: false, reason: 'registry_load_failed' };
-        }
-        if (!Array.isArray(tools) || tools.length === 0) {
-            return { ok: false, reason: 'registry_empty' };
-        }
-        return READY;
-    };
-}
-export function createTransportProbe(source) {
-    return () => (source.getStatus().connected ? READY : { ok: false, reason: 'transport_disconnected' });
-}
-export function createEditorProbe(source) {
-    return () => {
-        const status = source.metrics.connectionStatus;
-        if (status === 'connected')
-            return READY;
-        return { ok: false, reason: status === 'error' ? 'editor_error' : 'editor_unavailable' };
-    };
-}
-export function createDefaultReadinessProbes(deps) {
-    return {
-        registry: deps.loadRegistry ? createRegistryProbe(deps.loadRegistry) : createRegistryProbe(),
-        transport: createTransportProbe(deps.automationBridge),
-        editor: createEditorProbe(deps.healthMonitor),
-    };
-}
-//# sourceMappingURL=readiness.js.map

package/dist/services/telemetry/prometheus-exposition.d.ts

@@ -1,11 +0,0 @@
-import { type TelemetryActionClass, type TelemetrySurface } from '../telemetry-schema.js';
-import type { HistogramState, TelemetryReadinessView, TelemetryTimingFamily } from '../telemetry-registry.js';
-type SeriesKey = {
-    surface: TelemetrySurface;
-    actionClass: TelemetryActionClass;
-};
-type QuantileLookup = (family: TelemetryTimingFamily, selector: SeriesKey, quantile: number) => number | null;
-export declare function renderPrometheus(histograms: ReadonlyMap<string, HistogramState>, requestCounters: ReadonlyMap<string, number>, failureCounters: ReadonlyMap<string, number>, quantileSeconds: QuantileLookup, fallbackSurface: TelemetrySurface, readiness?: TelemetryReadinessView): string;
-export declare function seriesFor(histograms: ReadonlyMap<string, HistogramState>, family: TelemetryTimingFamily, fallbackSurface: TelemetrySurface): Array<[SeriesKey, HistogramState]>;
-export {};
-//# sourceMappingURL=prometheus-exposition.d.ts.map