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

package/dist/server/gateway/gateway-option-validate.js

@@ -1,73 +0,0 @@
-import { isRecord } from '../../utils/validation/type-guards.js';
-import { IdempotencyKeySchema } from '../../tools/catalog/capabilities/semantic/ids.js';
-import { EXECUTION_OPTION_KEYS, LIVE_STATE_REVISION_KEYS } from '../../tools/catalog/capabilities/semantic/execution-options.js';
-export const MAX_TIMEOUT_MS = 600_000;
-export function validateExecutionOptions(raw) {
-    if (raw === undefined || raw === null)
-        return undefined;
-    if (!isRecord(raw)) {
-        return { errorCode: 'INVALID_OPTIONS', message: 'options must be an object.' };
-    }
-    const supported = new Set(EXECUTION_OPTION_KEYS);
-    for (const key of Object.keys(raw)) {
-        if (!supported.has(key)) {
-            return {
-                errorCode: 'UNSUPPORTED_OPTION',
-                option: key,
-                message: `Unsupported execution option '${key}'. Supported: [${EXECUTION_OPTION_KEYS.join(', ')}]`
-            };
-        }
-    }
-    const timeout = Object.hasOwn(raw, 'timeoutMs') ? raw.timeoutMs : undefined;
-    if (timeout !== undefined
-        && (typeof timeout !== 'number' || !Number.isInteger(timeout) || timeout <= 0 || timeout > MAX_TIMEOUT_MS)) {
-        return {
-            errorCode: 'OUT_OF_RANGE',
-            option: 'timeoutMs',
-            message: `options.timeoutMs must be an integer in 1..${MAX_TIMEOUT_MS}`
-        };
-    }
-    const idempotencyKey = Object.hasOwn(raw, 'idempotencyKey') ? raw.idempotencyKey : undefined;
-    if (idempotencyKey !== undefined && !IdempotencyKeySchema.safeParse(idempotencyKey).success) {
-        return {
-            errorCode: 'INVALID_OPTIONS',
-            option: 'idempotencyKey',
-            pointer: '/options/idempotencyKey',
-            message: 'options.idempotencyKey must be a string of 1..128 characters.'
-        };
-    }
-    return validateExpectedRevisions(Object.hasOwn(raw, 'expectedRevisions') ? raw.expectedRevisions : undefined);
-}
-function validateExpectedRevisions(raw) {
-    if (raw === undefined)
-        return undefined;
-    if (!isRecord(raw)) {
-        return {
-            errorCode: 'INVALID_OPTIONS',
-            pointer: '/options/expectedRevisions',
-            message: 'options.expectedRevisions must be an object of state revisions.'
-        };
-    }
-    const pinnable = LIVE_STATE_REVISION_KEYS;
-    for (const [key, value] of Object.entries(raw)) {
-        if (!pinnable.includes(key)) {
-            return {
-                errorCode: 'UNSUPPORTED_OPTION',
-                option: `expectedRevisions.${key}`,
-                message: `Unsupported expected revision '${key}'. Supported: [${pinnable.join(', ')}]`
-            };
-        }
-        if (typeof value !== 'number' || !Number.isInteger(value) || value < 1) {
-            return {
-                errorCode: 'OUT_OF_RANGE',
-                option: `expectedRevisions.${key}`,
-                message: `options.expectedRevisions.${key} must be an integer >= 1`
-            };
-        }
-    }
-    return undefined;
-}
-export function findControlKeyInParams(params) {
-    return EXECUTION_OPTION_KEYS.find((control) => Object.hasOwn(params, control));
-}
-//# sourceMappingURL=gateway-option-validate.js.map

package/dist/server/gateway/gateway-receipt-context.d.ts

