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

package/dist/server/gateway/gateway-dispatch-by.js

@@ -1,67 +0,0 @@
-export function requestedAction(target) {
-    if (target.migratedFrom !== undefined)
-        return target.migratedFrom.action;
-    if (target.resolvedFromAlias !== undefined) {
-        const alias = target.resolvedFromAlias;
-        return alias.slice(alias.lastIndexOf('.') + 1);
-    }
-    return undefined;
-}
-export function foldedPairFor(record, action) {
-    if (action === undefined)
-        return undefined;
-    return record.legacyIds.find((entry) => entry.action === action && entry.folded !== undefined);
-}
-export function applyFoldedPins(target, params) {
-    const folded = foldedPairFor(target.record, requestedAction(target))?.folded;
-    if (folded === undefined)
-        return { params };
-    const pinned = { ...params };
-    for (const [name, value] of Object.entries(folded)) {
-        if (!Object.hasOwn(pinned, name))
-            pinned[name] = value;
-        else if (pinned[name] !== value)
-            return { conflict: { name, pinned: value, sent: pinned[name] } };
-    }
-    return { params: pinned };
-}
-export function inferSelector(record, params) {
-    const dispatchBy = record.routing.dispatchBy;
-    if (dispatchBy?.declaredBy === undefined || Object.hasOwn(params, dispatchBy.param))
-        return params;
-    let candidates;
-    for (const name of Object.keys(params)) {
-        const owners = Object.hasOwn(dispatchBy.declaredBy, name) ? dispatchBy.declaredBy[name] : undefined;
-        if (owners === undefined)
-            continue;
-        candidates = candidates === undefined ? owners : candidates.filter((value) => owners.includes(value));
-    }
-    return candidates?.length === 1 ? { ...params, [dispatchBy.param]: candidates[0] } : params;
-}
-export function unreadVariantParams(record, sent, params) {
-    const dispatchBy = record.routing.dispatchBy;
-    const selected = dispatchBy === undefined ? undefined : params[dispatchBy.param];
-    if (dispatchBy?.declaredBy === undefined || typeof selected !== 'string')
-        return [];
-    const declaredBy = dispatchBy.declaredBy;
-    return sent.flatMap((name) => {
-        const owners = Object.hasOwn(declaredBy, name) ? declaredBy[name] : undefined;
-        return owners === undefined || owners.includes(selected)
-            ? []
-            : [`${name} is read only when ${dispatchBy.param} is ${owners.join(' or ')}; this ${dispatchBy.param}=${selected} call did not use it.`];
-    });
-}
-export function resolveDispatchAction(target, params) {
-    const folded = foldedPairFor(target.record, requestedAction(target));
-    if (folded !== undefined)
-        return folded.action;
-    const dispatchBy = target.record.routing.dispatchBy;
-    if (dispatchBy === undefined)
-        return target.legacy.action;
-    const value = params[dispatchBy.param];
-    const mapped = typeof value === 'string' && Object.hasOwn(dispatchBy.actions, value)
-        ? dispatchBy.actions[value]
-        : undefined;
-    return mapped;
-}
-//# sourceMappingURL=gateway-dispatch-by.js.map

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

@@ -1,24 +0,0 @@
-import type { ITools } from '../../types/tools/tool-interfaces.js';
-import type { Draft202012ObjectSchema } from '../../tools/catalog/capabilities/model.js';
-import { Logger } from '../../utils/logging/logger.js';
-import { type GatewayControls } from '../../tools/handlers/foundation/dispatch/automation-request-dispatch.js';
-import type { ExecuteTarget } from './gateway-execute-resolve.js';
-import type { GatewayReceiptContext } from './gateway-receipt-context.js';
-export declare const MAX_EXECUTION_RESULT_CHARS = 100000;
-export declare const MAX_IMAGE_BASE64_CHARS = 6000000;
-export declare function resultCharBudget(result: unknown): number;
-export type GatewayContext = {
-    tools: ITools;
-    logger: Logger;
-    ensureConnected: () => Promise<boolean>;
-};
-export declare function projectCanonicalOutput(result: unknown, schema: Draft202012ObjectSchema): unknown;
-export declare function actorNotFoundGuidance(handlerCode: string | undefined, params: Record<string, unknown>): {
-    readonly suggestions?: readonly string[];
-    readonly nextCall?: Record<string, unknown>;
-};
-export declare function handlerNextCall(result: unknown): {
-    readonly nextCall?: Record<string, unknown>;
-};
-export declare function dispatchAndValidate(target: ExecuteTarget, params: Record<string, unknown>, options: Record<string, unknown> | undefined, context: GatewayContext, receiptContext: GatewayReceiptContext, controls: GatewayControls, unread?: readonly string[]): Promise<Record<string, unknown>>;
-//# sourceMappingURL=gateway-execute-dispatch.d.ts.map

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

