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

package/dist/resources/editor-state-resources.js

@@ -1,129 +0,0 @@
-import { coerceString, isRecord } from '../utils/validation/type-guards.js';
-import { LiveStateRevisionsSchema, } from '../tools/catalog/capabilities/semantic/live-state-revisions.js';
-import { RESOURCE_ERROR_CODES, ResourceError } from './resource-errors.js';
-const MAX_SELECTION = 200;
-const CONTENT_ROOT = '/Game';
-export class EditorStateResources {
-    source;
-    revisions;
-    projectName;
-    constructor(source, revisions, projectName) {
-        this.source = source;
-        this.revisions = revisions;
-        this.projectName = projectName;
-    }
-    async readProject() {
-        const uri = 'ue://project';
-        const connected = await this.source.isAvailable();
-        const engineVersion = connected ? await this.source.engineVersion() : null;
-        return {
-            uri,
-            revision: this.revisions.currentRevision('ue://project'),
-            data: { projectName: this.projectName, engineVersion, contentRoot: CONTENT_ROOT, connected },
-        };
-    }
-    async readEditor() {
-        const uri = 'ue://editor';
-        if (!(await this.source.isAvailable())) {
-            throw new ResourceError(RESOURCE_ERROR_CODES.UNAVAILABLE, uri, 'Editor state requires a connected Unreal Editor');
-        }
-        const [pieActive, currentLevel] = await Promise.all([this.source.pieActive(), this.source.currentLevel()]);
-        return { uri, revision: this.revisions.currentRevision('ue://pie'), data: { pieActive, currentLevel } };
-    }
-    async readSelection() {
-        const uri = 'ue://selection';
-        if (!(await this.source.isAvailable())) {
-            throw new ResourceError(RESOURCE_ERROR_CODES.UNAVAILABLE, uri, 'Selection requires a connected Unreal Editor');
-        }
-        const all = await this.source.selectedActors();
-        const capped = all.slice(0, MAX_SELECTION);
-        return {
-            uri,
-            revision: this.revisions.currentRevision('ue://selection'),
-            data: { count: capped.length, totalCount: all.length, truncated: all.length > capped.length, actors: capped },
-        };
-    }
-    async readStateRevisions() {
-        const uri = 'ue://state/revisions';
-        if (!(await this.source.isAvailable())) {
-            throw new ResourceError(RESOURCE_ERROR_CODES.UNAVAILABLE, uri, 'Live revisions require a connected Unreal Editor');
-        }
-        const data = await this.source.liveRevisions();
-        if (data === undefined) {
-            throw new ResourceError(RESOURCE_ERROR_CODES.UNAVAILABLE, uri, 'The connected Unreal bridge did not report live revisions');
-        }
-        return {
-            uri,
-            revision: Math.max(1, data.selection, data.level, data.assetRegistry, data.package),
-            data,
-        };
-    }
-}
-export class BridgeEditorStateSource {
-    automationBridge;
-    ensureConnected;
-    engineVersionProvider;
-    constructor(automationBridge, ensureConnected, engineVersionProvider) {
-        this.automationBridge = automationBridge;
-        this.ensureConnected = ensureConnected;
-        this.engineVersionProvider = engineVersionProvider;
-    }
-    async isAvailable() {
-        if (!this.automationBridge || typeof this.automationBridge.sendAutomationRequest !== 'function') {
-            return false;
-        }
-        return this.ensureConnected();
-    }
-    async engineVersion() {
-        return this.engineVersionProvider();
-    }
-    async pieActive() {
-        const result = this.nested(await this.request('inspect', { action: 'pie_report' }));
-        if (result === undefined) {
-            return false;
-        }
-        return Boolean(result.isPlaying ?? result.pie ?? result.active ?? result.isInPIE);
-    }
-    async currentLevel() {
-        const resp = await this.request('manage_level', { action: 'list_levels' });
-        const result = this.nested(resp);
-        return {
-            name: coerceString(resp?.currentMap) ?? coerceString(result?.currentMap) ?? 'None',
-            path: coerceString(resp?.currentMapPath) ?? coerceString(result?.currentMapPath) ?? 'None',
-        };
-    }
-    async selectedActors() {
-        const result = this.nested(await this.request('inspect', { action: 'get_selected_actors' }));
-        const list = Array.isArray(result?.actors) ? result.actors : Array.isArray(result?.selected) ? result.selected : [];
-        const entries = [];
-        for (const raw of list) {
-            if (!isRecord(raw)) {
-                continue;
-            }
-            entries.push({
-                name: coerceString(raw.name) ?? coerceString(raw.label) ?? '',
-                path: coerceString(raw.path) ?? coerceString(raw.actorPath) ?? '',
-            });
-        }
-        return entries;
-    }
-    async liveRevisions() {
-        const response = await this.request('inspect', { action: 'pie_report' });
-        const parsed = LiveStateRevisionsSchema.safeParse(response?.liveRevisions);
-        return parsed.success ? parsed.data : undefined;
-    }
-    async request(action, payload) {
-        if (!this.automationBridge) {
-            return undefined;
-        }
-        const response = await this.automationBridge.sendAutomationRequest(action, payload);
-        return isRecord(response) ? response : undefined;
-    }
-    nested(response) {
-        if (response === undefined) {
-            return undefined;
-        }
-        return isRecord(response.result) ? response.result : response;
-    }
-}
-//# sourceMappingURL=editor-state-resources.js.map