@@ -1,21 +0,0 @@
-import type { CapabilityRecord } from '../../tools/catalog/capabilities/model.js';
-import type { CapabilityRevision, CatalogRevision, CorrelationId, IdempotencyKey, RequestId, SchemaRevision } from '../../tools/catalog/capabilities/semantic/ids.js';
-export type GatewayReceiptContext = {
-    readonly correlationId: CorrelationId;
-    readonly requestId?: RequestId;
-    readonly idempotencyId?: IdempotencyKey;
-    readonly startedAt: number;
-};
-export declare function buildReceiptContext(correlationId: CorrelationId, options: Record<string, unknown> | undefined): GatewayReceiptContext;
-export declare function correlationFields(context: GatewayReceiptContext): {
-    correlationId: CorrelationId;
-    requestId?: RequestId;
-    idempotencyId?: IdempotencyKey;
-};
-export declare function revisionFields(record: CapabilityRecord): {
-    catalogRevision?: CatalogRevision;
-    capabilityRevision?: CapabilityRevision;
-    schemaRevision?: SchemaRevision;
-};
-export declare function elapsedMs(context: GatewayReceiptContext): number;
-//# sourceMappingURL=gateway-receipt-context.d.ts.map

package/dist/server/gateway/gateway-receipt-context.js

@@ -1,36 +0,0 @@
-import { getMcpRequestContext } from '../../automation/request-context.js';
-import { CapabilityRevisionSchema, CatalogRevisionSchema, IdempotencyKeySchema, RequestIdSchema, SchemaRevisionSchema } from '../../tools/catalog/capabilities/semantic/ids.js';
-import { catalogRevision } from './gateway-capability-index.js';
-export function buildReceiptContext(correlationId, options) {
-    const active = getMcpRequestContext();
-    const request = active?.requestId === undefined ? undefined : RequestIdSchema.safeParse(active.requestId);
-    const rawIdempotency = options?.idempotencyKey;
-    const idempotency = typeof rawIdempotency === 'string' ? IdempotencyKeySchema.safeParse(rawIdempotency) : undefined;
-    return {
-        correlationId,
-        ...(request?.success ? { requestId: request.data } : {}),
-        ...(idempotency?.success ? { idempotencyId: idempotency.data } : {}),
-        startedAt: Date.now()
-    };
-}
-export function correlationFields(context) {
-    return {
-        correlationId: context.correlationId,
-        ...(context.requestId === undefined ? {} : { requestId: context.requestId }),
-        ...(context.idempotencyId === undefined ? {} : { idempotencyId: context.idempotencyId })
-    };
-}
-export function revisionFields(record) {
-    const catalog = CatalogRevisionSchema.safeParse(catalogRevision());
-    const capability = CapabilityRevisionSchema.safeParse(record.hashes.content);
-    const schema = SchemaRevisionSchema.safeParse(record.hashes.schema);
-    return {
-        ...(catalog.success ? { catalogRevision: catalog.data } : {}),
-        ...(capability.success ? { capabilityRevision: capability.data } : {}),
-        ...(schema.success ? { schemaRevision: schema.data } : {})
-    };
-}
-export function elapsedMs(context) {
-    return Math.max(0, Date.now() - context.startedAt);
-}
-//# sourceMappingURL=gateway-receipt-context.js.map

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

@@ -1,14 +0,0 @@
-export type ViolationReason = 'missing-required' | 'required-one-of' | 'undeclared' | 'type' | 'enum' | 'range' | 'unsupported-keyword';
-export declare const VIOLATION_GATEWAY_CODES: Readonly<Record<ViolationReason, string>>;
-export declare function describeUndeclaredParameter(key: string, properties: Record<string, unknown> | undefined): string;
-export type SchemaViolation = {
-    readonly reason: ViolationReason;
-    readonly pointer: string;
-    readonly message: string;
-};
-export declare function describeMissingParameter(name: string, properties: Record<string, unknown> | undefined): string;
-export declare function validateAgainstCapabilitySchema(value: unknown, schema: unknown, pointer?: string): SchemaViolation | undefined;
-export declare function applyDeclaredDefaults(params: Record<string, unknown>, schema: unknown): Record<string, unknown>;
-export declare const VECTOR_KEY_SETS: ReadonlyArray<readonly string[]>;
-export declare function coerceVectorShapes(args: Record<string, unknown>, schema: unknown): Record<string, unknown>;
-//# sourceMappingURL=gateway-schema-validate.d.ts.map