@@ -1,204 +0,0 @@
-import { cleanObject } from '../../utils/serialization/safe-json.js';
-import { isRecord } from '../../utils/validation/type-guards.js';
-import { executeAutomationRequest } from '../../tools/handlers/foundation/dispatch/automation-request-dispatch.js';
-import { handleManageToolsCall } from '../tool-registry-manage-tools.js';
-import { McpRequestCancelledError } from '../../automation/request-cancellation-error.js';
-import { normalizeAutomationFrame } from '../../utils/responses/automation-frame-normalization.js';
-import { validateAgainstCapabilitySchema } from './gateway-schema-validate.js';
-import { resolveDispatchAction } from './gateway-dispatch-by.js';
-import { buildNextCall } from './gateway-guidance.js';
-import { executeSuccessEnvelope, refuseWithTarget } from './gateway-execute-envelope.js';
-export const MAX_EXECUTION_RESULT_CHARS = 100_000;
-export const MAX_IMAGE_BASE64_CHARS = 6_000_000;
-export function resultCharBudget(result) {
-    const image = isRecord(result) ? result.imageBase64 : undefined;
-    return typeof image === 'string' && image.length <= MAX_IMAGE_BASE64_CHARS
-        ? MAX_EXECUTION_RESULT_CHARS + image.length
-        : MAX_EXECUTION_RESULT_CHARS;
-}
-export function projectCanonicalOutput(result, schema) {
-    if (!isRecord(result))
-        return result;
-    if (!isRecord(schema.properties))
-        return {};
-    const payload = isRecord(result.data) ? result.data : undefined;
-    const projected = {};
-    for (const name of Object.keys(schema.properties)) {
-        if (name in result)
-            projected[name] = result[name];
-        else if (payload !== undefined && name in payload)
-            projected[name] = payload[name];
-    }
-    if ('details' in schema.properties) {
-        const existing = isRecord(projected.details) ? projected.details : undefined;
-        const details = existing ? { ...existing } : {};
-        const fold = (source) => {
-            for (const [name, value] of Object.entries(source)) {
-                if (name === 'data' || name === 'requestId' || name === 'type' || name === 'liveRevisions' || name === 'message'
-                    || name in schema.properties)
-                    continue;
-                if (!(name in details))
-                    details[name] = value;
-            }
-        };
-        fold(result);
-        if (payload !== undefined)
-            fold(payload);
-        if (Object.keys(details).length > 0)
-            projected.details = details;
-    }
-    return projected;
-}
-function handlerReportedFailure(result) {
-    return isRecord(result) && (result.success === false || result.isError === true);
-}
-function failureMessage(result) {
-    return isRecord(result) && typeof result.message === 'string'
-        ? result.message
-        : 'Unreal reported a failed execution.';
-}
-function failureString(result, key) {
-    if (!isRecord(result))
-        return undefined;
-    const value = result[key];
-    if (typeof value === 'string')
-        return value;
-    return typeof value === 'number' ? String(value) : undefined;
-}
-const WORLD_EDIT_CAPABILITY_PREFIXES = ['control_actor.', 'build_environment.'];
-function pieWorldWarnings(record, result) {
-    if (record.behavior.effect === 'read'
-        || !WORLD_EDIT_CAPABILITY_PREFIXES.some((prefix) => record.id.startsWith(prefix))) {
-        return [];
-    }
-    const details = isRecord(result) ? result.details : undefined;
-    const world = failureString(result, 'worldName') ?? failureString(details, 'worldName');
-    return world?.includes('/UEDPIE_') === true
-        ? [`Applied to the running Play-In-Editor world (${world}): the change is discarded when play stops and the editor level is unchanged. Stop PIE first to edit the level.`]
-        : [];
-}
-const HANDLER_CODE = /^[A-Z][A-Z0-9_]{0,63}$/;
-function readHandlerCode(result) {
-    for (const field of ['errorCode', 'error']) {
-        const value = failureString(result, field);
-        if (value !== undefined && HANDLER_CODE.test(value))
-            return value;
-    }
-    return undefined;
-}
-const NARROWING_PARAM = /summary|filter|name|path|kind|type|limit|offset|page|cursor|count|max|top|depth/i;
-function narrowingGuidance(record, target) {
-    const properties = record.schemas.input.properties;
-    const filters = properties === undefined
-        ? []
-        : Object.keys(properties).filter((key) => NARROWING_PARAM.test(key)).slice(0, 6);
-    return {
-        ...(filters.length === 0 ? {} : { suggestions: filters.map((name) => `narrow with '${name}'`) }),
-        nextCall: buildNextCall({
-            operation: 'describe',
-            tool: record.routing.parentTool,
-            action: target.legacy.action
-        })
-    };
-}
-export function actorNotFoundGuidance(handlerCode, params) {
-    const name = params.actorName;
-    if (handlerCode !== 'ACTOR_NOT_FOUND' || typeof name !== 'string' || name === '')
-        return {};
-    return {
-        suggestions: [`No actor in the world is labeled or named '${name}'; control_actor find by name lists near labels under similar.`],
-        nextCall: { operation: 'execute', tool: 'control_actor', action: 'find', params: { findBy: 'name', name } }
-    };
-}
-export function handlerNextCall(result) {
-    if (!isRecord(result))
-        return {};
-    for (const source of [result, result.data, result.result]) {
-        const next = isRecord(source) ? source.nextCall : undefined;
-        if (isRecord(next) && next.operation === 'execute' && typeof next.tool === 'string'
-            && typeof next.action === 'string' && isRecord(next.params)) {
-            return { nextCall: { operation: 'execute', tool: next.tool, action: next.action, params: next.params } };
-        }
-    }
-    return {};
-}
-async function runCapability(record, action, params, tools, controls) {
-    if (record.routing.parentTool === 'manage_tools')
-        return handleManageToolsCall({ ...params, action });
-    const tool = record.routing.parentTool;
-    try {
-        return normalizeAutomationFrame(await executeAutomationRequest(tools, tool, { ...params, action }, controls));
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        const code = err instanceof McpRequestCancelledError ? err.code
-            : /timeout/i.test(message) ? 'TOOL_TIMEOUT' : /security violation/i.test(message) ? 'SECURITY_VIOLATION' : 'TOOL_EXECUTION_FAILED';
-        return cleanObject({ success: false, isError: true, error: code, message: `Failed to execute ${tool}: ${message}`, toolName: tool, action });
-    }
-}
-export async function dispatchAndValidate(target, params, options, context, receiptContext, controls, unread = []) {
-    const record = target.record;
-    const action = resolveDispatchAction(target, params);
-    if (action === undefined) {
-        return refuseWithTarget(target, {
-            errorCode: 'INVALID_PARAMETER_VALUE',
-            message: 'The selector value does not map to an action on this capability.',
-            nextCall: buildNextCall({
-                operation: 'describe',
-                tool: record.routing.parentTool,
-                action: target.legacy.action
-            })
-        }, receiptContext);
-    }
-    const result = cleanObject(await runCapability(record, action, params, context.tools, controls));
-    const serialized = JSON.stringify(result);
-    const oversized = serialized !== undefined && serialized.length > resultCharBudget(result);
-    if (handlerReportedFailure(result)) {
-        const currentRevision = failureString(result, 'currentRevision');
-        const expectedRevision = failureString(result, 'expectedRevision');
-        const staleState = failureString(result, 'errorCode') === 'STALE_STATE'
-            || failureString(result, 'error') === 'STALE_STATE';
-        const handlerCode = staleState ? undefined : readHandlerCode(result);
-        return refuseWithTarget(target, {
-            errorCode: staleState ? 'STALE_STATE' : handlerCode ?? 'UNREAL_EXECUTION_ERROR',
-            message: failureMessage(result),
-            ...(handlerCode === undefined ? {} : { handlerCode }),
-            ...handlerNextCall(result),
-            ...actorNotFoundGuidance(handlerCode, params),
-            ...(staleState && currentRevision !== undefined ? { currentRevision } : {}),
-            ...(staleState && expectedRevision !== undefined ? { expectedRevision } : {}),
-            ...(oversized
-                ? { detailOmitted: true, resultChars: serialized?.length ?? 0 }
-                : { detail: result })
-        }, receiptContext);
-    }
-    if (oversized) {
-        const resultChars = serialized?.length ?? 0;
-        return refuseWithTarget(target, {
-            errorCode: 'RESULT_TOO_LARGE',
-            message: `Result exceeded the gateway safety limit (${resultChars} chars). Narrow the request with one of this capability's own filter parameters, then retry.`,
-            resultChars,
-            ...narrowingGuidance(record, target)
-        }, receiptContext);
-    }
-    const canonicalOutput = projectCanonicalOutput(result, record.schemas.output);
-    const violation = validateAgainstCapabilitySchema(canonicalOutput, record.schemas.output);
-    if (violation !== undefined) {
-        return refuseWithTarget(target, {
-            errorCode: 'OUTPUT_SCHEMA_VIOLATION',
-            message: `${record.id} returned a result that violates its declared output contract: ${violation.message}`,
-            pointer: violation.pointer,
-            detail: result
-        }, receiptContext);
-    }
-    return executeSuccessEnvelope({
-        record,
-        result,
-        canonicalOutput,
-        resolvedFromAlias: target.resolvedFromAlias,
-        migratedFrom: target.migratedFrom,
-        options,
-        warnings: [...pieWorldWarnings(record, result), ...unread]
-    }, receiptContext);
-}
-//# sourceMappingURL=gateway-execute-dispatch.js.map

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

