@contextvm/sdk 0.11.8 → 0.11.9

package/dist/esm/transport/nostr-server-transport.js

@@ -1,9 +1,7 @@
-import { InitializeResultSchema, ListPromptsResultSchema, ListResourcesResultSchema, ListResourceTemplatesResultSchema, ListToolsResultSchema, isJSONRPCRequest, isJSONRPCNotification, isJSONRPCResultResponse, isJSONRPCErrorResponse, } from '@modelcontextprotocol/sdk/types.js';
+import { isJSONRPCNotification, isJSONRPCResultResponse, isJSONRPCErrorResponse, } from '@modelcontextprotocol/sdk/types.js';
 import { BaseNostrTransport, } from './base-nostr-transport.js';
-import { CTXVM_MESSAGES_KIND, DEFAULT_TIMEOUT_MS, EPHEMERAL_GIFT_WRAP_KIND, GIFT_WRAP_KIND, NOSTR_TAGS, NOTIFICATIONS_INITIALIZED_METHOD, decryptMessage, DEFAULT_LRU_SIZE, } from '../core/index.js';
-import { EncryptionMode, GiftWrapMode } from '../core/interfaces.js';
-import { verifyEvent } from 'nostr-tools/pure';
-import { injectClientPubkey, injectRequestEventId, withTimeout, } from '../core/utils/utils.js';
+import { CTXVM_MESSAGES_KIND, DEFAULT_TIMEOUT_MS, NOSTR_TAGS, DEFAULT_LRU_SIZE, } from '../core/index.js';
+import { withTimeout } from '../core/utils/utils.js';
 import { CorrelationStore } from './nostr-server/correlation-store.js';
 import { SessionStore } from './nostr-server/session-store.js';
 import { LruCache } from '../core/utils/lru-cache.js';
@@ -11,10 +9,14 @@ import { ApplesauceRelayPool } from '../relay/applesauce-relay-pool.js';
 import { AuthorizationPolicy, } from './nostr-server/authorization-policy.js';
 import { AnnouncementManager, } from './nostr-server/announcement-manager.js';
 import { OversizedTransferReceiver, } from './oversized-transfer/index.js';
-import { OpenStreamReceiver, OpenStreamWriter, buildOpenStreamAcceptFrame, buildOpenStreamAbortFrame, buildOpenStreamPingFrame, buildOpenStreamPongFrame, } from './open-stream/index.js';
 import { DEFAULT_CHUNK_SIZE, DEFAULT_OVERSIZED_THRESHOLD, } from './oversized-transfer/constants.js';
