@contextvm/sdk 0.1.30-rc.0 → 0.1.30-rc.2

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

@@ -13,13 +13,17 @@ const logger = createLogger('nostr-server-transport');
  */
 export class NostrServerTransport extends BaseNostrTransport {
     constructor(options) {
+        var _a, _b;
         super(options);
         this.clientSessions = new Map();
+        this.eventIdToClient = new Map(); // eventId -> clientPubkey
         this.isInitialized = false;
         this.serverInfo = options.serverInfo;
         this.isPublicServer = options.isPublicServer;
         this.allowedPublicKeys = options.allowedPublicKeys;
         this.excludedCapabilities = options.excludedCapabilities;
+        this.cleanupIntervalMs = (_a = options.cleanupIntervalMs) !== null && _a !== void 0 ? _a : 60000;
+        this.sessionTimeoutMs = (_b = options.sessionTimeoutMs) !== null && _b !== void 0 ? _b : 300000;
     }
     /**
      * Generates common tags from server information for use in Nostr events.
@@ -27,6 +31,9 @@ export class NostrServerTransport extends BaseNostrTransport {
      */
     generateCommonTags() {
         var _a, _b, _c, _d;
+        if (this.cachedCommonTags) {
+            return this.cachedCommonTags;
+        }
         const commonTags = [];
         if ((_a = this.serverInfo) === null || _a === void 0 ? void 0 : _a.name) {
             commonTags.push([NOSTR_TAGS.NAME, this.serverInfo.name]);
@@ -43,6 +50,7 @@ export class NostrServerTransport extends BaseNostrTransport {
         if (this.encryptionMode !== EncryptionMode.DISABLED) {
             commonTags.push([NOSTR_TAGS.SUPPORT_ENCRYPTION]);
         }
+        this.cachedCommonTags = commonTags;
         return commonTags;
     }
     /**
@@ -50,24 +58,70 @@ export class NostrServerTransport extends BaseNostrTransport {
      * to receive incoming MCP requests.
      */
     async start() {
-        await this.connect();
-        const pubkey = await this.getPublicKey();
-        logger.info('Server pubkey:', pubkey);
-        // Subscribe to events targeting this server's public key
-        const filters = this.createSubscriptionFilters(pubkey);
-        await this.subscribe(filters, this.processIncomingEvent.bind(this));
-        if (this.isPublicServer) {
-            await this.getAnnouncementData();
+        var _a;
+        try {
+            await this.connect();
+            const pubkey = await this.getPublicKey();
+            logger.info('Server pubkey:', pubkey);
+            // Subscribe to events targeting this server's public key
+            const filters = this.createSubscriptionFilters(pubkey);
+            await this.subscribe(filters, async (event) => {
+                var _a;
+                try {
+                    await this.processIncomingEvent(event);
+                }
+                catch (error) {
+                    logger.error('Error processing incoming event', {
+                        error: error instanceof Error ? error.message : String(error),
+                        stack: error instanceof Error ? error.stack : undefined,
+                        eventId: event.id,
+                    });
+                    (_a = this.onerror) === null || _a === void 0 ? void 0 : _a.call(this, error instanceof Error ? error : new Error(String(error)));
+                }
+            });
+            if (this.isPublicServer) {
+                await this.getAnnouncementData();
+            }
+            // Start periodic cleanup of inactive sessions
+            this.cleanupInterval = setInterval(() => {
+                const cleaned = this.cleanupInactiveSessions();
+                if (cleaned > 0) {
+                    logger.info(`Cleaned up ${cleaned} inactive sessions`);
+                }
+            }, this.cleanupIntervalMs);
+        }
+        catch (error) {
+            logger.error('Error starting NostrServerTransport', {
+                error: error instanceof Error ? error.message : String(error),
+                stack: error instanceof Error ? error.stack : undefined,
+            });
+            (_a = this.onerror) === null || _a === void 0 ? void 0 : _a.call(this, error instanceof Error ? error : new Error(String(error)));
+            throw error;
         }
     }
     /**
      * Closes the transport, disconnecting from the relay.
      */
     async close() {
-        var _a;
-        await this.disconnect();
-        this.clientSessions.clear();
-        (_a = this.onclose) === null || _a === void 0 ? void 0 : _a.call(this);
+        var _a, _b;
+        try {
+            // Clear the cleanup interval
+            if (this.cleanupInterval) {
+                clearInterval(this.cleanupInterval);
+                this.cleanupInterval = undefined;
+            }
+            await this.disconnect();
+            this.clientSessions.clear();
+            (_a = this.onclose) === null || _a === void 0 ? void 0 : _a.call(this);
+        }
+        catch (error) {
+            logger.error('Error closing NostrServerTransport', {
+                error: error instanceof Error ? error.message : String(error),
+                stack: error instanceof Error ? error.stack : undefined,
+            });
+            (_b = this.onerror) === null || _b === void 0 ? void 0 : _b.call(this, error instanceof Error ? error : new Error(String(error)));
+            throw error;
+        }
     }
     /**
      * Sends JSON-RPC messages over the Nostr transport.
@@ -80,7 +134,6 @@ export class NostrServerTransport extends BaseNostrTransport {
             await this.handleResponse(message);
         }
         else if (isJSONRPCNotification(message)) {
-            this.cleanupInactiveSessions();
             await this.handleNotification(message);
         }
         else {
@@ -111,7 +164,17 @@ export class NostrServerTransport extends BaseNostrTransport {
             };
             // Collect events using the subscribe method with onEvent hook
             await this.relayHandler.subscribe([filter], (event) => {
-                events.push(event);
+                var _a;
+                try {
+                    events.push(event);
+                }
+                catch (error) {
+                    logger.error('Error in relay subscription event collection', {
+                        error: error instanceof Error ? error.message : String(error),
+                        eventId: event.id,
+                    });
+                    (_a = this.onerror) === null || _a === void 0 ? void 0 : _a.call(this, error instanceof Error ? error : new Error(String(error)));
+                }
             });
             if (!events.length) {
                 logger.info(`No events found for kind ${kind} to delete`);
@@ -136,43 +199,52 @@ export class NostrServerTransport extends BaseNostrTransport {
      * the initialize request, waiting for the response, and then proceeding with other announcements.
      */
     async getAnnouncementData() {
-        var _a, _b;
-        const initializeParams = {
-            protocolVersion: LATEST_PROTOCOL_VERSION,
-            capabilities: {},
-            clientInfo: {
-                name: 'DummyClient',
-                version: '1.0.0',
-            },
-        };
-        // Send the initialize request if not already initialized
-        if (!this.isInitialized) {
-            const initializeMessage = {
-                jsonrpc: '2.0',
-                id: 'announcement',
-                method: 'initialize',
-                params: initializeParams,
-            };
-            logger.info('Sending initialize request for announcement');
-            (_a = this.onmessage) === null || _a === void 0 ? void 0 : _a.call(this, initializeMessage);
-        }
+        var _a, _b, _c;
         try {
-            // Wait for initialization to complete
-            await this.waitForInitialization();
-            // Send all announcements now that we're initialized
-            for (const [key, methodValue] of Object.entries(announcementMethods)) {
-                logger.info('Sending announcement', { key, methodValue });
-                const message = {
+            const initializeParams = {
+                protocolVersion: LATEST_PROTOCOL_VERSION,
+                capabilities: {},
+                clientInfo: {
+                    name: 'DummyClient',
+                    version: '1.0.0',
+                },
+            };
+            // Send the initialize request if not already initialized
+            if (!this.isInitialized) {
+                const initializeMessage = {
                     jsonrpc: '2.0',
                     id: 'announcement',
-                    method: methodValue,
-                    params: key === 'server' ? initializeParams : {},
+                    method: 'initialize',
+                    params: initializeParams,
                 };
-                (_b = this.onmessage) === null || _b === void 0 ? void 0 : _b.call(this, message);
+                logger.info('Sending initialize request for announcement');
+                (_a = this.onmessage) === null || _a === void 0 ? void 0 : _a.call(this, initializeMessage);
+            }
+            try {
+                // Wait for initialization to complete
+                await this.waitForInitialization();
+                // Send all announcements now that we're initialized
+                for (const [key, methodValue] of Object.entries(announcementMethods)) {
+                    logger.info('Sending announcement', { key, methodValue });
+                    const message = {
+                        jsonrpc: '2.0',
+                        id: 'announcement',
+                        method: methodValue,
+                        params: key === 'server' ? initializeParams : {},
+                    };
+                    (_b = this.onmessage) === null || _b === void 0 ? void 0 : _b.call(this, message);
+                }
+            }
+            catch (error) {
+                logger.warn('Server not initialized after waiting, skipping announcements', { error: error instanceof Error ? error.message : error });
             }
         }
         catch (error) {
-            logger.warn('Server not initialized after waiting, skipping announcements', { error: error instanceof Error ? error.message : error });
+            logger.error('Error in getAnnouncementData', {
+                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)));
         }
     }
     /**
@@ -181,13 +253,18 @@ export class NostrServerTransport extends BaseNostrTransport {
      * The method will always resolve, allowing announcements to proceed.
      */
     async waitForInitialization() {
-        const startTime = Date.now();
-        const timeoutMs = 10000; // 10 seconds timeout
-        while (!this.isInitialized && Date.now() - startTime < timeoutMs) {
-            await new Promise((resolve) => setTimeout(resolve, 100));
+        if (this.isInitialized)
+            return;
+        if (!this.initializationPromise) {
+            this.initializationPromise = new Promise((resolve) => {
+                this.initializationResolver = resolve;
+            });
+        }
+        const timeout = new Promise((_, reject) => setTimeout(() => reject(new Error('Initialization timeout')), 10000));
+        try {
+            await Promise.race([this.initializationPromise, timeout]);
         }
-        // Log warning if not initialized but don't throw error
-        if (!this.isInitialized) {
+        catch (_a) {
             logger.warn('Server initialization not completed within timeout, proceeding with announcements');
         }
     }
@@ -197,33 +274,43 @@ export class NostrServerTransport extends BaseNostrTransport {
      * @param message The JSON-RPC response containing the announcement data.
      */
     async announcer(message) {
-        const recipientPubkey = await this.getPublicKey();
-        const commonTags = this.generateCommonTags();
-        const announcementMapping = [
-            {
-                schema: InitializeResultSchema,
-                kind: SERVER_ANNOUNCEMENT_KIND,
-                tags: commonTags,
-            },
-            { schema: ListToolsResultSchema, kind: TOOLS_LIST_KIND, tags: [] },
-            {
-                schema: ListResourcesResultSchema,
-                kind: RESOURCES_LIST_KIND,
-                tags: [],
-            },
-            {
-                schema: ListResourceTemplatesResultSchema,
-                kind: RESOURCETEMPLATES_LIST_KIND,
-                tags: [],
-            },
-            { schema: ListPromptsResultSchema, kind: PROMPTS_LIST_KIND, tags: [] },
-        ];
-        for (const mapping of announcementMapping) {
-            if (mapping.schema.safeParse(message.result).success) {
-                await this.sendMcpMessage(message.result, recipientPubkey, mapping.kind, mapping.tags);
-                break;
+        var _a;
+        try {
+            const recipientPubkey = await this.getPublicKey();
+            const commonTags = this.generateCommonTags();
+            const announcementMapping = [
+                {
+                    schema: InitializeResultSchema,
+                    kind: SERVER_ANNOUNCEMENT_KIND,
+                    tags: commonTags,
+                },
+                { schema: ListToolsResultSchema, kind: TOOLS_LIST_KIND, tags: [] },
+                {
+                    schema: ListResourcesResultSchema,
+                    kind: RESOURCES_LIST_KIND,
+                    tags: [],
+                },
+                {
+                    schema: ListResourceTemplatesResultSchema,
+                    kind: RESOURCETEMPLATES_LIST_KIND,
+                    tags: [],
+                },
+                { schema: ListPromptsResultSchema, kind: PROMPTS_LIST_KIND, tags: [] },
+            ];
+            for (const mapping of announcementMapping) {
+                if (mapping.schema.safeParse(message.result).success) {
+                    await this.sendMcpMessage(message.result, recipientPubkey, mapping.kind, mapping.tags);
+                    break;
+                }
             }
         }
+        catch (error) {
+            logger.error('Error in announcer', {
+                error: error instanceof Error ? error.message : String(error),
+                stack: error instanceof Error ? error.stack : undefined,
+            });
+            (_a = this.onerror) === null || _a === void 0 ? void 0 : _a.call(this, error instanceof Error ? error : new Error(String(error)));
+        }
     }
     /**
      * Gets or creates a client session with proper initialization.
@@ -240,6 +327,7 @@ export class NostrServerTransport extends BaseNostrTransport {
                 isEncrypted,
                 lastActivity: now,
                 pendingRequests: new Map(),
+                eventToProgressToken: new Map(),
             };
             this.clientSessions.set(clientPubkey, newSession);
             return newSession;
@@ -253,7 +341,7 @@ export class NostrServerTransport extends BaseNostrTransport {
      * @param eventId The Nostr event ID.
      * @param request The request message.
      */
-    handleIncomingRequest(session, eventId, request) {
+    handleIncomingRequest(session, eventId, request, clientPubkey) {
         var _a, _b;
         // Store the original request ID for later restoration
         const originalRequestId = request.id;
@@ -261,10 +349,13 @@ export class NostrServerTransport extends BaseNostrTransport {
         request.id = eventId;
         // Store in client session
         session.pendingRequests.set(eventId, originalRequestId);
+        this.eventIdToClient.set(eventId, clientPubkey);
         // Track progress tokens if provided
         const progressToken = (_b = (_a = request.params) === null || _a === void 0 ? void 0 : _a._meta) === null || _b === void 0 ? void 0 : _b.progressToken;
         if (progressToken) {
-            session.pendingRequests.set(String(progressToken), eventId);
+            const tokenStr = String(progressToken);
+            session.pendingRequests.set(tokenStr, eventId);
+            session.eventToProgressToken.set(eventId, tokenStr);
         }
     }
     /**
@@ -283,48 +374,45 @@ export class NostrServerTransport extends BaseNostrTransport {
      * @param response The JSON-RPC response or error to send.
      */
     async handleResponse(response) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d, _e;
         // Handle special announcement responses
         if (response.id === 'announcement') {
             if (isJSONRPCResponse(response)) {
                 if (InitializeResultSchema.safeParse(response.result).success) {
                     this.isInitialized = true;
+                    (_a = this.initializationResolver) === null || _a === void 0 ? void 0 : _a.call(this); // Resolve waiting promise
                     // Send the initialized notification
                     const initializedNotification = {
                         jsonrpc: '2.0',
                         method: 'notifications/initialized',
                     };
-                    (_a = this.onmessage) === null || _a === void 0 ? void 0 : _a.call(this, initializedNotification);
+                    (_b = this.onmessage) === null || _b === void 0 ? void 0 : _b.call(this, initializedNotification);
                     logger.info('Initialized');
                 }
                 await this.announcer(response);
             }
             return;
         }
-        // Find the client session with this pending request
+        // Find the client session with this pending request using O(1) lookup
         const nostrEventId = response.id;
-        let targetClientPubkey;
-        let originalRequestId;
-        for (const [clientPubkey, session] of this.clientSessions.entries()) {
-            const originalId = session.pendingRequests.get(nostrEventId);
-            if (originalId !== undefined) {
-                targetClientPubkey = clientPubkey;
-                originalRequestId = originalId;
-                break;
-            }
-        }
-        if (!targetClientPubkey || originalRequestId === undefined) {
-            (_b = this.onerror) === null || _b === void 0 ? void 0 : _b.call(this, new Error(`No pending request found for response ID: ${response.id}`));
+        const targetClientPubkey = this.eventIdToClient.get(nostrEventId);
+        if (!targetClientPubkey) {
+            (_c = this.onerror) === null || _c === void 0 ? void 0 : _c.call(this, new Error(`No pending request found for response ID: ${response.id}`));
             return;
         }
-        // Restore the original request ID in the response
-        response.id = originalRequestId;
-        // Send the response back to the original requester
         const session = this.clientSessions.get(targetClientPubkey);
         if (!session) {
-            (_c = this.onerror) === null || _c === void 0 ? void 0 : _c.call(this, new Error(`No session found for client: ${targetClientPubkey}`));
+            (_d = this.onerror) === null || _d === void 0 ? void 0 : _d.call(this, new Error(`No session found for client: ${targetClientPubkey}`));
             return;
         }
+        const originalRequestId = session.pendingRequests.get(nostrEventId);
+        if (originalRequestId === undefined) {
+            (_e = this.onerror) === null || _e === void 0 ? void 0 : _e.call(this, new Error(`No original request ID found for response ID: ${response.id}`));
+            return;
+        }
+        // Restore the original request ID in the response
+        response.id = originalRequestId;
+        // Send the response back to the original requester
         const tags = this.createResponseTags(targetClientPubkey, nostrEventId);
         if (isJSONRPCResponse(response) &&
             InitializeResultSchema.safeParse(response.result).success &&
@@ -336,19 +424,13 @@ export class NostrServerTransport extends BaseNostrTransport {
         }
         await this.sendMcpMessage(response, targetClientPubkey, CTXVM_MESSAGES_KIND, tags, session.isEncrypted);
         // Clean up the pending request and any associated progress token
-        if (session) {
-            session.pendingRequests.delete(nostrEventId);
-            // Find and delete the corresponding progress token if it exists
-            let progressTokenToDelete;
-            for (const [key, value] of session.pendingRequests.entries()) {
-                if (value === nostrEventId) {
-                    progressTokenToDelete = key;
-                    break;
-                }
-            }
-            if (progressTokenToDelete !== undefined) {
-                session.pendingRequests.delete(String(progressTokenToDelete));
-            }
+        session.pendingRequests.delete(nostrEventId);
+        this.eventIdToClient.delete(nostrEventId);
+        // Clean up progress token if it exists
+        const progressToken = session.eventToProgressToken.get(nostrEventId);
+        if (progressToken) {
+            session.pendingRequests.delete(progressToken);
+            session.eventToProgressToken.delete(nostrEventId);
         }
     }
     /**
@@ -356,30 +438,60 @@ export class NostrServerTransport extends BaseNostrTransport {
      * @param notification The JSON-RPC notification to send.
      */
     async handleNotification(notification) {
-        var _a, _b, _c;
-        // 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' &&
-            ((_b = (_a = notification.params) === null || _a === void 0 ? void 0 : _a._meta) === null || _b === void 0 ? void 0 : _b.progressToken)) {
-            const token = String(notification.params._meta.progressToken);
-            for (const [clientPubkey, session] of this.clientSessions.entries()) {
-                if (session.pendingRequests.has(token)) {
-                    const nostrEventId = session.pendingRequests.get(token);
-                    await this.sendNotification(clientPubkey, notification, nostrEventId);
+        var _a, _b, _c, _d, _e;
+        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' &&
+                ((_b = (_a = notification.params) === null || _a === void 0 ? void 0 : _a._meta) === null || _b === void 0 ? void 0 : _b.progressToken)) {
+                const token = String(notification.params._meta.progressToken);
+                // Use reverse lookup map for O(1) progress token routing
+                // First find the session that has this progress token
+                let targetClientPubkey;
+                let nostrEventId;
+                for (const [clientPubkey, session] of this.clientSessions.entries()) {
+                    if (session.pendingRequests.has(token)) {
+                        nostrEventId = session.pendingRequests.get(token);
+                        targetClientPubkey = clientPubkey;
+                        break;
+                    }
+                }
+                if (targetClientPubkey && nostrEventId) {
+                    await this.sendNotification(targetClientPubkey, notification, nostrEventId);
                     return;
                 }
+                const error = new Error(`No client found for progress token: ${token}`);
+                logger.error('Progress token not found', { token });
+                (_c = this.onerror) === null || _c === void 0 ? void 0 : _c.call(this, error);
+                return;
             }
-            (_c = this.onerror) === null || _c === void 0 ? void 0 : _c.call(this, new Error(`No client found for progress token: ${token}`));
-            return;
-        }
-        const promises = [];
-        for (const [clientPubkey, session] of this.clientSessions.entries()) {
-            if (session.isInitialized) {
-                promises.push(this.sendNotification(clientPubkey, notification));
+            const promises = [];
+            for (const [clientPubkey, session] of this.clientSessions.entries()) {
+                if (session.isInitialized) {
+                    promises.push(this.sendNotification(clientPubkey, notification));
+                }
             }
+            try {
+                await Promise.all(promises);
+            }
+            catch (error) {
+                logger.error('Error broadcasting notification', {
+                    error: error instanceof Error ? error.message : String(error),
+                    method: isJSONRPCNotification(notification)
+                        ? notification.method
+                        : 'unknown',
+                });
+                (_d = this.onerror) === null || _d === void 0 ? void 0 : _d.call(this, error instanceof Error ? error : new Error(String(error)));
+            }
+        }
+        catch (error) {
+            logger.error('Error in handleNotification', {
+                error: error instanceof Error ? error.message : String(error),
+                stack: error instanceof Error ? error.stack : undefined,
+            });
+            (_e = this.onerror) === null || _e === void 0 ? void 0 : _e.call(this, error instanceof Error ? error : new Error(String(error)));
         }
-        await Promise.all(promises);
     }
     /**
      * Sends a notification to a specific client by their public key.
@@ -406,11 +518,23 @@ export class NostrServerTransport extends BaseNostrTransport {
      * @param event The incoming Nostr event.
      */
     async processIncomingEvent(event) {
-        if (event.kind === GIFT_WRAP_KIND) {
-            await this.handleEncryptedEvent(event);
+        var _a;
+        try {
+            if (event.kind === GIFT_WRAP_KIND) {
+                await this.handleEncryptedEvent(event);
+            }
+            else {
+                this.handleUnencryptedEvent(event);
+            }
         }
-        else {
-            this.handleUnencryptedEvent(event);
+        catch (error) {
+            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)));
         }
     }
     /**
@@ -429,6 +553,12 @@ export class NostrServerTransport extends BaseNostrTransport {
             this.authorizeAndProcessEvent(currentEvent, true);
         }
         catch (error) {
+            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'));
@@ -479,66 +609,93 @@ export class NostrServerTransport extends BaseNostrTransport {
      * @param isEncrypted Whether the original event was encrypted.
      */
     authorizeAndProcessEvent(event, isEncrypted) {
-        var _a, _b, _c, _d;
-        const mcpMessage = this.convertNostrEventToMcpMessage(event);
-        if (!mcpMessage) {
-            logger.error('Skipping invalid Nostr event with malformed JSON content');
-            return;
-        }
-        if ((_a = this.allowedPublicKeys) === null || _a === void 0 ? void 0 : _a.length) {
-            // Check if the message should bypass whitelisting due to excluded capabilities
-            const shouldBypassWhitelisting = ((_b = this.excludedCapabilities) === null || _b === void 0 ? void 0 : _b.length) &&
-                (isJSONRPCRequest(mcpMessage) || isJSONRPCNotification(mcpMessage)) &&
-                this.isCapabilityExcluded(mcpMessage.method, (_c = mcpMessage.params) === null || _c === void 0 ? void 0 : _c.name);
-            if (!this.allowedPublicKeys.includes(event.pubkey) &&
-                !shouldBypassWhitelisting) {
-                logger.error(`Unauthorized message from ${event.pubkey}, message: ${JSON.stringify(mcpMessage)}. Ignoring.`);
-                if (this.isPublicServer && 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).catch((err) => {
-                        var _a;
-                        (_a = this.onerror) === null || _a === void 0 ? void 0 : _a.call(this, new Error(`Failed to send unauthorized response: ${err}`));
-                    });
-                }
+        var _a, _b, _c, _d, _e;
+        try {
+            const mcpMessage = this.convertNostrEventToMcpMessage(event);
+            if (!mcpMessage) {
+                logger.error('Skipping invalid Nostr event with malformed JSON content', {
+                    eventId: event.id,
+                    pubkey: event.pubkey,
+                    content: event.content,
+                });
                 return;
             }
+            if ((_a = this.allowedPublicKeys) === null || _a === void 0 ? void 0 : _a.length) {
+                // Check if the message should bypass whitelisting due to excluded capabilities
+                const shouldBypassWhitelisting = ((_b = this.excludedCapabilities) === null || _b === void 0 ? void 0 : _b.length) &&
+                    (isJSONRPCRequest(mcpMessage) || isJSONRPCNotification(mcpMessage)) &&
+                    this.isCapabilityExcluded(mcpMessage.method, (_c = mcpMessage.params) === null || _c === void 0 ? void 0 : _c.name);
+                if (!this.allowedPublicKeys.includes(event.pubkey) &&
+                    !shouldBypassWhitelisting) {
+                    logger.error(`Unauthorized message from ${event.pubkey}, message: ${JSON.stringify(mcpMessage)}. Ignoring.`);
+                    if (this.isPublicServer && 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).catch((err) => {
+                            var _a;
+                            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 now = Date.now();
+            const session = this.getOrCreateClientSession(event.pubkey, now, isEncrypted);
+            session.lastActivity = now;
+            if (isJSONRPCRequest(mcpMessage)) {
+                this.handleIncomingRequest(session, event.id, mcpMessage, event.pubkey);
+            }
+            else if (isJSONRPCNotification(mcpMessage)) {
+                this.handleIncomingNotification(session, mcpMessage);
+            }
+            (_d = this.onmessage) === null || _d === void 0 ? void 0 : _d.call(this, mcpMessage);
         }
-        const now = Date.now();
-        const session = this.getOrCreateClientSession(event.pubkey, now, isEncrypted);
-        session.lastActivity = now;
-        if (isJSONRPCRequest(mcpMessage)) {
-            this.handleIncomingRequest(session, event.id, mcpMessage);
-        }
-        else if (isJSONRPCNotification(mcpMessage)) {
-            this.handleIncomingNotification(session, mcpMessage);
+        catch (error) {
+            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,
+            });
+            (_e = this.onerror) === null || _e === void 0 ? void 0 : _e.call(this, error instanceof Error ? error : new Error(String(error)));
         }
-        (_d = this.onmessage) === null || _d === void 0 ? void 0 : _d.call(this, mcpMessage);
     }
     /**
      * Cleans up inactive client sessions based on a timeout.
      * @param timeoutMs Timeout in milliseconds for considering a session inactive (default: 5 minutes).
      * @returns The number of sessions that were cleaned up.
      */
-    cleanupInactiveSessions(timeoutMs = 300000) {
+    cleanupInactiveSessions(timeoutMs) {
         const now = Date.now();
-        const keysToDelete = [];
+        const timeout = timeoutMs !== null && timeoutMs !== void 0 ? timeoutMs : this.sessionTimeoutMs;
+        let cleaned = 0;
         for (const [clientPubkey, session] of this.clientSessions.entries()) {
-            if (now - session.lastActivity > timeoutMs) {
-                keysToDelete.push(clientPubkey);
+            if (now - session.lastActivity > timeout) {
+                // Clean up reverse lookup mappings for this session
+                for (const eventId of session.pendingRequests.keys()) {
+                    this.eventIdToClient.delete(eventId);
+                }
+                // Clean up progress token mappings
+                for (const eventId of session.eventToProgressToken.keys()) {
+                    this.eventIdToClient.delete(eventId);
+                }
+                this.clientSessions.delete(clientPubkey);
+                cleaned++;
             }
         }
-        for (const key of keysToDelete) {
-            this.clientSessions.delete(key);
-        }
-        return keysToDelete.length;
+        return cleaned;
     }
 }
 //# sourceMappingURL=nostr-server-transport.js.map