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

package/dist/server/gateway/gateway-execute-lookup.js

@@ -1,122 +0,0 @@
-import { legacyPairKey } from './gateway-capability-index.js';
-import { closestMatches, buildNextCall, guideUnknownAction, MAX_SUGGESTIONS } from './gateway-guidance.js';
-export function primaryLegacyPair(record) {
-    const first = record.legacyIds[0];
-    return first === undefined
-        ? { tool: record.routing.parentTool, action: record.routing.dispatchAction }
-        : { tool: first.tool, action: first.action };
-}
-function foldedPairForAlias(record, alias) {
-    if (alias === undefined)
-        return undefined;
-    const action = alias.slice(alias.lastIndexOf('.') + 1);
-    const folded = record.legacyIds.find((legacy) => legacy.folded !== undefined && String(legacy.action) === action);
-    return folded === undefined ? undefined : { tool: folded.tool, action: folded.action };
-}
-function fail(failure) {
-    return { ok: false, failure };
-}
-function lookupByCapability(capability, index) {
-    if (capability === undefined)
-        return { kind: 'absent' };
-    const canonical = index.byId.get(capability);
-    if (canonical !== undefined)
-        return { kind: 'found', record: canonical };
-    const owned = index.byAlias.get(capability);
-    if (owned !== undefined)
-        return { kind: 'found', record: owned, alias: capability };
-    const suggestions = closestMatches(capability, [...index.byId.keys()], MAX_SUGGESTIONS);
-    return {
-        kind: 'failed',
-        failure: {
-            errorCode: 'UNKNOWN_CAPABILITY',
-            message: `Unknown capability '${capability}'. Call search before execute.`,
-            suggestions,
-            nextCall: suggestions[0] === undefined
-                ? buildNextCall({ operation: 'search' })
-                : { operation: 'describe', capability: suggestions[0] }
-        }
-    };
-}
-function lookupByLegacyPair(requestedTool, action, index) {
-    if (requestedTool === undefined && action === undefined)
-        return { kind: 'absent' };
-    const tool = requestedTool !== undefined && !index.actionsByParentTool.has(requestedTool)
-        ? index.parentToolByNamespace.get(requestedTool) ?? requestedTool
-        : requestedTool;
-    if (tool === undefined || !index.actionsByParentTool.has(tool)) {
-        const suggestions = closestMatches(tool ?? '', [...index.actionsByParentTool.keys()], MAX_SUGGESTIONS);
-        return {
-            kind: 'failed',
-            failure: {
-                errorCode: 'UNKNOWN_TOOL',
-                message: 'Unknown tool. Call search before execute.',
-                suggestions,
-                nextCall: suggestions[0] === undefined
-                    ? buildNextCall({ operation: 'search' })
-                    : buildNextCall({ operation: 'describe', tool: suggestions[0] })
-            }
-        };
-    }
-    const record = action === undefined ? undefined : index.byLegacyPair.get(legacyPairKey(tool, action));
-    if (record === undefined) {
-        const available = index.actionsByParentTool.get(tool) ?? [];
-        const owners = action === undefined
-            ? []
-            : [...index.actionsByParentTool].filter(([, actions]) => actions.includes(action)).map(([owner]) => owner).sort();
-        const guide = guideUnknownAction(tool, action ?? '', available, owners);
-        return {
-            kind: 'failed',
-            failure: {
-                errorCode: 'UNKNOWN_ACTION',
-                message: `Unknown action ${action === undefined ? '' : `'${action}' `}for ${tool}.${guide.hint} Call describe before execute.`,
-                availableActions: available,
-                suggestions: guide.suggestions,
-                nextCall: guide.nextCall
-            }
-        };
-    }
-    return { kind: 'found', record, pair: { tool, action: action ?? '' } };
-}
-export function resolveExecuteTarget(request, index) {
-    const fromCapability = lookupByCapability(request.capability, index);
-    if (fromCapability.kind === 'failed')
-        return fail(fromCapability.failure);
-    const fromLegacy = lookupByLegacyPair(request.tool, request.action, index);
-    if (fromLegacy.kind === 'failed')
-        return fail(fromLegacy.failure);
-    if (fromCapability.kind === 'found' && fromLegacy.kind === 'found'
-        && fromCapability.record.id !== fromLegacy.record.id) {
-        return fail({
-            errorCode: 'FORM_CONFLICT',
-            capabilityId: fromCapability.record.id,
-            message: `capability '${fromCapability.record.id}' conflicts with tool/action '${fromLegacy.record.id}'. Supply one form.`,
-            nextCall: { operation: 'describe', capability: fromCapability.record.id }
-        });
-    }
-    const resolved = fromCapability.kind === 'found' ? fromCapability.record : undefined;
-    const migrated = fromLegacy.kind === 'found' ? fromLegacy.record : undefined;
-    const record = resolved ?? migrated;
-    if (record === undefined) {
-        return fail({
-            errorCode: 'MISSING_SELECTOR',
-            message: 'execute requires either capability or tool + action. Call describe with no arguments to list the parent tools, or search to find a capability.',
-            nextCall: buildNextCall({ operation: 'describe' })
-        });
-    }
-    const legacy = fromLegacy.kind === 'found'
-        ? fromLegacy.pair
-        : (fromCapability.kind === 'found' ? foldedPairForAlias(record, fromCapability.alias) : undefined) ?? primaryLegacyPair(record);
-    return {
-        ok: true,
-        target: {
-            record,
-            legacy,
-            ...(fromCapability.kind === 'found' && fromCapability.alias !== undefined
-                ? { resolvedFromAlias: fromCapability.alias }
-                : {}),
-            ...(fromLegacy.kind === 'found' ? { migratedFrom: fromLegacy.pair } : {})
-        }
-    };
-}
-//# sourceMappingURL=gateway-execute-lookup.js.map