package/dist/resources/knowledge-resources.d.ts

@@ -1,22 +0,0 @@
-import type { AutomationRequestBridge } from '../types/tools/tool-interfaces.js';
-import { type RevisionProvider, type RevisionedResource } from '../server/mcp-primitives/resource-revision.js';
-export interface KnowledgeData {
-    readonly topic: string;
-    readonly title: string;
-    readonly summary: string;
-    readonly references: readonly string[];
-}
-export interface AssetHandleData {
-    readonly path: string;
-    readonly exists: boolean;
-}
-export declare const knowledgeTopics: () => readonly string[];
-export declare class KnowledgeResources {
-    private readonly automationBridge;
-    private readonly ensureConnected;
-    private readonly revisions;
-    constructor(automationBridge: AutomationRequestBridge | undefined, ensureConnected: () => Promise<boolean>, revisions: RevisionProvider);
-    readKnowledge(uri: string, topic: string): RevisionedResource<KnowledgeData>;
-    readAsset(uri: string, rawPath: string): Promise<RevisionedResource<AssetHandleData>>;
-}
-//# sourceMappingURL=knowledge-resources.d.ts.map

package/dist/resources/knowledge-resources.js

@@ -1,59 +0,0 @@
-import { isRecord } from '../utils/validation/type-guards.js';
-import { INITIAL_REVISION, } from '../server/mcp-primitives/resource-revision.js';
-import { RESOURCE_ERROR_CODES, ResourceError, normalizeContentPath } from './resource-errors.js';
-export const knowledgeTopics = () => Object.keys(KNOWLEDGE).sort();
-const KNOWLEDGE = {
-    paths: {
-        title: 'Content Paths',
-        summary: 'Asset paths are addressed under UE mount roots (/Game, /Engine, /Script, /Temp, /Niagara). /Content maps to /Game.',
-        references: ['ue://project', 'ue://asset/{assetPath}'],
-    },
-    safety: {
-        title: 'Editor Safety',
-        summary: 'Hazardous editor operations (save, load, delete) run through safe wrappers on the game thread; reads never mutate state.',
-        references: ['ue://editor'],
-    },
-    gateway: {
-        title: 'Gateway Surface',
-        summary: 'A single unreal gateway tool exposes search, describe, execute, and configure operations; canonical tools are internal.',
-        references: ['ue://capability/catalog', 'ue://capability/{capabilityId}'],
-    },
-    transports: {
-        title: 'Transports',
-        summary: 'Two transports exist: the TypeScript stdio bridge and the native /mcp HTTP/SSE server. Both are loopback-first.',
-        references: ['ue://capability/catalog'],
-    },
-    resources: {
-        title: 'Resource Surface',
-        summary: 'Read-only resources return bounded, redacted data tagged with a monotonic revision; no host paths or secrets are exposed.',
-        references: ['ue://capability/catalog', 'ue://project', 'ue://selection'],
-    },
-};
-export class KnowledgeResources {
-    automationBridge;
-    ensureConnected;
-    revisions;
-    constructor(automationBridge, ensureConnected, revisions) {
-        this.automationBridge = automationBridge;
-        this.ensureConnected = ensureConnected;
-        this.revisions = revisions;
-    }
-    readKnowledge(uri, topic) {
-        const entry = KNOWLEDGE[topic.toLowerCase()];
-        if (entry === undefined) {
-            throw new ResourceError(RESOURCE_ERROR_CODES.NOT_FOUND, uri, `Unknown knowledge topic: ${topic}`);
-        }
-        return { uri, revision: INITIAL_REVISION, data: { topic: topic.toLowerCase(), ...entry } };
-    }
-    async readAsset(uri, rawPath) {
-        const path = normalizeContentPath(uri, rawPath);
-        if (!this.automationBridge || !(await this.ensureConnected())) {
-            throw new ResourceError(RESOURCE_ERROR_CODES.UNAVAILABLE, uri, 'asset reference resolution requires a connected Unreal Editor');
-        }
-        const response = await this.automationBridge.sendAutomationRequest('manage_asset', { subAction: 'exists', assetPath: path });
-        const result = isRecord(response) && isRecord(response.result) ? response.result : response;
-        const exists = isRecord(response) && response.success !== false && isRecord(result) && result.exists === true;
-        return { uri, revision: this.revisions.currentRevision('ue://asset-registry'), data: { path, exists } };
-    }
-}
-//# sourceMappingURL=knowledge-resources.js.map

