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

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

@@ -1,106 +0,0 @@
-import { rankCapabilityRecords } from '../../tools/catalog/capabilities/retrieval/scoring.js';
-import { capabilityIndex, catalogRevision } from './gateway-capability-index.js';
-import { capabilitySearchRow } from './gateway-capability-view.js';
-import { DEFAULT_SEARCH_MAX_BYTES, MAX_SEARCH_MAX_BYTES, MIN_SEARCH_MAX_BYTES, decodeCursor, encodeCursor, readFilters, selectCandidates, validateFilters } from './gateway-search-filters.js';
-import { DEFAULT_SEARCH_LIMIT, MAX_SEARCH_LIMIT, gatewayError, getBoundedInteger, getString, integerCoercion } from './gateway-shared.js';
-function orderCandidates(candidates, query) {
-    if (query.trim().length === 0) {
-        return candidates.map((record) => ({ record, reasons: [] }));
-    }
-    const ranked = rankCapabilityRecords(capabilityIndex().search, candidates, query);
-    return ranked.map((entry) => ({ record: entry.record, reasons: entry.reasons }));
-}
-function declaredFilters(filters) {
-    const declared = {};
-    for (const [name, value] of Object.entries(filters)) {
-        if (name !== 'query' && typeof value === 'string')
-            declared[name] = value;
-    }
-    return declared;
-}
-function envelope(filters, page, rows, byteBudgetTruncated, coercions) {
-    const hasMore = page.offset + rows.length < page.total;
-    const truncationReason = byteBudgetTruncated ? 'byte-budget' : hasMore ? 'limit' : 'none';
-    const result = {
-        success: true,
-        operation: 'search',
-        catalogRevision: catalogRevision(),
-        query: filters.query,
-        filters: declaredFilters(filters),
-        results: rows,
-        total: page.total,
-        offset: page.offset,
-        limit: page.limit,
-        maxBytes: page.maxBytes,
-        hasMore,
-        truncationReason,
-        message: 'Results are compact. Call describe with an exact capability before execute.'
-    };
-    if (hasMore)
-        result.nextCursor = encodeCursor(page.offset + rows.length);
-    if (rows.length === 0 && page.total === 0) {
-        result.message = filters.query.length === 0
-            ? 'No capability matches these filters. Remove a filter, or call describe with no selector to browse domains.'
-            : `No capability matched '${filters.query}'. Use 2-4 plain words naming the verb and the object (e.g. 'spawn actor'), drop any filter, or call describe with no selector to browse domains.`;
-        result.nextCall = { operation: 'describe' };
-    }
-    if (coercions.length > 0)
-        result.coercions = coercions;
-    return result;
-}
-function withinByteBudget(filters, page, rows, coercions) {
-    let kept = rows;
-    let response = envelope(filters, page, kept, false, coercions);
-    while (kept.length > 0 && JSON.stringify(response).length > page.maxBytes) {
-        kept = kept.slice(0, kept.length - 1);
-        response = envelope(filters, page, kept, true, coercions);
-    }
-    if (kept.length === 0 && rows.length > 0) {
-        delete response.nextCursor;
-        response.budgetExceeded = true;
-        response.message =
-            `No result fits maxBytes=${page.maxBytes}. Raise maxBytes and retry; `
-                + 'this page cannot advance at the current budget.';
-    }
-    return response;
-}
-function resolveOffset(args) {
-    const cursor = getString(args, 'cursor');
-    if (cursor === undefined)
-        return getBoundedInteger(args.offset, 0, 0, Number.MAX_SAFE_INTEGER);
-    const decoded = decodeCursor(cursor);
-    if (decoded === undefined) {
-        return {
-            ...gatewayError('search', 'INVALID_CURSOR', 'cursor is not a gateway search cursor. Re-run search without a cursor.'),
-            nextCall: { operation: 'search' }
-        };
-    }
-    return decoded;
-}
-function pageCoercions(args) {
-    const candidates = [
-        getString(args, 'cursor') === undefined
-            ? integerCoercion('offset', args.offset, 0, Number.MAX_SAFE_INTEGER)
-            : undefined,
-        integerCoercion('limit', args.limit, 1, MAX_SEARCH_LIMIT),
-        integerCoercion('maxBytes', args.maxBytes, MIN_SEARCH_MAX_BYTES, MAX_SEARCH_MAX_BYTES)
-    ];
-    return candidates.filter((entry) => entry !== undefined);
-}
-export function searchGatewayCapabilities(args) {
-    const filters = readFilters(args);
-    const invalidFilter = validateFilters(filters);
-    if (invalidFilter)
-        return invalidFilter;
-    const offset = resolveOffset(args);
-    if (typeof offset !== 'number')
-        return offset;
-    const limit = getBoundedInteger(args.limit, DEFAULT_SEARCH_LIMIT, 1, MAX_SEARCH_LIMIT);
-    const maxBytes = getBoundedInteger(args.maxBytes, DEFAULT_SEARCH_MAX_BYTES, MIN_SEARCH_MAX_BYTES, MAX_SEARCH_MAX_BYTES);
-    const ordered = orderCandidates(selectCandidates(filters), filters.query);
-    const rows = ordered
-        .slice(offset, offset + limit)
-        .map((entry) => capabilitySearchRow(entry.record, entry.reasons));
-    return withinByteBudget(filters, { offset, limit, total: ordered.length, maxBytes }, rows, pageCoercions(args));
-}
-//# sourceMappingURL=gateway-search.js.map

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