package/dist/server/gateway/gateway-execute-policy.d.ts

@@ -1,9 +0,0 @@
-import type { ResolvedFailure } from './gateway-execute-envelope.js';
-import type { ExecuteTarget } from './gateway-execute-resolve.js';
-import { type ConsentGrant } from '../../tools/catalog/capabilities/semantic/authorization.js';
-import type { BridgeAuthority } from '../../automation/message-schema.js';
-export declare function checkExpectedCatalogRevision(options: Record<string, unknown> | undefined): ResolvedFailure | undefined;
-export declare function checkScopeAuthorization(target: ExecuteTarget, authority: BridgeAuthority | undefined): ResolvedFailure | undefined;
-export declare function matchedFoldedGrant(name: string, target: ExecuteTarget): ExecuteTarget['record']['legacyIds'][number] | undefined;
-export declare function checkConsentAuthorization(target: ExecuteTarget, authority: BridgeAuthority | undefined, consent: ConsentGrant | undefined): ResolvedFailure | undefined;
-//# sourceMappingURL=gateway-execute-policy.d.ts.map

package/dist/server/gateway/gateway-execute-policy.js

@@ -1,93 +0,0 @@
-import { catalogRevision } from './gateway-capability-index.js';
-import { buildNextCall } from './gateway-guidance.js';
-import { CatalogRevisionSchema } from '../../tools/catalog/capabilities/semantic/ids.js';
-import { isConsentSatisfied, isScopeAuthorized } from '../../tools/catalog/capabilities/semantic/authorization.js';
-import { POLICY_SCOPES } from '../../tools/catalog/capabilities/constants.js';
-function knownScopes(advertised) {
-    const known = POLICY_SCOPES;
-    return advertised.filter((scope) => known.includes(scope));
-}
-export function checkExpectedCatalogRevision(options) {
-    const expected = options?.expectedCatalogRevision;
-    if (expected === undefined)
-        return undefined;
-    const parsed = CatalogRevisionSchema.safeParse(expected);
-    if (!parsed.success) {
-        return {
-            errorCode: 'INVALID_OPTIONS',
-            message: 'options.expectedCatalogRevision must be a lowercase hex catalog-revision digest of 1..64 characters.',
-            pointer: '/options/expectedCatalogRevision'
-        };
-    }
-    const current = catalogRevision();
-    if (parsed.data === current)
-        return undefined;
-    return {
-        errorCode: 'STALE_STATE',
-        message: `The capability catalog revision changed since it was read (expected '${parsed.data}', current '${current}'). Re-run search or describe and retry.`,
-        currentRevision: current,
-        expectedRevision: parsed.data,
-        nextCall: buildNextCall({ operation: 'search' })
-    };
-}
-export function checkScopeAuthorization(target, authority) {
-    const grantedScopes = authority?.scopes;
-    if (grantedScopes === undefined)
-        return undefined;
-    const requiredScope = target.record.policy.requiredScope;
-    if (isScopeAuthorized(requiredScope, knownScopes(grantedScopes))) {
-        return undefined;
-    }
-    return {
-        errorCode: 'SCOPE_NOT_GRANTED',
-        message: `This action requires the '${requiredScope}' scope, which the active principal does not hold. Retry with a principal granted '${requiredScope}' (or admin).`,
-        requiredScope,
-        grantedScopes,
-        nextCall: buildNextCall({
-            operation: 'describe',
-            tool: target.record.routing.parentTool,
-            action: target.legacy.action
-        })
-    };
-}
-function grantNamesCapability(name, target) {
-    const record = target.record;
-    if (name === String(record.id))
-        return true;
-    if ((record.aliases ?? []).some((alias) => String(alias) === name))
-        return true;
-    return (record.legacyIds ?? []).some((legacy) => `${String(legacy.tool)}.${String(legacy.action)}` === name);
-}
-export function matchedFoldedGrant(name, target) {
-    const record = target.record;
-    for (const legacy of record.legacyIds) {
-        if (legacy.folded !== undefined && `${String(legacy.tool)}.${String(legacy.action)}` === name) {
-            return legacy;
-        }
-    }
-    return undefined;
-}
-export function checkConsentAuthorization(target, authority, consent) {
-    if (authority?.scopes === undefined)
-        return undefined;
-    const policy = target.record.policy.consent;
-    if (policy === 'none')
-        return undefined;
-    const acknowledgement = consent !== undefined && grantNamesCapability(consent.capability, target)
-        ? consent.acknowledge
-        : undefined;
-    if (isConsentSatisfied(policy, acknowledgement))
-        return undefined;
-    const acknowledge = policy === 'elevated' ? 'elevated' : 'explicit';
-    return {
-        errorCode: 'CONSENT_REQUIRED',
-        message: `This action requires ${policy} consent. Re-run with consent: { capability: '${target.record.id}', acknowledge: '${acknowledge}' }.`,
-        requiredScope: target.record.policy.requiredScope,
-        nextCall: buildNextCall({
-            operation: 'describe',
-            tool: target.record.routing.parentTool,
-            action: target.legacy.action
-        })
-    };
-}
-//# sourceMappingURL=gateway-execute-policy.js.map