@@ -1,48 +0,0 @@
-import type { CapabilityRecord } from '../../tools/catalog/capabilities/model.js';
-import type { SemanticError } from '../../tools/catalog/capabilities/semantic/errors.js';
-import type { ExecuteTarget } from './gateway-execute-resolve.js';
-import { type GatewayReceiptContext } from './gateway-receipt-context.js';
-export type ExecuteFailure = {
-    readonly errorCode: string;
-    readonly message: string;
-    readonly record?: CapabilityRecord;
-    readonly option?: string;
-    readonly field?: string;
-    readonly pointer?: string;
-    readonly suggestions?: readonly string[];
-    readonly nextCall?: Record<string, unknown>;
-    readonly availableActions?: readonly string[];
-    readonly allowedParameters?: readonly string[];
-    readonly requestedTool?: string;
-    readonly requestedAction?: string;
-    readonly resolvedFromAlias?: string;
-    readonly migratedFrom?: {
-        readonly tool: string;
-        readonly action: string;
-    };
-    readonly detail?: unknown;
-    readonly detailOmitted?: boolean;
-    readonly resultChars?: number;
-    readonly currentRevision?: string;
-    readonly expectedRevision?: string;
-    readonly requiredScope?: string;
-    readonly grantedScopes?: readonly string[];
-    readonly handlerCode?: string;
-};
-export declare function toSemanticError(failure: ExecuteFailure): SemanticError;
-export type ResolvedFailure = Omit<ExecuteFailure, 'record' | 'resolvedFromAlias' | 'migratedFrom'>;
-export declare function refuseWithTarget(target: ExecuteTarget, failure: ResolvedFailure, context: GatewayReceiptContext): Record<string, unknown>;
-export declare function executeErrorEnvelope(failure: ExecuteFailure, context: GatewayReceiptContext): Record<string, unknown>;
-export declare function executeSuccessEnvelope(input: {
-    readonly record: CapabilityRecord;
-    readonly result: unknown;
-    readonly canonicalOutput: unknown;
-    readonly resolvedFromAlias?: string;
-    readonly migratedFrom?: {
-        readonly tool: string;
-        readonly action: string;
-    };
-    readonly options?: Record<string, unknown>;
-    readonly warnings: readonly string[];
-}, context: GatewayReceiptContext): Record<string, unknown>;
-//# sourceMappingURL=gateway-execute-envelope.d.ts.map

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