@@ -1,20 +0,0 @@
-import { type ManifestToolDefinition } from '../../gateway/gateway-manifest.js';
-import { type CorrelationId } from '../../tools/catalog/capabilities/semantic/ids.js';
-export declare const DEFAULT_SEARCH_LIMIT = 12;
-export declare const MAX_SEARCH_LIMIT = 25;
-export declare function getString(args: Record<string, unknown>, key: string): string | undefined;
-export declare function getBoundedInteger(value: unknown, fallback: number, minimum: number, maximum: number): number;
-export declare function getOptionalBoundedInteger(value: unknown, minimum: number, maximum: number): number | undefined;
-export type ParameterCoercion = {
-    readonly parameter: string;
-    readonly requested: number;
-    readonly applied: number;
-    readonly reason: string;
-};
-export declare function integerCoercion(parameter: string, value: unknown, minimum: number, maximum: number): ParameterCoercion | undefined;
-export declare function gatewayError(operation: string, errorCode: string, message: string): Record<string, unknown>;
-export declare function isGatewayFailure(result: unknown): result is Record<string, unknown>;
-export declare function findTool(name: string | undefined): ManifestToolDefinition | undefined;
-export declare function allToolNames(): string[];
-export declare function nextGatewayCorrelationId(): CorrelationId;
-//# sourceMappingURL=gateway-shared.d.ts.map

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

@@ -1,52 +0,0 @@
-import { getManifestToolDefinitions } from '../../gateway/gateway-manifest.js';
-import { isRecord } from '../../utils/validation/type-guards.js';
-import { CorrelationIdSchema } from '../../tools/catalog/capabilities/semantic/ids.js';
-export const DEFAULT_SEARCH_LIMIT = 12;
-export const MAX_SEARCH_LIMIT = 25;
-export function getString(args, key) {
-    const value = args[key];
-    return typeof value === 'string' && value.trim().length > 0 ? value.trim() : undefined;
-}
-export function getBoundedInteger(value, fallback, minimum, maximum) {
-    return typeof value === 'number' && Number.isInteger(value)
-        ? Math.min(Math.max(value, minimum), maximum)
-        : fallback;
-}
-export function getOptionalBoundedInteger(value, minimum, maximum) {
-    return typeof value === 'number' && Number.isInteger(value)
-        ? Math.min(Math.max(value, minimum), maximum)
-        : undefined;
-}
-export function integerCoercion(parameter, value, minimum, maximum) {
-    if (typeof value !== 'number' || !Number.isInteger(value))
-        return undefined;
-    const applied = Math.min(Math.max(value, minimum), maximum);
-    if (applied === value)
-        return undefined;
-    return {
-        parameter,
-        requested: value,
-        applied,
-        reason: value < minimum
-            ? `${parameter}=${value} is below the minimum of ${minimum}.`
-            : `${parameter}=${value} is above the maximum of ${maximum}.`
-    };
-}
-export function gatewayError(operation, errorCode, message) {
-    return { success: false, operation, errorCode, error: message, message };
-}
-export function isGatewayFailure(result) {
-    return isRecord(result) && result.success === false;
-}
-export function findTool(name) {
-    return name === undefined ? undefined : getManifestToolDefinitions().find((tool) => tool.name === name);
-}
-export function allToolNames() {
-    return getManifestToolDefinitions().map((tool) => tool.name);
-}
-let gatewayRequestCounter = 0;
-export function nextGatewayCorrelationId() {
-    gatewayRequestCounter += 1;
-    return CorrelationIdSchema.parse(`gw-${gatewayRequestCounter}`);
-}
-//# sourceMappingURL=gateway-shared.js.map