package/dist/server/gateway/gateway-execute-resolve.d.ts

@@ -1,28 +0,0 @@
-import type { CapabilityRecord } from '../../tools/catalog/capabilities/model.js';
-export type LegacyPair = {
-    readonly tool: string;
-    readonly action: string;
-};
-export type ExecuteTarget = {
-    readonly record: CapabilityRecord;
-    readonly legacy: LegacyPair;
-    readonly resolvedFromAlias?: string;
-    readonly migratedFrom?: LegacyPair;
-};
-export type ExecuteResolutionFailure = {
-    readonly errorCode: string;
-    readonly message: string;
-    readonly capabilityId?: string;
-    readonly suggestions?: readonly string[];
-    readonly nextCall?: Record<string, unknown>;
-    readonly availableActions?: readonly string[];
-};
-export type ExecuteResolution = {
-    readonly ok: true;
-    readonly target: ExecuteTarget;
-} | {
-    readonly ok: false;
-    readonly failure: ExecuteResolutionFailure;
-};
-export { resolveExecuteTarget } from './gateway-execute-lookup.js';
-//# sourceMappingURL=gateway-execute-resolve.d.ts.map

package/dist/server/gateway/gateway-execute-resolve.js

@@ -1,2 +0,0 @@
-export { resolveExecuteTarget } from './gateway-execute-lookup.js';
-//# sourceMappingURL=gateway-execute-resolve.js.map