package/dist/resources/resource-catalog.d.ts

@@ -1,15 +0,0 @@
-export interface ResourceDefinition {
-    readonly uri: string;
-    readonly name: string;
-    readonly description: string;
-    readonly mimeType: string;
-}
-export interface ResourceTemplateDefinition {
-    readonly uriTemplate: string;
-    readonly name: string;
-    readonly description: string;
-    readonly mimeType: string;
-}
-export declare const NEW_RESOURCE_DEFINITIONS: readonly ResourceDefinition[];
-export declare const RESOURCE_TEMPLATES: readonly ResourceTemplateDefinition[];
-//# sourceMappingURL=resource-catalog.d.ts.map

package/dist/resources/resource-catalog.js

@@ -1,54 +0,0 @@
-const JSON_MIME = 'application/json';
-export const NEW_RESOURCE_DEFINITIONS = [
-    {
-        uri: 'ue://capability/catalog',
-        name: 'Capability Catalog',
-        description: 'Bounded catalog of gateway capabilities with a monotonic revision',
-        mimeType: JSON_MIME,
-    },
-    {
-        uri: 'ue://project',
-        name: 'Project',
-        description: 'Redacted project name, engine version, and content root',
-        mimeType: JSON_MIME,
-    },
-    {
-        uri: 'ue://editor',
-        name: 'Editor State',
-        description: 'Bounded editor state: PIE status and current level',
-        mimeType: JSON_MIME,
-    },
-    {
-        uri: 'ue://selection',
-        name: 'Selection',
-        description: 'Bounded list of selected actor handles',
-        mimeType: JSON_MIME,
-    },
-    {
-        uri: 'ue://state/revisions',
-        name: 'Live State Revisions',
-        description: 'Current selection, level, asset-registry, and package revision counters',
-        mimeType: JSON_MIME,
-    },
-];
-export const RESOURCE_TEMPLATES = [
-    {
-        uriTemplate: 'ue://capability/{capabilityId}',
-        name: 'Capability Record',
-        description: 'Bounded record for one capability (identifier, category, action count; no full schema)',
-        mimeType: JSON_MIME,
-    },
-    {
-        uriTemplate: 'ue://knowledge/{topic}',
-        name: 'Engine Knowledge',
-        description: 'Stable Unreal knowledge keyed by topic',
-        mimeType: JSON_MIME,
-    },
-    {
-        uriTemplate: 'ue://asset/{assetPath}',
-        name: 'Asset Reference',
-        description: 'Normalized handle for an asset at a UE content path',
-        mimeType: JSON_MIME,
-    },
-];
-//# sourceMappingURL=resource-catalog.js.map

package/dist/resources/resource-errors.d.ts