package/dist/server/gateway/gateway-task-results.d.ts

@@ -1,6 +0,0 @@
-export declare const MAX_KEPT_TASKS = 32;
-export declare function noteTaskRunning(taskId: string): void;
-export declare function noteTaskDone(taskId: string, reply: Record<string, unknown>): void;
-export declare function describeTask(taskId: string): Record<string, unknown>;
-export declare function resetTasksForTest(): void;
-//# sourceMappingURL=gateway-task-results.d.ts.map

package/dist/server/gateway/gateway-task-results.js

@@ -1,40 +0,0 @@
-import { compactGatewayReply } from '../../utils/responses/gateway-reply-compaction.js';
-export const MAX_KEPT_TASKS = 32;
-const tasks = new Map();
-function remember(taskId, entry) {
-    tasks.delete(taskId);
-    tasks.set(taskId, entry);
-    while (tasks.size > MAX_KEPT_TASKS) {
-        const oldest = tasks.keys().next().value;
-        if (oldest === undefined)
-            break;
-        tasks.delete(oldest);
-    }
-}
-export function noteTaskRunning(taskId) {
-    remember(taskId, { state: 'running' });
-}
-export function noteTaskDone(taskId, reply) {
-    remember(taskId, { state: 'done', reply });
-}
-export function describeTask(taskId) {
-    const entry = tasks.get(taskId);
-    if (entry === undefined) {
-        return {
-            success: false,
-            errorCode: 'TASK_NOT_FOUND',
-            error: `No task ${taskId}: only a call answered "still running" since the server started is kept, the last ${MAX_KEPT_TASKS} of them.`
-        };
-    }
-    if (entry.state === 'running') {
-        return { success: true, taskId, state: 'running', message: `Task ${taskId} is still running.` };
-    }
-    const outcome = { ...compactGatewayReply(entry.reply) };
-    delete outcome.operation;
-    outcome.success = entry.reply.success === true;
-    return { success: true, taskId, state: 'done', outcome, message: `Task ${taskId} is done.` };
-}
-export function resetTasksForTest() {
-    tasks.clear();
-}
-//# sourceMappingURL=gateway-task-results.js.map

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

@@ -1,42 +0,0 @@
-export declare const DEFAULT_IDEMPOTENCY_TTL_MS: number;
-export declare const DEFAULT_MAX_IDEMPOTENCY_ENTRIES = 1024;
-export interface LedgerScope {
-    readonly principal: string;
-    readonly capabilityId: string;
-    readonly key: string;
-}
-export interface LedgerHandle {
-    readonly slot: string;
-}
-export type BeginOutcome = {
-    readonly kind: 'first';
-    readonly handle: LedgerHandle;
-} | {
-    readonly kind: 'in-flight';
-} | {
-    readonly kind: 'replay';
-    readonly receipt: Record<string, unknown>;
-} | {
-    readonly kind: 'conflict';
-};
-export interface IdempotencyLedgerOptions {
-    readonly clock: () => number;
-    readonly maxEntries?: number;
-    readonly ttlMs?: number;
-}
-export declare class IdempotencyLedger {
-    readonly maxEntries: number;
-    readonly ttlMs: number;
-    private readonly entries;
-    private readonly clock;
-    constructor(options: IdempotencyLedgerOptions);
-    begin(scope: LedgerScope, fingerprint: string): BeginOutcome;
-    complete(handle: LedgerHandle, receipt: Record<string, unknown>): void;
-    abandon(handle: LedgerHandle): void;
-    size(): number;
-    private admit;
-    private isExpired;
-    private evictCompletedOverCap;
-    static computeSlot(scope: LedgerScope): string;
-}
-//# sourceMappingURL=idempotency-ledger.d.ts.map

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

