@1mcp/agent 0.37.0 → 0.38.1

package/build/sdk/legacy/server/runtime/requestContextPreparation.js

@@ -0,0 +1,50 @@
+import { isOperatorDisabledTemplateDefinition } from '../../../../config/configuredServerTargets.js';
+import { resolveCanonicalSessionId, withCanonicalSessionId } from '../../../../utils/context/sessionIdentity.js';
+export async function prepareRequestContext(input) {
+    const { deps, context, filterConfig, transportSessionId } = input;
+    if (!context) {
+        return transportSessionId ? { status: 'routing_only', sessionId: transportSessionId } : { status: 'no_context' };
+    }
+    const sessionId = resolveCanonicalSessionId({
+        context,
+        transportSessionId,
+        deriveSessionId: deps.deriveSessionId,
+    });
+    const canonicalContext = withCanonicalSessionId(context, sessionId);
+    const renderedTemplates = await deps.loadRenderedTemplates(canonicalContext);
+    const templateEntries = Object.entries(renderedTemplates).filter(([_templateName, config]) => !isOperatorDisabledTemplateDefinition(config));
+    const templateNames = templateEntries.map(([templateName]) => templateName);
+    if (templateEntries.length === 0) {
+        return {
+            status: 'already_prepared',
+            sessionId,
+            templateNames,
+            createdTemplateNames: [],
+        };
+    }
+    for (const [templateName, config] of templateEntries) {
+        if (!deps.hasTemplateAdapter(templateName)) {
+            deps.registerTemplateAdapter(templateName, config);
+        }
+    }
+    const pendingTemplates = Object.fromEntries(templateEntries.filter(([templateName]) => !deps.getRenderedHashForSession(sessionId, templateName)));
+    const createdTemplateNames = Object.keys(pendingTemplates);
+    if (createdTemplateNames.length === 0) {
+        deps.touchEphemeralClient(sessionId);
+        return {
+            status: 'already_prepared',
+            sessionId,
+            templateNames,
+            createdTemplateNames,
+        };
+    }
+    await deps.createTemplateBasedServers(sessionId, canonicalContext, filterConfig, { mcpTemplates: pendingTemplates }, deps.getOutboundConnections(), deps.getClientTransports(), 'ephemeral');
+    await deps.refreshCapabilities();
+    return {
+        status: 'prepared',
+        sessionId,
+        templateNames,
+        createdTemplateNames,
+    };
+}
+//# sourceMappingURL=requestContextPreparation.js.map