package/dist/server/gateway/gateway-execute-static-check.d.ts

@@ -1,13 +0,0 @@
-import type { ExecuteTarget } from './gateway-execute-resolve.js';
-import type { ResolvedFailure } from './gateway-execute-envelope.js';
-import { type ExpectedRevisions } from '../../tools/catalog/capabilities/semantic/execution-options.js';
-export type StaticCheck = {
-    readonly failure: ResolvedFailure;
-} | {
-    readonly params: Record<string, unknown>;
-    readonly expectedRevisions?: ExpectedRevisions;
-    readonly timeoutMs?: number;
-    readonly unread: readonly string[];
-};
-export declare function checkStaticRequest(target: ExecuteTarget, args: Record<string, unknown>): StaticCheck;
-//# sourceMappingURL=gateway-execute-static-check.d.ts.map

package/dist/server/gateway/gateway-execute-static-check.js

@@ -1,127 +0,0 @@
-import { isRecord } from '../../utils/validation/type-guards.js';
-import { dynamicToolManager } from '../../tools/dynamic/dynamic-tool-manager.js';
-import { buildNextCall, closestMatches, MAX_SUGGESTIONS } from './gateway-guidance.js';
-import { capabilityIndex } from './gateway-capability-index.js';
-import { primaryLegacyPair } from './gateway-execute-lookup.js';
-import { applyFoldedPins, inferSelector, requestedAction, unreadVariantParams } from './gateway-dispatch-by.js';
-import { applyDeclaredDefaults, coerceVectorShapes, validateAgainstCapabilitySchema, VIOLATION_GATEWAY_CODES } from './gateway-schema-validate.js';
-import { findControlKeyInParams, validateExecutionOptions } from './gateway-option-validate.js';
-import { ExpectedRevisionsSchema } from '../../tools/catalog/capabilities/semantic/execution-options.js';
-function declaredParameterNames(schema) {
-    return isRecord(schema.properties)
-        ? Object.keys(schema.properties).filter((name) => name !== 'action').sort()
-        : [];
-}
-function validateInput(target, params) {
-    const record = target.record;
-    const declaresAction = isRecord(record.schemas.input.properties)
-        && 'action' in record.schemas.input.properties;
-    const candidate = declaresAction
-        ? { ...params, action: record.routing.dispatchAction }
-        : params;
-    const violation = validateAgainstCapabilitySchema(candidate, record.schemas.input);
-    if (violation === undefined)
-        return undefined;
-    const declared = declaredParameterNames(record.schemas.input);
-    const offending = violation.pointer.split('/').filter((part) => part.length > 0).pop() ?? '';
-    const suggestions = closestMatches(offending, declared, MAX_SUGGESTIONS);
-    return {
-        errorCode: VIOLATION_GATEWAY_CODES[violation.reason],
-        message: `${violation.message} for ${record.id}. Call describe before execution.`,
-        pointer: violation.pointer,
-        ...(violation.reason === 'range' ? { field: violation.pointer } : {}),
-        suggestions,
-        allowedParameters: declared,
-        nextCall: buildNextCall({
-            operation: 'describe',
-            tool: record.routing.parentTool,
-            action: target.legacy.action,
-            param: suggestions[0]
-        })
-    };
-}
-export function checkStaticRequest(target, args) {
-    const record = target.record;
-    const refuse = (failure) => ({ failure });
-    if (!dynamicToolManager.isToolEnabled(record.routing.parentTool)) {
-        return refuse({
-            errorCode: 'TOOL_DISABLED',
-            message: `Tool '${record.routing.parentTool}' is disabled or unavailable.`,
-            suggestions: closestMatches(record.routing.parentTool, [...capabilityIndex().actionsByParentTool.keys()], MAX_SUGGESTIONS),
-            nextCall: buildNextCall({ operation: 'configure', tool: record.routing.parentTool })
-        });
-    }
-    if (args.params !== undefined && !isRecord(args.params)) {
-        return refuse({
-            errorCode: 'INVALID_PARAMS',
-            message: 'params must be an object.',
-            suggestions: declaredParameterNames(record.schemas.input).slice(0, MAX_SUGGESTIONS),
-            nextCall: buildNextCall({
-                operation: 'describe',
-                tool: record.routing.parentTool,
-                action: target.legacy.action
-            })
-        });
-    }
-    const rawParams = isRecord(args.params) ? args.params : {};
-    const paramsAction = Object.hasOwn(rawParams, 'action') ? rawParams.action : undefined;
-    const scrubbed = typeof paramsAction === 'string' && paramsAction === target.legacy.action
-        ? (({ action: _droppedAction, ...rest }) => rest)(rawParams)
-        : rawParams;
-    if (Object.hasOwn(scrubbed, 'action') || Object.hasOwn(scrubbed, 'subAction')) {
-        return refuse({
-            errorCode: 'INVALID_PARAMS',
-            message: 'params must not override action or subAction. Supply the selected action at the gateway level.'
-        });
-    }
-    const control = findControlKeyInParams(scrubbed);
-    if (control !== undefined) {
-        return refuse({
-            errorCode: 'UNSUPPORTED_OPTION',
-            option: control,
-            message: `Gateway control '${control}' must not appear in action params. Supply it in options.`
-        });
-    }
-    const optionViolation = validateExecutionOptions(args.options);
-    if (optionViolation !== undefined) {
-        return refuse({
-            errorCode: optionViolation.errorCode,
-            message: optionViolation.message,
-            ...(optionViolation.option === undefined
-                ? {}
-                : { option: optionViolation.option, field: optionViolation.option }),
-            ...(optionViolation.pointer === undefined ? {} : { pointer: optionViolation.pointer })
-        });
-    }
-    const expectedRevisions = !isRecord(args.options) || args.options.expectedRevisions === undefined
-        ? undefined
-        : ExpectedRevisionsSchema.parse(args.options.expectedRevisions);
-    const timeoutMs = isRecord(args.options) && typeof args.options.timeoutMs === 'number'
-        ? args.options.timeoutMs
-        : undefined;
-    const pins = applyFoldedPins(target, scrubbed);
-    if ('conflict' in pins) {
-        const { conflict } = pins;
-        const primary = primaryLegacyPair(record).action;
-        return refuse({
-            errorCode: 'INVALID_PARAMETER_VALUE',
-            message: `'${requestedAction(target) ?? primary}' always runs with ${conflict.name} ${JSON.stringify(conflict.pinned)}, but the call sent ${conflict.name} ${JSON.stringify(conflict.sent)}. '${primary}' takes any ${conflict.name}: nextCall runs it with these params.`,
-            pointer: `/${conflict.name}`,
-            nextCall: {
-                ...buildNextCall({ operation: 'execute', tool: record.routing.parentTool, action: primary }),
-                params: scrubbed
-            }
-        });
-    }
-    const withDefaults = coerceVectorShapes(applyDeclaredDefaults(inferSelector(record, pins.params), record.schemas.input), record.schemas.input);
-    const inputFailure = validateInput(target, withDefaults);
-    return inputFailure === undefined
-        ? {
-            params: withDefaults,
-            unread: unreadVariantParams(record, Object.keys(pins.params), withDefaults),
-            ...(expectedRevisions === undefined ? {} : { expectedRevisions }),
-            ...(timeoutMs === undefined ? {} : { timeoutMs })
-        }
-        : { failure: inputFailure };
-}
-//# sourceMappingURL=gateway-execute-static-check.js.map

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