@@ -1,102 +0,0 @@
-import { createHash } from 'node:crypto';
-export const DEFAULT_IDEMPOTENCY_TTL_MS = 24 * 60 * 60 * 1000;
-export const DEFAULT_MAX_IDEMPOTENCY_ENTRIES = 1024;
-function appendLengthPrefixedField(hash, field) {
-    const bytes = Buffer.from(field, 'utf8');
-    hash.update(`${bytes.length}:`, 'utf8');
-    hash.update(bytes);
-}
-export class IdempotencyLedger {
-    maxEntries;
-    ttlMs;
-    entries = new Map();
-    clock;
-    constructor(options) {
-        const cap = options.maxEntries ?? DEFAULT_MAX_IDEMPOTENCY_ENTRIES;
-        if (!Number.isInteger(cap) || cap < 1) {
-            throw new RangeError(`Invalid maxEntries: ${String(cap)} (expected integer >= 1)`);
-        }
-        const ttl = options.ttlMs ?? DEFAULT_IDEMPOTENCY_TTL_MS;
-        if (!Number.isInteger(ttl) || ttl < 1) {
-            throw new RangeError(`Invalid ttlMs: ${String(ttl)} (expected integer >= 1)`);
-        }
-        this.maxEntries = cap;
-        this.ttlMs = ttl;
-        this.clock = options.clock;
-    }
-    begin(scope, fingerprint) {
-        const slot = IdempotencyLedger.computeSlot(scope);
-        const existing = this.entries.get(slot);
-        if (existing !== undefined && this.isExpired(existing)) {
-            this.entries.delete(slot);
-            return this.admit(slot, scope.principal, fingerprint);
-        }
-        if (existing === undefined) {
-            return this.admit(slot, scope.principal, fingerprint);
-        }
-        if (existing.fingerprint !== fingerprint) {
-            return { kind: 'conflict' };
-        }
-        if (existing.state === 'in-flight') {
-            return { kind: 'in-flight' };
-        }
-        return { kind: 'replay', receipt: existing.receipt ?? {} };
-    }
-    complete(handle, receipt) {
-        const entry = this.entries.get(handle.slot);
-        if (entry === undefined || entry.state === 'completed') {
-            return;
-        }
-        entry.state = 'completed';
-        entry.receipt = receipt;
-        entry.completedAt = this.clock();
-        this.evictCompletedOverCap();
-    }
-    abandon(handle) {
-        this.entries.delete(handle.slot);
-    }
-    size() {
-        return this.entries.size;
-    }
-    admit(slot, principal, fingerprint) {
-        this.entries.set(slot, {
-            principal,
-            fingerprint,
-            state: 'in-flight',
-            receipt: null,
-            completedAt: 0,
-        });
-        return { kind: 'first', handle: { slot } };
-    }
-    isExpired(entry) {
-        if (entry.state !== 'completed') {
-            return false;
-        }
-        return this.clock() - entry.completedAt > this.ttlMs;
-    }
-    evictCompletedOverCap() {
-        let completed = 0;
-        for (const entry of this.entries.values()) {
-            if (entry.state === 'completed') {
-                completed++;
-            }
-        }
-        for (const [slot, entry] of this.entries) {
-            if (completed <= this.maxEntries) {
-                return;
-            }
-            if (entry.state === 'completed') {
-                this.entries.delete(slot);
-                completed--;
-            }
-        }
-    }
-    static computeSlot(scope) {
-        const hash = createHash('sha256');
-        appendLengthPrefixedField(hash, scope.principal);
-        appendLengthPrefixedField(hash, scope.capabilityId);
-        appendLengthPrefixedField(hash, scope.key);
-        return hash.digest('hex');
-    }
-}
-//# sourceMappingURL=idempotency-ledger.js.map

package/dist/server/mcp-primitives/completions.d.ts