package/build/sdk/legacy/server/runtime/requestContextPreparation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"requestContextPreparation.js","sourceRoot":"","sources":["../../../../../src/sdk/legacy/server/runtime/requestContextPreparation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oCAAoC,EAAE,MAAM,wCAAwC,CAAC;AAO9F,OAAO,EAAE,yBAAyB,EAAE,sBAAsB,EAAE,MAAM,uCAAuC,CAAC;AAwC1G,MAAM,CAAC,KAAK,UAAU,qBAAqB,CACzC,KAAiC;IAEjC,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,GAAG,KAAK,CAAC;IAElE,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,OAAO,kBAAkB,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,cAAc,EAAE,SAAS,EAAE,kBAAkB,EAAE,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,YAAY,EAAE,CAAC;IACnH,CAAC;IAED,MAAM,SAAS,GAAG,yBAAyB,CAAC;QAC1C,OAAO;QACP,kBAAkB;QAClB,eAAe,EAAE,IAAI,CAAC,eAAe;KACtC,CAAC,CAAC;IACH,MAAM,gBAAgB,GAAG,sBAAsB,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;IACpE,MAAM,iBAAiB,GAAG,MAAM,IAAI,CAAC,qBAAqB,CAAC,gBAAgB,CAAC,CAAC;IAC7E,MAAM,eAAe,GAAG,MAAM,CAAC,OAAO,CAAC,iBAAiB,CAAC,CAAC,MAAM,CAC9D,CAAC,CAAC,aAAa,EAAE,MAAM,CAAC,EAAE,EAAE,CAAC,CAAC,oCAAoC,CAAC,MAAM,CAAC,CAC3E,CAAC;IACF,MAAM,aAAa,GAAG,eAAe,CAAC,GAAG,CAAC,CAAC,CAAC,YAAY,CAAC,EAAE,EAAE,CAAC,YAAY,CAAC,CAAC;IAE5E,IAAI,eAAe,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACjC,OAAO;YACL,MAAM,EAAE,kBAAkB;YAC1B,SAAS;YACT,aAAa;YACb,oBAAoB,EAAE,EAAE;SACzB,CAAC;IACJ,CAAC;IAED,KAAK,MAAM,CAAC,YAAY,EAAE,MAAM,CAAC,IAAI,eAAe,EAAE,CAAC;QACrD,IAAI,CAAC,IAAI,CAAC,kBAAkB,CAAC,YAAY,CAAC,EAAE,CAAC;YAC3C,IAAI,CAAC,uBAAuB,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC;QACrD,CAAC;IACH,CAAC;IAED,MAAM,gBAAgB,GAAG,MAAM,CAAC,WAAW,CACzC,eAAe,CAAC,MAAM,CAAC,CAAC,CAAC,YAAY,CAAC,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,yBAAyB,CAAC,SAAS,EAAE,YAAY,CAAC,CAAC,CACrG,CAAC;IACF,MAAM,oBAAoB,GAAG,MAAM,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;IAE3D,IAAI,oBAAoB,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACtC,IAAI,CAAC,oBAAoB,CAAC,SAAS,CAAC,CAAC;QACrC,OAAO;YACL,MAAM,EAAE,kBAAkB;YAC1B,SAAS;YACT,aAAa;YACb,oBAAoB;SACrB,CAAC;IACJ,CAAC;IAED,MAAM,IAAI,CAAC,0BAA0B,CACnC,SAAS,EACT,gBAAgB,EAChB,YAAY,EACZ,EAAE,YAAY,EAAE,gBAAgB,EAAE,EAClC,IAAI,CAAC,sBAAsB,EAAE,EAC7B,IAAI,CAAC,mBAAmB,EAAE,EAC1B,WAAW,CACZ,CAAC;IACF,MAAM,IAAI,CAAC,mBAAmB,EAAE,CAAC;IAEjC,OAAO;QACL,MAAM,EAAE,UAAU;QAClB,SAAS;QACT,aAAa;QACb,oBAAoB;KACrB,CAAC;AACJ,CAAC"}

package/build/sdk/legacy/server/runtime/serverManager.d.ts

