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

package/dist/server/gateway/gateway-capability-index.js

@@ -1,148 +0,0 @@
-import { CANONICAL_CAPABILITY_RECORDS, CATALOG_REVISION } from '../../tools/catalog/capabilities/generated/canonical-registry.generated.js';
-import { createCapabilitySearchIndex } from '../../tools/catalog/capabilities/retrieval/scoring.js';
-import { compareAscii } from '../../utils/serialization/ordering.js';
-export function deriveNamespaceAliases(records) {
-    const parentTools = new Set(records.map((record) => record.routing.parentTool));
-    const ownersByNamespace = new Map();
-    for (const record of records) {
-        const namespace = record.id.split('.')[0];
-        if (namespace === undefined || namespace.length === 0 || parentTools.has(namespace))
-            continue;
-        const owners = ownersByNamespace.get(namespace) ?? new Set();
-        owners.add(record.routing.parentTool);
-        ownersByNamespace.set(namespace, owners);
-    }
-    const aliases = new Map();
-    for (const [namespace, owners] of ownersByNamespace) {
-        const [only] = [...owners];
-        if (owners.size === 1 && only !== undefined)
-            aliases.set(namespace, only);
-    }
-    return aliases;
-}
-export function resolveToolNamespace(name) {
-    return capabilityIndex().parentToolByNamespace.get(name);
-}
-export function legacyPairKey(tool, action) {
-    return `${tool}::${action}`;
-}
-export function detectIndexConflicts(records) {
-    const aliasOwners = new Map();
-    const legacyPairOwners = new Map();
-    for (const record of records) {
-        for (const alias of record.aliases) {
-            const owners = aliasOwners.get(alias) ?? [];
-            owners.push(record.id);
-            aliasOwners.set(alias, owners);
-        }
-        for (const legacy of record.legacyIds) {
-            const key = legacyPairKey(legacy.tool, legacy.action);
-            const owners = legacyPairOwners.get(key) ?? [];
-            owners.push(record.id);
-            legacyPairOwners.set(key, owners);
-        }
-    }
-    const contested = (owners) => {
-        const out = new Map();
-        for (const [key, ids] of owners) {
-            const distinct = [...new Set(ids)].sort(compareAscii);
-            if (distinct.length > 1)
-                out.set(key, Object.freeze(distinct));
-        }
-        return out;
-    };
-    return {
-        aliasConflicts: contested(aliasOwners),
-        legacyPairConflicts: contested(legacyPairOwners)
-    };
-}
-function describeConflicts(label, conflicts) {
-    return [...conflicts]
-        .sort(([left], [right]) => compareAscii(left, right))
-        .map(([key, owners]) => `${label} '${key}' is claimed by ${owners.join(', ')}`);
-}
-function groupBy(records, key) {
-    const grouped = new Map();
-    for (const record of records) {
-        const bucket = grouped.get(key(record));
-        if (bucket === undefined)
-            grouped.set(key(record), [record]);
-        else
-            bucket.push(record);
-    }
-    return grouped;
-}
-export function buildCapabilityIndex(source) {
-    const records = Object.freeze([...source].sort((left, right) => compareAscii(left.id, right.id)));
-    const conflicts = detectIndexConflicts(records);
-    if (conflicts.aliasConflicts.size > 0 || conflicts.legacyPairConflicts.size > 0) {
-        const detail = [
-            ...describeConflicts('alias', conflicts.aliasConflicts),
-            ...describeConflicts('tool+action', conflicts.legacyPairConflicts)
-        ].join('; ');
-        throw new Error(`GATEWAY_INDEX_CONFLICT: the canonical catalogue contains ambiguous selectors - ${detail}. `
-            + 'Give each capability a distinct alias and legacy pair, then regenerate.');
-    }
-    const byId = new Map();
-    const byAlias = new Map();
-    const byLegacyPair = new Map();
-    const actionsByParentTool = new Map();
-    for (const record of records) {
-        byId.set(record.id, record);
-        for (const alias of record.aliases)
-            byAlias.set(alias, record);
-        for (const legacy of record.legacyIds) {
-            byLegacyPair.set(legacyPairKey(legacy.tool, legacy.action), record);
-            const actions = actionsByParentTool.get(legacy.tool) ?? [];
-            actions.push(legacy.action);
-            actionsByParentTool.set(legacy.tool, actions);
-        }
-    }
-    const byDomain = groupBy(records, (record) => record.discovery.domain);
-    const familiesByDomain = new Map();
-    for (const [domain, domainRecords] of byDomain) {
-        const families = [...new Set(domainRecords.map((record) => record.discovery.family))];
-        familiesByDomain.set(domain, Object.freeze(families.sort(compareAscii)));
-    }
-    return Object.freeze({
-        records,
-        byId,
-        byAlias,
-        byLegacyPair,
-        byParentTool: groupBy(records, (record) => record.routing.parentTool),
-        actionsByParentTool,
-        parentToolByNamespace: deriveNamespaceAliases(records),
-        domains: Object.freeze([...byDomain.keys()].sort(compareAscii)),
-        familiesByDomain,
-        search: createCapabilitySearchIndex(records)
-    });
-}
-let index;
-export function capabilityIndex() {
-    index ??= buildCapabilityIndex(CANONICAL_CAPABILITY_RECORDS);
-    return index;
-}
-export function catalogRevision() {
-    return CATALOG_REVISION;
-}
-export function resolveCapability(reference) {
-    const { byId, byAlias } = capabilityIndex();
-    const canonical = byId.get(reference);
-    if (canonical !== undefined)
-        return { kind: 'canonical', record: canonical };
-    const aliased = byAlias.get(reference);
-    if (aliased !== undefined)
-        return { kind: 'alias', record: aliased, alias: reference };
-    return { kind: 'unknown' };
-}
-export function resolveLegacyPair(tool, action) {
-    const record = capabilityIndex().byLegacyPair.get(legacyPairKey(tool, action));
-    return record === undefined ? { kind: 'unknown' } : { kind: 'legacy', record, tool, action };
-}
-export function allCapabilityIds() {
-    return capabilityIndex().records.map((record) => record.id);
-}
-export function capabilitiesInFamily(domain, family) {
-    return capabilityIndex().records.filter((record) => record.discovery.domain === domain && record.discovery.family === family);
-}
-//# sourceMappingURL=gateway-capability-index.js.map

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