@@ -1,17 +0,0 @@
-export declare const RESOURCE_ERROR_CODES: {
-    readonly INVALID_URI: "RESOURCE_INVALID_URI";
-    readonly NOT_FOUND: "RESOURCE_NOT_FOUND";
-    readonly UNAVAILABLE: "RESOURCE_UNAVAILABLE";
-    readonly TOO_LARGE: "RESOURCE_TOO_LARGE";
-    readonly TRAVERSAL: "RESOURCE_TRAVERSAL_REJECTED";
-};
-export type ResourceErrorCode = (typeof RESOURCE_ERROR_CODES)[keyof typeof RESOURCE_ERROR_CODES];
-export declare class ResourceError extends Error {
-    readonly code: ResourceErrorCode;
-    readonly uri: string;
-    constructor(code: ResourceErrorCode, uri: string, message: string);
-}
-export declare function enforceByteBudget(uri: string, text: string): void;
-export declare function normalizeContentPath(uri: string, rawPath: string): string;
-export declare function redactProjectName(raw: string | undefined): string | undefined;
-//# sourceMappingURL=resource-errors.d.ts.map

package/dist/resources/resource-errors.js

@@ -1,76 +0,0 @@
-import { HOST_PATH_PATTERN, MAX_BOUNDED_BYTES, UE_CONTENT_ROOTS, isTraversalPath, } from '../utils/paths/content-path-policy.js';
-import { isUnderAllowedContentRoot } from '../utils/paths/path-security.js';
-export const RESOURCE_ERROR_CODES = {
-    INVALID_URI: 'RESOURCE_INVALID_URI',
-    NOT_FOUND: 'RESOURCE_NOT_FOUND',
-    UNAVAILABLE: 'RESOURCE_UNAVAILABLE',
-    TOO_LARGE: 'RESOURCE_TOO_LARGE',
-    TRAVERSAL: 'RESOURCE_TRAVERSAL_REJECTED',
-};
-export class ResourceError extends Error {
-    code;
-    uri;
-    constructor(code, uri, message) {
-        super(message);
-        this.name = 'ResourceError';
-        this.code = code;
-        this.uri = uri;
-    }
-}
-export function enforceByteBudget(uri, text) {
-    const bytes = Buffer.byteLength(text, 'utf8');
-    if (bytes > MAX_BOUNDED_BYTES) {
-        throw new ResourceError(RESOURCE_ERROR_CODES.TOO_LARGE, uri, `Resource payload is ${bytes} bytes, exceeding the ${MAX_BOUNDED_BYTES} byte budget`);
-    }
-}
-export function normalizeContentPath(uri, rawPath) {
-    let decoded;
-    try {
-        decoded = decodeURIComponent(rawPath);
-    }
-    catch {
-        throw new ResourceError(RESOURCE_ERROR_CODES.INVALID_URI, uri, 'Malformed percent-encoding in resource path');
-    }
-    if (decoded.length === 0) {
-        throw new ResourceError(RESOURCE_ERROR_CODES.INVALID_URI, uri, 'Empty resource path');
-    }
-    if (/[\u0000-\u001f\u007f]/u.test(decoded)) {
-        throw new ResourceError(RESOURCE_ERROR_CODES.INVALID_URI, uri, 'Control characters in resource path');
-    }
-    if (HOST_PATH_PATTERN.test(decoded)) {
-        throw new ResourceError(RESOURCE_ERROR_CODES.TRAVERSAL, uri, 'Host filesystem paths are not addressable');
-    }
-    let normalized = decoded.replace(/\/+/gu, '/');
-    if (normalized.toLowerCase().startsWith('/content')) {
-        normalized = '/Game' + normalized.slice('/Content'.length);
-    }
-    if (!normalized.startsWith('/')) {
-        normalized = '/' + normalized;
-    }
-    if (isTraversalPath(normalized)) {
-        throw new ResourceError(RESOURCE_ERROR_CODES.TRAVERSAL, uri, 'Path traversal segments are not permitted');
-    }
-    if (normalized.length > 1) {
-        normalized = normalized.replace(/\/$/u, '');
-    }
-    if (!isUnderAllowedContentRoot(normalized)) {
-        throw new ResourceError(RESOURCE_ERROR_CODES.INVALID_URI, uri, `Path must resolve under a UE content root (${UE_CONTENT_ROOTS.join(', ')}, or a mount the connected editor reports)`);
-    }
-    return normalized;
-}
-export function redactProjectName(raw) {
-    if (raw === undefined) {
-        return undefined;
-    }
-    const trimmed = raw.trim();
-    if (trimmed.length === 0) {
-        return undefined;
-    }
-    const base = trimmed.split(/[\\/]/u).pop() ?? '';
-    const withoutExt = base.replace(/\.uproject$/iu, '');
-    if (withoutExt.length === 0 || /[\\/:]/u.test(withoutExt)) {
-        return undefined;
-    }
-    return withoutExt;
-}
-//# sourceMappingURL=resource-errors.js.map