@@ -0,0 +1,132 @@
+import { LazyLoadingOrchestrator } from '../../../../core/capabilities/lazyLoadingOrchestrator.js';
+import { ClientTemplateTracker, FilterCache, TemplateIndex } from '../../../../core/filtering/index.js';
+import { InstructionAggregator } from '../../../../core/instructions/instructionAggregator.js';
+import { ServerRegistry } from '../../../../core/server/adapters/ServerRegistry.js';
+import { TemplateServerManager } from '../../../../core/server/templateServerManager.js';
+import type { InboundConnection, InboundConnectionConfig, MCPServerParams, OperationOptions, OutboundConnection, OutboundConnections } from '../../../../core/types/index.js';
+import { Transport } from '../../shared/transport.js';
+import type { ContextData } from '../../../../types/context.js';
+/**
+ * Event data for context change events
+ */
+export interface ContextChangedEventData {
+    newContext: ContextData;
+    sessionIdChanged: boolean;
+}
+/**
+ * Refactored ServerManager that coordinates various server management components
+ *
+ * This class acts as a facade that delegates to specialized managers:
+ * - ConnectionManager: Handles transport connection lifecycle
+ * - TemplateServerManager: Manages template-based server instances
+ * - MCPServerLifecycleManager: Manages MCP server start/stop/restart operations
+ * - ConfigurationManager: Handles configuration reprocessing with circuit breaker
+ */
+export declare class ServerManager {
+    private static instance;
+    private serverConfig;
+    private serverCapabilities;
+    private outboundConns;
+    private transports;
+    private serverConfigData;
+    private instructionAggregator?;
+    private lazyLoadingOrchestrator?;
+    private connectionManager;
+    private templateServerManager;
+    private mcpServerLifecycleManager;
+    private templateConfigurationManager;
+    private serverRegistry;
+    private filterCache;
+    private constructor();
+    static getOrCreateInstance(config: {
+        name: string;
+        version: string;
+    }, capabilities: {
+        capabilities: Record<string, unknown>;
+    }, outboundConns: OutboundConnections, transports: Record<string, Transport>): ServerManager;
+    static get current(): ServerManager;
+    static resetInstance(): Promise<void>;
+    /**
+     * Set the instruction aggregator instance
+     */
+    setInstructionAggregator(aggregator: InstructionAggregator): void;
+    /**
+     * Set the lazy loading orchestrator instance
+     */
+    setLazyLoadingOrchestrator(orchestrator: LazyLoadingOrchestrator): void;
+    /**
+     * Get the lazy loading orchestrator instance
+     */
+    getLazyLoadingOrchestrator(): LazyLoadingOrchestrator | undefined;
+    /**
+     * Get the instruction aggregator instance
+     */
+    getInstructionAggregator(): InstructionAggregator | undefined;
+    /**
+     * Set up context change listener for dynamic template processing
+     */
+    private setupContextChangeListener;
+    /**
+     * Get current server configurations
+     */
+    private getCurrentServerConfigs;
+    /**
+     * Update all server instances with new aggregated instructions
+     */
+    private updateServerInstructions;
+    connectTransport(transport: Transport, sessionId: string, opts: InboundConnectionConfig, context?: ContextData): Promise<void>;
+    disconnectTransport(sessionId: string, forceClose?: boolean): Promise<void>;
+    getTransport(sessionId: string): Transport | undefined;
+    getTransports(): Map<string, Transport>;
+    getClientTransports(): Record<string, Transport>;
+    getClients(): OutboundConnections;
+    getClient(serverName: string): OutboundConnection | undefined;
+    getActiveTransportsCount(): number;
+    getServer(sessionId: string): InboundConnection | undefined;
+    getInboundConnections(): Map<string, InboundConnection>;
+    recordInboundConnectionError(sessionId: string, error: unknown): void;
+    getTemplateServerManager(): TemplateServerManager;
+    reloadTemplatesForRuntimeEnvironment(templateNames: readonly string[]): Promise<void>;
+    getServerRegistry(): ServerRegistry;
+    /** Notify attached callers that backend capability lists may have changed. */
+    notifyBackendCapabilityListsChanged(): Promise<void>;
+    updateClientsAndTransports(newClients: OutboundConnections, newTransports: Record<string, Transport>): void;
+    executeServerOperation<T>(inboundConn: InboundConnection, operation: (inboundConn: InboundConnection) => Promise<T>, options?: OperationOptions): Promise<T>;
+    startServer(serverName: string, config: MCPServerParams): Promise<void>;
+    stopServer(serverName: string): Promise<void>;
+    restartServer(serverName: string, config: MCPServerParams): Promise<void>;
+    loadMcpServer(serverName: string, config: MCPServerParams): Promise<void>;
+    unloadMcpServer(serverName: string): Promise<void>;
+    getMcpServerStatus(): Map<string, {
+        running: boolean;
+        config: MCPServerParams;
+    }>;
+    isMcpServerRunning(serverName: string): boolean;
+    recordMcpServerReady(serverName: string, config?: MCPServerParams): void;
+    syncMcpServerLifecycleFromConnectedClients(configs?: Record<string, MCPServerParams>): void;
+    private trackMcpServer;
+    private untrackMcpServer;
+    private getConnectedMcpTransport;
+    private resolveMcpServerConfig;
+    updateServerMetadata(serverName: string, newConfig: MCPServerParams): Promise<void>;
+    getFilteringStats(): {
+        tracker: ReturnType<ClientTemplateTracker['getStats']> | null;
+        cache: ReturnType<FilterCache['getStats']> | null;
+        index: ReturnType<TemplateIndex['getStats']> | null;
+        enabled: boolean;
+    };
+    getClientTemplateInfo(): ReturnType<ClientTemplateTracker['getDetailedInfo']>;
+    rebuildTemplateIndex(): void;
+    clearFilterCache(): void;
+    getIdleTemplateInstances(idleTimeoutMs?: number): Array<{
+        templateName: string;
+        instanceId: string;
+        idleTime: number;
+    }>;
+    cleanupIdleInstances(): Promise<number>;
+    /**
+     * Clean up all resources (for shutdown)
+     */
+    cleanup(): Promise<void>;
+}
+//# sourceMappingURL=serverManager.d.ts.map

