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

package/dist/tools/catalog/capabilities/semantic/paths.js

@@ -1,148 +0,0 @@
-import { z } from 'zod';
-import { getConfiguredContentRoots, getContentRoots, isUnderAllowedContentRoot, sanitizePath } from '../../../../utils/paths/path-security.js';
-import { SemanticBoundaryError } from './errors.js';
-function normalizeContentToGame(raw) {
-    let normalized = raw.replace(/\\/g, '/');
-    if (/^\/?content\//i.test(normalized)) {
-        const idx = normalized.toLowerCase().indexOf('content/');
-        normalized = `/Game/${normalized.slice(idx + 'content/'.length)}`;
-    }
-    return normalized;
-}
-function assertNoTraversal(normalized) {
-    if (normalized.includes('..')) {
-        throw new SemanticBoundaryError({
-            kind: 'path',
-            code: 'PATH_TRAVERSAL',
-            message: 'Invalid path: directory traversal (..) is not allowed',
-            input: normalized
-        });
-    }
-}
-function requireNonEmptyString(input) {
-    if (typeof input !== 'string' || input.length === 0) {
-        throw new SemanticBoundaryError({
-            kind: 'validation',
-            code: 'VALIDATION_ERROR',
-            message: 'Path must be a non-empty string'
-        });
-    }
-    return input;
-}
-function pathSuffixStart(normalized) {
-    const dot = normalized.indexOf('.');
-    const colon = normalized.indexOf(':');
-    return Math.min(dot === -1 ? Infinity : dot, colon === -1 ? Infinity : colon);
-}
-function assertValidRootAndNoTraversal(normalized) {
-    assertNoTraversal(normalized);
-    const end = pathSuffixStart(normalized);
-    const prefix = end === Infinity ? normalized : normalized.slice(0, end);
-    if (!isUnderAllowedContentRoot(prefix)) {
-        throw new SemanticBoundaryError({
-            kind: 'path',
-            code: 'INVALID_PATH_ROOT',
-            message: `Invalid path: must start with one of [${getConfiguredContentRoots().join(', ')}] or a content mount the connected editor reports`,
-            input: normalized
-        });
-    }
-}
-function sanitizePrefixViaShared(prefix) {
-    try {
-        return sanitizePath(prefix);
-    }
-    catch (err) {
-        throw new SemanticBoundaryError({
-            kind: 'path',
-            code: 'INVALID_PATH_ROOT',
-            message: err instanceof Error ? err.message : 'Invalid path',
-            input: prefix
-        });
-    }
-}
-function sanitizeObjectOrClassPath(input) {
-    const normalized = normalizeContentToGame(requireNonEmptyString(input));
-    if (normalized.includes('//')) {
-        throw new SemanticBoundaryError({
-            kind: 'path',
-            code: 'INVALID_PATH_ROOT',
-            message: 'Invalid path: double slash (//) is not allowed',
-            input: normalized
-        });
-    }
-    assertNoTraversal(normalized);
-    const end = pathSuffixStart(normalized);
-    const prefix = end === Infinity ? normalized : normalized.slice(0, end);
-    const suffix = end === Infinity ? '' : normalized.slice(end);
-    const sanitizedPrefix = sanitizePrefixViaShared(prefix);
-    if (suffixHasIllegalChars(suffix)) {
-        throw new SemanticBoundaryError({
-            kind: 'path',
-            code: 'INVALID_PATH_ROOT',
-            message: 'Invalid path: contains illegal characters',
-            input: normalized
-        });
-    }
-    return `${canonicalizeRoot(sanitizedPrefix)}${suffix}`;
-}
-function canonicalizeRoot(prefix) {
-    const lower = prefix.toLowerCase();
-    for (const root of getContentRoots()) {
-        const rootLower = root.toLowerCase();
-        if (lower === rootLower || lower.startsWith(`${rootLower}/`)) {
-            return `${root}${prefix.slice(root.length)}`;
-        }
-    }
-    return prefix;
-}
-function suffixHasIllegalChars(value) {
-    for (let i = 0; i < value.length; i++) {
-        const code = value.charCodeAt(i);
-        if (code <= 0x1f || code === 0x7f)
-            return true;
-        const ch = value[i];
-        if (ch === '<' || ch === '>' || ch === '"' || ch === '|' || ch === '?' || ch === '*')
-            return true;
-    }
-    return false;
-}
-function sanitizeAssetPathCore(raw) {
-    const normalized = normalizeContentToGame(raw);
-    assertValidRootAndNoTraversal(normalized);
-    try {
-        return sanitizePath(normalized);
-    }
-    catch (err) {
-        throw new SemanticBoundaryError({
-            kind: 'path',
-            code: 'INVALID_PATH_ROOT',
-            message: err instanceof Error ? err.message : 'Invalid path',
-            input: normalized
-        });
-    }
-}
-function reportSanitizerFailure(err, ctx) {
-    const message = err instanceof SemanticBoundaryError
-        ? err.semanticError.message
-        : err instanceof Error
-            ? err.message
-            : 'Invalid path';
-    ctx.addIssue({ code: 'custom', message, fatal: true });
-    return z.NEVER;
-}
-const sanitizing = (sanitize) => (raw, ctx) => {
-    try {
-        return sanitize(raw);
-    }
-    catch (err) {
-        return reportSanitizerFailure(err, ctx);
-    }
-};
-export const AssetPathSchema = z.string().transform(sanitizing(sanitizeAssetPathCore)).brand();
-export const ObjectPathSchema = z.string().transform(sanitizing(sanitizeObjectOrClassPath)).brand();
-export const ClassPathSchema = z.string().transform(sanitizing(sanitizeObjectOrClassPath)).brand();
-export function parseAssetPath(input) {
-    const sanitized = sanitizeAssetPathCore(requireNonEmptyString(input));
-    return AssetPathSchema.parse(sanitized);
-}
-//# sourceMappingURL=paths.js.map