package/dist/resources/resource-read-router.d.ts

@@ -1,19 +0,0 @@
-import type { CapabilityResources } from './capability-resources.js';
-import type { EditorStateResources } from './editor-state-resources.js';
-import type { KnowledgeResources } from './knowledge-resources.js';
-export interface ResourceReadResult {
-    contents: Array<{
-        uri: string;
-        mimeType: string;
-        text: string;
-    }>;
-}
-export declare class ResourceReadRouter {
-    private readonly capability;
-    private readonly editorState;
-    private readonly knowledge;
-    constructor(capability: CapabilityResources, editorState: EditorStateResources, knowledge: KnowledgeResources);
-    read(uri: string): Promise<ResourceReadResult>;
-    private route;
-}
-//# sourceMappingURL=resource-read-router.d.ts.map

package/dist/resources/resource-read-router.js

@@ -1,56 +0,0 @@
-import { RESOURCE_ERROR_CODES, ResourceError, enforceByteBudget } from './resource-errors.js';
-const CAPABILITY_PREFIX = 'ue://capability/';
-const KNOWLEDGE_PREFIX = 'ue://knowledge/';
-const ASSET_PREFIX = 'ue://asset/';
-function matchPrefix(uri, prefix) {
-    return uri.startsWith(prefix) ? uri.slice(prefix.length) : undefined;
-}
-export class ResourceReadRouter {
-    capability;
-    editorState;
-    knowledge;
-    constructor(capability, editorState, knowledge) {
-        this.capability = capability;
-        this.editorState = editorState;
-        this.knowledge = knowledge;
-    }
-    async read(uri) {
-        const revisioned = await this.route(uri);
-        return toContents(revisioned);
-    }
-    async route(uri) {
-        switch (uri) {
-            case 'ue://capability/catalog':
-                return this.capability.readCatalog();
-            case 'ue://project':
-                return this.editorState.readProject();
-            case 'ue://editor':
-                return this.editorState.readEditor();
-            case 'ue://selection':
-                return this.editorState.readSelection();
-            case 'ue://state/revisions':
-                return this.editorState.readStateRevisions();
-            default:
-                break;
-        }
-        const capabilityId = matchPrefix(uri, CAPABILITY_PREFIX);
-        if (capabilityId !== undefined) {
-            return this.capability.readRecord(uri, capabilityId);
-        }
-        const topic = matchPrefix(uri, KNOWLEDGE_PREFIX);
-        if (topic !== undefined) {
-            return this.knowledge.readKnowledge(uri, topic);
-        }
-        const assetPath = matchPrefix(uri, ASSET_PREFIX);
-        if (assetPath !== undefined) {
-            return this.knowledge.readAsset(uri, assetPath);
-        }
-        throw new ResourceError(RESOURCE_ERROR_CODES.NOT_FOUND, uri, `Unknown resource: ${uri}`);
-    }
-}
-function toContents(revisioned) {
-    const text = JSON.stringify({ uri: revisioned.uri, revision: revisioned.revision, data: revisioned.data }, null, 2);
-    enforceByteBudget(revisioned.uri, text);
-    return { contents: [{ uri: revisioned.uri, mimeType: 'application/json', text }] };
-}
-//# sourceMappingURL=resource-read-router.js.map

package/dist/resources/resources.test-support.d.ts

