@frontmcp/sdk 0.6.1 → 0.6.2

package/src/notification/notification.service.js

@@ -1,731 +0,0 @@
-"use strict";
-// file: libs/sdk/src/notification/notification.service.ts
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NotificationService = exports.MCP_LOGGING_LEVEL_PRIORITY = exports.MCP_APPS_EXTENSION_KEY = void 0;
-exports.hasMcpAppsExtension = hasMcpAppsExtension;
-exports.detectPlatformFromCapabilities = detectPlatformFromCapabilities;
-exports.detectPlatformFromUserAgent = detectPlatformFromUserAgent;
-exports.detectAIPlatform = detectAIPlatform;
-const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
-/**
- * MCP Apps extension key in capabilities.experimental
- */
-exports.MCP_APPS_EXTENSION_KEY = 'io.modelcontextprotocol/ui';
-/**
- * Check if client capabilities include MCP Apps extension.
- * @param capabilities - Client capabilities from initialize request
- * @returns true if the client supports MCP Apps
- */
-function hasMcpAppsExtension(capabilities) {
-    if (!capabilities?.experimental) {
-        return false;
-    }
-    const uiExtension = capabilities.experimental[exports.MCP_APPS_EXTENSION_KEY];
-    return uiExtension !== undefined && uiExtension !== null;
-}
-/**
- * Detect platform from client capabilities.
- * Checks for known extension capabilities before falling back to client info.
- * @param capabilities - Client capabilities from initialize request
- * @returns Platform type if detected from capabilities, undefined otherwise
- */
-function detectPlatformFromCapabilities(capabilities) {
-    if (hasMcpAppsExtension(capabilities)) {
-        return 'ext-apps';
-    }
-    return undefined;
-}
-/**
- * Match client name against custom mapping patterns.
- * @param clientName - The client name to match
- * @param mappings - Array of custom mapping entries
- * @returns The matched platform type, or undefined if no match
- */
-function matchCustomMappings(clientName, mappings) {
-    if (!mappings || mappings.length === 0) {
-        return undefined;
-    }
-    const lowerClientName = clientName.toLowerCase();
-    for (const mapping of mappings) {
-        if (typeof mapping.pattern === 'string') {
-            // Exact match (case-insensitive) - use RegExp for substring matching
-            if (lowerClientName === mapping.pattern.toLowerCase()) {
-                return mapping.platform;
-            }
-        }
-        else {
-            // RegExp match
-            if (mapping.pattern.test(clientName)) {
-                return mapping.platform;
-            }
-        }
-    }
-    return undefined;
-}
-/**
- * Default keyword-based platform detection.
- * Works with client names, user-agent strings, or any identifier.
- * @param identifier - The identifier to detect (clientInfo.name, user-agent, etc.)
- * @returns The detected platform type
- */
-function defaultPlatformDetection(identifier) {
-    const lowerIdentifier = identifier.toLowerCase();
-    // OpenAI/ChatGPT clients (includes user-agent like 'openai-mcp/1.0.0')
-    if (lowerIdentifier.includes('chatgpt') || lowerIdentifier.includes('openai') || lowerIdentifier.includes('gpt')) {
-        return 'openai';
-    }
-    // Claude clients
-    if (lowerIdentifier.includes('claude') || lowerIdentifier.includes('anthropic')) {
-        return 'claude';
-    }
-    // Google Gemini clients (use specific patterns to prevent false positives like "google-drive-connector")
-    if (lowerIdentifier.includes('gemini') ||
-        lowerIdentifier.includes('bard') ||
-        lowerIdentifier.includes('google-ai') ||
-        lowerIdentifier.includes('google ai')) {
-        return 'gemini';
-    }
-    // Cursor IDE
-    if (lowerIdentifier.includes('cursor')) {
-        return 'cursor';
-    }
-    // Continue.dev
-    if (lowerIdentifier.includes('continue')) {
-        return 'continue';
-    }
-    // Sourcegraph Cody
-    if (lowerIdentifier.includes('cody') || lowerIdentifier.includes('sourcegraph')) {
-        return 'cody';
-    }
-    // Generic MCP client (fallback for known MCP implementations)
-    if (lowerIdentifier.includes('mcp')) {
-        return 'generic-mcp';
-    }
-    return 'unknown';
-}
-/**
- * Detect platform from user-agent header.
- * Called during session creation before MCP initialize.
- *
- * @param userAgent - The User-Agent header value
- * @param config - Optional platform detection configuration
- * @returns The detected platform type
- */
-function detectPlatformFromUserAgent(userAgent, config) {
-    if (!userAgent) {
-        return 'unknown';
-    }
-    // Check custom mappings first
-    const customMatch = matchCustomMappings(userAgent, config?.mappings);
-    if (customMatch) {
-        return customMatch;
-    }
-    // If customOnly, don't use default detection
-    if (config?.customOnly) {
-        return 'unknown';
-    }
-    // Use default detection on user-agent
-    return defaultPlatformDetection(userAgent);
-}
-/**
- * Detect the AI platform type from client info.
- * Supports custom mappings that are checked before default detection.
- *
- * @param clientInfo - Client info from MCP initialize request
- * @param config - Optional platform detection configuration with custom mappings
- * @returns The detected platform type
- */
-function detectAIPlatform(clientInfo, config) {
-    if (!clientInfo?.name) {
-        return 'unknown';
-    }
-    // First, check custom mappings if provided
-    const customMatch = matchCustomMappings(clientInfo.name, config?.mappings);
-    if (customMatch) {
-        return customMatch;
-    }
-    // If customOnly is true, don't fall back to default detection
-    if (config?.customOnly) {
-        return 'unknown';
-    }
-    // Fall back to default keyword-based detection
-    return defaultPlatformDetection(clientInfo.name);
-}
-/**
- * MCP logging level priority (lower number = more verbose).
- * Uses LoggingLevel from MCP SDK for type safety.
- */
-exports.MCP_LOGGING_LEVEL_PRIORITY = {
-    debug: 0,
-    info: 1,
-    notice: 2,
-    warning: 3,
-    error: 4,
-    critical: 5,
-    alert: 6,
-    emergency: 7,
-};
-/**
- * NotificationService manages server→client notifications per MCP 2025-11-25 spec.
- *
- * It tracks all active MCP server instances and broadcasts notifications when
- * registries (resources, tools, prompts) change.
- *
- * It also manages resource subscriptions per session, allowing clients to
- * subscribe to specific resource URIs and receive notifications when they change.
- *
- * @example
- * ```typescript
- * // In LocalTransportAdapter after server.connect()
- * scope.notifications.registerServer(sessionId, this.server);
- *
- * // On session close
- * scope.notifications.unregisterServer(sessionId);
- *
- * // Resource subscriptions
- * scope.notifications.subscribeResource(sessionId, 'file://path/to/file');
- * scope.notifications.unsubscribeResource(sessionId, 'file://path/to/file');
- * ```
- */
-class NotificationService {
-    scope;
-    logger;
-    servers = new Map();
-    unsubscribers = [];
-    /** Maps session ID to set of subscribed resource URIs */
-    subscriptions = new Map();
-    /** Maps session ID to minimum log level for that session */
-    logLevels = new Map();
-    /**
-     * Set of terminated session IDs (for session invalidation on DELETE).
-     * Uses LRU-style eviction to prevent unbounded memory growth.
-     */
-    terminatedSessions = new Set();
-    /** Maximum number of terminated sessions to track before eviction */
-    static MAX_TERMINATED_SESSIONS = 10000;
-    constructor(scope) {
-        this.scope = scope;
-        this.logger = scope.logger.child('NotificationService');
-    }
-    /**
-     * Initialize the notification service and subscribe to registry changes.
-     * Called after all registries are ready.
-     */
-    async initialize() {
-        this.logger.verbose('Initializing notification service');
-        // Subscribe to resource changes
-        const unsubResources = this.scope.resources.subscribe({ immediate: false }, (event) => {
-            if (event.changeScope === 'global') {
-                this.broadcastNotification('notifications/resources/list_changed');
-            }
-        });
-        this.unsubscribers.push(unsubResources);
-        // Subscribe to tool changes
-        const unsubTools = this.scope.tools.subscribe({ immediate: false }, (event) => {
-            if (event.changeScope === 'global') {
-                this.broadcastNotification('notifications/tools/list_changed');
-            }
-        });
-        this.unsubscribers.push(unsubTools);
-        // Subscribe to prompt changes
-        const unsubPrompts = this.scope.prompts.subscribe({ immediate: false }, (event) => {
-            if (event.changeScope === 'global') {
-                this.broadcastNotification('notifications/prompts/list_changed');
-            }
-        });
-        this.unsubscribers.push(unsubPrompts);
-        this.logger.info('Notification service initialized with registry subscriptions');
-    }
-    /**
-     * Register an MCP server instance for receiving notifications.
-     * Call this when a transport connection is established.
-     *
-     * @param sessionId - Unique session identifier
-     * @param server - The MCP server instance
-     */
-    registerServer(sessionId, server) {
-        if (this.servers.has(sessionId)) {
-            this.logger.warn(`Server already registered for session: ${sessionId.slice(0, 20)}...`);
-            return;
-        }
-        this.servers.set(sessionId, {
-            sessionId,
-            server,
-            registeredAt: Date.now(),
-        });
-        this.logger.verbose(`Registered server for session: ${sessionId.slice(0, 20)}... (total: ${this.servers.size})`);
-    }
-    /**
-     * Unregister an MCP server instance.
-     * Call this when a transport connection is closed.
-     * Also cleans up any resource subscriptions for this session.
-     *
-     * @param sessionId - The session identifier to unregister
-     * @returns true if the server was registered and is now unregistered, false if not found
-     */
-    unregisterServer(sessionId) {
-        const deleted = this.servers.delete(sessionId);
-        // Clean up resource subscriptions for this session
-        const subCount = this.subscriptions.get(sessionId)?.size ?? 0;
-        this.subscriptions.delete(sessionId);
-        // Clean up log level setting for this session
-        const hadLogLevel = this.logLevels.delete(sessionId);
-        if (deleted) {
-            this.logger.verbose(`Unregistered server for session: ${sessionId.slice(0, 20)}... (remaining: ${this.servers.size}, cleaned ${subCount} subscription(s)${hadLogLevel ? ', removed log level' : ''})`);
-        }
-        return deleted;
-    }
-    /**
-     * Terminate a session. This adds the session ID to the terminated set,
-     * preventing further use of this session ID. This is called during DELETE
-     * session handling per MCP 2025-11-25 spec.
-     *
-     * Note: For stateless sessions (encrypted JWTs), the session ID cannot be
-     * truly "invalidated" cryptographically, but we track it in memory to reject
-     * future requests with this session ID on this server instance.
-     *
-     * @param sessionId - The session ID to terminate
-     * @returns true if the session was registered and is now terminated
-     */
-    terminateSession(sessionId) {
-        // First unregister the server (cleans up subscriptions, log levels, etc.)
-        const wasRegistered = this.unregisterServer(sessionId);
-        // Cleanup SESSION-scoped providers to prevent memory leak
-        // This is critical: without cleanup, terminated session providers remain cached forever
-        this.scope.providers.cleanupSession(sessionId);
-        this.logger.verbose(`Cleaned up provider cache for terminated session: ${sessionId.slice(0, 20)}...`);
-        // Add to terminated sessions set (even if not registered, to handle edge cases)
-        // Implement LRU-style eviction to prevent unbounded memory growth
-        if (this.terminatedSessions.size >= NotificationService.MAX_TERMINATED_SESSIONS) {
-            // Remove the oldest entry (first item in Set maintains insertion order)
-            const oldest = this.terminatedSessions.values().next().value;
-            if (oldest) {
-                this.terminatedSessions.delete(oldest);
-                this.logger.verbose(`Evicted oldest terminated session to make room: ${oldest.slice(0, 20)}...`);
-            }
-        }
-        this.terminatedSessions.add(sessionId);
-        this.logger.verbose(`Terminated session: ${sessionId.slice(0, 20)}... (total terminated: ${this.terminatedSessions.size})`);
-        return wasRegistered;
-    }
-    /**
-     * Check if a session has been terminated.
-     * Used during session verification to reject requests with terminated session IDs.
-     *
-     * @param sessionId - The session ID to check
-     * @returns true if the session has been terminated
-     */
-    isSessionTerminated(sessionId) {
-        return this.terminatedSessions.has(sessionId);
-    }
-    /**
-     * Broadcast a notification to all registered servers.
-     *
-     * @param method - The MCP notification method
-     * @param params - Optional notification parameters
-     */
-    broadcastNotification(method, params) {
-        if (this.servers.size === 0) {
-            this.logger.verbose(`No servers registered for notification: ${method}`);
-            return;
-        }
-        this.logger.verbose(`Broadcasting ${method} to ${this.servers.size} server(s)`);
-        for (const [sessionId, { server }] of this.servers) {
-            this.sendNotificationToServer(server, sessionId, method, params);
-        }
-    }
-    /**
-     * Send a notification to a specific session.
-     *
-     * @param sessionId - The target session
-     * @param method - The MCP notification method
-     * @param params - Optional notification parameters
-     */
-    sendNotificationToSession(sessionId, method, params) {
-        const registered = this.servers.get(sessionId);
-        if (!registered) {
-            this.logger.warn(`Cannot send notification to unregistered session: ${sessionId.slice(0, 20)}...`);
-            return;
-        }
-        this.sendNotificationToServer(registered.server, sessionId, method, params);
-    }
-    /**
-     * Subscribe a session to receive notifications when a specific resource changes.
-     *
-     * @param sessionId - The session to subscribe
-     * @param uri - The resource URI to subscribe to
-     * @returns true if this is a new subscription, false if already subscribed
-     */
-    subscribeResource(sessionId, uri) {
-        if (!this.servers.has(sessionId)) {
-            this.logger.warn(`Cannot subscribe unregistered session ${sessionId.slice(0, 20)}... to resource ${uri}`);
-            return false;
-        }
-        let sessionSubs = this.subscriptions.get(sessionId);
-        if (!sessionSubs) {
-            sessionSubs = new Set();
-            this.subscriptions.set(sessionId, sessionSubs);
-        }
-        const isNew = !sessionSubs.has(uri);
-        sessionSubs.add(uri);
-        if (isNew) {
-            this.logger.verbose(`Session ${sessionId.slice(0, 20)}... subscribed to resource ${uri}`);
-        }
-        return isNew;
-    }
-    /**
-     * Unsubscribe a session from a specific resource.
-     *
-     * @param sessionId - The session to unsubscribe
-     * @param uri - The resource URI to unsubscribe from
-     * @returns true if the subscription was removed, false if not subscribed
-     */
-    unsubscribeResource(sessionId, uri) {
-        const sessionSubs = this.subscriptions.get(sessionId);
-        if (!sessionSubs) {
-            return false;
-        }
-        const wasSubscribed = sessionSubs.delete(uri);
-        // Clean up empty subscription sets
-        if (sessionSubs.size === 0) {
-            this.subscriptions.delete(sessionId);
-        }
-        if (wasSubscribed) {
-            this.logger.verbose(`Session ${sessionId.slice(0, 20)}... unsubscribed from resource ${uri}`);
-        }
-        return wasSubscribed;
-    }
-    /**
-     * Check if a session is subscribed to a specific resource.
-     *
-     * @param sessionId - The session to check
-     * @param uri - The resource URI
-     * @returns true if subscribed
-     */
-    isSubscribed(sessionId, uri) {
-        return this.subscriptions.get(sessionId)?.has(uri) ?? false;
-    }
-    /**
-     * Get all sessions subscribed to a specific resource.
-     *
-     * @param uri - The resource URI
-     * @returns Array of session IDs subscribed to this resource
-     */
-    getSubscribersForResource(uri) {
-        const subscribers = [];
-        for (const [sessionId, uris] of this.subscriptions) {
-            if (uris.has(uri)) {
-                subscribers.push(sessionId);
-            }
-        }
-        return subscribers;
-    }
-    /**
-     * Send a resource update notification to subscribed sessions only.
-     * Per MCP 2025-11-25 spec, only sessions that have subscribed to this
-     * resource via `resources/subscribe` will receive the notification.
-     *
-     * @param uri - The resource URI that was updated
-     */
-    notifyResourceUpdated(uri) {
-        const subscribers = this.getSubscribersForResource(uri);
-        if (subscribers.length === 0) {
-            this.logger.verbose(`No subscribers for resource ${uri}, skipping notification`);
-            return;
-        }
-        this.logger.verbose(`Notifying ${subscribers.length} subscriber(s) of resource update: ${uri}`);
-        for (const sessionId of subscribers) {
-            this.sendNotificationToSession(sessionId, 'notifications/resources/updated', { uri });
-        }
-    }
-    /**
-     * Get the number of registered servers.
-     */
-    get serverCount() {
-        return this.servers.size;
-    }
-    /**
-     * Set the minimum log level for a session.
-     * Only log messages at or above this level will be sent to the session.
-     * Per MCP spec, the default level when not set is determined by the server.
-     *
-     * @param sessionId - The session to configure
-     * @param level - The minimum log level
-     * @returns true if the session was found and level was set
-     */
-    setLogLevel(sessionId, level) {
-        if (!this.servers.has(sessionId)) {
-            this.logger.warn(`Cannot set log level for unregistered session: ${sessionId.slice(0, 20)}...`);
-            return false;
-        }
-        this.logLevels.set(sessionId, level);
-        this.logger.verbose(`Set log level to '${level}' for session ${sessionId.slice(0, 20)}...`);
-        return true;
-    }
-    /**
-     * Get the current log level for a session.
-     *
-     * @param sessionId - The session to query
-     * @returns The log level, or undefined if not set
-     */
-    getLogLevel(sessionId) {
-        return this.logLevels.get(sessionId);
-    }
-    /**
-     * Send a log message to all sessions that have enabled the given level.
-     * Per MCP 2025-11-25 spec, this sends a 'notifications/message' notification
-     * to sessions whose configured minimum level allows this message through.
-     *
-     * @param level - The log level of this message
-     * @param loggerName - Optional logger name/component identifier
-     * @param data - The log message data (string or structured data)
-     */
-    sendLogMessage(level, loggerName, data) {
-        const messagePriority = exports.MCP_LOGGING_LEVEL_PRIORITY[level];
-        for (const [sessionId, { server }] of this.servers) {
-            const sessionLevel = this.logLevels.get(sessionId);
-            // If session hasn't set a level, skip (server decides default behavior)
-            // Here we default to NOT sending unless explicitly subscribed
-            if (!sessionLevel) {
-                continue;
-            }
-            const sessionPriority = exports.MCP_LOGGING_LEVEL_PRIORITY[sessionLevel];
-            // Only send if message level >= session's minimum level
-            if (messagePriority >= sessionPriority) {
-                const params = {
-                    level,
-                    data,
-                };
-                if (loggerName) {
-                    params['logger'] = loggerName;
-                }
-                this.sendNotificationToServer(server, sessionId, 'notifications/message', params);
-            }
-        }
-    }
-    /**
-     * Send a log message to a specific session, respecting its log level.
-     *
-     * @param sessionId - The target session
-     * @param level - The log level of this message
-     * @param loggerName - Optional logger name/component identifier
-     * @param data - The log message data
-     * @returns true if the message was sent (session exists and level allows)
-     */
-    sendLogMessageToSession(sessionId, level, loggerName, data) {
-        const registered = this.servers.get(sessionId);
-        if (!registered) {
-            return false;
-        }
-        const sessionLevel = this.logLevels.get(sessionId);
-        if (!sessionLevel) {
-            // Session hasn't enabled logging
-            return false;
-        }
-        const messagePriority = exports.MCP_LOGGING_LEVEL_PRIORITY[level];
-        const sessionPriority = exports.MCP_LOGGING_LEVEL_PRIORITY[sessionLevel];
-        if (messagePriority < sessionPriority) {
-            // Message level is too verbose for this session
-            return false;
-        }
-        const params = {
-            level,
-            data,
-        };
-        if (loggerName) {
-            params['logger'] = loggerName;
-        }
-        this.sendNotificationToServer(registered.server, sessionId, 'notifications/message', params);
-        return true;
-    }
-    // =====================================================
-    // Client Capabilities & Roots API (MCP 2025-11-25)
-    // =====================================================
-    /**
-     * Set client capabilities for a session.
-     * Called during initialization to store what the client supports.
-     *
-     * @param sessionId - The session to configure
-     * @param capabilities - The client's capabilities from the initialize request
-     * @returns true if the session was found and capabilities were set
-     */
-    setClientCapabilities(sessionId, capabilities) {
-        const registered = this.servers.get(sessionId);
-        if (!registered) {
-            this.logger.warn(`Cannot set client capabilities for unregistered session: ${sessionId.slice(0, 20)}...`);
-            return false;
-        }
-        registered.clientCapabilities = capabilities;
-        this.logger.verbose(`Set client capabilities for session ${sessionId.slice(0, 20)}...: roots.listChanged=${capabilities.roots?.listChanged ?? false}`);
-        return true;
-    }
-    /**
-     * Get client capabilities for a session.
-     *
-     * @param sessionId - The session to query
-     * @returns The client's capabilities, or undefined if not set
-     */
-    getClientCapabilities(sessionId) {
-        return this.servers.get(sessionId)?.clientCapabilities;
-    }
-    /**
-     * Set client info for a session and auto-detect the AI platform type.
-     * Called during initialization to store who the client is.
-     * Uses the scope's platform detection configuration for custom mappings.
-     *
-     * @param sessionId - The session to configure
-     * @param clientInfo - The client's info (name/version) from the initialize request
-     * @returns The detected platform type, or undefined if the session was not found
-     */
-    setClientInfo(sessionId, clientInfo) {
-        const registered = this.servers.get(sessionId);
-        if (!registered) {
-            this.logger.warn(`Cannot set client info for unregistered session: ${sessionId.slice(0, 20)}...`);
-            return undefined;
-        }
-        registered.clientInfo = clientInfo;
-        // Use platform detection config from scope if available
-        const platformDetectionConfig = this.scope.metadata.transport?.platformDetection;
-        registered.platformType = detectAIPlatform(clientInfo, platformDetectionConfig);
-        this.logger.verbose(`Set client info for session ${sessionId.slice(0, 20)}...: name=${clientInfo.name}, version=${clientInfo.version}, platform=${registered.platformType}`);
-        return registered.platformType;
-    }
-    /**
-     * Get client info for a session.
-     *
-     * @param sessionId - The session to query
-     * @returns The client's info, or undefined if not set
-     */
-    getClientInfo(sessionId) {
-        return this.servers.get(sessionId)?.clientInfo;
-    }
-    /**
-     * Get the detected AI platform type for a session.
-     * This is auto-detected from client info during initialization.
-     *
-     * @param sessionId - The session to query
-     * @returns The detected platform type, or 'unknown' if not detected
-     */
-    getPlatformType(sessionId) {
-        const session = this.servers.get(sessionId);
-        return session?.platformType ?? 'unknown';
-    }
-    /**
-     * Check if a session's client supports roots listing.
-     *
-     * @param sessionId - The session to check
-     * @returns true if the client supports roots
-     */
-    supportsRoots(sessionId) {
-        const capabilities = this.getClientCapabilities(sessionId);
-        return capabilities?.roots !== undefined;
-    }
-    /**
-     * List roots from the client for a session.
-     * This sends a `roots/list` request to the client and returns the roots.
-     *
-     * If the client doesn't support roots, returns an empty array.
-     * Results are cached and invalidated when `notifications/roots/list_changed` is received.
-     *
-     * @param sessionId - The session to request roots from
-     * @param options - Options for the request
-     * @param options.forceRefresh - If true, bypass the cache and fetch fresh roots
-     * @param options.timeout - Timeout in milliseconds (default: 30000)
-     * @returns Array of roots from the client
-     */
-    async listRoots(sessionId, options) {
-        const registered = this.servers.get(sessionId);
-        if (!registered) {
-            this.logger.warn(`Cannot list roots for unregistered session: ${sessionId.slice(0, 20)}...`);
-            return [];
-        }
-        // Check if client supports roots
-        if (!this.supportsRoots(sessionId)) {
-            this.logger.verbose(`Client for session ${sessionId.slice(0, 20)}... does not support roots`);
-            return [];
-        }
-        // Return cached roots if available and not forcing refresh
-        if (!options?.forceRefresh && registered.cachedRoots !== undefined) {
-            this.logger.verbose(`Returning cached roots for session ${sessionId.slice(0, 20)}... (${registered.cachedRoots.length} roots)`);
-            return registered.cachedRoots;
-        }
-        try {
-            this.logger.verbose(`Requesting roots from client for session ${sessionId.slice(0, 20)}...`);
-            // Send roots/list request to client
-            const result = await registered.server.request({ method: 'roots/list' }, types_js_1.ListRootsResultSchema, {
-                timeout: options?.timeout ?? 30000,
-            });
-            // Cache the result
-            registered.cachedRoots = result.roots;
-            registered.rootsFetchedAt = Date.now();
-            this.logger.verbose(`Received ${registered.cachedRoots.length} root(s) from client for session ${sessionId.slice(0, 20)}...`);
-            return registered.cachedRoots;
-        }
-        catch (error) {
-            this.logger.warn(`Failed to list roots for session ${sessionId.slice(0, 20)}...: ${error instanceof Error ? error.message : 'Unknown error'}`);
-            // Return cached roots if available, otherwise empty array
-            return registered.cachedRoots ?? [];
-        }
-    }
-    /**
-     * Invalidate cached roots for a session.
-     * Call this when receiving `notifications/roots/list_changed` from the client.
-     *
-     * @param sessionId - The session whose roots cache should be invalidated
-     * @returns true if the session was found and cache was invalidated
-     */
-    invalidateRootsCache(sessionId) {
-        const registered = this.servers.get(sessionId);
-        if (!registered) {
-            return false;
-        }
-        const hadCache = registered.cachedRoots !== undefined;
-        registered.cachedRoots = undefined;
-        registered.rootsFetchedAt = undefined;
-        if (hadCache) {
-            this.logger.verbose(`Invalidated roots cache for session ${sessionId.slice(0, 20)}...`);
-        }
-        return hadCache;
-    }
-    /**
-     * Get the cached roots for a session without fetching from the client.
-     *
-     * @param sessionId - The session to query
-     * @returns Cached roots, or undefined if not cached
-     */
-    getCachedRoots(sessionId) {
-        return this.servers.get(sessionId)?.cachedRoots;
-    }
-    /**
-     * Clean up subscriptions and resources.
-     */
-    async destroy() {
-        this.logger.verbose('Destroying notification service');
-        // Unsubscribe from all registry listeners
-        for (const unsub of this.unsubscribers) {
-            unsub();
-        }
-        this.unsubscribers.length = 0;
-        // Clear server registrations, resource subscriptions, log levels, and terminated sessions
-        this.servers.clear();
-        this.subscriptions.clear();
-        this.logLevels.clear();
-        this.terminatedSessions.clear();
-        this.logger.info('Notification service destroyed');
-    }
-    sendNotificationToServer(server, sessionId, method, params) {
-        try {
-            // MCP SDK's server.notification() sends a JSON-RPC notification
-            server.notification({ method, params: params ?? {} });
-            this.logger.verbose(`Sent ${method} to session ${sessionId.slice(0, 20)}...`);
-        }
-        catch (error) {
-            // Connection may have closed; log and continue
-            this.logger.warn(`Failed to send notification ${method} to session ${sessionId.slice(0, 20)}...: ${error instanceof Error ? error.message : 'Unknown error'}`);
-            // Optionally unregister dead sessions
-            this.unregisterServer(sessionId);
-        }
-    }
-}
-exports.NotificationService = NotificationService;
-//# sourceMappingURL=notification.service.js.map