@@ -1,6 +0,0 @@
-import { type GatewayContext } from './gateway-execute-dispatch.js';
-import type { CorrelationId } from '../../tools/catalog/capabilities/semantic/ids.js';
-export type { GatewayContext };
-export declare function executeGatewayCall(args: Record<string, unknown>, context: GatewayContext, correlationId: CorrelationId): Promise<Record<string, unknown>>;
-export declare const STILL_RUNNING_AFTER_MS = 27000;
-//# sourceMappingURL=gateway-execute.d.ts.map

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

@@ -1,145 +0,0 @@
-import { isRecord } from '../../utils/validation/type-guards.js';
-import { getString } from './gateway-shared.js';
-import { buildNextCall } from './gateway-guidance.js';
-import { resolveExecuteTarget } from './gateway-execute-resolve.js';
-import { capabilityIndex } from './gateway-capability-index.js';
-import { resolveDispatchAction } from './gateway-dispatch-by.js';
-import { checkStaticRequest } from './gateway-execute-static-check.js';
-import { executeErrorEnvelope, executeSuccessEnvelope, refuseWithTarget } from './gateway-execute-envelope.js';
-import { dispatchAndValidate } from './gateway-execute-dispatch.js';
-import { checkConsentAuthorization, checkExpectedCatalogRevision, checkScopeAuthorization, matchedFoldedGrant } from './gateway-execute-policy.js';
-import { ConsentGrantSchema } from '../../tools/catalog/capabilities/semantic/authorization.js';
-import { buildReceiptContext } from './gateway-receipt-context.js';
-import { noteTaskDone, noteTaskRunning } from './gateway-task-results.js';
-import { conflictMessage, IDEMPOTENCY_CONFLICT_CODE, LOCAL_PRINCIPAL, markReplayed, runWithIdempotency, sharedExecuteLedger } from './gateway-execute-idempotency.js';
-export async function executeGatewayCall(args, context, correlationId) {
-    const options = isRecord(args.options) ? args.options : undefined;
-    const receiptContext = buildReceiptContext(correlationId, options);
-    const index = capabilityIndex();
-    const resolution = resolveExecuteTarget({
-        capability: getString(args, 'capability'),
-        tool: getString(args, 'tool'),
-        action: getString(args, 'action'),
-        params: isRecord(args.params) ? args.params : {}
-    }, index);
-    if (!resolution.ok) {
-        const { capabilityId, ...failure } = resolution.failure;
-        return executeErrorEnvelope({
-            ...failure,
-            record: capabilityId === undefined ? undefined : index.byId.get(capabilityId),
-            requestedTool: getString(args, 'tool'),
-            requestedAction: getString(args, 'action')
-        }, receiptContext);
-    }
-    const target = resolution.target;
-    const checked = checkStaticRequest(target, args);
-    if ('failure' in checked)
-        return refuseWithTarget(target, checked.failure, receiptContext);
-    const policyFailure = checkExpectedCatalogRevision(options);
-    if (policyFailure !== undefined)
-        return refuseWithTarget(target, policyFailure, receiptContext);
-    if (!await context.ensureConnected()) {
-        const bridgeTarget = context.tools.automationBridge?.getClientUrl?.();
-        return refuseWithTarget(target, {
-            errorCode: 'NOT_CONNECTED',
-            message: bridgeTarget
-                ? `Unreal Engine is not connected: no bridge listener responded at ${bridgeTarget}.`
-                : 'Unreal Engine is not connected.',
-            nextCall: buildNextCall({ operation: 'search' })
-        }, receiptContext);
-    }
-    const authority = context.tools.automationBridge?.getAuthority?.();
-    const scopeFailure = checkScopeAuthorization(target, authority);
-    if (scopeFailure !== undefined)
-        return refuseWithTarget(target, scopeFailure, receiptContext);
-    let consentGrant;
-    if (args.consent !== undefined) {
-        const parsedConsent = ConsentGrantSchema.safeParse(args.consent);
-        if (!parsedConsent.success) {
-            return refuseWithTarget(target, {
-                errorCode: 'INVALID_CONSENT',
-                message: 'consent must be { capability: <exact capability id>, acknowledge: "explicit" | "elevated" }.',
-                nextCall: buildNextCall({ operation: 'describe', tool: target.record.routing.parentTool, action: target.legacy.action })
-            }, receiptContext);
-        }
-        consentGrant = parsedConsent.data;
-    }
-    const consentFailure = checkConsentAuthorization(target, authority, consentGrant);
-    if (consentFailure !== undefined)
-        return refuseWithTarget(target, consentFailure, receiptContext);
-    if (consentGrant !== undefined && target.record.policy.consent !== 'none') {
-        const granted = matchedFoldedGrant(consentGrant.capability, target);
-        const dispatchAction = resolveDispatchAction(target, checked.params);
-        if (granted !== undefined && dispatchAction !== undefined && String(granted.action) !== dispatchAction) {
-            return refuseWithTarget(target, {
-                errorCode: 'CONSENT_REQUIRED',
-                message: `The consent grant names '${String(granted.tool)}.${String(granted.action)}', which authorizes that operation only; this call dispatches '${dispatchAction}'. Re-run with consent naming the capability id '${target.record.id}' to authorize the family.`,
-                requiredScope: target.record.policy.requiredScope,
-                nextCall: buildNextCall({
-                    operation: 'describe',
-                    tool: target.record.routing.parentTool,
-                    action: target.legacy.action
-                })
-            }, receiptContext);
-        }
-    }
-    const dispatch = async () => {
-        const receipt = await dispatchAndValidate(target, checked.params, options, context, receiptContext, {
-            correlationId,
-            consent: consentGrant,
-            expectedRevisions: checked.expectedRevisions,
-            timeoutMs: checked.timeoutMs
-        }, checked.unread);
-        const versionMismatch = receipt.success === true ? undefined : context.tools.automationBridge?.getVersionMismatch?.();
-        return versionMismatch === undefined ? receipt : { ...receipt, versionMismatch };
-    };
-    const settled = runWithIdempotency({
-        capabilityId: target.record.id,
-        principal: authority?.profile ?? LOCAL_PRINCIPAL,
-        params: checked.params,
-        idempotencyKey: receiptContext.idempotencyId
-    }, sharedExecuteLedger(), dispatch, (receipt) => receipt.success === true, (reason) => refuseWithTarget(target, {
-        errorCode: IDEMPOTENCY_CONFLICT_CODE,
-        message: conflictMessage(reason),
-        nextCall: buildNextCall({
-            operation: 'describe',
-            tool: target.record.routing.parentTool,
-            action: target.legacy.action
-        })
-    }, receiptContext), (recorded) => markReplayed(recorded, receiptContext.correlationId));
-    if (checked.timeoutMs !== undefined)
-        return await settled;
-    return await answerWhileRunning(settled, target.record, receiptContext, context);
-}
-export const STILL_RUNNING_AFTER_MS = 27_000;
-async function answerWhileRunning(settled, record, receiptContext, context) {
-    let timer;
-    const running = new Promise((resolve) => {
-        timer = setTimeout(resolve, STILL_RUNNING_AFTER_MS, undefined);
-    });
-    const first = await Promise.race([settled, running]).finally(() => clearTimeout(timer));
-    if (first !== undefined)
-        return first;
-    const taskId = receiptContext.correlationId;
-    noteTaskRunning(taskId);
-    settled.then((receipt) => {
-        noteTaskDone(taskId, receipt);
-        context.logger.info(`${record.id} finished after its still-running answer (success=${String(receipt.success)}).`);
-    }, (error) => {
-        const text = error instanceof Error ? error.message : String(error);
-        noteTaskDone(taskId, { success: false, errorCode: 'EXECUTION_ERROR', message: text });
-        context.logger.warn(`${record.id} failed after its still-running answer: ${text}`);
-    });
-    const again = receiptContext.idempotencyId === undefined
-        ? 'do not send this call again: it would run twice.'
-        : 'the same call with the same idempotencyKey also answers with it instead of running again.';
-    const message = `Still running after ${STILL_RUNNING_AFTER_MS / 1000} s. Unreal keeps going; this answer does not stop it. `
-        + `Read its result with manage_tools get_task_result taskId ${taskId} once it is done; ${again}`;
-    return executeSuccessEnvelope({
-        record,
-        result: { success: true, message, task: { taskId, state: 'running' } },
-        canonicalOutput: { message },
-        warnings: []
-    }, receiptContext);
-}
-//# sourceMappingURL=gateway-execute.js.map

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