package/dist/tools/catalog/capabilities/semantic/receipt-outcome.d.ts

@@ -1,10 +0,0 @@
-import { type TaskStatus } from './errors.js';
-import { type TypedHandle } from './handles.js';
-export declare const CHANGE_ASSET_SINGLE_FIELDS: readonly ["assetPath", "createdAssetPath", "savedAssetPath", "destinationPath", "deletedPath", "widgetPath"];
-export declare const CHANGE_ACTOR_SINGLE_FIELDS: readonly ["actorName", "actorPath"];
-export declare const AFFECTED_ACTOR_HANDLE_LIMIT = 20;
-export declare const isTransientPackagePath: (path: string) => boolean;
-export declare function extractHandles(result: unknown): TypedHandle[];
-export declare function extractChanges(result: unknown): string[];
-export declare function extractTask(result: unknown): TaskStatus | undefined;
-//# sourceMappingURL=receipt-outcome.d.ts.map

package/dist/tools/catalog/capabilities/semantic/receipt-outcome.js

@@ -1,114 +0,0 @@
-import { isRecord } from '../../../../utils/validation/type-guards.js';
-import { TaskStatusSchema } from './errors.js';
-import { TypedHandleSchema } from './handles.js';
-function makeReader(result) {
-    const data = isRecord(result.data) ? result.data : undefined;
-    const details = isRecord(result.details) ? result.details : undefined;
-    const dataDetails = isRecord(data?.details) ? data.details : undefined;
-    return (key) => {
-        const rooted = result[key];
-        if (rooted !== undefined)
-            return rooted;
-        const nested = data?.[key];
-        if (nested !== undefined)
-            return nested;
-        const inDetails = details?.[key];
-        if (inDetails !== undefined)
-            return inDetails;
-        return dataDetails?.[key];
-    };
-}
-const ASSET_FIELDS = ['assetPath', 'createdAssetPath', 'savedAssetPath', 'destinationPath', 'widgetPath', 'deletedPath', 'blueprintPath'];
-const ACTOR_FIELDS = ['actorName', 'actorLabel', 'actorPath'];
-const CHANGE_ARRAY_FIELDS = ['changes', 'changedEntities', 'changedAssets', 'affectedActors', 'modifiedPaths', 'deleted'];
-export const CHANGE_ASSET_SINGLE_FIELDS = ['assetPath', 'createdAssetPath', 'savedAssetPath', 'destinationPath', 'deletedPath', 'widgetPath'];
-export const CHANGE_ACTOR_SINGLE_FIELDS = ['actorName', 'actorPath'];
-export const AFFECTED_ACTOR_HANDLE_LIMIT = 20;
-export const isTransientPackagePath = (path) => path === '/Engine/Transient' || path.startsWith('/Engine/Transient.') || path.startsWith('/Engine/Transient:');
-export function extractHandles(result) {
-    if (!isRecord(result))
-        return [];
-    const read = makeReader(result);
-    const handles = [];
-    const seen = new Set();
-    const add = (handle) => {
-        const key = JSON.stringify(handle);
-        if (!seen.has(key)) {
-            seen.add(key);
-            handles.push(handle);
-        }
-    };
-    const explicit = read('handles');
-    if (Array.isArray(explicit)) {
-        for (const raw of explicit) {
-            const parsed = TypedHandleSchema.safeParse(raw);
-            if (parsed.success)
-                add(parsed.data);
-        }
-    }
-    for (const field of ASSET_FIELDS) {
-        const value = read(field);
-        if (typeof value === 'string' && !isTransientPackagePath(value)) {
-            const parsed = TypedHandleSchema.safeParse({ kind: 'asset', path: value });
-            if (parsed.success) {
-                add(parsed.data);
-                break;
-            }
-        }
-    }
-    for (const field of ACTOR_FIELDS) {
-        const value = read(field);
-        if (typeof value === 'string' && value.length > 0) {
-            const parsed = TypedHandleSchema.safeParse({ kind: 'actor', ref: value });
-            if (parsed.success) {
-                add(parsed.data);
-                break;
-            }
-        }
-    }
-    const affected = read('affectedActors');
-    if (Array.isArray(affected)) {
-        for (const ref of affected.slice(0, AFFECTED_ACTOR_HANDLE_LIMIT)) {
-            if (typeof ref !== 'string')
-                continue;
-            const parsed = TypedHandleSchema.safeParse({ kind: 'actor', ref });
-            if (parsed.success)
-                add(parsed.data);
-        }
-    }
-    return handles;
-}
-export function extractChanges(result) {
-    if (!isRecord(result))
-        return [];
-    const read = makeReader(result);
-    const collected = [];
-    for (const field of CHANGE_ARRAY_FIELDS) {
-        const value = read(field);
-        if (Array.isArray(value)) {
-            for (const entry of value) {
-                if (typeof entry === 'string' && entry.length > 0)
-                    collected.push(entry);
-            }
-        }
-    }
-    const assetsStated = Array.isArray(read('changedAssets'));
-    const singles = assetsStated ? CHANGE_ACTOR_SINGLE_FIELDS : [...CHANGE_ASSET_SINGLE_FIELDS, ...CHANGE_ACTOR_SINGLE_FIELDS];
-    for (const field of singles) {
-        const value = read(field);
-        if (typeof value === 'string' && value.length > 0 && !isTransientPackagePath(value))
-            collected.push(value);
-    }
-    return [...new Set(collected)];
-}
-export function extractTask(result) {
-    if (!isRecord(result))
-        return undefined;
-    const read = makeReader(result);
-    const raw = read('task') ?? read('taskStatus');
-    if (!isRecord(raw))
-        return undefined;
-    const parsed = TaskStatusSchema.safeParse(raw);
-    return parsed.success ? parsed.data : undefined;
-}
-//# sourceMappingURL=receipt-outcome.js.map

