@nitrostack/core 1.0.16 → 1.1.0-beta.0

package/dist/core/server.js

@@ -2,7 +2,7 @@ import { Server as McpServer } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
 import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema, ListResourceTemplatesRequestSchema, SubscribeRequestSchema, UnsubscribeRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
-import { ResourceTemplate, createResource } from './resource.js';
+import { Resource, ResourceTemplate, createResource } from './resource.js';
 import { buildResourceReadContentsMeta } from './widget-mcp-meta.js';
 import { getWidgetMimeType, isMcpAppMode, isOpenAiMode, getAppMode } from './app-mode.js';
 import { createLogger } from './logger.js';
@@ -16,6 +16,9 @@ import { triggerLifecycleHook } from './lifecycle.js';
 import { resolveProtocolEra, needsModernEngine, protocolVersionForEra, } from './protocol/version.js';
 import { isInputRequired } from './protocol/features/mrtr.js';
 import { extractBearerToken } from '../auth/token-validation.js';
+import { SessionVisibilityStore } from './transforms/visibility/session-store.js';
+import { MemorySpilloverStore } from './interceptors/spillover/memory-spillover.store.js';
+import { FsSpilloverStore } from './interceptors/spillover/fs-spillover.store.js';
 /** Optional Streamable HTTP session limits from environment variables. */
 function getStreamableHttpEnvOptions() {
     const maxSessions = process.env.MCP_MAX_SESSIONS
@@ -29,15 +32,50 @@ function getStreamableHttpEnvOptions() {
         ...(sessionTimeout !== undefined && !Number.isNaN(sessionTimeout) ? { sessionTimeout } : {}),
     };
 }