@@ -1,194 +0,0 @@
-import { buildErrorReceipt, buildSuccessReceipt } from '../../tools/catalog/capabilities/semantic/envelope.js';
-import { EXECUTION_OPTION_KEYS } from '../../tools/catalog/capabilities/semantic/execution-options.js';
-import { JsonValueSchema } from '../../tools/catalog/capabilities/semantic/errors.js';
-import { liveStateRevisionsFromEnvelope } from '../../tools/catalog/capabilities/semantic/live-state-revisions.js';
-import { extractChanges, extractHandles, extractTask } from '../../tools/catalog/capabilities/semantic/receipt-outcome.js';
-import { maskSecretsDeep, redactText } from '../../tools/catalog/capabilities/semantic/receipt-redaction.js';
-import { catalogRevision } from './gateway-capability-index.js';
-import { IDEMPOTENCY_CONFLICT_CODE } from './gateway-execute-idempotency.js';
-import { correlationFields, elapsedMs, revisionFields } from './gateway-receipt-context.js';
-const UNREPORTED_REVISION = 'unreported';
-const UNREPORTED_SCOPE = 'unreported';
-export function toSemanticError(failure) {
-    const { errorCode, message } = failure;
-    if (failure.handlerCode !== undefined) {
-        return {
-            kind: 'execution',
-            code: 'UNREAL_ENGINE_ERROR',
-            message,
-            retryable: false,
-            handlerCode: failure.handlerCode
-        };
-    }
-    switch (errorCode) {
-        case 'STALE_STATE':
-            return {
-                kind: 'staleState',
-                code: 'STALE_STATE',
-                message,
-                currentRevision: failure.currentRevision ?? UNREPORTED_REVISION,
-                expectedRevision: failure.expectedRevision ?? UNREPORTED_REVISION
-            };
-        case 'UNSUPPORTED_OPTION':
-            return {
-                kind: 'option',
-                code: 'UNSUPPORTED_OPTION',
-                option: failure.option ?? '',
-                supported: [...EXECUTION_OPTION_KEYS],
-                message
-            };
-        case 'OUT_OF_RANGE':
-            return { kind: 'range', code: 'OUT_OF_RANGE', field: failure.field ?? failure.pointer ?? '', message };
-        case 'NOT_CONNECTED':
-        case 'ROUTING_ERROR':
-        case 'DISPATCH_ERROR':
-            return {
-                kind: 'dispatch',
-                code: errorCode === 'NOT_CONNECTED' ? 'NOT_CONNECTED' : 'DISPATCH_ERROR',
-                message,
-                retryable: true
-            };
-        case 'TOOL_DISABLED':
-        case 'CAPABILITY_DISABLED':
-            return { kind: 'capability', code: 'CAPABILITY_DISABLED', message, retryable: false };
-        case 'CAPABILITY_UNAVAILABLE':
-            return { kind: 'capability', code: 'CAPABILITY_UNAVAILABLE', message, retryable: false };
-        case IDEMPOTENCY_CONFLICT_CODE:
-            return { kind: 'conflict', code: IDEMPOTENCY_CONFLICT_CODE, message };
-        case 'FORM_CONFLICT':
-            return { kind: 'conflict', code: 'STATE_CONFLICT', message };
-        case 'OUTPUT_SCHEMA_VIOLATION':
-            return {
-                kind: 'output',
-                code: 'OUTPUT_SCHEMA_VIOLATION',
-                message,
-                ...(failure.pointer === undefined ? {} : { pointer: failure.pointer })
-            };
-        case 'RESULT_TOO_LARGE':
-            return {
-                kind: 'output',
-                code: 'RESULT_TOO_LARGE',
-                message,
-                ...(failure.resultChars === undefined ? {} : { resultChars: failure.resultChars })
-            };
-        case 'UNREAL_EXECUTION_ERROR':
-            return { kind: 'execution', code: 'UNREAL_ENGINE_ERROR', message, retryable: false };
-        case 'SCOPE_NOT_GRANTED':
-            return {
-                kind: 'authorization',
-                code: 'SCOPE_NOT_GRANTED',
-                message,
-                requiredScope: failure.requiredScope ?? UNREPORTED_SCOPE,
-                grantedScopes: failure.grantedScopes ?? []
-            };
-        case 'CONSENT_REQUIRED':
-            return { kind: 'consent', code: 'CONSENT_REQUIRED', message, scope: failure.requiredScope ?? UNREPORTED_SCOPE };
-        default:
-            return {
-                kind: 'validation',
-                code: 'VALIDATION_ERROR',
-                message,
-                ...(failure.pointer === undefined ? {} : { pointer: failure.pointer })
-            };
-    }
-}
-function capabilityFields(record, requested) {
-    if (record === undefined) {
-        return { tool: requested?.tool, action: requested?.action };
-    }
-    return {
-        capability: record.id,
-        tool: record.routing.parentTool,
-        action: record.legacyIds[0]?.action ?? record.routing.dispatchAction
-    };
-}
-function definedOnly(entries) {
-    const out = {};
-    for (const [key, value] of Object.entries(entries)) {
-        if (value !== undefined)
-            out[key] = value;
-    }
-    return out;
-}
-export function refuseWithTarget(target, failure, context) {
-    return executeErrorEnvelope({
-        ...failure,
-        record: target.record,
-        ...(target.resolvedFromAlias === undefined ? {} : { resolvedFromAlias: target.resolvedFromAlias }),
-        ...(target.migratedFrom === undefined ? {} : { migratedFrom: target.migratedFrom })
-    }, context);
-}
-export function executeErrorEnvelope(failure, context) {
-    const liveRevisions = liveStateRevisionsFromEnvelope(failure.detail);
-    const receipt = failure.record === undefined
-        ? undefined
-        : buildErrorReceipt({
-            capabilityId: failure.record.id,
-            error: toSemanticError(failure),
-            ...correlationFields(context),
-            ...revisionFields(failure.record),
-            liveRevisions,
-            timingMs: elapsedMs(context)
-        });
-    return definedOnly({
-        success: false,
-        operation: 'execute',
-        errorCode: failure.errorCode,
-        error: redactText(failure.message),
-        message: redactText(failure.message),
-        correlationId: context.correlationId,
-        catalogRevision: catalogRevision(),
-        ...capabilityFields(failure.record, { tool: failure.requestedTool, action: failure.requestedAction }),
-        resolvedFromAlias: failure.resolvedFromAlias,
-        migratedFrom: failure.migratedFrom,
-        suggestions: failure.suggestions,
-        nextCall: failure.nextCall,
-        availableActions: failure.availableActions,
-        allowedParameters: failure.allowedParameters,
-        pointer: failure.pointer,
-        resultChars: failure.resultChars,
-        detailOmitted: failure.detailOmitted,
-        liveRevisions,
-        result: maskSecretsDeep(failure.detail),
-        receipt
-    });
-}
-export function executeSuccessEnvelope(input, context) {
-    const capabilityId = input.record.id;
-    const liveRevisions = liveStateRevisionsFromEnvelope(input.result);
-    const parsedOutput = JsonValueSchema.safeParse(maskSecretsDeep(input.canonicalOutput));
-    const publishedData = parsedOutput.success ? parsedOutput.data : null;
-    const receipt = buildSuccessReceipt({
-        capabilityId,
-        data: publishedData,
-        handles: extractHandles(input.result),
-        changes: input.record.behavior.effect === 'read' ? [] : extractChanges(input.result),
-        task: extractTask(input.result),
-        warnings: input.warnings,
-        ...correlationFields(context),
-        ...revisionFields(input.record),
-        timingMs: elapsedMs(context),
-        validation: { outputSchema: 'passed' },
-        liveRevisions
-    });
-    const handlerMessage = typeof input.result === 'object' && input.result !== null && 'message' in input.result
-        ? input.result.message
-        : undefined;
-    return definedOnly({
-        success: true,
-        operation: 'execute',
-        message: typeof handlerMessage === 'string' && handlerMessage !== '' ? redactText(handlerMessage) : undefined,
-        correlationId: context.correlationId,
-        catalogRevision: catalogRevision(),
-        ...capabilityFields(input.record),
-        resolvedFromAlias: input.resolvedFromAlias,
-        migratedFrom: input.migratedFrom,
-        options: input.options,
-        warnings: input.warnings.length > 0 ? input.warnings : undefined,
-        liveRevisions,
-        receipt,
-        data: publishedData,
-        result: maskSecretsDeep(input.result)
-    });
-}
-//# sourceMappingURL=gateway-execute-envelope.js.map

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