package/build/sdk/legacy/server/runtime/serverManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serverManager.d.ts","sourceRoot":"","sources":["../../../../../src/sdk/legacy/server/runtime/serverManager.ts"],"names":[],"mappings":"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"}

package/build/sdk/legacy/server/runtime/serverManager.js

@@ -0,0 +1,462 @@
+import { ConfigManager } from '../../../../config/configManager.js';
+import { getGlobalContextManager } from '../../../../core/context/globalContextManager.js';
+import { getFilterCache } from '../../../../core/filtering/index.js';
+import { LoadingState } from '../../../../core/loading/loadingStateTracker.js';
+import { McpLoadingManager } from '../../../../core/loading/mcpLoadingManager.js';
+import { ServerRegistry } from '../../../../core/server/adapters/ServerRegistry.js';
+import { AgentConfigManager } from '../../../../core/server/agentConfig.js';
+import { ConnectionManager } from '../../../../core/server/connectionManager.js';
+import { MCPServerLifecycleManager } from '../../../../core/server/mcpServerLifecycleManager.js';
+import { TemplateConfigurationManager } from '../../../../core/server/templateConfigurationManager.js';
+import { TemplateServerManager } from '../../../../core/server/templateServerManager.js';
+import { ClientStatus } from '../../../../core/types/index.js';
+import logger, { debugIf } from '../../../../logger/logger.js';
+import { getLegacyTransport } from '../../client/runtime/legacyOutboundConnection.js';
+/**
+ * Refactored ServerManager that coordinates various server management components
+ *
+ * This class acts as a facade that delegates to specialized managers:
+ * - ConnectionManager: Handles transport connection lifecycle
+ * - TemplateServerManager: Manages template-based server instances
+ * - MCPServerLifecycleManager: Manages MCP server start/stop/restart operations
+ * - ConfigurationManager: Handles configuration reprocessing with circuit breaker
+ */
+export class ServerManager {
+    static instance;
+    serverConfig;
+    serverCapabilities;
+    outboundConns;
+    transports;
+    serverConfigData = null; // Cache the config data
+    instructionAggregator;
+    lazyLoadingOrchestrator;
+    // Component managers
+    connectionManager;
+    templateServerManager;
+    mcpServerLifecycleManager;
+    templateConfigurationManager;
+    serverRegistry;
+    // Filtering cache (kept separate as it's a shared resource)
+    filterCache = getFilterCache();
+    constructor(config, capabilities, outboundConns, transports) {
+        this.serverConfig = config;
+        this.serverCapabilities = capabilities;
+        this.outboundConns = outboundConns;
+        this.transports = transports;
+        // Initialize component managers
+        this.connectionManager = new ConnectionManager(config, capabilities, outboundConns);
+        this.templateServerManager = new TemplateServerManager(AgentConfigManager.getInstance().get('templateInstancePool'));
+        this.mcpServerLifecycleManager = new MCPServerLifecycleManager();
+        this.templateConfigurationManager = new TemplateConfigurationManager();
+        this.serverRegistry = new ServerRegistry(outboundConns, this.templateServerManager);
+    }
+    static getOrCreateInstance(config, capabilities, outboundConns, transports) {
+        if (!ServerManager.instance) {
+            ServerManager.instance = new ServerManager(config, capabilities, outboundConns, transports);
+        }
+        return ServerManager.instance;
+    }
+    static get current() {
+        if (!ServerManager.instance) {
+            throw new Error('ServerManager not initialized');
+        }
+        return ServerManager.instance;
+    }
+    // Test utility method to reset singleton state
+    static async resetInstance() {
+        if (ServerManager.instance) {
+            await ServerManager.instance.cleanup();
+            ServerManager.instance = undefined;
+        }
+    }
+    /**
+     * Set the instruction aggregator instance
+     */
+    setInstructionAggregator(aggregator) {
+        this.instructionAggregator = aggregator;
+        // Set instruction aggregator on template server manager
+        // This ensures template servers can extract and cache their instructions
+        this.templateServerManager.setInstructionAggregator(aggregator);
+        // Listen for instruction changes and update existing server instances
+        aggregator.on('instructions-changed', () => {
+            this.updateServerInstructions();
+        });
+        // Set up context change listener for template processing
+        this.setupContextChangeListener();
+        debugIf('Instruction aggregator set for ServerManager');
+    }
+    /**
+     * Set the lazy loading orchestrator instance
+     */
+    setLazyLoadingOrchestrator(orchestrator) {
+        this.lazyLoadingOrchestrator = orchestrator;
+        this.connectionManager.setLazyLoadingOrchestrator(orchestrator);
+        if (this.instructionAggregator) {
+            this.instructionAggregator.setLazyLoadingOrchestrator(orchestrator);
+        }
+        debugIf('Lazy loading orchestrator set for ServerManager');
+    }
+    /**
+     * Get the lazy loading orchestrator instance
+     */
+    getLazyLoadingOrchestrator() {
+        return this.lazyLoadingOrchestrator;
+    }
+    /**
+     * Get the instruction aggregator instance
+     */
+    getInstructionAggregator() {
+        return this.instructionAggregator;
+    }
+    /**
+     * Set up context change listener for dynamic template processing
+     */
+    setupContextChangeListener() {
+        const globalContextManager = getGlobalContextManager();
+        globalContextManager.on('context-changed', async (data) => {
+            logger.info('Context changed, reprocessing templates', {
+                sessionId: data.newContext?.sessionId,
+                sessionChanged: data.sessionIdChanged,
+            });
+            try {
+                await this.templateConfigurationManager.reprocessTemplatesWithNewContext(data.newContext, async (newConfig) => {
+                    try {
+                        await this.templateConfigurationManager.updateServersWithNewConfig(newConfig, this.getCurrentServerConfigs(), (serverName, config) => this.loadMcpServer(serverName, config), (serverName) => this.unloadMcpServer(serverName), (serverName, config) => this.loadMcpServer(serverName, config));
+                    }
+                    catch (updateError) {
+                        logger.error('Failed to update all servers with new config, attempting individual updates:', updateError);
+                        await this.templateConfigurationManager.updateServersIndividually(newConfig, (serverName, config) => this.updateServerMetadata(serverName, config));
+                    }
+                });
+            }
+            catch (error) {
+                logger.error('Failed to reprocess templates after context change:', error);
+            }
+        });
+        debugIf('Context change listener set up for ServerManager');
+    }
+    /**
+     * Get current server configurations
+     */
+    getCurrentServerConfigs() {
+        const configs = new Map();
+        const status = this.mcpServerLifecycleManager.getMcpServerStatus();
+        for (const [serverName, serverInfo] of status) {
+            if (serverInfo.running) {
+                configs.set(serverName, serverInfo.config);
+            }
+        }
+        return configs;
+    }
+    /**
+     * Update all server instances with new aggregated instructions
+     */
+    updateServerInstructions() {
+        const inboundConns = this.connectionManager.getInboundConnections();
+        logger.info(`Server instructions have changed. Active sessions: ${inboundConns.size}`);
+        for (const [sessionId, _inboundConn] of inboundConns) {
+            try {
+                debugIf(() => ({
+                    message: `Instructions changed notification for session ${sessionId}`,
+                    meta: { sessionId },
+                }));
+            }
+            catch (error) {
+                logger.warn(`Failed to process instruction change for session ${sessionId}: ${error}`);
+            }
+        }
+    }
+    async connectTransport(transport, sessionId, opts, context) {
+        // Load configuration data
+        // Always process templates when context is available to ensure context-specific rendering
+        const configManager = ConfigManager.getInstance();
+        if (!this.serverConfigData) {
+            // First load - static servers only (templates processed separately per context)
+            const { staticServers } = await configManager.loadConfigWithTemplates(undefined);
+            this.serverConfigData = {
+                mcpServers: staticServers,
+                mcpTemplates: {}, // Will be populated per context
+            };
+        }
+        // Always process templates with current context when context is available
+        if (context) {
+            const { templateServers } = await configManager.loadConfigWithTemplates(context);
+            this.serverConfigData.mcpTemplates = templateServers;
+            // Note: ConfigManager.loadConfigWithTemplates already handles conflict detection
+            // by filtering out static servers that conflict with template servers
+        }
+        // Populate server registry with external servers
+        if (this.serverConfigData.mcpServers) {
+            for (const [name, config] of Object.entries(this.serverConfigData.mcpServers)) {
+                if (!this.serverRegistry.has(name)) {
+                    this.serverRegistry.registerExternal(name, config);
+                }
+            }
+        }
+        // If we have context, create template-based servers
+        if (context && this.serverConfigData.mcpTemplates) {
+            await this.templateServerManager.createTemplateBasedServers(sessionId, context, opts, this.serverConfigData, this.outboundConns, this.transports);
+            // Populate server registry with template servers
+            for (const [name, config] of Object.entries(this.serverConfigData.mcpTemplates)) {
+                if (!this.serverRegistry.has(name)) {
+                    this.serverRegistry.registerTemplate(name, config);
+                }
+            }
+            // CRITICAL: Refresh tool registry after template servers are added
+            // This ensures template server tools are included in lazy loading mode
+            if (this.lazyLoadingOrchestrator) {
+                await this.lazyLoadingOrchestrator.refreshCapabilities();
+            }
+        }
+        // IMPORTANT: Get filtered instructions AFTER template servers are created
+        // This ensures template server instructions are included in the initialize response
+        this.instructionAggregator?.setRuntimeInstructionConfiguration(configManager.getRuntimeInstructionConfiguration());
+        const filteredInstructions = this.instructionAggregator?.getFilteredInstructions(opts, this.outboundConns) || '';
+        // Connect the transport
+        await this.connectionManager.connectTransport(transport, sessionId, opts, context, filteredInstructions);
+    }
+    async disconnectTransport(sessionId, forceClose = false) {
+        // Clean up template-based servers for this client
+        await this.templateServerManager.cleanupTemplateServers(sessionId, this.outboundConns, this.transports);
+        // Disconnect the transport
+        await this.connectionManager.disconnectTransport(sessionId, forceClose);
+    }
+    getTransport(sessionId) {
+        return this.connectionManager.getTransport(sessionId);
+    }
+    getTransports() {
+        return this.connectionManager.getTransports();
+    }
+    getClientTransports() {
+        return this.transports;
+    }
+    getClients() {
+        return this.outboundConns;
+    }
+    getClient(serverName) {
+        return this.outboundConns.get(serverName);
+    }
+    getActiveTransportsCount() {
+        return this.connectionManager.getActiveTransportsCount();
+    }
+    getServer(sessionId) {
+        return this.connectionManager.getServer(sessionId);
+    }
+    getInboundConnections() {
+        return this.connectionManager.getInboundConnections();
+    }
+    recordInboundConnectionError(sessionId, error) {
+        this.connectionManager.recordConnectionError(sessionId, error);
+    }
+    getTemplateServerManager() {
+        return this.templateServerManager;
+    }
+    async reloadTemplatesForRuntimeEnvironment(templateNames) {
+        const reloadTargets = await this.templateServerManager.retireTemplatesForRuntimeEnvironment(templateNames);
+        if (reloadTargets.length === 0)
+            return;
+        const templatesBySession = new Map();
+        for (const { sessionId, templateName, lifecycle } of reloadTargets) {
+            const target = templatesBySession.get(sessionId) ?? { names: new Set(), lifecycle };
+            target.names.add(templateName);
+            templatesBySession.set(sessionId, target);
+        }
+        try {
+            for (const [sessionId, { names: affectedNames, lifecycle }] of templatesBySession) {
+                const inboundConnection = this.connectionManager.getInboundConnections().get(sessionId);
+                const context = inboundConnection?.context;
+                if (!inboundConnection || !context)
+                    continue;
+                const { templateServers, errors } = await ConfigManager.getInstance().loadConfigWithTemplates(context);
+                if (errors.length > 0) {
+                    logger.warn('Some templates could not be rendered during Runtime Scope environment reload', {
+                        templateCount: affectedNames.size,
+                        errorCount: errors.length,
+                    });
+                }
+                const affectedTemplates = Object.fromEntries(Object.entries(templateServers).filter(([templateName]) => affectedNames.has(templateName)));
+                await this.templateServerManager.createTemplateBasedServers(sessionId, context, inboundConnection, { mcpTemplates: affectedTemplates }, this.outboundConns, this.transports, lifecycle);
+            }
+        }
+        finally {
+            await this.notifyBackendCapabilityListsChanged();
+        }
+    }
+    getServerRegistry() {
+        return this.serverRegistry;
+    }
+    /** Notify attached callers that backend capability lists may have changed. */
+    async notifyBackendCapabilityListsChanged() {
+        if (this.lazyLoadingOrchestrator) {
+            try {
+                await this.lazyLoadingOrchestrator.refreshCapabilities();
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                logger.warn(`Failed to refresh lazy backend capabilities: ${message}`);
+            }
+        }
+        const notifications = [
+            'notifications/tools/list_changed',
+            'notifications/resources/list_changed',
+            'notifications/prompts/list_changed',
+        ];
+        for (const inbound of this.connectionManager.getInboundConnections().values()) {
+            if (inbound.status !== 'connected')
+                continue;
+            for (const method of notifications) {
+                try {
+                    await inbound.adapter.notify({ method, params: {} });
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    logger.warn(`Failed to send ${method} to an inbound client: ${message}`);
+                }
+            }
+        }
+    }
+    updateClientsAndTransports(newClients, newTransports) {
+        this.outboundConns = newClients;
+        this.transports = newTransports;
+    }
+    async executeServerOperation(inboundConn, operation, options = {}) {
+        return this.connectionManager.executeServerOperation(inboundConn, operation, options);
+    }
+    async startServer(serverName, config) {
+        await this.mcpServerLifecycleManager.startServer(serverName, config, this.outboundConns, this.transports);
+    }
+    async stopServer(serverName) {
+        await this.mcpServerLifecycleManager.stopServer(serverName, this.outboundConns, this.transports);
+    }
+    async restartServer(serverName, config) {
+        await this.mcpServerLifecycleManager.restartServer(serverName, config, this.outboundConns, this.transports);
+    }
+    async loadMcpServer(serverName, config) {
+        const loadingManager = McpLoadingManager.current;
+        await loadingManager.loadServer(serverName, config);
+        if (config.disabled) {
+            this.untrackMcpServer(serverName);
+            return;
+        }
+        const loadingState = loadingManager.getStateTracker().getServerState(serverName)?.state;
+        if (loadingState !== LoadingState.Ready) {
+            this.untrackMcpServer(serverName);
+            debugIf(() => ({
+                message: `Skipping lifecycle tracking for ${serverName}; loading state is ${loadingState ?? 'unknown'}`,
+            }));
+            return;
+        }
+        this.recordMcpServerReady(serverName, config);
+    }
+    async unloadMcpServer(serverName) {
+        try {
+            await McpLoadingManager.current.unloadServer(serverName);
+        }
+        finally {
+            this.untrackMcpServer(serverName);
+        }
+    }
+    getMcpServerStatus() {
+        return this.mcpServerLifecycleManager.getMcpServerStatus();
+    }
+    isMcpServerRunning(serverName) {
+        return this.mcpServerLifecycleManager.isMcpServerRunning(serverName);
+    }
+    recordMcpServerReady(serverName, config) {
+        const resolvedConfig = config ?? this.resolveMcpServerConfig(serverName);
+        if (!resolvedConfig) {
+            this.untrackMcpServer(serverName);
+            debugIf(() => ({ message: `No config available to track lifecycle for ${serverName}` }));
+            return;
+        }
+        if (resolvedConfig.disabled) {
+            this.untrackMcpServer(serverName);
+            return;
+        }
+        const transport = this.getConnectedMcpTransport(serverName);
+        if (!transport) {
+            this.untrackMcpServer(serverName);
+            debugIf(() => ({ message: `No connected transport available to track lifecycle for ${serverName}` }));
+            return;
+        }
+        this.trackMcpServer(serverName, resolvedConfig, transport);
+    }
+    syncMcpServerLifecycleFromConnectedClients(configs) {
+        for (const [serverName, connection] of this.outboundConns.entries()) {
+            if (connection.status !== ClientStatus.Connected) {
+                this.untrackMcpServer(serverName);
+                continue;
+            }
+            this.recordMcpServerReady(serverName, configs?.[serverName]);
+        }
+    }
+    trackMcpServer(serverName, config, transport) {
+        this.mcpServerLifecycleManager.trackServer(serverName, config, transport);
+    }
+    untrackMcpServer(serverName) {
+        this.mcpServerLifecycleManager.untrackServer(serverName);
+    }
+    getConnectedMcpTransport(serverName) {
+        const connection = this.outboundConns.get(serverName);
+        if (connection?.status === ClientStatus.Connected) {
+            return getLegacyTransport(connection);
+        }
+        return undefined;
+    }
+    resolveMcpServerConfig(serverName) {
+        const existing = this.mcpServerLifecycleManager.getMcpServerStatus().get(serverName)?.config;
+        if (existing) {
+            return existing;
+        }
+        try {
+            return ConfigManager.getInstance().getTransportConfig()[serverName];
+        }
+        catch (error) {
+            debugIf(() => ({ message: `Could not resolve config for ${serverName}: ${error}` }));
+            return undefined;
+        }
+    }
+    async updateServerMetadata(serverName, newConfig) {
+        await this.mcpServerLifecycleManager.updateServerMetadata(serverName, newConfig, this.outboundConns);
+    }
+    getFilteringStats() {
+        const stats = this.templateServerManager.getFilteringStats();
+        return {
+            tracker: stats.tracker,
+            cache: this.filterCache.getStats(),
+            index: stats.index,
+            enabled: stats.enabled,
+        };
+    }
+    getClientTemplateInfo() {
+        return this.templateServerManager.getClientTemplateInfo();
+    }
+    rebuildTemplateIndex() {
+        this.templateServerManager.rebuildTemplateIndex(this.serverConfigData || undefined);
+    }
+    clearFilterCache() {
+        this.filterCache.clear();
+        logger.info('Filter cache cleared');
+    }
+    getIdleTemplateInstances(idleTimeoutMs = 10 * 60 * 1000) {
+        return this.templateServerManager.getIdleTemplateInstances(idleTimeoutMs);
+    }
+    async cleanupIdleInstances() {
+        return this.templateServerManager.cleanupIdleInstances();
+    }
+    /**
+     * Clean up all resources (for shutdown)
+     */
+    async cleanup() {
+        // Clean up all connections
+        await this.connectionManager.cleanup();
+        // Clean up template server manager
+        await this.templateServerManager.shutdown();
+        // Clean up configuration manager
+        this.templateConfigurationManager.cleanup();
+        // Clear cache
+        this.filterCache.clear();
+        logger.info('ServerManager cleanup completed');
+    }
+}
+//# sourceMappingURL=serverManager.js.map