@@ -1,20 +0,0 @@
-import type { CapabilityRecord } from '../../tools/catalog/capabilities/model.js';
-import { type CapabilityAvailability } from './gateway-availability.js';
-export type CapabilityNextCall = Record<string, unknown>;
-export declare function capabilityConsentGrant(record: CapabilityRecord): {
-    capability: string;
-    acknowledge: 'explicit' | 'elevated';
-} | undefined;
-export declare function primaryLegacyId(record: CapabilityRecord): CapabilityRecord['legacyIds'][number] | undefined;
-export declare function primaryExecutableAction(record: CapabilityRecord): string;
-export declare function capabilityNextCall(record: CapabilityRecord, availability: CapabilityAvailability): CapabilityNextCall;
-export declare function searchNextCall(record: CapabilityRecord, availability: CapabilityAvailability): CapabilityNextCall;
-export declare function paramsInputSchema(record: CapabilityRecord): Record<string, unknown>;
-export declare function declaredParameterNames(record: CapabilityRecord): readonly string[];
-export declare function parameterSchema(record: CapabilityRecord, name: string): Record<string, unknown> | undefined;
-export declare function parameterVariants(record: CapabilityRecord, name: string): readonly string[] | undefined;
-export declare function parameterSummaries(record: CapabilityRecord): Array<Record<string, unknown>>;
-export declare function isRequiredParameter(record: CapabilityRecord, name: string): boolean;
-export declare function capabilitySearchRow(record: CapabilityRecord, reasons: readonly unknown[]): Record<string, unknown>;
-export declare function capabilityContract(record: CapabilityRecord): Record<string, unknown>;
-//# sourceMappingURL=gateway-capability-view.d.ts.map

