@frontmcp/sdk 0.4.1 → 0.5.0

package/src/notification/notification.service.js

@@ -0,0 +1,727 @@
+"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);
+        // 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?.session?.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