+/**
+ * Visibility and spillover key.
+ *
+ * The subject is the verified `extra.auth.subject` only. An unsigned bearer
+ * payload must not select a session. No transport session means no key.
+ *
+ * Anonymous and authenticated callers use disjoint prefixes, and both parts are
+ * encoded, so a client-supplied `mcp-session-id` cannot equal another
+ * principal's key.
+ */
+export function sessionIsolationKey(transportSessionId, verifiedSubject) {
+    if (!transportSessionId)
+        return undefined;
+    const session = encodeURIComponent(transportSessionId);
+    if (!verifiedSubject)
+        return `anon:${session}`;
+    return `user:${encodeURIComponent(verifiedSubject)}:${session}`;
+}
+function createSpilloverStore(config) {
+    const spillover = config.spillover;
+    if (spillover?.driver === 'filesystem') {
+        return new FsSpilloverStore({
+            storageDir: spillover.storageDir,
+            maxSizeBytes: spillover.maxSizeBytes,
+        });
+    }
+    return new MemorySpilloverStore(spillover?.maxSizeBytes !== undefined ? { maxSizeBytes: spillover.maxSizeBytes } : {});
+}
 /**
  * NitroStackServer - Main server class
  */
 export class NitroStackServer {
     mcpServer;
+    /** Process-local session for the legacy stdio peer. Not taken from the client. */
+    legacyStdioSessionId;
     tools = new Map();
+    sessionVisibilityStore;
+    pendingListChangedSessions = new Set();
+    notificationScheduled = false;
     resources = new Map();
     resourceTemplates = new Map();
     templateResources = new Map();
+    defaultSpilloverStore;
+    startTime = Date.now();
     prompts = new Map();
     modules = [];
     config;
@@ -72,12 +110,23 @@ export class NitroStackServer {
     protocolEra;
     /** Lazily constructed modern (2026-07-28) adapter (only on modern/auto). */
     modernAdapter;
+    /** Registered MCP catalog transforms in pipeline order */
+    transforms = [];
     constructor(config) {
         // Default config if not provided (e.g., when instantiated by DI container)
         this.config = config || {
             name: 'nitrostack-server',
             version: '1.0.0',
         };
+        this.defaultSpilloverStore = createSpilloverStore(this.config);
+        this.transforms = this.config.transforms ? [...this.config.transforms] : [];
+        const existingVisibilityTransform = this.transforms.find((t) => t.name === 'visibility');
+        if (existingVisibilityTransform?.store) {
+            this.sessionVisibilityStore = existingVisibilityTransform.store;
+        }
+        else {
+            this.sessionVisibilityStore = new SessionVisibilityStore();
+        }
         // Register itself in DI container so modules can inject the server.
         // NOTE: DIContainer is a process-wide singleton, so this assumes a single
         // NitroStackServer instance per process. Multiple instances would overwrite
@@ -90,6 +139,7 @@ export class NitroStackServer {
             serviceName: this.config.name,
             enableConsole: false, // CRITICAL: Console disabled for MCP compatibility
         });
+        this.sessionVisibilityStore.setLogger(this.logger);
         // Initialize task manager for MCP Tasks support
         this.taskManager = new TaskManager({
             logger: this.logger,
@@ -112,6 +162,23 @@ export class NitroStackServer {
             version: this.config.version,
         }, NitroStackServer.mcpServerOptions);
         this.setupHandlersOn(this.mcpServer);
+        this.registerSpilloverResourceTemplate();
+        for (const transform of this.transforms) {
+            this.noteVisibilityBoundary(transform);
+            transform.onRegister?.(this);
+        }
+    }
+    /**
+     * Modern HTTP must present a session id this process minted before
+     * tools/list or tools/call. Visibility is not applied to a missing header.
+     */
+    noteVisibilityBoundary(transform) {
+        if (transform.name !== 'visibility')
+            return;
+        if (this.protocolEra !== 'auto' && this.protocolEra !== 'modern')
+            return;
+        this.logger.warn('VisibilityTransform requires a server-issued session on the modern HTTP path. ' +
+            'tools/list and tools/call without a session issued by this process are rejected.');
     }
     /**
      * Build the read-only registry view the modern protocol adapter consumes.
@@ -122,12 +189,18 @@ export class NitroStackServer {
             config: this.config,
             logger: this.logger,
             getTools: () => this.tools,
+            getTransformedTools: async (ctx) => {
+                const tools = await this.runToolPipeline(ctx);
+                return new Map(tools.map((t) => [t.name, t]));
+            },
+            resolveTool: (name, ctx) => this.resolveTool(name, ctx),
             getResources: () => this.resources,
             getResourceTemplates: () => this.resourceTemplates,
             getTemplateResources: () => this.templateResources,
             getPrompts: () => this.prompts,
             getTaskManager: () => this.taskManager,
             createExecutionContext: (options) => this.createContext(options),
+            hasSessionVisibility: () => this.transforms.some((transform) => transform.name === 'visibility'),
         };
     }
     /**
@@ -307,6 +380,98 @@ export class NitroStackServer {
         }
         return this;
     }
+    /**
+     * Register a tool with the server (alias for tool()).
+     */
+    registerTool(tool) {
+        return this.tool(tool);
+    }
+    /**
+     * Get a registered tool by name.
+     */
+    getTool(name) {
+        return this.tools.get(name);
+    }
+    /**
+     * Get all registered raw tools, keyed by name.
+     */
+    getTools() {
+        return new Map(this.tools);
+    }
+    /**
+     * Register a transform into the MCP tool catalog pipeline.
+     */
+    addTransform(transform) {
+        this.transforms.push(transform);
+        this.noteVisibilityBoundary(transform);
+        if (transform.name === 'visibility' && transform.store) {
+            this.sessionVisibilityStore = transform.store;
+        }
+        transform.onRegister?.(this);
+        return this;
+    }
+    /**
+     * Get all registered transforms in the pipeline.
+     */
+    getTransforms() {
+        return [...this.transforms];
+    }
+    /**
+     * Returns live telemetry descriptors for all active transforms in pipeline order.
+     */
+    getTransformTelemetry() {
+        return this.transforms.map((transform, index) => {
+            const customTelemetry = typeof transform.getTelemetry === 'function'
+                ? transform.getTelemetry()
+                : {};
+            return {
+                name: transform.name,
+                type: transform.constructor.name,
+                order: index,
+                details: customTelemetry,
+            };
+        });
+    }
+    /**
+     * Get server uptime in seconds.
+     */
+    getUptimeSeconds() {
+        return Math.floor((Date.now() - this.startTime) / 1000);
+    }
+    /**
+     * Runs all registered transforms sequentially on the current tools catalog.
+     */
+    async runToolPipeline(context) {
+        let tools = Array.from(this.tools.values());
+        for (const transform of this.transforms) {
+            if (transform.transformTools) {
+                try {
+                    tools = await transform.transformTools(tools, context);
+                }
+                catch (error) {
+                    this.logger.error(`Transform '${transform.name}' failed during transformTools`, error instanceof Error ? error : new Error(String(error)));
+                    throw error;
+                }
+            }
+        }
+        return tools;
+    }
+    /**
+     * Resolves a tool by traversing the transforms in onion-order.
+     */
+    async resolveTool(name, context) {
+        const dispatch = async (i, toolName, ctx) => {
+            if (i >= this.transforms.length) {
+                return this.tools.get(toolName);
+            }
+            const transform = this.transforms[i];
+            if (transform.resolveTool) {
+                return transform.resolveTool(toolName, (nextName, nextCtx) => dispatch(i + 1, nextName, nextCtx ?? ctx), ctx);
+            }
+            return dispatch(i + 1, toolName, ctx);
+        };
+        return dispatch(0, name, context);
+    }
     /**
      * Register a component as an MCP resource
      */
@@ -400,6 +565,70 @@ export class NitroStackServer {
         this.logger.info(`Resource template registered: ${template.uriTemplate}`);
         return this;
     }
+    /**
+     * Initializes the built-in spillover resource template.
+     * Called during server initialization.
+     */
+    registerSpilloverResourceTemplate() {
+        const templateUri = 'resource://data-spillover/{id}';
+        const spilloverResource = new Resource({
+            uri: templateUri,
+            name: 'Data Spillover Storage',
+            title: 'Spillover Dataset Storage',
+            description: 'Parameterized retrieval endpoint for large tool output spillover payloads',
+            mimeType: 'application/json',
+            handler: async (uri, context) => {
+                // Extract ID from URI (e.g. resource://data-spillover/spill-12345)
+                const id = uri.split('/').pop() || uri.replace('resource://data-spillover/', '');
+                const record = await this.defaultSpilloverStore.get(id);
+                if (!record) {
+                    throw new ResourceNotFoundError(uri);
+                }
+                const visibilityOn = this.transforms.some((transform) => transform.name === 'visibility');
+                // With visibility installed, a row that has no session is not readable.
+                // A row written for a session is readable only by that isolation key.
+                if (visibilityOn && !record.sessionId) {
+                    throw new ResourceNotFoundError(uri);
+                }
+                if (record.sessionId && record.sessionId !== context.sessionId) {
+                    throw new ResourceNotFoundError(uri);
+                }
+                if (record.mimeType === 'application/json') {
+                    return {
+                        type: 'json',
+                        data: JSON.parse(record.data),
+                    };
+                }
+                if (record.mimeType === 'application/octet-stream') {
+                    return {
+                        type: 'binary',
+                        data: Buffer.from(record.data, 'base64'),
+                    };
+                }
+                return {
+                    type: 'text',
+                    data: record.data,
+                };
+            },
+        });
+        this.resource(spilloverResource);
+    }
+    /**
+     * Get the default spillover store used for payload offloading.
+     */
+    getSpilloverStore() {
+        return this.defaultSpilloverStore;
+    }
+    /**
+     * Set the default spillover store used for payload offloading.
+     */
+    setSpilloverStore(store) {
+        if (this.defaultSpilloverStore && this.defaultSpilloverStore !== store) {
+            this.defaultSpilloverStore.dispose().catch(() => { });
+        }
+        this.defaultSpilloverStore = store;
+        return this;
+    }
     /**
      * Notify clients that the list of resources has changed
      */
@@ -436,20 +665,91 @@ export class NitroStackServer {
         }
     }
     /**
-     * Notify clients that the list of tools has changed
+     * Get the session visibility store
      */
-    notifyToolsListChanged() {
-        this.modernAdapter?.notifyToolsListChanged();
+    getSessionVisibilityStore() {
+        return this.sessionVisibilityStore;
+    }
+    /** True when a VisibilityTransform is in the pipeline. */
+    hasSessionVisibility() {
+        return this.transforms.some((transform) => transform.name === 'visibility');
+    }
+    /**
+     * Dispatches notifications/tools/list_changed.
+     * If sessionId is provided, targets the specific session; if omitted, broadcasts globally.
+     * Coalesced via queueMicrotask to avoid duplicate notifications in a single tick.
+     */
+    notifyToolsListChanged(sessionId) {
+        if (sessionId) {
+            this.pendingListChangedSessions.add(sessionId);
+        }
+        else {
+            this.pendingListChangedSessions.add('*'); // Global broadcast flag
+        }
+        if (!this.notificationScheduled) {
+            this.notificationScheduled = true;
+            queueMicrotask(() => this.flushListChangedNotifications());
+        }
+    }
+    async flushListChangedNotifications() {
+        this.notificationScheduled = false;
+        const targetSessions = new Set(this.pendingListChangedSessions);
+        this.pendingListChangedSessions.clear();
+        const isGlobal = targetSessions.has('*');
+        // 1. Modern Protocol Adapter (2026-07-28)
+        if (this.modernAdapter) {
+            const modernTargets = isGlobal ? [undefined] : [...targetSessions];
+            for (const target of modernTargets) {
+                try {
+                    this.modernAdapter.notifyToolsListChanged(target);
+                }
+                catch (err) {
+                    this.logger.error('Failed to dispatch modern notifyToolsListChanged', { error: String(err) });
+                }
+            }
+        }
+        // 2. Legacy HTTP+SSE Sessions (2025-06-18)
+        if (isGlobal) {
+            for (const [sid, session] of this.legacySdkSseSessions.entries()) {
+                this.sendSessionNotification(session.server, 'notifications/tools/list_changed', sid);
+            }
+        }
+        else {
+            for (const sid of targetSessions) {
+                const session = this.legacySdkSseSessions.get(sid);
+                if (session) {
+                    this.sendSessionNotification(session.server, 'notifications/tools/list_changed', sid);
+                }
+            }
+        }
+        // 3. Legacy stdio (the standalone McpServer instance). Its single peer has a
+        // process-local session; a change for any other session is not its concern.
+        const stdioTargeted = this.legacyStdioSessionId !== undefined && targetSessions.has(this.legacyStdioSessionId);
+        if (isGlobal || stdioTargeted) {
+            try {
+                const serverWithNotify = this.mcpServer;
+                if (serverWithNotify.notification) {
+                    await serverWithNotify.notification({ method: 'notifications/tools/list_changed' });
+                }
+            }
+            catch {
+                /* ignore if stdio client is disconnected */
+            }
+        }
+    }
+    sendSessionNotification(server, method, sessionId) {
         try {
-            const mcpServerWithNotification = this.mcpServer;
-            if (mcpServerWithNotification.notification) {
-                mcpServerWithNotification.notification({ method: 'notifications/tools/list_changed' })
-                    .catch(err => this.logger.error('Failed to send tools list changed notification', { error: err instanceof Error ? err.message : String(err) }));
+            if (typeof server?.notification === 'function') {
+                server.notification({ method }).catch((err) => {
+                    this.logger.debug('Failed to deliver session list_changed notification', {
+                        sessionId,
+                        error: err instanceof Error ? err.message : String(err),
+                    });
+                });
             }
         }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            this.logger.error('Error sending tools list changed notification', { error: errorMessage });
+        catch (err) {
+            this.logger.debug('Error dispatching session notification', { sessionId, error: String(err) });
         }
     }
     /**
@@ -553,7 +853,7 @@ export class NitroStackServer {
     /**
      * Create execution context
      */
-    createContext(options) {
+    createContext(options, sessionContext) {
         const metadata = options?.metadata || {};
         let auth = options?.extra?.auth;
         if (!auth) {
@@ -584,25 +884,105 @@ export class NitroStackServer {
                 };
             }
         }
+        const extra = options?.extra;
+        // Transport session wins. extra is applied below, but must not replace this
+        // value — a client-supplied extra.sessionId would otherwise read another session.
+        const transportSessionId = sessionContext?.sessionId || extra?.sessionId;
+        // Verified subject only. The unsigned bearer decode above fills `auth` for
+        // existing consumers and must not choose the isolation key.
+        const verifiedSubject = typeof extra?.auth?.subject === 'string' ? extra.auth.subject : undefined;
+        const sessionId = sessionIsolationKey(transportSessionId, verifiedSubject);
+        const enableTools = async (names) => {
+            if (!sessionId) {
+                this.logger.warn('ctx.enableTools called without an active sessionId; no-op');
+                return;
+            }
+            // Validation: Warn on unregistered tools
+            for (const name of names) {
+                if (!this.tools.has(name)) {
+                    this.logger.warn(`ctx.enableTools: tool '${name}' is not registered in the catalog`);
+                }
+            }
+            if (verifiedSubject) {
+                this.sessionVisibilityStore.enableSubject(verifiedSubject, names);
+            }
+            this.sessionVisibilityStore.enableTools(sessionId, names);
+            if (transportSessionId)
+                this.notifyToolsListChanged(transportSessionId);
+        };
+        const disableTools = async (names) => {
+            if (!sessionId) {
+                this.logger.warn('ctx.disableTools called without an active sessionId; no-op');
+                return;
+            }
+            this.sessionVisibilityStore.disableTools(sessionId, names);
+            if (verifiedSubject) {
+                this.sessionVisibilityStore.disableSubject(verifiedSubject, names);
+            }
+            if (transportSessionId)
+                this.notifyToolsListChanged(transportSessionId);
+        };
+        const getVisibleTools = () => {
+            if (!sessionId)
+                return undefined;
+            const session = this.sessionVisibilityStore.getSession(sessionId);
+            const subjectRestricted = verifiedSubject
+                ? this.sessionVisibilityStore.hasSubjectDenies(verifiedSubject)
+                : false;
+            if (!session && !this.sessionVisibilityStore.hasRevocations(sessionId) && !subjectRestricted) {
+                return undefined;
+            }
+            const allowed = new Set();
+            for (const [name, tool] of this.tools.entries()) {
+                if (verifiedSubject && this.sessionVisibilityStore.hasSubjectDisabled(verifiedSubject, name)) {
+                    continue;
+                }
+                if (this.sessionVisibilityStore.hasDisabled(sessionId, name))
+                    continue;
+                if (session?.enabledTools.has(name) || tool.visibility !== 'hidden') {
+                    allowed.add(name);
+                }
+            }
+            return allowed;
+        };
         return {
+            // Additive 2026-07-28 fields (protocolVersion, requestState, inputResponses,
+            // trace, clientInfo, clientCapabilities, auth) supplied by the modern adapter.
+            ...(extra || {}),
             logger: this.logger,
             requestId: uuidv4(),
-            toolName: options?.toolName,
+            toolName: options?.toolName ?? extra?.toolName,
             metadata,
-            auth,
-            // Additive 2026-07-28 fields (protocolVersion, requestState, inputResponses,
-            // trace, clientInfo, clientCapabilities, auth) supplied by the modern adapter.
-            ...(options?.extra || {}),
+            auth: extra?.auth ?? auth,
+            sessionId,
+            verifiedSubject,
+            enableTools,
+            disableTools,
+            getVisibleTools,
         };
     }
+    /**
+     * Build an execution context (alias for createContext()).
+     */
+    createExecutionContext(options, sessionContext) {
+        return this.createContext(options, sessionContext);
+    }
     /**
      * Register MCP protocol handlers on the given server instance (main or per legacy SSE session).
      */
     setupHandlersOn(mcp, sessionContext) {
+        // The standalone server only ever serves the stdio peer, whose session starts at connect.
+        const sessionId = () => sessionContext?.sessionId ?? (mcp === this.mcpServer ? this.legacyStdioSessionId : undefined);
         // List tools
         mcp.setRequestHandler(ListToolsRequestSchema, async () => {
             this.logger.debug('Listing tools');
-            const tools = await Promise.all(Array.from(this.tools.values()).map((tool) => tool.toMcpTool()));
+            const context = this.createContext({
+                extra: {
+                    sessionId: sessionId(),
+                },
+            });
+            const rawTools = await this.runToolPipeline(context);
+            const tools = await Promise.all(rawTools.map((tool) => tool.toMcpTool()));
             return {
                 tools,
             };
@@ -610,28 +990,7 @@ export class NitroStackServer {
         // Call tool
         mcp.setRequestHandler(CallToolRequestSchema, async (request) => {
             const { name, arguments: args } = request.params;
-            const tool = this.tools.get(name);
-            if (!tool) {
-                throw new ToolExecutionError(name, new Error('Tool not found'));
-            }
-            // ----------------------------------------------------------------
-            // MCP Tasks: detect task-augmented requests
-            // The client sends `task: { ttl?: number }` in params to request
-            // async task execution.
-            // ----------------------------------------------------------------
             const requestParams = request.params;
-            const taskParam = requestParams['task'];
-            const isTaskAugmented = taskParam !== undefined;
-            // Enforce tool-level task support negotiation
-            if (isTaskAugmented && tool.taskSupport === 'forbidden') {
-                throw {
-                    code: -32601,
-                    message: `Tool '${name}' does not support task augmentation`,
-                };
-            }
-            if (!isTaskAugmented && tool.taskSupport === 'required') {
-                throw new TaskAugmentationRequiredError();
-            }
             // Extract _meta from request params (MCP spec) and from arguments
             // (legacy Studio clients); params._meta takes precedence.
             const argsRecord = (args || {});
@@ -654,8 +1013,33 @@ export class NitroStackServer {
             }
             const context = this.createContext({
                 metadata: combinedMeta,
-                toolName: name
+                toolName: name,
+                extra: {
+                    sessionId: sessionId(),
+                },
             });
+            // Resolve tool through the pipeline with context
+            const tool = await this.resolveTool(name, context);
+            if (!tool) {
+                throw new ToolExecutionError(name, new Error(`Tool '${name}' not found`));
+            }
+            // ----------------------------------------------------------------
+            // MCP Tasks: detect task-augmented requests
+            // The client sends `task: { ttl?: number }` in params to request
+            // async task execution.
+            // ----------------------------------------------------------------
+            const taskParam = requestParams['task'];
+            const isTaskAugmented = taskParam !== undefined;
+            // Enforce tool-level task support negotiation
+            if (isTaskAugmented && tool.taskSupport === 'forbidden') {
+                throw {
+                    code: -32601,
+                    message: `Tool '${name}' does not support task augmentation`,
+                };
+            }
+            if (!isTaskAugmented && tool.taskSupport === 'required') {
+                throw new TaskAugmentationRequiredError();
+            }
             // ----------------------------------------------------------------
             // Task-augmented path: create task, run async, return immediately
             // ----------------------------------------------------------------
@@ -900,7 +1284,9 @@ export class NitroStackServer {
             if (!resource) {
                 throw new ResourceNotFoundError(uri);
             }
-            const context = this.createContext();
+            const context = this.createContext({
+                extra: { sessionId: sessionId() },
+            });
             try {
                 const content = await resource.fetch(context, uri);
                 let responseContent;
@@ -994,7 +1380,9 @@ export class NitroStackServer {
             if (!prompt) {
                 throw new PromptNotFoundError(name);
             }
-            const context = this.createContext();
+            const context = this.createContext({
+                extra: { sessionId: sessionId() },
+            });
             try {
                 const result = await prompt.execute(args || {}, context);
                 this.stats.promptExecutions++;
@@ -1087,7 +1475,8 @@ export class NitroStackServer {
             await this.configureTransportForProtocol(httpTransport);
             // Set up tools callback and server config for documentation page
             httpTransport.setToolsCallback(async () => {
-                const tools = await Promise.all(Array.from(this.tools.values()).map((tool) => tool.toMcpTool()));
+                const rawTools = await this.runToolPipeline();
+                const tools = await Promise.all(rawTools.map((tool) => tool.toMcpTool()));
                 return tools;
             });
             httpTransport.setServerConfig({
@@ -1172,6 +1561,7 @@ export class NitroStackServer {
                     await (await this.getModernAdapter()).serveStdio();
                 }
                 else {
+                    this.legacyStdioSessionId ??= uuidv4();
                     const stdioTransport = new StdioServerTransport();
                     await this.mcpServer.connect(stdioTransport);
                 }
@@ -1198,7 +1588,8 @@ export class NitroStackServer {
                     await this.configureTransportForProtocol(transport);
                     // Set up tools callback and server config for documentation page
                     transport.setToolsCallback(async () => {
-                        const tools = await Promise.all(Array.from(this.tools.values()).map((tool) => tool.toMcpTool()));
+                        const rawTools = await this.runToolPipeline();
+                        const tools = await Promise.all(rawTools.map((tool) => tool.toMcpTool()));
                         return tools;
                     });
                     transport.setServerConfig({
@@ -1225,6 +1616,7 @@ export class NitroStackServer {
                     await (await this.getModernAdapter()).serveStdio();
                 }
                 else {
+                    this.legacyStdioSessionId ??= uuidv4();
                     const transport = new StdioServerTransport();
                     await this.mcpServer.connect(transport);
                 }
@@ -1459,6 +1851,20 @@ export class NitroStackServer {
             }
             // Destroy task manager (stops cleanup interval)
             this.taskManager.destroy();
+            // Destroy session visibility store (stops cleanup interval)
+            this.sessionVisibilityStore.destroy();
+            // Dispose transforms (terminates sandbox worker threads)
+            for (const transform of this.transforms) {
+                try {
+                    await transform.dispose?.();
+                }
+                catch (error) {
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    this.logger.error(`Error disposing transform ${transform.name}`, { error: errorMessage });
+                }
+            }
+            // Dispose default spillover store (stops sweep interval)
+            await this.defaultSpilloverStore.dispose();
             // Close the modern protocol adapter (aborts in-flight modern exchanges).
             if (this.modernAdapter) {
                 await this.modernAdapter.close();