package/dist/server/gateway/gateway-schema-validate.js

@@ -1,316 +0,0 @@
-import { isRecord } from '../../utils/validation/type-guards.js';
-const SUPPORTED_SCHEMA_KEYWORDS = new Set([
-    '$schema',
-    'type',
-    'description',
-    'properties',
-    'required',
-    'requiredOneOf',
-    'additionalProperties',
-    'items',
-    'minItems',
-    'maxItems',
-    'enum',
-    'default',
-    'minimum',
-    'maximum',
-    'maxLength',
-    'x-unreal-reflection-boundary'
-]);
-const REFLECTION_BOUNDARY_KEYWORD = 'x-unreal-reflection-boundary';
-export const VIOLATION_GATEWAY_CODES = {
-    'missing-required': 'MISSING_REQUIRED_PARAMETER',
-    'required-one-of': 'MISSING_REQUIRED_ONEOF',
-    undeclared: 'UNDECLARED_PARAMETER',
-    type: 'INVALID_PARAMETER_TYPE',
-    enum: 'INVALID_PARAMETER_VALUE',
-    range: 'OUT_OF_RANGE',
-    'unsupported-keyword': 'UNSUPPORTED_SCHEMA_KEYWORD'
-};
-const MAX_LISTED_PARAMETERS = 24;
-function parameterNameTokens(name) {
-    return name
-        .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
-        .toLowerCase()
-        .split(/[^a-z0-9]+/)
-        .filter((token) => token.length > 0);
-}
-export function describeUndeclaredParameter(key, properties) {
-    const declared = properties === undefined
-        ? []
-        : Object.keys(properties).filter((name) => name !== 'action' && name !== 'subAction').sort();
-    if (declared.length === 0) {
-        return `Undeclared parameter '${key}' (this action declares no parameters)`;
-    }
-    const lowerKey = key.toLowerCase();
-    const keyTokens = new Set(parameterNameTokens(key));
-    const score = (name) => {
-        const lower = name.toLowerCase();
-        const substring = lower.includes(lowerKey) || lowerKey.includes(lower) ? 2 : 0;
-        const shared = parameterNameTokens(name).some((token) => keyTokens.has(token)) ? 1 : 0;
-        return substring + shared;
-    };
-    const near = declared
-        .filter((name) => score(name) > 0)
-        .sort((a, b) => (score(b) - score(a)) || (a.length - b.length) || (a < b ? -1 : a > b ? 1 : 0));
-    const hint = near.length > 0 ? `did you mean '${near[0]}'; ` : '';
-    const ranked = [...near, ...declared.filter((name) => score(name) === 0)];
-    const listed = ranked.slice(0, MAX_LISTED_PARAMETERS);
-    const more = ranked.length > listed.length ? ` and ${ranked.length - listed.length} more` : '';
-    return `Undeclared parameter '${key}' (${hint}allowed: ${listed.join(', ')}${more})`;
-}
-export function describeMissingParameter(name, properties) {
-    const propertySchema = properties === undefined ? undefined : properties[name];
-    if (isRecord(propertySchema) && Array.isArray(propertySchema.enum)) {
-        const allowed = propertySchema.enum.filter((entry) => typeof entry === 'string');
-        if (allowed.length > 0) {
-            return `Missing required parameter '${name}' (one of: ${allowed.join(', ')})`;
-        }
-    }
-    return `Missing required parameter '${name}'`;
-}
-function typeMatches(value, declared) {
-    switch (declared) {
-        case 'string': return typeof value === 'string';
-        case 'number': return typeof value === 'number' && Number.isFinite(value);
-        case 'integer': return typeof value === 'number' && Number.isInteger(value);
-        case 'boolean': return typeof value === 'boolean';
-        case 'array': return Array.isArray(value);
-        case 'object': return isRecord(value);
-        case 'null': return value === null;
-        default: return false;
-    }
-}
-function declaredTypes(schema) {
-    const declared = schema.type;
-    if (typeof declared === 'string')
-        return [declared];
-    if (Array.isArray(declared))
-        return declared.filter((entry) => typeof entry === 'string');
-    return [];
-}
-function rejectUnsupportedKeywords(schema, pointer) {
-    for (const keyword of Object.keys(schema)) {
-        if (SUPPORTED_SCHEMA_KEYWORDS.has(keyword))
-            continue;
-        return {
-            reason: 'unsupported-keyword',
-            pointer,
-            message: `Schema keyword '${keyword}' at ${pointer} is not implemented by the canonical validator`
-        };
-    }
-    return undefined;
-}
-function validateScalarBounds(value, schema, pointer) {
-    if (typeof value === 'number') {
-        if (typeof schema.minimum === 'number' && value < schema.minimum) {
-            return { reason: 'range', pointer, message: `${pointer} must be >= ${schema.minimum}` };
-        }
-        if (typeof schema.maximum === 'number' && value > schema.maximum) {
-            return { reason: 'range', pointer, message: `${pointer} must be <= ${schema.maximum}` };
-        }
-    }
-    if (typeof value === 'string' && typeof schema.maxLength === 'number' && value.length > schema.maxLength) {
-        return { reason: 'range', pointer, message: `${pointer} must be at most ${schema.maxLength} characters` };
-    }
-    if (Array.isArray(value)) {
-        if (typeof schema.minItems === 'number' && value.length < schema.minItems) {
-            return { reason: 'range', pointer, message: `${pointer} must have at least ${schema.minItems} item(s)` };
-        }
-        if (typeof schema.maxItems === 'number' && value.length > schema.maxItems) {
-            return { reason: 'range', pointer, message: `${pointer} must have at most ${schema.maxItems} item(s)` };
-        }
-    }
-    return undefined;
-}
-function ownProperty(properties, key) {
-    return Object.hasOwn(properties, key) ? properties[key] : undefined;
-}
-function validateObject(value, schema, pointer) {
-    const properties = isRecord(schema.properties) ? schema.properties : undefined;
-    if (Array.isArray(schema.required)) {
-        for (const name of schema.required) {
-            if (typeof name === 'string' && !Object.hasOwn(value, name)) {
-                const stray = schema.additionalProperties === false
-                    ? Object.keys(value).filter((key) => properties === undefined || !Object.hasOwn(properties, key))
-                    : [];
-                const missing = describeMissingParameter(name, properties);
-                return {
-                    reason: 'missing-required',
-                    pointer: `${pointer}/${name}`,
-                    message: stray.length === 0 ? missing : `${missing}; sent ${stray.join(', ')}, which this action does not take`
-                };
-            }
-        }
-    }
-    if (Array.isArray(schema.requiredOneOf)) {
-        const group = schema.requiredOneOf.filter((name) => typeof name === 'string');
-        if (group.length > 0 && !group.some((name) => Object.hasOwn(value, name))) {
-            return {
-                reason: 'required-one-of',
-                pointer: `${pointer}/requiredOneOf`,
-                message: `At least one of [${group.join(', ')}] must be provided`
-            };
-        }
-    }
-    if (schema[REFLECTION_BOUNDARY_KEYWORD] === true)
-        return undefined;
-    if (schema.additionalProperties === false) {
-        for (const key of Object.keys(value)) {
-            if (properties === undefined || !Object.hasOwn(properties, key)) {
-                return {
-                    reason: 'undeclared',
-                    pointer: `${pointer}/${key}`,
-                    message: describeUndeclaredParameter(key, properties)
-                };
-            }
-        }
-    }
-    if (properties !== undefined) {
-        for (const [key, entry] of Object.entries(value)) {
-            const propertySchema = ownProperty(properties, key);
-            if (propertySchema === undefined)
-                continue;
-            const violation = validateAgainstCapabilitySchema(entry, propertySchema, `${pointer}/${key}`);
-            if (violation !== undefined)
-                return violation;
-        }
-    }
-    return undefined;
-}
-export function validateAgainstCapabilitySchema(value, schema, pointer = '') {
-    if (!isRecord(schema)) {
-        return { reason: 'type', pointer, message: `Schema at ${pointer || '/'} is not an object` };
-    }
-    const unsupported = rejectUnsupportedKeywords(schema, pointer || '/');
-    if (unsupported !== undefined)
-        return unsupported;
-    const types = declaredTypes(schema);
-    if (types.length > 0 && !types.some((declared) => typeMatches(value, declared))) {
-        return {
-            reason: 'type',
-            pointer: pointer || '/',
-            message: `${pointer || '/'} must be of type ${types.join(' | ')}`
-        };
-    }
-    if (Array.isArray(schema.enum) && !schema.enum.some((allowed) => allowed === value)) {
-        return {
-            reason: 'enum',
-            pointer: pointer || '/',
-            message: `${pointer || '/'} must be one of [${schema.enum.map(String).join(', ')}]`
-        };
-    }
-    const bounds = validateScalarBounds(value, schema, pointer || '/');
-    if (bounds !== undefined)
-        return bounds;
-    if (isRecord(value)) {
-        const violation = validateObject(value, schema, pointer);
-        if (violation !== undefined)
-            return violation;
-    }
-    if (Array.isArray(value) && schema.items !== undefined) {
-        for (let index = 0; index < value.length; index += 1) {
-            const violation = validateAgainstCapabilitySchema(value[index], schema.items, `${pointer}/${index}`);
-            if (violation !== undefined)
-                return violation;
-        }
-    }
-    return undefined;
-}
-export function applyDeclaredDefaults(params, schema) {
-    if (!isRecord(schema) || !isRecord(schema.properties))
-        return params;
-    const withDefaults = { ...params };
-    for (const [name, propertySchema] of Object.entries(schema.properties)) {
-        if (Object.hasOwn(withDefaults, name))
-            continue;
-        if (isRecord(propertySchema) && Object.hasOwn(propertySchema, 'default')) {
-            withDefaults[name] = propertySchema.default;
-        }
-    }
-    return withDefaults;
-}
-export const VECTOR_KEY_SETS = [
-    ['pitch', 'yaw', 'roll'],
-    ['x', 'y', 'z', 'w'],
-    ['x', 'y', 'z'],
-    ['r', 'g', 'b', 'a'],
-    ['width', 'height'],
-    ['x', 'y']
-];
-const isFiniteNumber = (value) => typeof value === 'number' && Number.isFinite(value);
-function objectToVector(value) {
-    const ownKeys = Object.keys(value);
-    for (const keys of VECTOR_KEY_SETS) {
-        const required = keys.length === 4 ? keys.length - 1 : keys.length;
-        if (!ownKeys.every((key) => keys.includes(key)))
-            continue;
-        if (!keys.slice(0, required).every((key) => Object.hasOwn(value, key) && isFiniteNumber(value[key])))
-            continue;
-        if (!ownKeys.every((key) => isFiniteNumber(value[key])))
-            continue;
-        const vector = [];
-        for (const key of keys) {
-            const member = value[key];
-            if (isFiniteNumber(member))
-                vector.push(member);
-        }
-        return vector;
-    }
-    return undefined;
-}
-function isShadowedByLongerSet(keys, declared) {
-    return VECTOR_KEY_SETS.some((longer) => longer.length > keys.length
-        && keys.every((key) => longer.includes(key))
-        && longer.some((key) => !keys.includes(key) && declared.includes(key)));
-}
-function vectorToObject(values, propertySchema) {
-    const declared = isRecord(propertySchema.properties) ? Object.keys(propertySchema.properties) : [];
-    if (declared.length === 0)
-        return undefined;
-    for (const keys of VECTOR_KEY_SETS) {
-        const required = keys.length === 4 ? keys.length - 1 : keys.length;
-        if (!keys.slice(0, required).every((key) => declared.includes(key)))
-            continue;
-        if (isShadowedByLongerSet(keys, declared))
-            continue;
-        const consumed = keys.filter((key) => declared.includes(key));
-        if (values.length < required || values.length > consumed.length)
-            continue;
-        const out = {};
-        for (let index = 0; index < values.length; index += 1)
-            out[keys[index]] = values[index];
-        return out;
-    }
-    return undefined;
-}
-export function coerceVectorShapes(args, schema) {
-    if (!isRecord(schema) || !isRecord(schema.properties))
-        return args;
-    let out;
-    for (const [name, propertySchema] of Object.entries(schema.properties)) {
-        if (!isRecord(propertySchema) || !Object.hasOwn(args, name))
-            continue;
-        const value = args[name];
-        const types = declaredTypes(propertySchema);
-        let replacement;
-        if (types.includes('array') && !types.includes('object') && isRecord(value) && !Array.isArray(value)) {
-            replacement = objectToVector(value);
-        }
-        else if (types.includes('object') && !types.includes('array') && Array.isArray(value) && value.every(isFiniteNumber)) {
-            replacement = vectorToObject(value, propertySchema);
-        }
-        else if (types.includes('array') && Array.isArray(value) && isRecord(propertySchema.items)) {
-            const itemSchema = propertySchema.items;
-            const mapped = value.map((entry) => (isRecord(entry) && !Array.isArray(entry) ? coerceVectorShapes(entry, itemSchema) : entry));
-            if (mapped.some((entry, index) => entry !== value[index]))
-                replacement = mapped;
-        }
-        if (replacement !== undefined) {
-            out = out ?? { ...args };
-            out[name] = replacement;
-        }
-    }
-    return out ?? args;
-}
-//# sourceMappingURL=gateway-schema-validate.js.map