@@ -1,19 +0,0 @@
-import { IdempotencyLedger } from './idempotency-ledger.js';
-export declare const IDEMPOTENCY_CONFLICT_CODE = "IDEMPOTENCY_CONFLICT";
-export declare const LOCAL_PRINCIPAL = "local";
-export declare function sharedExecuteLedger(): IdempotencyLedger;
-export declare function resetSharedExecuteLedger(): void;
-export declare function conflictMessage(reason: ConflictReason): string;
-export type ConflictReason = 'IN_FLIGHT' | 'FINGERPRINT_MISMATCH';
-export interface IdempotentRequest {
-    readonly capabilityId: string;
-    readonly principal: string;
-    readonly params: Record<string, unknown>;
-    readonly idempotencyKey: string | undefined;
-}
-type Receipt = Record<string, unknown>;
-export declare function canonicalFingerprint(capabilityId: string, params: Record<string, unknown>): string;
-export declare function markReplayed(recorded: Receipt, correlationId: string): Receipt;
-export declare function runWithIdempotency(request: IdempotentRequest, ledger: IdempotencyLedger, dispatch: () => Promise<Receipt>, isCacheable: (receipt: Receipt) => boolean, conflict: (reason: ConflictReason) => Receipt, onReplay?: (recorded: Receipt) => Receipt): Promise<Receipt>;
-export {};
-//# sourceMappingURL=gateway-execute-idempotency.d.ts.map

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