@@ -1,15 +0,0 @@
-export declare const MAX_SUGGESTIONS = 3;
-export declare function closestMatches(target: string, candidates: string[], limit?: number): string[];
-export interface UnknownActionGuide {
-    readonly suggestions: string[];
-    readonly nextCall: Record<string, unknown>;
-    readonly hint: string;
-}
-export declare function guideUnknownAction(tool: string, action: string, actions: readonly string[], owningTools: readonly string[]): UnknownActionGuide;
-export declare function buildNextCall(parts: {
-    operation: string;
-    tool?: string;
-    action?: string;
-    param?: string;
-}): Record<string, unknown>;
-//# sourceMappingURL=gateway-guidance.d.ts.map

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

@@ -1,78 +0,0 @@
-export const MAX_SUGGESTIONS = 3;
-function levenshtein(a, b) {
-    const m = a.length;
-    const n = b.length;
-    if (m === 0)
-        return n;
-    if (n === 0)
-        return m;
-    let previous = Array.from({ length: n + 1 }, (_, index) => index);
-    let current = new Array(n + 1).fill(0);
-    for (let i = 1; i <= m; i++) {
-        current[0] = i;
-        for (let j = 1; j <= n; j++) {
-            const cost = a[i - 1] === b[j - 1] ? 0 : 1;
-            current[j] = Math.min(previous[j] + 1, current[j - 1] + 1, previous[j - 1] + cost);
-        }
-        [previous, current] = [current, previous];
-    }
-    return previous[n];
-}
-function commonPrefixLength(left, right) {
-    const limit = Math.min(left.length, right.length);
-    let shared = 0;
-    while (shared < limit && left[shared] === right[shared])
-        shared += 1;
-    return shared;
-}
-export function closestMatches(target, candidates, limit = MAX_SUGGESTIONS) {
-    if (limit <= 0)
-        return [];
-    const normalized = target.trim().toLowerCase();
-    if (normalized.length === 0)
-        return candidates.slice(0, limit);
-    return candidates
-        .map((candidate) => {
-        const lower = candidate.toLowerCase();
-        let score = levenshtein(lower, normalized);
-        if (lower.includes(normalized) || normalized.includes(lower))
-            score -= 4;
-        return { candidate, score, prefix: commonPrefixLength(lower, normalized) };
-    })
-        .sort((left, right) => left.score - right.score
-        || right.prefix - left.prefix
-        || (left.candidate < right.candidate ? -1 : left.candidate > right.candidate ? 1 : 0))
-        .slice(0, limit)
-        .map((entry) => entry.candidate);
-}
-function actionVerb(action) {
-    return (action.split('_', 1)[0] ?? '').toLowerCase();
-}
-export function guideUnknownAction(tool, action, actions, owningTools) {
-    const suggestions = closestMatches(action, [...actions], MAX_SUGGESTIONS);
-    const others = owningTools.filter((owner) => owner !== tool);
-    if (others.length === 1) {
-        return {
-            suggestions,
-            hint: ` '${action}' is a ${others[0]} action.`,
-            nextCall: buildNextCall({ operation: 'describe', tool: others[0], action })
-        };
-    }
-    const trimmed = action.trim();
-    const verb = actionVerb(trimmed);
-    if (verb !== '' && !suggestions.some((suggestion) => levenshtein(actionVerb(suggestion), verb) <= 1)) {
-        return { suggestions, hint: '', nextCall: { operation: 'search', query: trimmed.replaceAll('_', ' ') } };
-    }
-    return { suggestions, hint: '', nextCall: buildNextCall({ operation: 'describe', tool, action: suggestions[0] }) };
-}
-export function buildNextCall(parts) {
-    const call = { operation: parts.operation };
-    if (parts.tool !== undefined)
-        call.tool = parts.tool;
-    if (parts.action !== undefined)
-        call.action = parts.action;
-    if (parts.param !== undefined)
-        call.param = parts.param;
-    return call;
-}
-//# sourceMappingURL=gateway-guidance.js.map

package/dist/server/gateway/gateway-option-validate.d.ts

@@ -1,10 +0,0 @@
-export declare const MAX_TIMEOUT_MS = 600000;
-export type OptionViolation = {
-    readonly errorCode: 'UNSUPPORTED_OPTION' | 'INVALID_OPTIONS' | 'OUT_OF_RANGE';
-    readonly message: string;
-    readonly option?: string;
-    readonly pointer?: string;
-};
-export declare function validateExecutionOptions(raw: unknown): OptionViolation | undefined;
-export declare function findControlKeyInParams(params: Record<string, unknown>): string | undefined;
-//# sourceMappingURL=gateway-option-validate.d.ts.map