package/dist/server/gateway/gateway-capability-view.js

@@ -1,144 +0,0 @@
-import { isRecord } from '../../utils/validation/type-guards.js';
-import { capabilityAvailability, isRunnable } from './gateway-availability.js';
-import { getParentToolMetadata } from '../../tools/catalog/capabilities/records/parent-metadata.js';
-export function capabilityConsentGrant(record) {
-    if (record.policy.consent === 'none')
-        return undefined;
-    return {
-        capability: record.id,
-        acknowledge: record.policy.consent === 'elevated' ? 'elevated' : 'explicit'
-    };
-}
-export function primaryLegacyId(record) {
-    return record.legacyIds.find((entry) => entry.tool === record.routing.parentTool && entry.folded === undefined)
-        ?? record.legacyIds.find((entry) => entry.tool === record.routing.parentTool)
-        ?? record.legacyIds[0];
-}
-export function primaryExecutableAction(record) {
-    return primaryLegacyId(record)?.action ?? record.routing.dispatchAction;
-}
-export function capabilityNextCall(record, availability) {
-    if (availability.status === 'disabled') {
-        return { operation: 'configure', tool: record.routing.parentTool };
-    }
-    const legacy = primaryLegacyId(record);
-    return {
-        operation: 'execute',
-        capability: record.id,
-        ...(legacy === undefined ? {} : { tool: legacy.tool, action: legacy.action }),
-        params: {}
-    };
-}
-export function searchNextCall(record, availability) {
-    if (availability.status === 'available') {
-        return { operation: 'describe', capability: record.id };
-    }
-    return capabilityNextCall(record, availability);
-}
-const GATEWAY_CONTROL_PARAMS = new Set(['action', 'subAction']);
-export function paramsInputSchema(record) {
-    const input = record.schemas.input;
-    const properties = {};
-    for (const [name, schema] of Object.entries(input.properties)) {
-        if (!GATEWAY_CONTROL_PARAMS.has(name))
-            properties[name] = schema;
-    }
-    return {
-        ...input,
-        properties,
-        required: input.required.filter((name) => !GATEWAY_CONTROL_PARAMS.has(name))
-    };
-}
-export function declaredParameterNames(record) {
-    return Object.keys(record.schemas.input.properties)
-        .filter((name) => !GATEWAY_CONTROL_PARAMS.has(name))
-        .sort();
-}
-function requiredSet(record) {
-    return new Set(record.schemas.input.required.filter((name) => !GATEWAY_CONTROL_PARAMS.has(name)));
-}
-export function parameterSchema(record, name) {
-    const schema = record.schemas.input.properties[name];
-    return isRecord(schema) ? schema : undefined;
-}
-export function parameterVariants(record, name) {
-    const declaredBy = record.routing.dispatchBy?.declaredBy;
-    return declaredBy !== undefined && Object.hasOwn(declaredBy, name) ? declaredBy[name] : undefined;
-}
-export function parameterSummaries(record) {
-    const required = requiredSet(record);
-    return declaredParameterNames(record).map((name) => {
-        const schema = parameterSchema(record, name) ?? {};
-        const summary = {
-            name,
-            type: typeof schema.type === 'string' ? schema.type : 'unknown',
-            required: required.has(name)
-        };
-        if (typeof schema.description === 'string')
-            summary.description = schema.description;
-        if (Array.isArray(schema.enum))
-            summary.enum = schema.enum;
-        const variants = parameterVariants(record, name);
-        if (variants !== undefined)
-            summary.variants = [...variants];
-        return summary;
-    });
-}
-export function isRequiredParameter(record, name) {
-    return requiredSet(record).has(name);
-}
-export function capabilitySearchRow(record, reasons) {
-    const availability = capabilityAvailability(record);
-    return {
-        capability: record.id,
-        parentTool: record.routing.parentTool,
-        action: primaryExecutableAction(record),
-        category: getParentToolMetadata(record.routing.parentTool).category,
-        domain: record.discovery.domain,
-        family: record.discovery.family,
-        summary: record.discovery.summary,
-        effect: record.behavior.effect,
-        availability,
-        policy: record.policy,
-        outputs: Object.keys(record.schemas.output.properties),
-        hashes: record.hashes,
-        reasons,
-        runnable: isRunnable(availability),
-        nextCall: searchNextCall(record, availability)
-    };
-}
-export function capabilityContract(record) {
-    const availability = capabilityAvailability(record);
-    const parameters = parameterSummaries(record);
-    const consentGrant = capabilityConsentGrant(record);
-    return {
-        ...(consentGrant === undefined ? {} : { consentGrant }),
-        scope: 'capability',
-        capability: record.id,
-        parentTool: record.routing.parentTool,
-        action: primaryExecutableAction(record),
-        category: getParentToolMetadata(record.routing.parentTool).category,
-        domain: record.discovery.domain,
-        family: record.discovery.family,
-        topics: record.discovery.topics,
-        summary: record.discovery.summary,
-        whenToUse: record.discovery.whenToUse,
-        whenNotToUse: record.discovery.whenNotToUse,
-        aliases: record.aliases,
-        legacyIds: record.legacyIds,
-        perActionSchemas: true,
-        inputSchema: paramsInputSchema(record),
-        outputSchema: record.schemas.output,
-        parameters,
-        parameterCount: parameters.length,
-        examples: record.examples,
-        availability,
-        behavior: record.behavior,
-        policy: record.policy,
-        cost: record.cost,
-        hashes: record.hashes,
-        runnable: isRunnable(availability),
-        nextCall: capabilityNextCall(record, availability)
-    };
-}
-//# sourceMappingURL=gateway-capability-view.js.map