@@ -1,64 +0,0 @@
-import { createHash } from 'node:crypto';
-import { stableJsonStringify } from '../../tools/catalog/capabilities/hashing.js';
-import { IdempotencyLedger } from './idempotency-ledger.js';
-export const IDEMPOTENCY_CONFLICT_CODE = 'IDEMPOTENCY_CONFLICT';
-export const LOCAL_PRINCIPAL = 'local';
-let sharedLedger;
-export function sharedExecuteLedger() {
-    sharedLedger ??= new IdempotencyLedger({ clock: () => Date.now() });
-    return sharedLedger;
-}
-export function resetSharedExecuteLedger() {
-    sharedLedger = undefined;
-}
-export function conflictMessage(reason) {
-    return reason === 'IN_FLIGHT'
-        ? 'This idempotency key is already executing. Wait for the first call to finish and read its receipt; do not retry with the same key.'
-        : 'This idempotency key was already used with different parameters. Use a new idempotency key, or resend the original parameters to replay the recorded receipt.';
-}
-export function canonicalFingerprint(capabilityId, params) {
-    const canonical = stableJsonStringify(JSON.parse(JSON.stringify(params)));
-    return createHash('sha256').update(capabilityId).update('\u0000').update(canonical).digest('hex');
-}
-export function markReplayed(recorded, correlationId) {
-    return {
-        ...recorded,
-        ...(typeof recorded.correlationId === 'string' ? { replayedFrom: recorded.correlationId } : {}),
-        replayed: true,
-        correlationId
-    };
-}
-export async function runWithIdempotency(request, ledger, dispatch, isCacheable, conflict, onReplay = (recorded) => recorded) {
-    const key = request.idempotencyKey;
-    if (key === undefined || key.length === 0) {
-        return dispatch();
-    }
-    const fingerprint = canonicalFingerprint(request.capabilityId, request.params);
-    const outcome = ledger.begin({ principal: request.principal, capabilityId: request.capabilityId, key }, fingerprint);
-    if (outcome.kind === 'replay') {
-        return onReplay(outcome.receipt);
-    }
-    if (outcome.kind === 'in-flight') {
-        return conflict('IN_FLIGHT');
-    }
-    if (outcome.kind === 'conflict') {
-        return conflict('FINGERPRINT_MISMATCH');
-    }
-    const handle = outcome.handle;
-    let receipt;
-    try {
-        receipt = await dispatch();
-    }
-    catch (error) {
-        ledger.abandon(handle);
-        throw error;
-    }
-    if (isCacheable(receipt)) {
-        ledger.complete(handle, receipt);
-    }
-    else {
-        ledger.abandon(handle);
-    }
-    return receipt;
-}
-//# sourceMappingURL=gateway-execute-idempotency.js.map

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

@@ -1,11 +0,0 @@
-import type { CapabilityRecord } from '../../tools/catalog/capabilities/model.js';
-import { type CapabilityIndex } from './gateway-capability-index.js';
-import type { ExecuteResolution, LegacyPair } from './gateway-execute-resolve.js';
-export declare function primaryLegacyPair(record: CapabilityRecord): LegacyPair;
-export declare function resolveExecuteTarget(request: {
-    readonly capability?: string;
-    readonly tool?: string;
-    readonly action?: string;
-    readonly params?: Record<string, unknown>;
-}, index: CapabilityIndex): ExecuteResolution;
-//# sourceMappingURL=gateway-execute-lookup.d.ts.map