package/dist/tools/catalog/capabilities/semantic/receipt-redaction.d.ts

@@ -1,19 +0,0 @@
-export declare const MAX_RECEIPT_ARRAY = 200;
-export declare const MAX_RECEIPT_TEXT = 2048;
-export declare const REDACTED = "[REDACTED]";
-export declare function maskSecrets(value: string): string;
-export declare function redactText(value: string): string;
-export declare function boundStrings(values: readonly string[]): string[];
-export declare function boundArray<T>(values: readonly T[]): T[];
-export declare const SECRET_KEY_WORDS: Set<string>;
-export declare const TRANSPARENT_HEADS: Set<string>;
-export declare const MEASUREMENT_HEADS: Set<string>;
-export declare const SECRET_QUALIFIERS: Set<string>;
-export declare const CREDENTIAL_TAILS: Set<string>;
-export declare const MAX_KEY_NAME_LENGTH = 128;
-export declare const GENERIC_VALUE_KEYS: ReadonlySet<string>;
-export declare const NAME_BEARING_KEYS: ReadonlySet<string>;
-export declare const MAX_RECEIPT_DEPTH = 100;
-export declare function assignJsonKey(target: Record<string, unknown>, key: string, value: unknown): void;
-export declare function maskSecretsDeep(value: unknown, depth?: number): unknown;
-//# sourceMappingURL=receipt-redaction.d.ts.map