package/dist/server/gateway/gateway-describe-browse.d.ts

@@ -1,14 +0,0 @@
-declare const DEFAULT_BROWSE_LIMIT = 50;
-type Page = {
-    readonly limit: number;
-    readonly offset: number;
-};
-export declare function describeCatalog(page: Page): Record<string, unknown>;
-export declare function unknownDomainError(domain: string): Record<string, unknown>;
-export declare function unknownFamilyError(domain: string, family: string): Record<string, unknown>;
-export declare function describeDomain(domain: string, page: Page): Record<string, unknown>;
-export declare function describeFamily(domain: string, family: string, page: Page): Record<string, unknown>;
-export declare function resolveDomainForFamily(family: string): string | undefined;
-export { DEFAULT_BROWSE_LIMIT };
-export type { Page };
-//# sourceMappingURL=gateway-describe-browse.d.ts.map

package/dist/server/gateway/gateway-describe-browse.js

@@ -1,110 +0,0 @@
-import { capabilitiesInFamily, capabilityIndex, catalogRevision } from './gateway-capability-index.js';
-import { capabilityAvailability } from './gateway-availability.js';
-import { primaryExecutableAction } from './gateway-capability-view.js';
-import { closestMatches, MAX_SUGGESTIONS } from './gateway-guidance.js';
-import { gatewayError } from './gateway-shared.js';
-const DEFAULT_BROWSE_LIMIT = 50;
-function paged(entries, page) {
-    const rows = entries.slice(page.offset, page.offset + page.limit);
-    return { rows, hasMore: page.offset + rows.length < entries.length };
-}
-function browseEnvelope(scope, extra) {
-    return { success: true, operation: 'describe', catalogRevision: catalogRevision(), scope, ...extra };
-}
-export function describeCatalog(page) {
-    const index = capabilityIndex();
-    const counts = new Map();
-    for (const record of index.records) {
-        counts.set(record.discovery.domain, (counts.get(record.discovery.domain) ?? 0) + 1);
-    }
-    const { rows, hasMore } = paged(index.domains, page);
-    return browseEnvelope('catalog', {
-        domains: rows.map((domain) => ({
-            domain,
-            capabilityCount: counts.get(domain) ?? 0,
-            familyCount: (index.familiesByDomain.get(domain) ?? []).length,
-            nextCall: { operation: 'describe', domain }
-        })),
-        domainCount: index.domains.length,
-        domainOffset: page.offset,
-        domainLimit: page.limit,
-        domainHasMore: hasMore,
-        capabilityCount: index.records.length,
-        message: 'Catalog domains. Drill into a domain to list its families, then a family to list capabilities.'
-    });
-}
-export function unknownDomainError(domain) {
-    return {
-        ...gatewayError('describe', 'UNKNOWN_DOMAIN', `Unknown domain '${domain}'.`),
-        suggestions: closestMatches(domain, [...capabilityIndex().domains], MAX_SUGGESTIONS),
-        nextCall: { operation: 'describe' }
-    };
-}
-export function unknownFamilyError(domain, family) {
-    const families = capabilityIndex().familiesByDomain.get(domain) ?? [];
-    return {
-        ...gatewayError('describe', 'UNKNOWN_FAMILY', `Unknown family '${family}' in domain '${domain}'.`),
-        domain,
-        availableFamilies: families,
-        suggestions: closestMatches(family, [...families], MAX_SUGGESTIONS),
-        nextCall: { operation: 'describe', domain }
-    };
-}
-export function describeDomain(domain, page) {
-    const index = capabilityIndex();
-    if (!index.domains.includes(domain))
-        return unknownDomainError(domain);
-    const families = index.familiesByDomain.get(domain) ?? [];
-    const { rows, hasMore } = paged(families, page);
-    return browseEnvelope('domain', {
-        domain,
-        families: rows.map((family) => ({
-            family,
-            capabilityCount: capabilitiesInFamily(domain, family).length,
-            nextCall: { operation: 'describe', domain, family }
-        })),
-        familyCount: families.length,
-        familyOffset: page.offset,
-        familyLimit: page.limit,
-        familyHasMore: hasMore,
-        message: 'Domain families. Drill into a family to list its capabilities.'
-    });
-}
-export function describeFamily(domain, family, page) {
-    const index = capabilityIndex();
-    if (!index.domains.includes(domain))
-        return unknownDomainError(domain);
-    if (!(index.familiesByDomain.get(domain) ?? []).includes(family)) {
-        return unknownFamilyError(domain, family);
-    }
-    const records = capabilitiesInFamily(domain, family);
-    const { rows, hasMore } = paged(records, page);
-    return browseEnvelope('family', {
-        domain,
-        family,
-        capabilities: rows.map((record) => ({
-            capability: record.id,
-            parentTool: record.routing.parentTool,
-            action: primaryExecutableAction(record),
-            summary: record.discovery.summary,
-            effect: record.behavior.effect,
-            availability: capabilityAvailability(record).status,
-            nextCall: { operation: 'describe', capability: record.id }
-        })),
-        capabilityCount: records.length,
-        capabilityOffset: page.offset,
-        capabilityLimit: page.limit,
-        capabilityHasMore: hasMore,
-        message: 'Family capabilities. Drill into a capability for its exact contract.'
-    });
-}
-export function resolveDomainForFamily(family) {
-    const index = capabilityIndex();
-    for (const domain of index.domains) {
-        if ((index.familiesByDomain.get(domain) ?? []).includes(family))
-            return domain;
-    }
-    return undefined;
-}
-export { DEFAULT_BROWSE_LIMIT };
-//# sourceMappingURL=gateway-describe-browse.js.map

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