-import { learnPeerCapabilities } from './discovery-tags.js';
-import { sendAcceptFrame, sendOversizedServerResponse, } from './nostr-server/oversized-server-handler.js';
+import { ServerCapabilityNegotiator } from './capability-negotiator.js';
+import { InboundNotificationDispatcher } from './nostr-server/inbound-notification-dispatcher.js';
+import { OutboundResponseRouter } from './nostr-server/outbound-response-router.js';
+import { OutboundNotificationBroadcaster } from './nostr-server/outbound-notification-broadcaster.js';
+import { ServerOpenStreamFactory } from './nostr-server/open-stream-factory.js';
+import { ServerEventPipeline } from './nostr-server/event-pipeline.js';
+import { ServerInboundCoordinator } from './nostr-server/inbound-coordinator.js';
 /**
  * A server-side transport layer for CTXVM that uses Nostr events for communication.
  * This transport listens for incoming MCP requests via Nostr events and can send
@@ -23,7 +25,7 @@ import { sendAcceptFrame, sendOversizedServerResponse, } from './nostr-server/ov
  */
 export class NostrServerTransport extends BaseNostrTransport {
     constructor(options) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
         super('nostr-server-transport', options);
         this.inboundMiddlewares = [];
         this.listToolsResultTransformers = [];
@@ -34,14 +36,6 @@ export class NostrServerTransport extends BaseNostrTransport {
          * Used for gift-wrap envelopes (outer event ids) and decrypted inner events.
          */
         this.seenEventIds = new LruCache(DEFAULT_LRU_SIZE);
-        /** Pending final responses held until their CEP-41 stream terminates. */
-        this.pendingOpenStreamResponses = new Map();
-        /** Sessions logically evicted after CEP-41 probe timeout, retained only to flush deferred finals. */
-        this.pendingOpenStreamSessionEvictions = new Map();
-        /** Client pubkeys that should no longer receive new notifications. */
-        this.evictedOpenStreamClientPubkeys = new Set();
-        /** Active server-side CEP-41 writers keyed by inbound request event id. */
-        this.openStreamWriters = new Map();
         this.injectClientPubkey = (_a = options.injectClientPubkey) !== null && _a !== void 0 ? _a : false;
         this.shouldInjectRequestEventId = (_b = options.injectRequestEventId) !== null && _b !== void 0 ? _b : false;
         this.onClientSessionEvicted = options.onClientSessionEvicted;
@@ -120,56 +114,6 @@ export class NostrServerTransport extends BaseNostrTransport {
         this.oversizedChunkSize = (_g = ot === null || ot === void 0 ? void 0 : ot.chunkSizeBytes) !== null && _g !== void 0 ? _g : DEFAULT_CHUNK_SIZE;
         this.oversizedReceiver = new OversizedTransferReceiver((_h = ot === null || ot === void 0 ? void 0 : ot.policy) !== null && _h !== void 0 ? _h : {}, this.logger);
         this.openStreamEnabled = (_k = (_j = options.openStream) === null || _j === void 0 ? void 0 : _j.enabled) !== null && _k !== void 0 ? _k : false;
-        this.openStreamReceiver = new OpenStreamReceiver({
-            maxConcurrentStreams: (_m = (_l = options.openStream) === null || _l === void 0 ? void 0 : _l.policy) === null || _m === void 0 ? void 0 : _m.maxConcurrentStreams,
-            maxBufferedChunksPerStream: (_p = (_o = options.openStream) === null || _o === void 0 ? void 0 : _o.policy) === null || _p === void 0 ? void 0 : _p.maxBufferedChunksPerStream,
-            maxBufferedBytesPerStream: (_r = (_q = options.openStream) === null || _q === void 0 ? void 0 : _q.policy) === null || _r === void 0 ? void 0 : _r.maxBufferedBytesPerStream,
-            idleTimeoutMs: (_t = (_s = options.openStream) === null || _s === void 0 ? void 0 : _s.policy) === null || _t === void 0 ? void 0 : _t.idleTimeoutMs,
-            probeTimeoutMs: (_v = (_u = options.openStream) === null || _u === void 0 ? void 0 : _u.policy) === null || _v === void 0 ? void 0 : _v.probeTimeoutMs,
-            closeGracePeriodMs: (_x = (_w = options.openStream) === null || _w === void 0 ? void 0 : _w.policy) === null || _x === void 0 ? void 0 : _x.closeGracePeriodMs,
-            getSessionOptions: (progressToken) => {
-                let progress = 0;
-                return {
-                    sendPing: async (nonce) => {
-                        progress += 1;
-                        await this.sendNotification(progressToken, {
-                            jsonrpc: '2.0',
-                            method: 'notifications/progress',
-                            params: buildOpenStreamPingFrame({
-                                progressToken,
-                                progress,
-                                nonce,
-                            }),
-                        });
-                    },
-                    sendPong: async (nonce) => {
-                        progress += 1;
-                        await this.sendNotification(progressToken, {
-                            jsonrpc: '2.0',
-                            method: 'notifications/progress',
-                            params: buildOpenStreamPongFrame({
-                                progressToken,
-                                progress,
-                                nonce,
-                            }),
-                        });
-                    },
-                    sendAbort: async (reason) => {
-                        progress += 1;
-                        await this.sendNotification(progressToken, {
-                            jsonrpc: '2.0',
-                            method: 'notifications/progress',
-                            params: buildOpenStreamAbortFrame({
-                                progressToken,
-                                progress,
-                                reason,
-                            }),
-                        });
-                    },
-                };
-            },
-            logger: this.logger,
-        });
         // Advertise CEP-22 support so clients can skip the accept handshake.
         const internalCommonTags = [];
         if (this.oversizedEnabled) {
@@ -179,6 +123,97 @@ export class NostrServerTransport extends BaseNostrTransport {
             internalCommonTags.push([NOSTR_TAGS.SUPPORT_OPEN_STREAM]);
         }
         this.announcementManager.setInternalCommonTags(internalCommonTags);
+        this.capabilityNegotiator = new ServerCapabilityNegotiator({
+            getCommonTags: this.announcementManager.getCommonTags.bind(this.announcementManager),
+            composeOutboundTags: this.composeOutboundTags.bind(this),
+            giftWrapMode: this.giftWrapMode,
+        });
+        this.openStreamFactory = new ServerOpenStreamFactory({
+            openStreamEnabled: this.openStreamEnabled,
+            sendNotification: this.sendNotification.bind(this),
+            handleResponse: async (response) => {
+                await this.outboundResponseRouter.route(response);
+            },
+            sessionStore: this.sessionStore,
+            onClientSessionEvicted: this.onClientSessionEvicted,
+            correlationStore: this.correlationStore,
+            policy: (_l = options.openStream) === null || _l === void 0 ? void 0 : _l.policy,
+            logger: this.logger,
+        });
+        this.inboundCoordinator = new ServerInboundCoordinator({
+            sessionStore: this.sessionStore,
+            correlationStore: this.correlationStore,
+            authorizationPolicy: this.authorizationPolicy,
+            openStreamFactory: this.openStreamFactory,
+            inboundMiddlewares: this.inboundMiddlewares,
+            injectClientPubkey: this.injectClientPubkey,
+            shouldInjectRequestEventId: this.shouldInjectRequestEventId,
+            oversizedEnabled: this.oversizedEnabled,
+            openStreamEnabled: this.openStreamEnabled,
+            giftWrapMode: this.giftWrapMode,
+            sendMcpMessage: this.sendMcpMessage.bind(this),
+            createResponseTags: (clientPubkey, requestId) => this.createResponseTags(clientPubkey, String(requestId)),
+            getOrCreateClientSession: this.getOrCreateClientSession.bind(this),
+            forwardMessage: async (msg, clientPubkey) => {
+                var _a, _b;
+                (_a = this.onmessage) === null || _a === void 0 ? void 0 : _a.call(this, msg);
+                (_b = this.onmessageWithContext) === null || _b === void 0 ? void 0 : _b.call(this, msg, { clientPubkey });
+                return true;
+            },
+            logger: this.logger,
+            onerror: (error) => { var _a; return (_a = this.onerror) === null || _a === void 0 ? void 0 : _a.call(this, error); },
+        });
+        this.inboundNotificationDispatcher = new InboundNotificationDispatcher({
+            openStreamReceiver: this.openStreamFactory.getReceiver(),
+            oversizedReceiver: this.oversizedReceiver,
+            openStreamFactory: this.openStreamFactory,
+            correlationStore: this.correlationStore,
+            sendNotification: this.sendNotification.bind(this),
+            handleIncomingRequest: this.inboundCoordinator.handleIncomingRequest.bind(this.inboundCoordinator),
+            handleIncomingNotification: this.inboundCoordinator.handleIncomingNotification.bind(this.inboundCoordinator),
+            cleanupDroppedRequest: this.inboundCoordinator.cleanupDroppedRequest.bind(this.inboundCoordinator),
+            shouldInjectRequestEventId: this.shouldInjectRequestEventId,
+            injectClientPubkey: this.injectClientPubkey,
+            logger: this.logger,
+            onerror: (error) => { var _a; return (_a = this.onerror) === null || _a === void 0 ? void 0 : _a.call(this, error); },
+        });
+        this.inboundCoordinator.setNotificationDispatcher(this.inboundNotificationDispatcher);
+        this.outboundResponseRouter = new OutboundResponseRouter({
+            correlationStore: this.correlationStore,
+            sessionStore: this.sessionStore,
+            announcementManager: this.announcementManager,
+            openStreamFactory: this.openStreamFactory,
+            oversizedConfig: {
+                enabled: this.oversizedEnabled,
+                threshold: this.oversizedThreshold,
+                chunkSize: this.oversizedChunkSize,
+            },
+            applyListToolsResultTransformers: this.applyListToolsResultTransformers.bind(this),
+            buildOutboundTags: this.capabilityNegotiator.buildOutboundTags.bind(this.capabilityNegotiator),
+            createResponseTags: this.createResponseTags.bind(this),
+            chooseGiftWrapKind: this.capabilityNegotiator.chooseOutboundGiftWrapKind.bind(this.capabilityNegotiator),
+            sendMcpMessage: this.sendMcpMessage.bind(this),
+            measurePublishedMcpMessageSize: this.measurePublishedMcpMessageSize.bind(this),
+            resolveSafeOversizedChunkSize: this.resolveSafeOversizedChunkSize.bind(this),
+            logger: this.logger,
+            onerror: (error) => { var _a; return (_a = this.onerror) === null || _a === void 0 ? void 0 : _a.call(this, error); },
+        });
+        this.outboundNotificationBroadcaster = new OutboundNotificationBroadcaster({
+            correlationStore: this.correlationStore,
+            sessionStore: this.sessionStore,
+            sendNotification: this.sendNotification.bind(this),
+            enqueueTask: this.taskQueue.add.bind(this.taskQueue),
+            logger: this.logger,
+            onerror: (error) => { var _a; return (_a = this.onerror) === null || _a === void 0 ? void 0 : _a.call(this, error); },
+        });
+        this.eventPipeline = new ServerEventPipeline({
+            signer: this.signer,
+            seenEventIds: this.seenEventIds,
+            encryptionMode: this.encryptionMode,
+            giftWrapMode: this.giftWrapMode,
+            logger: this.logger,
+            onerror: (error) => { var _a; return (_a = this.onerror) === null || _a === void 0 ? void 0 : _a.call(this, error); },
+        });
     }
     /**
      * Sets extra tags to include in server announcement + initialize response events.
@@ -273,9 +308,8 @@ export class NostrServerTransport extends BaseNostrTransport {
             this.correlationStore.clear();
             this.seenEventIds.clear();
             this.oversizedReceiver.clear();
-            this.openStreamReceiver.clear();
-            this.pendingOpenStreamResponses.clear();
-            this.openStreamWriters.clear();
+            this.openStreamFactory.getReceiver().clear();
+            this.openStreamFactory.clear();
             (_a = this.onclose) === null || _a === void 0 ? void 0 : _a.call(this);
         }
         catch (error) {
@@ -332,39 +366,6 @@ export class NostrServerTransport extends BaseNostrTransport {
         }
         return session;
     }
-    takePendingServerDiscoveryTags(session) {
-        if (session.hasSentCommonTags) {
-            return [];
-        }
-        session.hasSentCommonTags = true;
-        return this.announcementManager.getCommonTags();
-    }
-    buildServerOutboundTags(params) {
-        const { baseTags, session, includeDiscovery = true, negotiationTags = [], } = params;
-        return this.composeOutboundTags({
-            baseTags,
-            discoveryTags: includeDiscovery
-                ? this.takePendingServerDiscoveryTags(session)
-                : [],
-            negotiationTags,
-        });
-    }
-    chooseServerOutboundGiftWrapKind(params) {
-        const { session, fallbackWrapKind } = params;
-        if (!session.isEncrypted) {
-            return undefined;
-        }
-        if (this.giftWrapMode === GiftWrapMode.EPHEMERAL) {
-            return EPHEMERAL_GIFT_WRAP_KIND;
-        }
-        if (this.giftWrapMode === GiftWrapMode.PERSISTENT) {
-            return GIFT_WRAP_KIND;
-        }
-        if (session.supportsEphemeralEncryption) {
-            return EPHEMERAL_GIFT_WRAP_KIND;
-        }
-        return fallbackWrapKind;
-    }
     getRelayUrls(relayHandler) {
         return relayHandler.getRelayUrls();
     }
@@ -391,108 +392,6 @@ export class NostrServerTransport extends BaseNostrTransport {
             });
         }
     }
-    /**
-     * Handles incoming requests with correlation tracking.
-     * @param eventId The Nostr event ID.
-     * @param request The request message.
-     * @param clientPubkey The client's public key.
-     */
-    handleIncomingRequest(event, eventId, request, clientPubkey, wrapKind) {
-        var _a, _b;
-        // Store the original request ID for later restoration
-        const originalRequestId = request.id;
-        // Use the unique Nostr event ID as the MCP request ID to avoid collisions
-        request.id = eventId;
-        // Register the event route in the correlation store
-        const progressToken = (_b = (_a = request.params) === null || _a === void 0 ? void 0 : _a._meta) === null || _b === void 0 ? void 0 : _b.progressToken;
-        this.correlationStore.registerEventRoute(eventId, clientPubkey, originalRequestId, progressToken ? String(progressToken) : undefined, wrapKind, this.shouldInjectRequestEventId ? event : undefined);
-        if (this.openStreamEnabled && progressToken) {
-            const writer = new OpenStreamWriter({
-                progressToken: String(progressToken),
-                publishFrame: async (frame) => {
-                    await this.sendNotification(clientPubkey, {
-                        jsonrpc: '2.0',
-                        method: 'notifications/progress',
-                        params: frame,
-                    });
-                    return undefined;
-                },
-                onClose: async () => {
-                    await this.flushPendingOpenStreamResponse(eventId);
-                },
-                onAbort: async (reason) => {
-                    await this.handleOpenStreamWriterAbort(clientPubkey, eventId, reason);
-                },
-            });
-            this.openStreamWriters.set(eventId, writer);
-        }
-    }
-    async flushPendingOpenStreamResponse(eventId) {
-        const pendingResponse = this.pendingOpenStreamResponses.get(eventId);
-        this.pendingOpenStreamResponses.delete(eventId);
-        this.openStreamWriters.delete(eventId);
-        if (!pendingResponse) {
-            return;
-        }
-        await this.handleResponse(pendingResponse);
-    }
-    async handleOpenStreamWriterAbort(clientPubkey, eventId, reason) {
-        if (reason === 'Probe timeout') {
-            const session = this.sessionStore.getSession(clientPubkey);
-            if (session) {
-                this.pendingOpenStreamSessionEvictions.set(eventId, {
-                    clientPubkey,
-                    session: { ...session },
-                });
-                this.evictedOpenStreamClientPubkeys.add(clientPubkey);
-            }
-            const removed = this.sessionStore.removeSession(clientPubkey);
-            if (removed || session) {
-                this.logger.info('Removed session after open-stream probe timeout', {
-                    clientPubkey,
-                    eventId,
-                });
-            }
-        }
-        await this.flushPendingOpenStreamResponse(eventId);
-    }
-    finalizePendingOpenStreamSessionEviction(eventId) {
-        const pendingEviction = this.pendingOpenStreamSessionEvictions.get(eventId);
-        if (!pendingEviction) {
-            return;
-        }
-        this.pendingOpenStreamSessionEvictions.delete(eventId);
-        this.evictedOpenStreamClientPubkeys.delete(pendingEviction.clientPubkey);
-    }
-    findEventIdByProgressToken(progressToken) {
-        for (const [clientPubkey] of this.sessionStore.getAllSessions()) {
-            const eventId = this.correlationStore.getEventIdByProgressToken(clientPubkey, progressToken);
-            if (eventId) {
-                return eventId;
-            }
-        }
-        return undefined;
-    }
-    /**
-     * Cleans up request correlation for a request that was dropped by middleware.
-     */
-    cleanupDroppedRequest(message) {
-        if (!isJSONRPCRequest(message)) {
-            return;
-        }
-        this.correlationStore.popEventRoute(String(message.id));
-    }
-    /**
-     * Handles incoming notifications.
-     * @param clientPubkey The client's public key.
-     * @param notification The notification message.
-     */
-    handleIncomingNotification(clientPubkey, notification) {
-        if (isJSONRPCNotification(notification) &&
-            notification.method === NOTIFICATIONS_INITIALIZED_METHOD) {
-            this.sessionStore.markInitialized(clientPubkey);
-        }
-    }
     /**
      * Handles response messages by finding the original request and routing back to client.
      * @param response The JSON-RPC response or error to send.
@@ -504,183 +403,14 @@ export class NostrServerTransport extends BaseNostrTransport {
         return this.listToolsAnnouncementTagsProducers.flatMap((producer) => producer(result));
     }
     async handleResponse(response) {
-        var _a, _b, _c;
-        // Handle special announcement responses
-        if (response.id === 'announcement') {
-            const wasHandled = await this.announcementManager.handleAnnouncementResponse(response);
-            if (wasHandled && isJSONRPCResultResponse(response)) {
-                if (InitializeResultSchema.safeParse(response.result).success) {
-                    this.logger.info('Initialized');
-                }
-            }
-            return;
-        }
-        // Find the event route using O(1) lookup
-        const nostrEventId = response.id;
-        const existingOpenStreamWriter = this.openStreamWriters.get(nostrEventId);
-        if (existingOpenStreamWriter && existingOpenStreamWriter.isActive) {
-            this.pendingOpenStreamResponses.set(nostrEventId, response);
-            return;
-        }
-        const route = this.correlationStore.popEventRoute(nostrEventId);
-        if (!route) {
-            (_a = this.onerror) === null || _a === void 0 ? void 0 : _a.call(this, new Error(`No pending request found for response ID: ${response.id}`));
-            return;
-        }
-        const pendingEviction = this.pendingOpenStreamSessionEvictions.get(nostrEventId);
-        const session = (_b = this.sessionStore.getSession(route.clientPubkey)) !== null && _b !== void 0 ? _b : pendingEviction === null || pendingEviction === void 0 ? void 0 : pendingEviction.session;
-        if (!session) {
-            (_c = this.onerror) === null || _c === void 0 ? void 0 : _c.call(this, new Error(`No session found for client: ${route.clientPubkey}`));
-            return;
-        }
-        const parsedListToolsResult = isJSONRPCResultResponse(response)
-            ? ListToolsResultSchema.safeParse(response.result)
-            : null;
-        const responseToSend = (parsedListToolsResult === null || parsedListToolsResult === void 0 ? void 0 : parsedListToolsResult.success)
-            ? {
-                ...response,
-                result: this.applyListToolsResultTransformers(parsedListToolsResult.data),
-            }
-            : response;
-        // Restore the original request ID in the response
-        responseToSend.id = route.originalRequestId;
-        // CEP-22 Oversized Transfer (proactive path for server responses)
-        if (this.oversizedEnabled &&
-            route.progressToken &&
-            session.supportsOversizedTransfer) {
-            // Serialize after restoring id so the client receives the original JSON-RPC id.
-            const serialized = JSON.stringify(responseToSend);
-            const continuationFrameTags = this.createResponseTags(route.clientPubkey, nostrEventId);
-            const startFrameTags = this.buildServerOutboundTags({
-                baseTags: continuationFrameTags,
-                session,
-            });
-            const giftWrapKind = this.chooseServerOutboundGiftWrapKind({
-                session,
-                fallbackWrapKind: route.wrapKind,
-            });
-            const publishedEventSize = await this.measurePublishedMcpMessageSize(responseToSend, route.clientPubkey, CTXVM_MESSAGES_KIND, startFrameTags, session.isEncrypted, giftWrapKind);
-            if (publishedEventSize > this.oversizedThreshold) {
-                const chunkSizeBytes = await this.resolveSafeOversizedChunkSize({
-                    desiredChunkSizeBytes: this.oversizedChunkSize,
-                    maxPublishedEventBytes: this.oversizedThreshold,
-                    recipientPublicKey: route.clientPubkey,
-                    kind: CTXVM_MESSAGES_KIND,
-                    progressToken: route.progressToken,
-                    progress: 2,
-                    tags: continuationFrameTags,
-                    isEncrypted: session.isEncrypted,
-                    giftWrapKind,
-                });
-                try {
-                    await sendOversizedServerResponse({
-                        serialized,
-                        clientPubkey: route.clientPubkey,
-                        progressToken: route.progressToken,
-                        startFrameTags,
-                        continuationFrameTags,
-                        isEncrypted: session.isEncrypted,
-                        giftWrapKind,
-                    }, {
-                        chunkSizeBytes,
-                    }, {
-                        sendMcpMessage: this.sendMcpMessage.bind(this),
-                        logger: this.logger,
-                    });
-                }
-                catch (error) {
-                    this.correlationStore.registerEventRoute(nostrEventId, route.clientPubkey, route.originalRequestId, route.progressToken, route.wrapKind);
-                    throw error;
-                }
-                finally {
-                    this.finalizePendingOpenStreamSessionEviction(nostrEventId);
-                }
-                return;
-            }
-        }
-        // Send the response back to the original requester
-        const tags = this.buildServerOutboundTags({
-            baseTags: this.createResponseTags(route.clientPubkey, nostrEventId),
-            session,
-        });
-        const giftWrapKind = this.chooseServerOutboundGiftWrapKind({
-            session,
-            fallbackWrapKind: route.wrapKind,
-        });
-        // Attach pricing tags to capability list responses so clients can access CEP-8 pricing
-        if (isJSONRPCResultResponse(responseToSend)) {
-            const result = responseToSend.result;
-            if (ListToolsResultSchema.safeParse(result).success ||
-                ListResourcesResultSchema.safeParse(result).success ||
-                ListResourceTemplatesResultSchema.safeParse(result).success ||
-                ListPromptsResultSchema.safeParse(result).success) {
-                tags.push(...this.announcementManager.getPricingTags());
-            }
-        }
-        try {
-            await this.sendMcpMessage(responseToSend, route.clientPubkey, CTXVM_MESSAGES_KIND, tags, session.isEncrypted, undefined, giftWrapKind);
-        }
-        catch (error) {
-            this.correlationStore.registerEventRoute(nostrEventId, route.clientPubkey, route.originalRequestId, route.progressToken, route.wrapKind);
-            throw error;
-        }
-        finally {
-            this.finalizePendingOpenStreamSessionEviction(nostrEventId);
-        }
+        await this.outboundResponseRouter.route(response);
     }
     /**
      * Handles notification messages with routing.
      * @param notification The JSON-RPC notification to send.
      */
     async handleNotification(notification) {
-        var _a, _b, _c;
-        try {
-            // Special handling for progress notifications
-            // TODO: Add handling for `notifications/resources/updated`, as they need to be associated with an id
-            if (isJSONRPCNotification(notification) &&
-                notification.method === 'notifications/progress' &&
-                ((_a = notification.params) === null || _a === void 0 ? void 0 : _a.progressToken)) {
-                const token = String(notification.params.progressToken);
-                const nostrEventId = this.findEventIdByProgressToken(token);
-                if (nostrEventId) {
-                    const route = this.correlationStore.getEventRoute(nostrEventId);
-                    if (route) {
-                        await this.sendNotification(route.clientPubkey, notification, nostrEventId);
-                        return;
-                    }
-                }
-                const error = new Error(`No client found for progress token: ${token}`);
-                this.logger.error('Progress token not found', { token });
-                (_b = this.onerror) === null || _b === void 0 ? void 0 : _b.call(this, error);
-                return;
-            }
-            // Use TaskQueue for outbound notification broadcasting to prevent event loop blocking
-            for (const [clientPubkey, session,] of this.sessionStore.getAllSessions()) {
-                if (session.isInitialized) {
-                    this.taskQueue.add(async () => {
-                        try {
-                            await this.sendNotification(clientPubkey, notification);
-                        }
-                        catch (error) {
-                            this.logger.error('Error sending notification', {
-                                error: error instanceof Error ? error.message : String(error),
-                                clientPubkey,
-                                method: isJSONRPCNotification(notification)
-                                    ? notification.method
-                                    : 'unknown',
-                            });
-                        }
-                    });
-                }
-            }
-        }
-        catch (error) {
-            this.logger.error('Error in handleNotification', {
-                error: error instanceof Error ? error.message : String(error),
-                stack: error instanceof Error ? error.stack : undefined,
-            });
-            (_c = this.onerror) === null || _c === void 0 ? void 0 : _c.call(this, error instanceof Error ? error : new Error(String(error)));
-        }
+        await this.outboundNotificationBroadcaster.broadcast(notification);
     }
     /**
      * Sends a notification to a specific client by their public key.
@@ -689,7 +419,7 @@ export class NostrServerTransport extends BaseNostrTransport {
      * @returns Promise that resolves when the notification is sent.
      */
     async sendNotification(clientPubkey, notification, correlatedEventId) {
-        if (this.evictedOpenStreamClientPubkeys.has(clientPubkey)) {
+        if (this.openStreamFactory.isClientEvicted(clientPubkey)) {
             throw new Error(`No active session found for client: ${clientPubkey}`);
         }
         const session = this.sessionStore.getSession(clientPubkey);
@@ -700,11 +430,11 @@ export class NostrServerTransport extends BaseNostrTransport {
         if (correlatedEventId) {
             baseTags.push([NOSTR_TAGS.EVENT_ID, correlatedEventId]);
         }
-        const tags = this.buildServerOutboundTags({
+        const tags = this.capabilityNegotiator.buildOutboundTags({
             baseTags,
             session,
         });
-        const giftWrapKind = this.chooseServerOutboundGiftWrapKind({
+        const giftWrapKind = this.capabilityNegotiator.chooseOutboundGiftWrapKind({
             session,
         });
         await this.sendMcpMessage(notification, clientPubkey, CTXVM_MESSAGES_KIND, tags, session.isEncrypted, undefined, giftWrapKind);
@@ -716,369 +446,18 @@ export class NostrServerTransport extends BaseNostrTransport {
      * @param event The incoming Nostr event.
      */
     async processIncomingEvent(event) {
-        var _a;
-        try {
-            if (event.kind === GIFT_WRAP_KIND ||
-                event.kind === EPHEMERAL_GIFT_WRAP_KIND) {
-                if (!this.isGiftWrapKindAllowed(event.kind)) {
-                    this.logger.debug('Skipping gift wrap due to GiftWrapMode policy', {
-                        eventId: event.id,
-                        kind: event.kind,
-                    });
-                    return;
-                }
-                // Deduplicate gift-wrap envelopes before any expensive decryption.
-                if (this.seenEventIds.has(event.id)) {
-                    this.logger.debug('Skipping duplicate gift-wrapped event', {
-                        eventId: event.id,
-                    });
-                    return;
-                }
-                this.seenEventIds.set(event.id, true);
-                await this.handleEncryptedEvent(event);
-            }
-            else {
-                await this.handleUnencryptedEvent(event);
-            }
-        }
-        catch (error) {
-            this.logger.error('Error in processIncomingEvent', {
-                error: error instanceof Error ? error.message : String(error),
-                stack: error instanceof Error ? error.stack : undefined,
-                eventId: event.id,
-                eventKind: event.kind,
-            });
-            (_a = this.onerror) === null || _a === void 0 ? void 0 : _a.call(this, error instanceof Error ? error : new Error(String(error)));
-        }
-    }
-    /**
-     * Handles encrypted (gift-wrapped) events.
-     * @param event The incoming gift-wrapped Nostr event.
-     */
-    async handleEncryptedEvent(event) {
-        var _a;
-        if (this.encryptionMode === EncryptionMode.DISABLED) {
-            this.logger.error(`Received encrypted message from ${event.pubkey} but encryption is disabled. Ignoring.`);
-            return;
-        }
-        try {
-            const decryptedJson = await withTimeout(decryptMessage(event, this.signer), DEFAULT_TIMEOUT_MS, 'Decrypt message timed out');
-            const currentEvent = JSON.parse(decryptedJson);
-            // Verify the inner event's cryptographic signature to prevent identity
-            // forgery. Without this check an attacker can place any pubkey inside
-            // the plaintext and bypass allowlists. (Fixes #64)
-            if (!verifyEvent(currentEvent)) {
-                this.logger.error('Rejecting decrypted inner event with invalid signature', {
-                    innerEventId: currentEvent.id,
-                    innerPubkey: currentEvent.pubkey,
-                    outerEventId: event.id,
-                });
-                return;
-            }
-            // Deduplicate decrypted inner events before authorization and dispatch.
-            if (this.seenEventIds.has(currentEvent.id)) {
-                this.logger.debug('Skipping duplicate decrypted inner event', {
-                    outerEventId: event.id,
-                    innerEventId: currentEvent.id,
-                });
-                return;
-            }
-            this.seenEventIds.set(currentEvent.id, true);
-            await this.authorizeAndProcessEvent(currentEvent, true, event.kind);
-        }
-        catch (error) {
-            this.logger.error('Failed to handle encrypted Nostr event', {
-                error: error instanceof Error ? error.message : String(error),
-                stack: error instanceof Error ? error.stack : undefined,
-                eventId: event.id,
-                pubkey: event.pubkey,
-            });
-            (_a = this.onerror) === null || _a === void 0 ? void 0 : _a.call(this, error instanceof Error
-                ? error
-                : new Error('Failed to handle encrypted Nostr event'));
-        }
-    }
-    /**
-     * Handles unencrypted events.
-     * @param event The incoming Nostr event.
-     */
-    async handleUnencryptedEvent(event) {
-        if (this.encryptionMode === EncryptionMode.REQUIRED) {
-            this.logger.error(`Received unencrypted message from ${event.pubkey} but encryption is required. Ignoring.`);
-            return;
-        }
-        if (!verifyEvent(event)) {
-            this.logger.error('Rejecting unencrypted event with invalid signature', {
-                eventId: event.id,
-                pubkey: event.pubkey,
-            });
-            return;
-        }
-        await this.authorizeAndProcessEvent(event, false);
-    }
-    /**
-     * Authorizes and processes an incoming Nostr event, handling message validation,
-     * client authorization, session management, and optional client public key injection.
-     * @param event The Nostr event to process.
-     * @param isEncrypted Whether the original event was encrypted.
-     */
-    async authorizeAndProcessEvent(event, isEncrypted, wrapKind) {
-        var _a, _b, _c, _d, _e, _f, _g, _h;
-        try {
-            const mcpMessage = this.convertNostrEventToMcpMessage(event);
+        const unwrapped = await this.eventPipeline.unwrap(event);
+        if (unwrapped) {
+            const mcpMessage = this.convertNostrEventToMcpMessage(unwrapped.event);
             if (!mcpMessage) {
                 this.logger.error('Skipping invalid Nostr event with malformed JSON content', {
-                    eventId: event.id,
-                    pubkey: event.pubkey,
-                    content: event.content,
+                    eventId: unwrapped.event.id,
+                    pubkey: unwrapped.event.pubkey,
+                    content: unwrapped.event.content,
                 });
                 return;
             }
-            const inboundMessage = mcpMessage;
-            // Check authorization using the authorization policy
-            const authDecision = await this.authorizationPolicy.authorize(event.pubkey, mcpMessage);
-            if (!authDecision.allowed) {
-                this.logger.error(`Unauthorized message from ${event.pubkey}, message: ${JSON.stringify(mcpMessage)}. Ignoring.`);
-                if ('shouldReplyUnauthorized' in authDecision &&
-                    authDecision.shouldReplyUnauthorized &&
-                    isJSONRPCRequest(mcpMessage)) {
-                    const errorResponse = {
-                        jsonrpc: '2.0',
-                        id: mcpMessage.id,
-                        error: {
-                            code: -32000,
-                            message: 'Unauthorized',
-                        },
-                    };
-                    const tags = this.createResponseTags(event.pubkey, event.id);
-                    this.sendMcpMessage(errorResponse, event.pubkey, CTXVM_MESSAGES_KIND, tags, isEncrypted, undefined, isEncrypted
-                        ? this.giftWrapMode === GiftWrapMode.EPHEMERAL
-                            ? EPHEMERAL_GIFT_WRAP_KIND
-                            : this.giftWrapMode === GiftWrapMode.PERSISTENT
-                                ? GIFT_WRAP_KIND
-                                : wrapKind
-                        : undefined).catch((err) => {
-                        var _a;
-                        this.logger.error('Failed to send unauthorized response', {
-                            error: err instanceof Error ? err.message : String(err),
-                            pubkey: event.pubkey,
-                            eventId: event.id,
-                        });
-                        (_a = this.onerror) === null || _a === void 0 ? void 0 : _a.call(this, new Error(`Failed to send unauthorized response: ${err}`));
-                    });
-                }
-                return;
-            }
-            const session = this.getOrCreateClientSession(event.pubkey, isEncrypted);
-            const hadLearnedOversizedSupport = session.supportsOversizedTransfer;
-            const discoveredCapabilities = learnPeerCapabilities(event.tags);
-            session.supportsEncryption || (session.supportsEncryption = discoveredCapabilities.supportsEncryption);
-            session.supportsEphemeralEncryption || (session.supportsEphemeralEncryption = discoveredCapabilities.supportsEphemeralEncryption);
-            session.supportsOversizedTransfer || (session.supportsOversizedTransfer = this.oversizedEnabled &&
-                discoveredCapabilities.supportsOversizedTransfer);
-            session.supportsOpenStream || (session.supportsOpenStream = this.openStreamEnabled && discoveredCapabilities.supportsOpenStream);
-            const shouldSendAccept = !hadLearnedOversizedSupport;
-            const forward = async (msg) => {
-                var _a, _b;
-                (_a = this.onmessage) === null || _a === void 0 ? void 0 : _a.call(this, msg);
-                (_b = this.onmessageWithContext) === null || _b === void 0 ? void 0 : _b.call(this, msg, {
-                    clientPubkey: event.pubkey,
-                });
-                return true;
-            };
-            const clientPmis = event.tags
-                .filter((tag) => tag[0] === 'pmi' && typeof tag[1] === 'string')
-                .map((tag) => tag[1]);
-            const ctx = {
-                clientPubkey: event.pubkey,
-                clientPmis: clientPmis.length > 0 ? clientPmis : undefined,
-            };
-            const middlewares = this.inboundMiddlewares;
-            const dispatch = async (index, msg) => {
-                const mw = middlewares[index];
-                if (!mw) {
-                    return await forward(msg);
-                }
-                let forwarded = false;
-                await mw(msg, ctx, async (nextMsg) => {
-                    forwarded = await dispatch(index + 1, nextMsg);
-                });
-                return forwarded;
-            };
-            if (isJSONRPCRequest(inboundMessage)) {
-                this.handleIncomingRequest(event, event.id, inboundMessage, event.pubkey, wrapKind);
-                if (this.shouldInjectRequestEventId) {
-                    injectRequestEventId(inboundMessage, event.id);
-                }
-                if (this.injectClientPubkey) {
-                    injectClientPubkey(inboundMessage, event.pubkey);
-                }
-                const openStreamWriter = this.openStreamWriters.get(event.id);
-                if (openStreamWriter) {
-                    const params = (_a = inboundMessage.params) !== null && _a !== void 0 ? _a : {};
-                    inboundMessage.params = params;
-                    const meta = (_b = params._meta) !== null && _b !== void 0 ? _b : {};
-                    params._meta = meta;
-                    meta.stream = openStreamWriter;
-                }
-            }
-            else if (isJSONRPCNotification(inboundMessage)) {
-                this.handleIncomingNotification(event.pubkey, inboundMessage);
-                if (inboundMessage.method === 'notifications/progress' &&
-                    OpenStreamReceiver.isOpenStreamFrame(inboundMessage)) {
-                    const frame = (_c = inboundMessage.params) === null || _c === void 0 ? void 0 : _c.cvm;
-                    if ((frame === null || frame === void 0 ? void 0 : frame.frameType) === 'abort') {
-                        const progressToken = String((_e = (_d = inboundMessage.params) === null || _d === void 0 ? void 0 : _d.progressToken) !== null && _e !== void 0 ? _e : '');
-                        const eventId = this.correlationStore.getEventIdByProgressToken(event.pubkey, progressToken);
-                        const writer = eventId
-                            ? this.openStreamWriters.get(eventId)
-                            : undefined;
-                        if (writer) {
-                            void writer.abort(frame.reason).catch((err) => {
-                                var _a;
-                                this.logger.error('Open stream abort propagation failed (server)', {
-                                    error: err instanceof Error ? err.message : String(err),
-                                    pubkey: event.pubkey,
-                                    progressToken,
-                                });
-                                (_a = this.onerror) === null || _a === void 0 ? void 0 : _a.call(this, err instanceof Error ? err : new Error(String(err)));
-                            });
-                        }
-                        return;
-                    }
-                    if ((frame === null || frame === void 0 ? void 0 : frame.frameType) === 'ping') {
-                        const progressToken = String((_g = (_f = inboundMessage.params) === null || _f === void 0 ? void 0 : _f.progressToken) !== null && _g !== void 0 ? _g : '');
-                        const nonce = 'nonce' in frame && typeof frame.nonce === 'string'
-                            ? frame.nonce
-                            : '';
-                        const eventId = this.correlationStore.getEventIdByProgressToken(event.pubkey, progressToken);
-                        const writer = eventId
-                            ? this.openStreamWriters.get(eventId)
-                            : undefined;
-                        if (writer) {
-                            void writer.pong(nonce).catch((err) => {
-                                var _a;
-                                this.logger.error('Open stream ping handling failed (server)', {
-                                    error: err instanceof Error ? err.message : String(err),
-                                    pubkey: event.pubkey,
-                                    progressToken,
-                                });
-                                (_a = this.onerror) === null || _a === void 0 ? void 0 : _a.call(this, err instanceof Error ? err : new Error(String(err)));
-                            });
-                            return;
-                        }
-                    }
-                    this.openStreamReceiver
-                        .processFrame(inboundMessage)
-                        .then(async () => {
-                        var _a, _b, _c, _d;
-                        const frameType = frame === null || frame === void 0 ? void 0 : frame.frameType;
-                        if (frameType === 'start' && session.supportsOpenStream) {
-                            await this.sendNotification(event.pubkey, {
-                                jsonrpc: '2.0',
-                                method: 'notifications/progress',
-                                params: buildOpenStreamAcceptFrame({
-                                    progressToken: String((_b = (_a = inboundMessage.params) === null || _a === void 0 ? void 0 : _a.progressToken) !== null && _b !== void 0 ? _b : ''),
-                                    progress: Number((_d = (_c = inboundMessage.params) === null || _c === void 0 ? void 0 : _c.progress) !== null && _d !== void 0 ? _d : 0) + 1,
-                                }),
-                            });
-                        }
-                    })
-                        .catch((err) => {
-                        var _a;
-                        this.logger.error('Open stream error (server)', {
-                            error: err instanceof Error ? err.message : String(err),
-                            pubkey: event.pubkey,
-                        });
-                        (_a = this.onerror) === null || _a === void 0 ? void 0 : _a.call(this, err instanceof Error ? err : new Error(String(err)));
-                    });
-                    return;
-                }
-                if (inboundMessage.method === 'notifications/progress' &&
-                    OversizedTransferReceiver.isOversizedFrame(inboundMessage)) {
-                    this.oversizedReceiver
-                        .processFrame(inboundMessage)
-                        .then(async (synthetic) => {
-                        var _a, _b, _c, _d;
-                        if (synthetic === null) {
-                            if (((_b = (_a = inboundMessage.params) === null || _a === void 0 ? void 0 : _a.cvm) === null || _b === void 0 ? void 0 : _b.frameType) === 'start' &&
-                                shouldSendAccept) {
-                                await sendAcceptFrame({
-                                    clientPubkey: event.pubkey,
-                                    progressToken: String((_d = (_c = inboundMessage.params) === null || _c === void 0 ? void 0 : _c.progressToken) !== null && _d !== void 0 ? _d : ''),
-                                }, {
-                                    sendNotification: this.sendNotification.bind(this),
-                                }).catch((err) => {
-                                    this.logger.error('Failed to send oversized accept', {
-                                        error: err instanceof Error ? err.message : String(err),
-                                    });
-                                });
-                            }
-                            return;
-                        }
-                        if (isJSONRPCRequest(synthetic)) {
-                            this.handleIncomingRequest(event, event.id, synthetic, event.pubkey, wrapKind);
-                            if (this.shouldInjectRequestEventId) {
-                                injectRequestEventId(synthetic, event.id);
-                            }
-                            if (this.injectClientPubkey) {
-                                injectClientPubkey(synthetic, event.pubkey);
-                            }
-                        }
-                        else if (isJSONRPCNotification(synthetic)) {
-                            this.handleIncomingNotification(event.pubkey, synthetic);
-                        }
-                        void dispatch(0, synthetic)
-                            .then((forwarded) => {
-                            if (!forwarded) {
-                                this.cleanupDroppedRequest(synthetic);
-                            }
-                        })
-                            .catch((err) => {
-                            var _a;
-                            this.logger.error('Error dispatching reassembled oversized message', {
-                                error: err instanceof Error ? err.message : String(err),
-                                pubkey: event.pubkey,
-                            });
-                            (_a = this.onerror) === null || _a === void 0 ? void 0 : _a.call(this, err instanceof Error
-                                ? err
-                                : new Error('oversized dispatch failed'));
-                        });
-                    })
-                        .catch((err) => {
-                        var _a;
-                        this.logger.error('Oversized transfer error (server)', {
-                            error: err instanceof Error ? err.message : String(err),
-                        });
-                        (_a = this.onerror) === null || _a === void 0 ? void 0 : _a.call(this, err instanceof Error ? err : new Error(String(err)));
-                    });
-                    return;
-                }
-            }
-            void dispatch(0, inboundMessage)
-                .then((forwarded) => {
-                if (!forwarded) {
-                    this.cleanupDroppedRequest(inboundMessage);
-                }
-            })
-                .catch((err) => {
-                var _a;
-                this.logger.error('Error in inboundMiddleware chain', {
-                    error: err instanceof Error ? err.message : String(err),
-                    eventId: event.id,
-                    pubkey: event.pubkey,
-                });
-                (_a = this.onerror) === null || _a === void 0 ? void 0 : _a.call(this, err instanceof Error ? err : new Error('inboundMiddleware failed'));
-            });
-        }
-        catch (error) {
-            this.logger.error('Error in authorizeAndProcessEvent', {
-                error: error instanceof Error ? error.message : String(error),
-                stack: error instanceof Error ? error.stack : undefined,
-                eventId: event.id,
-                pubkey: event.pubkey,
-            });
-            (_h = this.onerror) === null || _h === void 0 ? void 0 : _h.call(this, error instanceof Error ? error : new Error(String(error)));
+            await this.inboundCoordinator.authorizeAndProcessEvent(unwrapped.event, unwrapped.isEncrypted, mcpMessage, unwrapped.wrapKind);
         }
     }
     /**
@@ -1090,10 +469,11 @@ export class NostrServerTransport extends BaseNostrTransport {
             sessionStore: this.sessionStore,
             correlationStore: this.correlationStore,
             oversizedReceiver: this.oversizedReceiver,
-            openStreamReceiver: this.openStreamReceiver,
-            pendingOpenStreamResponses: this.pendingOpenStreamResponses,
-            pendingOpenStreamSessionEvictions: this.pendingOpenStreamSessionEvictions,
-            openStreamWriters: this.openStreamWriters,
+            openStreamReceiver: this.openStreamFactory.getReceiver(),
+            openStreamWriters: this.openStreamFactory.getWritersMap(),
+            pendingOpenStreamResponses: this.openStreamFactory.getPendingResponsesMap(),
+            openStreamFactory: this.openStreamFactory,
+            inboundCoordinator: this.inboundCoordinator,
         };
     }
 }