@@ -1,11 +0,0 @@
-export interface CompletionResult {
-    readonly values: string[];
-    readonly total: number;
-    readonly hasMore: boolean;
-}
-export declare function complete(ref: {
-    type: string;
-    name?: string;
-    uri?: string;
-}, argument: string, prefix: string): CompletionResult;
-//# sourceMappingURL=completions.d.ts.map

package/dist/server/mcp-primitives/completions.js

@@ -1,103 +0,0 @@
-import { knowledgeTopics } from '../../resources/knowledge-resources.js';
-import { dynamicToolManager } from '../../tools/dynamic/dynamic-tool-manager.js';
-import { HOST_PATH_PATTERN, UE_CONTENT_ROOTS, isTraversalPath } from '../../utils/paths/content-path-policy.js';
-import { capabilityIndex } from '../gateway/gateway-capability-index.js';
-import { WORKFLOW_PROMPTS } from './prompts.js';
-const MAX_ITEMS = 100;
-const MAX_BYTES = 8192;
-const MAX_PREFIX = 128;
-const EMPTY = { values: [], total: 0, hasMore: false };
-function capabilityCandidates() {
-    const values = new Set();
-    for (const record of capabilityIndex().records) {
-        if (!dynamicToolManager.isToolEnabled(record.routing.parentTool))
-            continue;
-        values.add(String(record.id));
-        for (const alias of record.aliases)
-            values.add(String(alias));
-        for (const legacy of record.legacyIds)
-            values.add(`${String(legacy.tool)}.${String(legacy.action)}`);
-    }
-    return [...values];
-}
-function candidatesFor(ref, argument) {
-    if (ref.type === 'ref/prompt') {
-        return WORKFLOW_PROMPTS.find((prompt) => prompt.id === ref.name)?.arguments.find((spec) => spec.name === argument)?.allowed;
-    }
-    if (ref.uri === 'ue://capability/{capabilityId}' && argument === 'capabilityId')
-        return capabilityCandidates();
-    if (ref.uri === 'ue://knowledge/{topic}' && argument === 'topic')
-        return knowledgeTopics();
-    if (ref.uri === 'ue://asset/{assetPath}' && argument === 'assetPath')
-        return [...UE_CONTENT_ROOTS];
-    return undefined;
-}
-function withinOneEdit(a, b) {
-    if (Math.abs(a.length - b.length) > 1)
-        return false;
-    let i = 0;
-    let j = 0;
-    let edits = 0;
-    while (i < a.length && j < b.length) {
-        if (a[i] === b[j]) {
-            i += 1;
-            j += 1;
-            continue;
-        }
-        edits += 1;
-        if (edits > 1)
-            return false;
-        if (a.length > b.length)
-            i += 1;
-        else if (b.length > a.length)
-            j += 1;
-        else {
-            i += 1;
-            j += 1;
-        }
-    }
-    return edits + (i < a.length || j < b.length ? 1 : 0) <= 1;
-}
-function isSubsequence(needle, haystack) {
-    let n = 0;
-    for (let h = 0; h < haystack.length && n < needle.length; h += 1)
-        if (haystack[h] === needle[n])
-            n += 1;
-    return n === needle.length;
-}
-function tierFor(value, prefix) {
-    if (prefix.length === 0 || value.startsWith(prefix))
-        return 0;
-    if (value.includes(prefix))
-        return 1;
-    if (isSubsequence(prefix, value))
-        return 2;
-    if (withinOneEdit(prefix, value.slice(0, prefix.length)) || withinOneEdit(prefix, value.slice(0, prefix.length + 1)))
-        return 3;
-    return undefined;
-}
-export function complete(ref, argument, prefix) {
-    if (prefix.length > MAX_PREFIX || HOST_PATH_PATTERN.test(prefix) || isTraversalPath(prefix))
-        return EMPTY;
-    const pool = candidatesFor(ref, argument);
-    if (pool === undefined)
-        return EMPTY;
-    const lowered = prefix.toLowerCase();
-    const scored = pool.flatMap((value) => {
-        const tier = tierFor(value.toLowerCase(), lowered);
-        return tier === undefined ? [] : [{ value, tier }];
-    });
-    const matched = scored.some((entry) => entry.tier < 3) ? scored.filter((entry) => entry.tier < 3) : scored;
-    matched.sort((a, b) => a.tier - b.tier || (a.value < b.value ? -1 : a.value > b.value ? 1 : 0));
-    const values = [];
-    let bytes = 0;
-    for (const { value } of matched) {
-        const size = Buffer.byteLength(value, 'utf8');
-        if (values.length >= MAX_ITEMS || (values.length > 0 && bytes + size > MAX_BYTES))
-            break;
-        values.push(value);
-        bytes += size;
-    }
-    return { values, total: matched.length, hasMore: values.length < matched.length };
-}
-//# sourceMappingURL=completions.js.map