@@ -1,6 +0,0 @@
-import type { CapabilityRecord } from '../../tools/catalog/capabilities/model.js';
-export declare function unknownCapabilityError(reference: string): Record<string, unknown>;
-export declare function describeCapabilityRecord(record: CapabilityRecord, origin: Record<string, unknown>): Record<string, unknown>;
-export declare function describeCapabilityParameter(record: CapabilityRecord, param: string, origin: Record<string, unknown>): Record<string, unknown>;
-export declare function describeCapabilityReference(reference: string, param: string | undefined): Record<string, unknown>;
-//# sourceMappingURL=gateway-describe-capability.d.ts.map

package/dist/server/gateway/gateway-describe-capability.js

@@ -1,74 +0,0 @@
-import { catalogRevision, resolveCapability, allCapabilityIds } from './gateway-capability-index.js';
-import { capabilityConsentGrant, capabilityContract, declaredParameterNames, isRequiredParameter, parameterSchema, parameterVariants, primaryExecutableAction } from './gateway-capability-view.js';
-import { closestMatches, MAX_SUGGESTIONS } from './gateway-guidance.js';
-import { gatewayError } from './gateway-shared.js';
-export function unknownCapabilityError(reference) {
-    const suggestions = closestMatches(reference, [...allCapabilityIds()], MAX_SUGGESTIONS);
-    const nextCall = suggestions.length > 0
-        ? { operation: 'describe', capability: suggestions[0] }
-        : { operation: 'search', query: reference };
-    return {
-        ...gatewayError('describe', 'UNKNOWN_CAPABILITY', `Unknown capability '${reference}'. Call search to find canonical capability IDs.`),
-        suggestions,
-        nextCall
-    };
-}
-function unknownParamError(record, param) {
-    const declared = declaredParameterNames(record);
-    const suggestions = closestMatches(param, [...declared], MAX_SUGGESTIONS);
-    const nextCall = { operation: 'describe', capability: record.id };
-    if (suggestions.length > 0)
-        nextCall.param = suggestions[0];
-    return {
-        ...gatewayError('describe', 'UNKNOWN_PARAM', `Unknown parameter '${param}' for capability '${record.id}'.`),
-        capability: record.id,
-        availableParameters: declared,
-        suggestions,
-        nextCall
-    };
-}
-export function describeCapabilityRecord(record, origin) {
-    return {
-        success: true,
-        operation: 'describe',
-        catalogRevision: catalogRevision(),
-        ...capabilityContract(record),
-        ...origin,
-        message: 'Exact capability contract. inputSchema declares every parameter this action accepts.'
-    };
-}
-export function describeCapabilityParameter(record, param, origin) {
-    if (!declaredParameterNames(record).includes(param))
-        return unknownParamError(record, param);
-    const consentGrant = capabilityConsentGrant(record);
-    const variants = parameterVariants(record, param);
-    return {
-        success: true,
-        operation: 'describe',
-        catalogRevision: catalogRevision(),
-        scope: 'parameter',
-        capability: record.id,
-        ...(consentGrant ? { consentGrant } : {}),
-        parentTool: record.routing.parentTool,
-        action: primaryExecutableAction(record),
-        param,
-        required: isRequiredParameter(record, param),
-        schema: parameterSchema(record, param) ?? {},
-        ...(variants === undefined ? {} : { variants: [...variants] }),
-        perActionSchemas: true,
-        ...origin,
-        message: 'Single parameter schema for this capability. Pass it with the exact casing shown.'
-    };
-}
-export function describeCapabilityReference(reference, param) {
-    const resolved = resolveCapability(reference);
-    if (resolved.kind === 'unknown')
-        return unknownCapabilityError(reference);
-    const origin = resolved.kind === 'alias'
-        ? { resolvedFromAlias: resolved.alias }
-        : {};
-    return param === undefined
-        ? describeCapabilityRecord(resolved.record, origin)
-        : describeCapabilityParameter(resolved.record, param, origin);
-}
-//# sourceMappingURL=gateway-describe-capability.js.map

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

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

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