@@ -1,5 +0,0 @@
-import type { RevisionProvider, RevisionedUri } from '../server/mcp-primitives/resource-revision.js';
-import type { AutomationRequestBridge } from '../types/tools/tool-interfaces.js';
-export declare function revisionsAt(revisions?: Partial<Record<RevisionedUri, number>>): RevisionProvider;
-export declare function assetExistsBridge(exists: boolean): AutomationRequestBridge;
-//# sourceMappingURL=resources.test-support.d.ts.map

package/dist/resources/resources.test-support.js

@@ -1,7 +0,0 @@
-export function revisionsAt(revisions = {}) {
-    return { currentRevision: (uri) => (revisions[uri] ?? 1) };
-}
-export function assetExistsBridge(exists) {
-    return { isConnected: () => true, sendAutomationRequest: async () => ({ success: true, result: { exists } }) };
-}
-//# sourceMappingURL=resources.test-support.js.map

package/dist/server/gateway/direct-call-migration.d.ts

@@ -1,26 +0,0 @@
-declare const DIRECT_TOOL_CALL_REMOVED = "DIRECT_TOOL_CALL_REMOVED";
-type ExecuteNextCall = {
-    readonly operation: 'execute';
-    readonly tool: string;
-    readonly action: string;
-    readonly params: Record<string, unknown>;
-};
-type DescribeNextCall = {
-    readonly operation: 'describe';
-    readonly tool: string;
-};
-type SearchNextCall = {
-    readonly operation: 'search';
-};
-export type DirectCallMigrationResult = {
-    readonly success: false;
-    readonly operation: 'search' | 'describe' | 'execute';
-    readonly errorCode: typeof DIRECT_TOOL_CALL_REMOVED;
-    readonly tool: string;
-    readonly message: string;
-    readonly nextCall: ExecuteNextCall | DescribeNextCall | SearchNextCall;
-    readonly suggestions?: readonly string[];
-};
-export declare function buildDirectCallMigration(toolName: string, args: Record<string, unknown>): DirectCallMigrationResult;
-export {};
-//# sourceMappingURL=direct-call-migration.d.ts.map

package/dist/server/gateway/direct-call-migration.js

@@ -1,46 +0,0 @@
-import { isRecord } from '../../utils/validation/type-guards.js';
-import { closestMatches, MAX_SUGGESTIONS } from './gateway-guidance.js';
-import { allToolNames, getString } from './gateway-shared.js';
-const DIRECT_TOOL_CALL_REMOVED = 'DIRECT_TOOL_CALL_REMOVED';
-const CONTROL_FIELDS = ['action', 'subAction', 'params', 'operation'];
-function migratedParams(args) {
-    const nested = isRecord(args.params) ? args.params : {};
-    const merged = { ...nested, ...args };
-    for (const field of CONTROL_FIELDS)
-        delete merged[field];
-    return merged;
-}
-export function buildDirectCallMigration(toolName, args) {
-    const parents = allToolNames();
-    if (!parents.includes(toolName)) {
-        return {
-            success: false,
-            operation: 'search',
-            errorCode: DIRECT_TOOL_CALL_REMOVED,
-            tool: toolName,
-            message: `Direct tool calls are removed. '${toolName}' is not a known tool; call the 'unreal' gateway with operation 'search' to discover the right capability.`,
-            nextCall: { operation: 'search' },
-            suggestions: closestMatches(toolName, parents, MAX_SUGGESTIONS)
-        };
-    }
-    const action = getString(args, 'action') ?? getString(args, 'subAction');
-    if (action === undefined) {
-        return {
-            success: false,
-            operation: 'describe',
-            errorCode: DIRECT_TOOL_CALL_REMOVED,
-            tool: toolName,
-            message: `Direct tool calls are removed. Call the 'unreal' gateway: describe '${toolName}' to choose an action, then execute it.`,
-            nextCall: { operation: 'describe', tool: toolName }
-        };
-    }
-    return {
-        success: false,
-        operation: 'execute',
-        errorCode: DIRECT_TOOL_CALL_REMOVED,
-        tool: toolName,
-        message: `Direct tool calls are removed. Call the 'unreal' gateway with operation 'execute' to run '${toolName}.${action}'.`,
-        nextCall: { operation: 'execute', tool: toolName, action, params: migratedParams(args) }
-    };
-}
-//# sourceMappingURL=direct-call-migration.js.map