package/dist/server/mcp-primitives/primitive-wiring.d.ts

@@ -1,12 +0,0 @@
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { type ServerCapabilities } from '@modelcontextprotocol/sdk/types.js';
-export declare const SERVER_CAPABILITIES: ServerCapabilities;
-export declare function discoverResult(serverInfo: {
-    name: string;
-    version: string;
-}, instructions: string): Record<string, unknown>;
-export declare function wirePrimitives(server: Server, serverInfo: {
-    name: string;
-    version: string;
-}, instructions: string): void;
-//# sourceMappingURL=primitive-wiring.d.ts.map

package/dist/server/mcp-primitives/primitive-wiring.js

@@ -1,31 +0,0 @@
-import { CompleteRequestSchema, GetPromptRequestSchema, ListPromptsRequestSchema, SUPPORTED_PROTOCOL_VERSIONS, } from '@modelcontextprotocol/sdk/types.js';
-import { z } from 'zod';
-import { complete } from './completions.js';
-import { getPrompt, listPrompts } from './prompts.js';
-export const SERVER_CAPABILITIES = {
-    tools: {},
-    resources: {},
-    prompts: {},
-    completions: {},
-};
-const DiscoverRequestSchema = z.object({ method: z.literal('server/discover'), params: z.optional(z.looseObject({})) });
-export function discoverResult(serverInfo, instructions) {
-    return {
-        resultType: 'complete',
-        supportedVersions: [...SUPPORTED_PROTOCOL_VERSIONS],
-        capabilities: SERVER_CAPABILITIES,
-        instructions,
-        ttlMs: 3_600_000,
-        cacheScope: 'public',
-        _meta: { 'io.modelcontextprotocol/serverInfo': serverInfo },
-    };
-}
-export function wirePrimitives(server, serverInfo, instructions) {
-    server.setRequestHandler(ListPromptsRequestSchema, () => ({ prompts: listPrompts() }));
-    server.setRequestHandler(GetPromptRequestSchema, (request) => getPrompt(request.params.name, request.params.arguments ?? {}));
-    server.setRequestHandler(CompleteRequestSchema, (request) => ({
-        completion: complete(request.params.ref, request.params.argument.name, request.params.argument.value),
-    }));
-    server.setRequestHandler(DiscoverRequestSchema, () => discoverResult(serverInfo, instructions));
-}
-//# sourceMappingURL=primitive-wiring.js.map

package/dist/server/mcp-primitives/progress/progress-reporter.d.ts

@@ -1,33 +0,0 @@
-import type { ProgressToken } from './progress-token.js';
-export declare const MAX_PROGRESS_NOTIFICATIONS = 64;
-export declare const MAX_PROGRESS_MESSAGE_LENGTH = 512;
-export interface ProgressNotification {
-    readonly method: 'notifications/progress';
-    readonly params: {
-        readonly progressToken: ProgressToken;
-        readonly progress: number;
-        readonly total?: number;
-        readonly message?: string;
-    };
-}
-export interface ProgressUpdate {
-    readonly progress: number;
-    readonly total?: number;
-    readonly message?: string;
-}
-export type ProgressNotifier = (notification: ProgressNotification) => Promise<void>;
-export interface ProgressReporter {
-    report(update: ProgressUpdate): void;
-    close(): void;
-    drain(): Promise<void>;
-    readonly sent: number;
-    readonly active: boolean;
-}
-export interface CreateProgressReporterOptions {
-    readonly token: ProgressToken | undefined;
-    readonly notify: ProgressNotifier;
-    readonly max?: number;
-    readonly onError?: (error: unknown) => void;
-}
-export declare function createProgressReporter(options: CreateProgressReporterOptions): ProgressReporter;
-//# sourceMappingURL=progress-reporter.d.ts.map