@@ -1,109 +0,0 @@
-import { dynamicToolManager } from '../../tools/dynamic/dynamic-tool-manager.js';
-import { resolveLegacyPair, resolveToolNamespace } from './gateway-capability-index.js';
-import { describeCapabilityParameter, describeCapabilityRecord, describeCapabilityReference } from './gateway-describe-capability.js';
-import { DEFAULT_BROWSE_LIMIT, describeCatalog, describeDomain, describeFamily, resolveDomainForFamily, unknownFamilyError } from './gateway-describe-browse.js';
-import { getString, getBoundedInteger, getOptionalBoundedInteger, gatewayError, findTool, allToolNames } from './gateway-shared.js';
-import { closestMatches, buildNextCall, guideUnknownAction, MAX_SUGGESTIONS } from './gateway-guidance.js';
-const MAX_DESCRIBE_LIMIT = 50;
-function unknownToolError(toolArg) {
-    const error = gatewayError('describe', 'UNKNOWN_TOOL', 'Unknown tool. Call search to retrieve canonical tool names.');
-    const suggestions = closestMatches(toolArg ?? '', allToolNames(), MAX_SUGGESTIONS);
-    const nextCall = suggestions.length > 0
-        ? buildNextCall({ operation: 'describe', tool: suggestions[0] })
-        : buildNextCall({ operation: 'search' });
-    return { ...error, suggestions, nextCall };
-}
-function unknownActionError(toolName, actionArg, actions) {
-    const owners = allToolNames().filter((name) => resolveLegacyPair(name, actionArg).kind !== 'unknown');
-    const guide = guideUnknownAction(toolName, actionArg, actions, owners);
-    const error = gatewayError('describe', 'UNKNOWN_ACTION', `Unknown action '${actionArg}' for ${toolName}.${guide.hint}`);
-    return { ...error, tool: toolName, availableActions: actions, suggestions: guide.suggestions, nextCall: guide.nextCall };
-}
-function describeToolSummary(tool, query, requestedLimit, offset) {
-    const actions = tool.actions;
-    const filtered = query.length === 0
-        ? actions
-        : actions.filter((name) => name.toLowerCase().includes(query));
-    const limit = requestedLimit ?? filtered.length;
-    const paged = filtered.slice(offset, offset + limit);
-    const first = paged[0] ?? actions[0];
-    return {
-        success: true,
-        operation: 'describe',
-        tool: tool.name,
-        category: tool.category,
-        description: tool.description,
-        enabled: dynamicToolManager.isToolEnabled(tool.name),
-        actions: paged,
-        actionCount: filtered.length,
-        actionOffset: offset,
-        actionLimit: limit,
-        actionHasMore: offset + paged.length < filtered.length,
-        scope: 'tool',
-        perActionSchemas: false,
-        drillDown: buildNextCall({ operation: 'describe', tool: tool.name, action: first }),
-        browse: { operation: 'search', tool: tool.name },
-        message: 'Legacy parent-tool summary: action names only. To choose one, send the browse call (search filtered to this tool; add query words and read the row summaries), or drill into an action for its exact contract.'
-    };
-}
-function describeLegacyPair(toolName, action, param) {
-    const resolved = resolveLegacyPair(toolName, action);
-    if (resolved.kind === 'unknown') {
-        const tool = findTool(toolName);
-        return tool === undefined
-            ? unknownToolError(toolName)
-            : unknownActionError(tool.name, action, tool.actions);
-    }
-    const origin = { migratedFrom: { tool: toolName, action } };
-    return param === undefined
-        ? describeCapabilityRecord(resolved.record, origin)
-        : describeCapabilityParameter(resolved.record, param, origin);
-}
-function describeLegacyTool(toolName, args, page, query) {
-    const namespaceOwner = findTool(toolName) === undefined ? resolveToolNamespace(toolName) : undefined;
-    const resolvedName = namespaceOwner ?? toolName;
-    const action = getString(args, 'action');
-    if (action !== undefined)
-        return describeLegacyPair(resolvedName, action, getString(args, 'param'));
-    const tool = findTool(resolvedName);
-    if (tool === undefined)
-        return unknownToolError(toolName);
-    const requestedLimit = getOptionalBoundedInteger(args.limit, 1, MAX_DESCRIBE_LIMIT);
-    const summary = describeToolSummary(tool, query, requestedLimit, page.offset);
-    return namespaceOwner === undefined ? summary : { ...summary, resolvedFromNamespace: toolName };
-}
-function describeBrowse(domain, family, page) {
-    if (family !== undefined) {
-        const owningDomain = domain ?? resolveDomainForFamily(family);
-        if (owningDomain === undefined)
-            return unknownFamilyError(domain ?? '', family);
-        return describeFamily(owningDomain, family, page);
-    }
-    if (domain !== undefined)
-        return describeDomain(domain, page);
-    return describeCatalog(page);
-}
-function paramWithoutCapabilityError(toolArg) {
-    const error = gatewayError('describe', 'MISSING_ACTION', 'param selects one parameter of one capability, so it needs a capability, or a tool with an action.');
-    const nextCall = toolArg === undefined
-        ? buildNextCall({ operation: 'search' })
-        : buildNextCall({ operation: 'describe', tool: toolArg });
-    return { ...error, nextCall };
-}
-export function describeGatewayCapability(args) {
-    const query = (getString(args, 'query') ?? '').toLowerCase();
-    const offset = getBoundedInteger(args.offset ?? args.actionOffset, 0, 0, Number.MAX_SAFE_INTEGER);
-    const limit = getBoundedInteger(args.limit, DEFAULT_BROWSE_LIMIT, 1, MAX_DESCRIBE_LIMIT);
-    const page = { limit, offset };
-    const capability = getString(args, 'capability');
-    if (capability !== undefined)
-        return describeCapabilityReference(capability, getString(args, 'param'));
-    const toolArg = getString(args, 'tool');
-    if (getString(args, 'param') !== undefined && getString(args, 'action') === undefined) {
-        return paramWithoutCapabilityError(toolArg);
-    }
-    if (toolArg !== undefined)
-        return describeLegacyTool(toolArg, args, page, query);
-    return describeBrowse(getString(args, 'domain'), getString(args, 'family'), page);
-}
-//# sourceMappingURL=gateway-describe.js.map

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

@@ -1,17 +0,0 @@
-import type { CapabilityRecord, LegacyCapabilityId } from '../../tools/catalog/capabilities/model.js';
-import type { ExecuteTarget } from './gateway-execute-resolve.js';
-export declare function requestedAction(target: ExecuteTarget): string | undefined;
-export declare function foldedPairFor(record: CapabilityRecord, action: string | undefined): LegacyCapabilityId | undefined;
-export declare function applyFoldedPins(target: ExecuteTarget, params: Record<string, unknown>): {
-    params: Record<string, unknown>;
-} | {
-    conflict: {
-        name: string;
-        pinned: unknown;
-        sent: unknown;
-    };
-};
-export declare function inferSelector(record: CapabilityRecord, params: Record<string, unknown>): Record<string, unknown>;
-export declare function unreadVariantParams(record: CapabilityRecord, sent: readonly string[], params: Record<string, unknown>): readonly string[];
-export declare function resolveDispatchAction(target: ExecuteTarget, params: Record<string, unknown>): string | undefined;
-//# sourceMappingURL=gateway-dispatch-by.d.ts.map