package/dist/server/gateway/gateway-availability.d.ts

@@ -1,10 +0,0 @@
-import type { CapabilityRecord } from '../../tools/catalog/capabilities/model.js';
-export type CapabilityAvailability = {
-    readonly status: 'available' | 'disabled';
-    readonly reasons: readonly string[];
-    readonly requiredPlugins: readonly string[];
-    readonly editorStates: readonly string[];
-};
-export declare function capabilityAvailability(record: CapabilityRecord): CapabilityAvailability;
-export declare function isRunnable(availability: CapabilityAvailability): boolean;
-//# sourceMappingURL=gateway-availability.d.ts.map

package/dist/server/gateway/gateway-availability.js

@@ -1,15 +0,0 @@
-import { dynamicToolManager } from '../../tools/dynamic/dynamic-tool-manager.js';
-import { compareAscii } from '../../utils/serialization/ordering.js';
-export function capabilityAvailability(record) {
-    const enabled = dynamicToolManager.isToolEnabled(record.routing.parentTool);
-    return {
-        status: enabled ? 'available' : 'disabled',
-        reasons: enabled ? [] : ['parent_tool_disabled'],
-        requiredPlugins: [...record.availability.requiredPlugins].sort(compareAscii),
-        editorStates: [...record.availability.editorStates].sort(compareAscii)
-    };
-}
-export function isRunnable(availability) {
-    return availability.status === 'available';
-}
-//# sourceMappingURL=gateway-availability.js.map

package/dist/server/gateway/gateway-capability-index.d.ts

@@ -1,45 +0,0 @@
-import type { CapabilityRecord } from '../../tools/catalog/capabilities/model.js';
-import { type CapabilitySearchIndex } from '../../tools/catalog/capabilities/retrieval/scoring.js';
-export type CapabilityIndex = {
-    readonly records: readonly CapabilityRecord[];
-    readonly byId: ReadonlyMap<string, CapabilityRecord>;
-    readonly byAlias: ReadonlyMap<string, CapabilityRecord>;
-    readonly byLegacyPair: ReadonlyMap<string, CapabilityRecord>;
-    readonly byParentTool: ReadonlyMap<string, readonly CapabilityRecord[]>;
-    readonly actionsByParentTool: ReadonlyMap<string, readonly string[]>;
-    readonly parentToolByNamespace: ReadonlyMap<string, string>;
-    readonly domains: readonly string[];
-    readonly familiesByDomain: ReadonlyMap<string, readonly string[]>;
-    readonly search: CapabilitySearchIndex;
-};
-export declare function deriveNamespaceAliases(records: readonly CapabilityRecord[]): ReadonlyMap<string, string>;
-export declare function resolveToolNamespace(name: string): string | undefined;
-export declare function legacyPairKey(tool: string, action: string): string;
-export type IndexConflicts = {
-    readonly aliasConflicts: ReadonlyMap<string, readonly string[]>;
-    readonly legacyPairConflicts: ReadonlyMap<string, readonly string[]>;
-};
-export declare function detectIndexConflicts(records: readonly CapabilityRecord[]): IndexConflicts;
-export declare function buildCapabilityIndex(source: readonly CapabilityRecord[]): CapabilityIndex;
-export declare function capabilityIndex(): CapabilityIndex;
-export declare function catalogRevision(): string;
-export type CapabilityResolution = {
-    readonly kind: 'canonical';
-    readonly record: CapabilityRecord;
-} | {
-    readonly kind: 'alias';
-    readonly record: CapabilityRecord;
-    readonly alias: string;
-} | {
-    readonly kind: 'legacy';
-    readonly record: CapabilityRecord;
-    readonly tool: string;
-    readonly action: string;
-} | {
-    readonly kind: 'unknown';
-};
-export declare function resolveCapability(reference: string): CapabilityResolution;
-export declare function resolveLegacyPair(tool: string, action: string): CapabilityResolution;
-export declare function allCapabilityIds(): readonly string[];
-export declare function capabilitiesInFamily(domain: string, family: string): readonly CapabilityRecord[];
-//# sourceMappingURL=gateway-capability-index.d.ts.map