package/dist/server/mcp-primitives/progress/progress-reporter.js

@@ -1,50 +0,0 @@
-export const MAX_PROGRESS_NOTIFICATIONS = 64;
-export const MAX_PROGRESS_MESSAGE_LENGTH = 512;
-export function createProgressReporter(options) {
-    const { token, notify, onError } = options;
-    const max = options.max ?? MAX_PROGRESS_NOTIFICATIONS;
-    let lastProgress = Number.NEGATIVE_INFINITY;
-    let sent = 0;
-    let active = true;
-    let chain = Promise.resolve();
-    const accepts = (update) => active &&
-        sent < max &&
-        Number.isFinite(update.progress) &&
-        update.progress > lastProgress;
-    const buildParams = (activeToken, update) => ({
-        progressToken: activeToken,
-        progress: update.progress,
-        ...(Number.isFinite(update.total) ? { total: update.total } : {}),
-        ...(typeof update.message === 'string' && update.message.length > 0
-            ? { message: update.message.slice(0, MAX_PROGRESS_MESSAGE_LENGTH) }
-            : {}),
-    });
-    return {
-        report(update) {
-            if (token === undefined || !accepts(update))
-                return;
-            lastProgress = update.progress;
-            sent += 1;
-            const notification = {
-                method: 'notifications/progress',
-                params: buildParams(token, update),
-            };
-            chain = chain.then(() => notify(notification).then(() => undefined, (error) => {
-                onError?.(error);
-            }), () => undefined);
-        },
-        close() {
-            active = false;
-        },
-        drain() {
-            return chain;
-        },
-        get sent() {
-            return sent;
-        },
-        get active() {
-            return active;
-        },
-    };
-}
-//# sourceMappingURL=progress-reporter.js.map

package/dist/server/mcp-primitives/progress/progress-sink-registry.d.ts

@@ -1,17 +0,0 @@
-import type { ProgressReporter, ProgressUpdate } from './progress-reporter.js';
-export declare const MAX_TRACKED_PROGRESS_REQUESTS = 256;
-export interface ProgressSinkRegistryOptions {
-    readonly max?: number;
-}
-export declare class ProgressSinkRegistry {
-    private readonly sinks;
-    private readonly max;
-    constructor(options?: ProgressSinkRegistryOptions);
-    register(mcpRequestId: string, reporter: ProgressReporter): void;
-    report(mcpRequestId: string, update: ProgressUpdate): void;
-    unregister(mcpRequestId: string): void;
-    close(mcpRequestId: string): void;
-    clear(): void;
-    get size(): number;
-}
-//# sourceMappingURL=progress-sink-registry.d.ts.map

package/dist/server/mcp-primitives/progress/progress-sink-registry.js

@@ -1,35 +0,0 @@
-import { evictOldestUntilUnder } from '../../../utils/collections/bounded.js';
-export const MAX_TRACKED_PROGRESS_REQUESTS = 256;
-export class ProgressSinkRegistry {
-    sinks = new Map();
-    max;
-    constructor(options = {}) {
-        this.max = options.max ?? MAX_TRACKED_PROGRESS_REQUESTS;
-    }
-    register(mcpRequestId, reporter) {
-        if (mcpRequestId.length === 0)
-            return;
-        this.sinks.delete(mcpRequestId);
-        evictOldestUntilUnder(this.sinks, this.max);
-        this.sinks.set(mcpRequestId, reporter);
-    }
-    report(mcpRequestId, update) {
-        this.sinks.get(mcpRequestId)?.report(update);
-    }
-    unregister(mcpRequestId) {
-        this.sinks.delete(mcpRequestId);
-    }
-    close(mcpRequestId) {
-        this.sinks.get(mcpRequestId)?.close();
-        this.sinks.delete(mcpRequestId);
-    }
-    clear() {
-        for (const reporter of this.sinks.values())
-            reporter.close();
-        this.sinks.clear();
-    }
-    get size() {
-        return this.sinks.size;
-    }
-}
-//# sourceMappingURL=progress-sink-registry.js.map