package/dist/server/gateway/gateway-search-filters.d.ts

@@ -1,19 +0,0 @@
-import type { CapabilityRecord } from '../../tools/catalog/capabilities/model.js';
-export declare const DEFAULT_SEARCH_MAX_BYTES = 24576;
-export declare const MIN_SEARCH_MAX_BYTES = 512;
-export declare const MAX_SEARCH_MAX_BYTES = 262144;
-export type SearchFilters = {
-    readonly query: string;
-    readonly domain: string | undefined;
-    readonly family: string | undefined;
-    readonly tool: string | undefined;
-    readonly action: string | undefined;
-    readonly capability: string | undefined;
-    readonly effect: string | undefined;
-};
-export declare function readFilters(args: Record<string, unknown>): SearchFilters;
-export declare function encodeCursor(offset: number): string;
-export declare function decodeCursor(cursor: string): number | undefined;
-export declare function validateFilters(filters: SearchFilters): Record<string, unknown> | undefined;
-export declare function selectCandidates(filters: SearchFilters): readonly CapabilityRecord[];
-//# sourceMappingURL=gateway-search-filters.d.ts.map

package/dist/server/gateway/gateway-search-filters.js

@@ -1,107 +0,0 @@
-import { capabilityIndex, resolveCapability, resolveLegacyPair } from './gateway-capability-index.js';
-import { closestMatches, MAX_SUGGESTIONS } from './gateway-guidance.js';
-import { gatewayError, getString } from './gateway-shared.js';
-export const DEFAULT_SEARCH_MAX_BYTES = 24_576;
-export const MIN_SEARCH_MAX_BYTES = 512;
-export const MAX_SEARCH_MAX_BYTES = 262_144;
-const CURSOR_PREFIX = 'c:';
-export function readFilters(args) {
-    return {
-        query: getString(args, 'query') ?? '',
-        domain: getString(args, 'domain'),
-        family: getString(args, 'family'),
-        tool: getString(args, 'tool'),
-        action: getString(args, 'action'),
-        capability: getString(args, 'capability'),
-        effect: getString(args, 'effect')
-    };
-}
-export function encodeCursor(offset) {
-    return `${CURSOR_PREFIX}${offset}`;
-}
-export function decodeCursor(cursor) {
-    if (!cursor.startsWith(CURSOR_PREFIX))
-        return undefined;
-    const raw = cursor.slice(CURSOR_PREFIX.length);
-    if (!/^\d+$/.test(raw))
-        return undefined;
-    const offset = Number.parseInt(raw, 10);
-    return Number.isSafeInteger(offset) ? offset : undefined;
-}
-function guidedFilterError(errorCode, message, dimension, target, candidates, base) {
-    const suggestions = closestMatches(target, [...candidates], MAX_SUGGESTIONS);
-    const nextCall = { operation: 'search', ...base };
-    if (suggestions.length > 0)
-        nextCall[dimension] = suggestions[0];
-    return { ...gatewayError('search', errorCode, message), suggestions, nextCall };
-}
-function validateDomain(filters) {
-    if (filters.domain === undefined)
-        return undefined;
-    const { domains } = capabilityIndex();
-    if (domains.includes(filters.domain))
-        return undefined;
-    return guidedFilterError('UNKNOWN_DOMAIN', `Unknown domain '${filters.domain}'. Call describe with no selector to list domains.`, 'domain', filters.domain, domains, {});
-}
-function validateFamily(filters) {
-    if (filters.family === undefined)
-        return undefined;
-    const index = capabilityIndex();
-    const candidates = filters.domain === undefined
-        ? [...new Set(index.records.map((record) => record.discovery.family))].sort()
-        : index.familiesByDomain.get(filters.domain) ?? [];
-    if (candidates.includes(filters.family))
-        return undefined;
-    const base = filters.domain === undefined ? {} : { domain: filters.domain };
-    return guidedFilterError('UNKNOWN_FAMILY', `Unknown family '${filters.family}'. Call describe on the domain to list its families.`, 'family', filters.family, candidates, base);
-}
-function validateTool(filters) {
-    if (filters.tool === undefined)
-        return undefined;
-    const { byParentTool } = capabilityIndex();
-    if (byParentTool.has(filters.tool))
-        return undefined;
-    return guidedFilterError('UNKNOWN_TOOL', `Unknown tool '${filters.tool}'. Call search without a tool filter to browse capabilities.`, 'tool', filters.tool, [...byParentTool.keys()].sort(), {});
-}
-function validateEffect(filters) {
-    if (filters.effect === undefined)
-        return undefined;
-    const effects = [...new Set(capabilityIndex().records.map((record) => record.behavior.effect))].sort();
-    if (effects.some((effect) => effect === filters.effect))
-        return undefined;
-    return guidedFilterError('UNKNOWN_EFFECT', `Unknown effect '${filters.effect}'. Declared effects: ${effects.join(', ')}.`, 'effect', filters.effect, effects, {});
-}
-export function validateFilters(filters) {
-    return validateDomain(filters)
-        ?? validateFamily(filters)
-        ?? validateTool(filters)
-        ?? validateEffect(filters);
-}
-function matchesFilters(record, filters) {
-    if (filters.domain !== undefined && record.discovery.domain !== filters.domain)
-        return false;
-    if (filters.family !== undefined && record.discovery.family !== filters.family)
-        return false;
-    if (filters.tool !== undefined && record.routing.parentTool !== filters.tool)
-        return false;
-    if (filters.effect !== undefined && record.behavior.effect !== filters.effect)
-        return false;
-    return true;
-}
-export function selectCandidates(filters) {
-    if (filters.capability !== undefined) {
-        const resolved = resolveCapability(filters.capability);
-        return resolved.kind === 'unknown' ? [] : [resolved.record];
-    }
-    if (filters.tool !== undefined && filters.action !== undefined) {
-        const resolved = resolveLegacyPair(filters.tool, filters.action);
-        return resolved.kind === 'unknown' ? [] : [resolved.record];
-    }
-    const candidates = capabilityIndex().records.filter((record) => matchesFilters(record, filters));
-    if (filters.action === undefined)
-        return candidates;
-    const action = filters.action;
-    return candidates.filter((record) => record.routing.dispatchAction === action
-        || record.legacyIds.some((legacy) => legacy.action === action));
-}
-//# sourceMappingURL=gateway-search-filters.js.map

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

@@ -1,2 +0,0 @@
-export declare function searchGatewayCapabilities(args: Record<string, unknown>): Record<string, unknown>;
-//# sourceMappingURL=gateway-search.d.ts.map