package/dist/tools/catalog/capabilities/semantic/receipt-redaction.js

@@ -1,176 +0,0 @@
-export const MAX_RECEIPT_ARRAY = 200;
-export const MAX_RECEIPT_TEXT = 2048;
-const SECRET_ASSIGNMENT = /((?:token|secret|password|passwd|pwd|api[_-]?key|apikey|authorization)["']?\s*[:=]\s*["']?(?:Bearer\s+)?)([^\s"']+)/gi;
-const BEARER = /(\bBearer\s+)([^\s"']+)/gi;
-export const REDACTED = '[REDACTED]';
-export function maskSecrets(value) {
-    return value
-        .replace(SECRET_ASSIGNMENT, (_m, prefix) => `${prefix}${REDACTED}`)
-        .replace(BEARER, (_m, prefix) => `${prefix}${REDACTED}`);
-}
-export function redactText(value) {
-    const masked = maskSecrets(value);
-    return masked.length > MAX_RECEIPT_TEXT ? `${masked.slice(0, MAX_RECEIPT_TEXT - 1)}\u2026` : masked;
-}
-export function boundStrings(values) {
-    return values.slice(0, MAX_RECEIPT_ARRAY).map(redactText);
-}
-export function boundArray(values) {
-    return values.slice(0, MAX_RECEIPT_ARRAY);
-}
-export const SECRET_KEY_WORDS = new Set([
-    'token',
-    'secret',
-    'password',
-    'passwd',
-    'pwd',
-    'apikey',
-    'authorization',
-    'credential',
-    'privatekey',
-    'accesskey',
-    'signingkey',
-]);
-export const TRANSPARENT_HEADS = new Set(['value', 'data', 'string', 'text', 'raw', 'plain']);
-export const MEASUREMENT_HEADS = new Set([
-    'count', 'budget', 'length', 'size', 'limit', 'total', 'max', 'min',
-    'index', 'order', 'position', 'offset', 'depth', 'age', 'ttl',
-    'found', 'required', 'enabled', 'disabled', 'expired', 'valid', 'present',
-    'missing', 'used', 'remaining', 'supported', 'allowed',
-    'name', 'id', 'type', 'kind', 'label', 'status', 'state', 'mode', 'policy',
-    'rule', 'scheme', 'algorithm', 'format', 'source', 'reason', 'message',
-    'error', 'version', 'timestamp', 'time', 'date', 'duration', 'at',
-    'saved', 'spent', 'earned', 'collected', 'consumed', 'generated', 'processed',
-    'balance', 'rate', 'cost', 'left',
-]);
-export const SECRET_QUALIFIERS = new Set([
-    'api', 'access', 'auth', 'private', 'public', 'client', 'server', 'session',
-    'user', 'admin', 'root', 'master', 'signing', 'refresh', 'bearer', 'oauth',
-    'app', 'service', 'encryption', 'shared', 'secret',
-]);
-export const CREDENTIAL_TAILS = new Set([
-    'key', 'token', 'secret', 'password', 'passwd', 'pwd', 'credential',
-    'authorization', 'signature', 'cert', 'certificate',
-    'hash', 'bytes', 'digest', 'header', 'blob',
-]);
-const SPLITTABLE_WORDS = new Set([
-    ...SECRET_KEY_WORDS, ...SECRET_QUALIFIERS, ...CREDENTIAL_TAILS,
-    ...MEASUREMENT_HEADS, ...TRANSPARENT_HEADS,
-]);
-const MAX_COMPOUND_PARTS = 3;
-function segmentations(word, parts) {
-    if (parts === 1)
-        return SPLITTABLE_WORDS.has(word) ? [[word]] : [];
-    const found = [];
-    for (let cut = 2; cut <= word.length - 2; cut += 1) {
-        const head = word.slice(0, cut);
-        if (!SPLITTABLE_WORDS.has(head))
-            continue;
-        for (const rest of segmentations(word.slice(cut), parts - 1))
-            found.push([head, ...rest]);
-    }
-    return found;
-}
-const splitNamesCredential = (parts) => parts.some((part) => SECRET_KEY_WORDS.has(part)) ||
-    CREDENTIAL_TAILS.has(parts[parts.length - 1] ?? '');
-function splitCompound(word) {
-    if (word.length < 6 || SPLITTABLE_WORDS.has(word))
-        return [word];
-    for (let parts = 2; parts <= MAX_COMPOUND_PARTS; parts += 1) {
-        const split = segmentations(word, parts).find(splitNamesCredential);
-        if (split !== undefined)
-            return split;
-    }
-    return [word];
-}
-function keyWords(key) {
-    return key
-        .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
-        .split(/[^A-Za-z0-9]+/)
-        .filter((word) => word.length > 0)
-        .flatMap((word) => splitCompound(word.toLowerCase()));
-}
-const singular = (word) => word.length > 1 && word.endsWith('s') ? word.slice(0, -1) : word;
-const inSet = (set, word) => set.has(word) || set.has(singular(word));
-function namesCredential(words) {
-    return words.some((word, index) => {
-        if (inSet(SECRET_KEY_WORDS, word))
-            return true;
-        const next = words[index + 1];
-        if (next === undefined)
-            return false;
-        return (inSet(SECRET_KEY_WORDS, `${word}${next}`) ||
-            inSet(SECRET_KEY_WORDS, `${singular(word)}${singular(next)}`));
-    });
-}
-export const MAX_KEY_NAME_LENGTH = 128;
-function isSecretKey(key) {
-    if (key.length > MAX_KEY_NAME_LENGTH)
-        return false;
-    const words = keyWords(key);
-    if (!namesCredential(words))
-        return false;
-    let end = words.length;
-    while (end > 1 && inSet(TRANSPARENT_HEADS, words[end - 1] ?? ''))
-        end -= 1;
-    return !inSet(MEASUREMENT_HEADS, words[end - 1] ?? '');
-}
-export const GENERIC_VALUE_KEYS = new Set([
-    'value', 'values', 'currentvalue', 'previousvalue', 'oldvalue', 'newvalue',
-    'defaultvalue', 'element', 'elements', 'entry', 'entries', 'result',
-]);
-export const NAME_BEARING_KEYS = new Set([
-    'propertyname', 'propertypath', 'property', 'field', 'key', 'settingname',
-    'setting', 'name',
-]);
-const MAX_SIBLING_NAME_LENGTH = 128;
-function namesCredentialBySibling(value) {
-    for (const [key, entry] of Object.entries(value)) {
-        if (typeof entry !== 'string')
-            continue;
-        if (entry.length > MAX_SIBLING_NAME_LENGTH)
-            continue;
-        if (!NAME_BEARING_KEYS.has(key.toLowerCase()))
-            continue;
-        if (isSecretKey(entry))
-            return true;
-    }
-    return false;
-}
-export const MAX_RECEIPT_DEPTH = 100;
-export function assignJsonKey(target, key, value) {
-    if (key === '__proto__') {
-        Object.defineProperty(target, key, {
-            value,
-            enumerable: true,
-            writable: true,
-            configurable: true,
-        });
-        return;
-    }
-    target[key] = value;
-}
-export function maskSecretsDeep(value, depth = 0) {
-    if (typeof value === 'string')
-        return maskSecrets(value);
-    if (Array.isArray(value)) {
-        if (depth >= MAX_RECEIPT_DEPTH)
-            return REDACTED;
-        return value.map((entry) => maskSecretsDeep(entry, depth + 1));
-    }
-    if (value !== null && typeof value === 'object') {
-        if (depth >= MAX_RECEIPT_DEPTH)
-            return REDACTED;
-        const out = {};
-        const bySibling = namesCredentialBySibling(value);
-        for (const [key, entry] of Object.entries(value)) {
-            const isGenericSiblingCarrier = bySibling && GENERIC_VALUE_KEYS.has(key.toLowerCase());
-            const masked = typeof entry !== 'boolean' &&
-                (isSecretKey(key) || (isGenericSiblingCarrier && typeof entry !== 'number'));
-            assignJsonKey(out, key, masked ? REDACTED : maskSecretsDeep(entry, depth + 1));
-        }
-        return out;
-    }
-    return value;
-}
-//# sourceMappingURL=receipt-redaction.js.map

package/dist/tools/catalog/unreal-gateway-definition.d.ts

@@ -1,5 +0,0 @@
-import type { ToolDefinition } from '../definitions/shared/tool-definition.js';
-export declare const UNREAL_GATEWAY_DESCRIPTION: string;
-export declare const UNREAL_GATEWAY_INSTRUCTIONS: string;
-export declare const unrealGatewayToolDefinition: ToolDefinition;
-//# sourceMappingURL=unreal-gateway-definition.d.ts.map

package/dist/tools/catalog/unreal-gateway-definition.js

@@ -1,147 +0,0 @@
-export const UNREAL_GATEWAY_DESCRIPTION = 'Unreal Engine editor automation: one tool, four operations. Always in this order: '
-    + "(1) search with query = 2-4 plain words naming the verb and the object, e.g. 'spawn actor', 'add variable blueprint', 'save level'; every result row carries a one-line summary, its effect and a ready-made nextCall. "
-    + "(2) describe: send the chosen row's nextCall unchanged; the reply is the exact contract: parameters (name, type, required), inputSchema, a working example and, when required, consentGrant. "
-    + "(3) execute: send describe's nextCall with params filled in, using ONLY the parameter names describe listed. "
-    + 'Rules: never guess capability ids, tool names, action names or parameter names; never put action or subAction inside params; a failed call returns suggestions and an executable nextCall, so send that nextCall instead of retrying blindly. '
-    + 'To browse instead of search, call describe with no selector and follow the nextCall on each row one level down. '
-    + 'configure only enables or disables internal tool groups; it never performs editor work.';
-export const UNREAL_GATEWAY_INSTRUCTIONS = [
-    'Unreal Engine MCP server. The only tool is `unreal`; it reaches the whole editor (actors, levels, Blueprints and their graphs, widgets, materials, audio, animation, effects and more) through four operations: search, describe, execute, configure.',
-    '',
-    'Workflow for every task:',
-    '1. search: {"operation":"search","query":"spawn actor"}. Use 2-4 plain words (verb + object), not a sentence. Each result row has a one-line summary, an effect (read, write or destructive) and a nextCall. Pick the row whose summary matches the task. If none fits, retry with different words, narrow with a filter (domain, tool, effect), or browse by calling describe with no selector and following each row\'s nextCall one level down.',
-    '2. describe: send the chosen row\'s nextCall unchanged. The reply is the exact contract for that one action: parameters[] (name, type, required, description, and variants when only some variants of a family read it), inputSchema, examples[] with a working input, consentGrant when consent is required, and the nextCall for execute.',
-    '3. execute: send describe\'s nextCall with params filled in. Use only the parameter names describe listed, with the same casing. Never put action or subAction inside params. If describe returned consentGrant, pass it back as the top-level consent field.',
-    '',
-    'Recovery: every failed call returns errorCode, message, suggestions[] and an executable nextCall. Send that nextCall (adjusting params) instead of guessing another tool, action or capability. UNKNOWN_TOOL, UNKNOWN_ACTION and UNKNOWN_CAPABILITY mean a name was invented: go back to search. INVALID_PARAMS names the offending field in pointer and lists allowedParameters. NOT_CONNECTED means the Unreal Editor is not running with the bridge; report it instead of retrying.',
-    '',
-    'Conventions: asset paths start with /Game (e.g. /Game/Blueprints/BP_Door); class paths look like /Script/Engine.Actor; vectors are objects {x, y, z}. Read with inspect-style capabilities before mutating, and never run a destructive capability without the consentGrant describe returned. configure only enables or disables internal tool groups; it never performs editor work.'
-].join('\n');
-export const unrealGatewayToolDefinition = {
-    name: 'unreal',
-    description: UNREAL_GATEWAY_DESCRIPTION,
-    inputSchema: {
-        type: 'object',
-        properties: {
-            operation: {
-                type: 'string',
-                enum: ['search', 'describe', 'execute', 'configure'],
-                description: "search finds capabilities by plain words. describe returns one capability's exact contract, or browses one level when given no selector. execute runs one validated action. configure enables or disables internal tool groups."
-            },
-            query: { type: 'string', description: "2-4 plain words naming the verb and the object, e.g. 'spawn actor', 'add variable blueprint', 'save level'. Matched against action names, topics, family, domain and summary; full sentences and filler words rank worse." },
-            capability: { type: 'string', description: 'Exact canonical capability id (or declared alias) copied from a search row or describe response, e.g. blueprint.create. Preferred selector for describe and execute; never guessed.' },
-            domain: { type: 'string', description: 'Capability domain to browse or filter by. Call describe with no selector to list domains.' },
-            family: { type: 'string', description: 'Capability family inside a domain. Call describe with a domain to list its families.' },
-            effect: { type: 'string', enum: ['read', 'write', 'destructive'], description: 'Filter search results by declared behavior effect.' },
-            tool: { type: 'string', description: 'Exact parent tool name copied from a search row (parentTool) or a describe response. Always paired with action; never guessed.' },
-            action: { type: 'string', description: 'Exact action name copied from a search row or describe response. For configure, this is a manage_tools action.' },
-            param: { type: 'string', description: 'Exact parameter name to inspect on one capability. Use with describe plus tool and action; returns that single parameter\x27s schema plus the consent grant, when the capability needs one.' },
-            params: { type: 'object', additionalProperties: true, description: 'Parameters for execute or configure: an object whose keys are exactly the parameter names describe listed for this action, with the same casing. Never include action or subAction here.' },
-            consent: {
-                type: 'object',
-                properties: {
-                    capability: { type: 'string', description: 'Exact canonical capability ID this grant authorizes, as returned by describe.' },
-                    acknowledge: { type: 'string', enum: ['explicit', 'elevated'], description: "Acknowledgement strength. 'explicit' satisfies an explicit policy; 'elevated' is required by a destructive policy and also satisfies explicit." }
-                },
-                required: ['capability', 'acknowledge'],
-                additionalProperties: false,
-                description: "Per-call consent grant for a capability whose policy.consent is not 'none'. Bound to one capability and one call; never persisted, inherited or reused. Read the exact grant from describe.consentGrant. Use with execute only."
-            },
-            options: {
-                type: 'object',
-                properties: {
-                    idempotencyKey: { type: 'string', description: 'Client-chosen key. A repeated execute with the same key and params returns the recorded receipt instead of running the action again.' },
-                    expectedCatalogRevision: { type: 'string', description: 'Refuse to run unless the catalog revision still equals this value; read it from any search or describe response.' },
-                    expectedRevisions: {
-                        type: 'object',
-                        properties: {
-                            selection: { type: 'integer', minimum: 1 },
-                            level: { type: 'integer', minimum: 1 },
-                            assetRegistry: { type: 'integer', minimum: 1 },
-                            package: { type: 'integer', minimum: 1 }
-                        },
-                        additionalProperties: false,
-                        description: 'Live editor-state revisions to pin, as the ue://state/revisions resource reports them; the call is refused with STALE_STATE when one has moved.'
-                    },
-                    timeoutMs: { type: 'integer', minimum: 1, maximum: 600000, description: 'Deadline for this call in milliseconds.' }
-                },
-                additionalProperties: false,
-                description: 'Execution controls for execute only; never put these inside params. Honored keys: idempotencyKey, expectedCatalogRevision, expectedRevisions, timeoutMs.'
-            },
-            limit: { type: 'integer', minimum: 1, maximum: 25, description: 'Maximum rows per page: search results (default 12) or describe action rows (default 20). Defaults to 12.' },
-            offset: { type: 'integer', minimum: 0, description: 'Zero-based offset into search results or into a described tool\x27s action list. Defaults to 0.' },
-            cursor: { type: 'string', description: 'Opaque search cursor from a previous response nextCursor. Supersedes offset.' },
-            maxBytes: { type: 'integer', minimum: 512, maximum: 262144, description: 'Serialized byte ceiling for a search response. Results are dropped from the end until the response fits.' }
-        },
-        required: ['operation'],
-        additionalProperties: false
-    },
-    outputSchema: {
-        type: 'object',
-        properties: {
-            success: { type: 'boolean' },
-            operation: { type: 'string' },
-            error: { type: 'string' },
-            errorCode: { type: 'string' },
-            message: { type: 'string' },
-            results: { type: 'array' },
-            result: {},
-            data: { description: "Execute payload projected against the capability's declared output schema; the same location the native /mcp surface publishes." },
-            tool: { type: 'string' },
-            action: { type: 'string' },
-            param: { type: 'string' },
-            total: { type: 'integer' },
-            offset: { type: 'integer' },
-            limit: { type: 'integer' },
-            hasMore: { type: 'boolean' },
-            perActionSchemas: { type: 'boolean' },
-            scope: { type: 'string', description: "Catalog scope: 'tool' for a tool summary, 'union' for the tool-union parameter catalog." },
-            actions: { type: 'array', description: 'Paginated/filterable action list on tool-only describe.' },
-            actionCount: { type: 'integer' },
-            actionOffset: { type: 'integer' },
-            actionLimit: { type: 'integer' },
-            actionHasMore: { type: 'boolean' },
-            parameters: { type: 'array', description: 'Paginated/filterable compact parameter catalog on tool+action describe.' },
-            parameterCount: { type: 'integer' },
-            parameterOffset: { type: 'integer' },
-            parameterLimit: { type: 'integer' },
-            parameterHasMore: { type: 'boolean' },
-            required: { type: 'boolean', description: 'Whether the described param is required.' },
-            schema: { type: 'object', description: 'Full schema of the single described param.' },
-            drillDown: { type: 'object', description: 'Example nextCall payload to drill one level deeper.' },
-            browse: { type: 'object', description: 'On a tool-only describe: a search call filtered to that tool, whose rows carry per-action summaries.' },
-            suggestions: { type: 'array', description: 'Closest-match names for an invalid tool/action/param call.' },
-            nextCall: { type: 'object', description: 'Directly-invokable gateway request for guided self-correction.' },
-            availableActions: { type: 'array' },
-            availableParameters: { type: 'array' },
-            catalogRevision: { type: 'string', description: 'Revision of the generated canonical capability catalog this response was served from.' },
-            capability: { type: 'string', description: 'Canonical capability ID this response describes.' },
-            parentTool: { type: 'string', description: 'Legacy parent tool that dispatches the described capability.' },
-            domain: { type: 'string' },
-            family: { type: 'string' },
-            domains: { type: 'array', description: 'Bounded domain list on a catalog-level describe.' },
-            families: { type: 'array', description: 'Bounded family list on a domain-level describe.' },
-            capabilities: { type: 'array', description: 'Bounded capability list on a family-level describe.' },
-            inputSchema: { type: 'object', description: 'Exact input schema of the described capability. Never a parent-tool union.' },
-            outputSchema: { type: 'object', description: 'Exact output schema of the described capability.' },
-            availability: { description: 'Whether the capability is available, disabled or unavailable, and why.' },
-            behavior: { type: 'object' },
-            policy: { type: 'object' },
-            consentGrant: { type: 'object', description: "Exact consent grant this capability requires, ready to pass back as the execute call's consent sibling. Absent when policy.consent is 'none'." },
-            cost: { type: 'object' },
-            hashes: { type: 'object', description: 'Per-record schema and content hashes from the generated catalog.' },
-            runnable: { type: 'boolean', description: 'False when the capability cannot currently be executed; nextCall then points at the fix.' },
-            migratedFrom: { type: 'object', description: 'Legacy tool/action pair that resolved to this capability.' },
-            resolvedFromAlias: { type: 'string', description: 'Declared alias that resolved to this capability.' },
-            nextCursor: { type: 'string', description: 'Cursor to pass back as cursor to continue a search.' },
-            maxBytes: { type: 'integer' },
-            truncated: { type: 'boolean', description: 'True when results were dropped to fit the byte budget.' },
-            filters: { type: 'object', description: 'Filters applied to this search.' },
-            reasons: { type: 'array' },
-            outputs: { type: 'array' }
-        },
-        required: ['success', 'operation'],
-        additionalProperties: true
-    }
-};
-//# sourceMappingURL=unreal-gateway-definition.js.map

package/dist/tools/definitions/shared/tool-definition.d.ts

@@ -1,9 +0,0 @@
-export interface ToolDefinition {
-    category?: 'core' | 'world' | 'gameplay' | 'utility';
-    name: string;
-    description: string;
-    inputSchema: Record<string, unknown>;
-    outputSchema?: Record<string, unknown>;
-    [key: string]: unknown;
-}
-//# sourceMappingURL=tool-definition.d.ts.map

package/dist/tools/definitions/shared/tool-definition.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=tool-definition.js.map