@apify/actors-mcp-server 0.12.1-beta.3 → 0.13.1-beta.0

package/dist/mcp/server.js

@@ -1,96 +1,107 @@
 /**
  * Model Context Protocol (MCP) server for Apify Actors
  */
-import { randomUUID } from 'node:crypto';
-import { InMemoryTaskStore } from '@modelcontextprotocol/sdk/experimental/tasks/stores/in-memory.js';
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { CallToolRequestSchema, CancelTaskRequestSchema, ErrorCode, GetPromptRequestSchema, GetTaskPayloadRequestSchema, GetTaskRequestSchema, InitializeRequestSchema, ListPromptsRequestSchema, ListResourcesRequestSchema, ListResourceTemplatesRequestSchema, ListTasksRequestSchema, ListToolsRequestSchema, McpError, ReadResourceRequestSchema, RELATED_TASK_META_KEY, SetLevelRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
 import log from '@apify/log';
 import { parseBooleanOrNull } from '@apify/utilities';
 import { ApifyClient } from '../apify_client.js';
-import { DEFAULT_TELEMETRY_ENABLED, DEFAULT_TELEMETRY_ENV, FAILURE_CATEGORY, HELPER_TOOLS, TOOL_STATUS, } from '../const.js';
+import { DEFAULT_TELEMETRY_ENABLED, DEFAULT_TELEMETRY_ENV, HELPER_TOOLS } from '../const.js';
 import { prompts } from '../prompts/index.js';
 import { createPromptService } from '../prompts/prompt_service.js';
 import { createResourceService } from '../resources/resource_service.js';
 import { resolveAvailableWidgets } from '../resources/widgets.js';
-import { getServerInfo } from '../server_card.js';
 import { getTelemetryEnv } from '../telemetry.js';
-import { withReportProblemNudge } from '../tools/dev/report_problem.js';
 import { SERVER_MODE, TOOL_TYPE } from '../types.js';
-import { isMcpClientFaultMessage, sanitizeMezmoMessage } from '../utils/logging.js';
 import { getRequestOriginForClient, isReportProblemBlockedForClient } from '../utils/mcp_clients.js';
 import { getServerInstructions } from '../utils/server-instructions/index.js';
 import { parseServerMode, resolveServerMode } from '../utils/server_mode.js';
-import { buildActorFields, getToolFullName, getToolPublicFieldOnly } from '../utils/tools.js';
 import { getActors, getToolsForServerMode, toolNamesToInput } from '../utils/tools_loader.js';
 import { buildMcpClientContext, isUiSupportedByClient } from './client_context.js';
-import { LOG_LEVEL_MAP } from './const.js';
-import { InternalError, InvalidParamsError } from './errors.js';
-import { emitTaskStatusNotification, executeToolAndUpdateTask } from './task_execution.js';
-import { buildPreflightFailureOutcome, classifyToolCallError, executeSyncToolCall, prepareToolCall, } from './tool_call_engine.js';
-import { logToolCallAndTelemetry, prepareTelemetryData } from './tool_call_telemetry.js';
-import { parseInputParamsFromUrl, storeTaskResultOrSkipIfExpired } from './utils.js';
+import { LegacyMcpServer } from './legacy_server.js';
+import { parseInputParamsFromUrl } from './utils.js';
 /**
- * Legacy protocol boundary: project a service's domain error to its v1 `McpError`, copying `message`
- * and `data` unchanged so the wire output (code, message, presence of `data`) is byte-identical.
- * Non-domain errors pass through untouched.
+ * Stable identity of a fetch input, so reloading the same input replaces its retained source rather
+ * than adding another (see {@link ActorsMcpServer.toolSources}). Keys are sorted because callers
+ * need not agree on property order. The array replacer filters keys at every depth — safe only
+ * while `Input` stays flat; a nested object's keys would be silently dropped and inputs collide.
  */
-function toLegacyMcpError(error) {
-    if (error instanceof InvalidParamsError)
-        return new McpError(ErrorCode.InvalidParams, error.message, error.data);
-    if (error instanceof InternalError)
-        return new McpError(ErrorCode.InternalError, error.message, error.data);
-    return error;
+function toolSourceKey(input) {
+    return JSON.stringify(input, Object.keys(input).sort());
 }
 /**
- * Create Apify MCP server
+ * Read the widget registry from disk. Mode-agnostic, so a successful read is resolved once and
+ * shared (see {@link ActorsMcpServer.resolveWidgetsForMode}). Rejects on a failed scan so the
+ * caller can tell that apart from a successful empty registry.
+ */
+async function resolveServableWidgets() {
+    const resolved = await resolveAvailableWidgets(dirname(fileURLToPath(import.meta.url)));
+    const readyWidgets = [];
+    const missingWidgets = [];
+    for (const [uri, widget] of resolved.entries()) {
+        if (widget.exists) {
+            readyWidgets.push(widget.name);
+        }
+        else {
+            missingWidgets.push(widget.name);
+            log.softFail(`Widget file not found: ${widget.jsPath} (widget: ${uri})`);
+        }
+    }
+    if (readyWidgets.length > 0) {
+        log.debug('Ready widgets', { widgets: readyWidgets });
+    }
+    if (missingWidgets.length > 0) {
+        log.softFail('Some widgets are not ready', {
+            widgets: missingWidgets,
+            note: 'These widgets will not be available. Ensure web/dist files are built and included in deployment.',
+        });
+    }
+    return resolved;
+}
+/**
+ * The shared-Apify-behavior facade: owns the tool registry + loaders, server-mode resolution,
+ * telemetry config, widgets, prompt/resource services, and token/client resolution. Constructs
+ * exactly one {@link LegacyMcpServer} (2025-era adapter) and delegates all v1 protocol work to it.
+ * Implements {@link StatelessMcpServerHost} for the 2026-07-28 adapter too, but does not construct
+ * it — `createStatelessServer` builds one per request from a snapshot this facade hands out.
  */
 export class ActorsMcpServer {
+    get clientContext() {
+        return this._clientContext;
+    }
+    get serverMode() {
+        return this._serverMode;
+    }
+    /** The instance's own view: what a stateful connection composes and gates against. */
+    get servingContext() {
+        return { serverMode: this._serverMode, clientContext: this._clientContext };
+    }
     constructor(options = {}) {
         var _a;
-        Object.defineProperty(this, "server", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
+        /**
+         * The resolved tool map the instance's own (stateful) connection serves, composed from
+         * `toolSources` once the handshake makes mode and client known. A stateless request never
+         * reads it — its snapshot re-composes from the sources ({@link createRequestSnapshot}).
+         */
         Object.defineProperty(this, "tools", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "sigintHandler", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "currentLogLevel", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 'info'
-        });
         Object.defineProperty(this, "options", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "taskStore", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
         Object.defineProperty(this, "actorStore", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "clientContext", {
+        Object.defineProperty(this, "_clientContext", {
             enumerable: true,
             configurable: true,
             writable: true,
@@ -98,10 +109,10 @@ export class ActorsMcpServer {
         });
         /**
          * Resolved server mode. Preliminary value at construction (`'auto'` → `DEFAULT`).
-         * Finalized inside the `initialize` request handler (see constructor) once the
+         * Finalized inside the `initialize` request handler (see {@link applyInitialize}) once the
          * client's capabilities are known. Effectively set-once per connection.
          */
-        Object.defineProperty(this, "serverMode", {
+        Object.defineProperty(this, "_serverMode", {
             enumerable: true,
             configurable: true,
             writable: true,
@@ -118,10 +129,9 @@ export class ActorsMcpServer {
             writable: true,
             value: void 0
         });
-        /** True once the server mode is final: at construction for explicit `default`/`apps`, or after
-         *  the initialize handler resolves `'auto'`. Composing before this in `'auto'` mode would use
-         *  the preliminary DEFAULT mode and produce the wrong (non-widget) tool variants, so composition
-         *  waits for it. Distinct from {@link clientKnown}, which only withholds client-gated tools. */
+        /** True once the server mode is final (at construction, or after initialize resolves `'auto'`).
+         *  Composition waits for it — composing earlier in `'auto'` mode would produce the wrong tool
+         *  variants. Distinct from {@link clientKnown}, which only withholds client-gated tools. */
         Object.defineProperty(this, "serverModeResolved", {
             enumerable: true,
             configurable: true,
@@ -129,17 +139,30 @@ export class ActorsMcpServer {
             value: void 0
         });
         /**
-         * Tool sources queued until composition is possible. Enqueued when the mode is not yet resolved
-         * (`'auto'` before initialize), and re-composed by the initialize flush — which is also when the
-         * client becomes known, so any client-gated tools withheld by an eager compose are added then.
-         * We capture the exact actor-tool slice fetched for each request so the flush composes every
-         * entry against *its own* actor list rather than the accumulated union across unrelated requests.
+         * Tool sources queued until composition is possible (`'auto'` mode before initialize),
+         * re-composed by the initialize flush once mode and client are known. Each entry keeps the
+         * exact actor-tool slice fetched for its input, so the flush composes it against its own list.
+         * Keyed like {@link toolSources}: a stateless-only facade never drains this queue, so a reload
+         * replaces its entry instead of appending, keeping the queue bounded by distinct inputs.
          */
         Object.defineProperty(this, "pendingToolsUntilClientKnown", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: []
+            value: new Map()
+        });
+        /**
+         * The unresolved inputs `tools` is composed from — not a second tool registry. Retained (never
+         * drained) so a stateless request, whose identity arrives per request, can compose its own
+         * resolved set from the same inputs without touching `tools`. Keyed by input because nothing
+         * drains it: a reload replaces its entry instead of appending, bounding the map by distinct
+         * inputs instead of growing per reload for the facade's lifetime.
+         */
+        Object.defineProperty(this, "toolSources", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
         });
         // Telemetry configuration (resolved from options and env vars, see setupTelemetry)
         Object.defineProperty(this, "telemetryEnabled", {
@@ -154,6 +177,19 @@ export class ActorsMcpServer {
             writable: true,
             value: void 0
         });
+        // Neutral prompt/resource services; the legacy adapter wires SDK handlers to these.
+        Object.defineProperty(this, "promptService", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "resourceService", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         // List of widgets that are ready to be served
         Object.defineProperty(this, "availableWidgets", {
             enumerable: true,
@@ -161,6 +197,16 @@ export class ActorsMcpServer {
             writable: true,
             value: new Map()
         });
+        /**
+         * In-flight or successfully settled widget resolution, memoized so the disk scan runs once. A
+         * failed attempt is dropped rather than kept (see {@link resolveWidgetsForMode}).
+         */
+        Object.defineProperty(this, "widgetsResolution", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         /** Set in the initialize handler once client capabilities are known. */
         Object.defineProperty(this, "clientSupportsUi", {
             enumerable: true,
@@ -168,18 +214,15 @@ export class ActorsMcpServer {
             writable: true,
             value: false
         });
+        // The v1 SDK adapter. Package-private: constructed here and never exposed on the public surface.
+        Object.defineProperty(this, "legacyServer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this.options = options;
-        this.clientContext = buildMcpClientContext((_a = options.initializeRequestData) === null || _a === void 0 ? void 0 : _a.params);
-        // for stdio use in memory task store if not provided, otherwise use provided task store
-        if (this.options.transportType === 'stdio' && !this.options.taskStore) {
-            this.taskStore = new InMemoryTaskStore();
-        }
-        else if (this.options.taskStore) {
-            this.taskStore = this.options.taskStore;
-        }
-        else {
-            throw new Error('Task store must be provided for non-stdio transport types');
-        }
+        this._clientContext = buildMcpClientContext((_a = options.initializeRequestData) === null || _a === void 0 ? void 0 : _a.params);
         this.actorStore = options.actorStore;
         // Constructor is an ingestion boundary for programmatic callers. Normalize via
         // parseServerMode so that runtime-invalid values ('openai' alias, stray strings)
@@ -192,44 +235,19 @@ export class ActorsMcpServer {
             rawServerMode !== undefined ? parseServerMode(rawServerMode) : parseServerMode(legacyUiMode);
         // Preliminary resolution — re-resolved inside the initialize handler once
         // client capabilities are known (only for 'auto').
-        this.serverMode = resolveServerMode(this.serverModeOption, false);
+        this._serverMode = resolveServerMode(this.serverModeOption, false);
         this.serverModeResolved = this.serverModeOption !== 'auto';
-        const { setupSigintHandler = true } = options;
-        this.server = new Server(getServerInfo(), {
-            capabilities: {
-                tools: {
-                    listChanged: true,
-                },
-                // Declare long-running task support
-                tasks: {
-                    list: {},
-                    cancel: {},
-                    requests: {
-                        tools: {
-                            call: {},
-                        },
-                    },
-                },
-                // Declared but unused — some clients (e.g. Claude Desktop) fail without it.
-                resources: {},
-                prompts: {},
-                logging: {},
-            },
-            instructions: getServerInstructions(),
-        });
         const { telemetryEnabled, telemetryEnv } = this.setupTelemetry();
         this.telemetryEnabled = telemetryEnabled;
         this.telemetryEnv = telemetryEnv;
-        this.setupInitializeHandler();
-        this.setupLoggingProxy();
         this.tools = new Map();
-        this.setupErrorHandling(setupSigintHandler);
-        this.setupLoggingHandlers();
-        this.setupToolHandlers();
-        this.setupPromptHandlers();
-        // Handle resource requests so clients like Claude Desktop don't fail.
-        this.setupResourceHandlers();
-        this.setupTaskHandlers();
+        this.promptService = createPromptService(prompts);
+        this.resourceService = createResourceService({
+            paymentProvider: this.options.paymentProvider,
+            getMode: () => this.serverMode,
+            getAvailableWidgets: () => this.availableWidgets,
+        });
+        this.legacyServer = new LegacyMcpServer(this);
     }
     /**
      * Telemetry configuration with precedence: explicit options > env vars > defaults
@@ -253,51 +271,83 @@ export class ActorsMcpServer {
         return { telemetryEnabled, telemetryEnv };
     }
     /**
-     * Override the SDK's `initialize` request handler to run mode resolution and
-     * pending-source flush before `InitializeResult` is sent. Delegates boilerplate
-     * (protocolVersion, capabilities, instructions) to the SDK's captured `_oninitialize`.
-     *
-     * Not using `server.oninitialized`: the SDK dispatches notification handlers
-     * fire-and-forget (separate microtask), so a follow-up `tools/list` can race past them.
-     * The request handler guarantees tools are final before the response and the first `tools/list`.
+     * The shared initialize steps the legacy adapter delegates to before returning
+     * `InitializeResult`: refresh client context, capture the raw request for session recovery,
+     * resolve `'auto'` mode against client capabilities, flush pending tool sources, resolve
+     * widgets. Ordering is load-bearing: mode before compose, compose before instructions, so tool
+     * presence reflects the final composed set.
      */
-    setupInitializeHandler() {
-        // Capture the SDK's default initialize handler installed in its constructor.
-        // Private-field access on the SDK Server — verified against
-        // @modelcontextprotocol/sdk ^1.25.x (see package.json). On SDK bumps, re-check
-        // `@modelcontextprotocol/sdk/shared/protocol.js` for a still-named `_oninitialize`;
-        // if renamed or made non-delegable, rebuild the InitializeResult shape here
-        // (protocolVersion, serverInfo, capabilities, instructions) instead of delegating.
-        // The capability-gating unit tests construct a server and act as a canary.
-        // eslint-disable-next-line no-underscore-dangle
-        const sdkInitHandler = this.server._oninitialize.bind(this.server);
-        this.server.setRequestHandler(InitializeRequestSchema, async (request) => {
-            var _a;
-            this.clientContext = buildMcpClientContext(request.params);
-            this.options.initializeRequestData = request;
-            this.clientSupportsUi = isUiSupportedByClient(this.clientContext);
-            if (this.serverModeOption === 'auto') {
-                const resolved = resolveServerMode('auto', this.clientSupportsUi);
-                if (resolved !== this.serverMode) {
-                    this.serverMode = resolved;
-                }
-                this.serverModeResolved = true;
+    async applyInitialize(request) {
+        var _a;
+        this._clientContext = buildMcpClientContext(request.params);
+        this.options.initializeRequestData = request;
+        this.clientSupportsUi = isUiSupportedByClient(this.clientContext);
+        if (this.serverModeOption === 'auto') {
+            const resolved = resolveServerMode('auto', this.clientSupportsUi);
+            if (resolved !== this._serverMode) {
+                this._serverMode = resolved;
             }
-            log.info('Resolved server mode for client capabilities', {
-                serverMode: this.serverMode,
-                serverModeOption: this.serverModeOption,
-                clientSupportsUi: this.clientSupportsUi,
-                capabilities: (_a = request === null || request === void 0 ? void 0 : request.params) === null || _a === void 0 ? void 0 : _a.capabilities,
-            });
-            this.composePendingToolsForClient();
-            await this.resolveWidgets();
-            const result = await sdkInitHandler(request);
-            // Tools are final here (composePendingToolsForClient ran above, applying the per-client
-            // blocklist), so tool presence is the ground truth for whether to advertise
-            // report-problem in the instructions.
-            result.instructions = getServerInstructions(this.serverMode, this.tools.has(HELPER_TOOLS.PROBLEM_REPORT));
-            return result;
+            this.serverModeResolved = true;
+        }
+        log.info('Resolved server mode for client capabilities', {
+            serverMode: this.serverMode,
+            serverModeOption: this.serverModeOption,
+            clientSupportsUi: this.clientSupportsUi,
+            capabilities: (_a = request === null || request === void 0 ? void 0 : request.params) === null || _a === void 0 ? void 0 : _a.capabilities,
         });
+        this.composePendingToolsForClient();
+        await this.resolveInstanceWidgets();
+    }
+    /**
+     * Server instructions for the current connection: mode plus whether report-problem is loaded.
+     * Read by the legacy adapter after `applyInitialize`, when the tool set is final.
+     */
+    getServerInstructions() {
+        return getServerInstructions(this.serverMode, this.tools.has(HELPER_TOOLS.PROBLEM_REPORT));
+    }
+    /**
+     * Instructions for a stateless serving unit. The SDK answers `server/discover` from them before
+     * any request's envelope is seen, so they are configuration-level: no report-problem mention
+     * (that tool's presence is decided per request) and the configured mode only. Reads
+     * `serverModeOption`, never `_serverMode` — one facade serves both eras, and a legacy
+     * `initialize` rewrites `_serverMode`, which must not leak into later stateless requests.
+     */
+    getStatelessServerInstructions() {
+        return getServerInstructions(resolveServerMode(this.serverModeOption, false));
+    }
+    /**
+     * Build the read-only view one stateless (2026-07-28) request is served from: mode and tool set
+     * resolved against *that request's* declared identity, and a resource service bound to both.
+     * Nothing request-specific is written back to the facade, so concurrent requests with different
+     * identities cannot contaminate each other.
+     */
+    async createRequestSnapshot(clientContext) {
+        // From the configured option, not `_serverMode` — same reason as
+        // {@link getStatelessServerInstructions}.
+        const serverMode = resolveServerMode(this.serverModeOption, isUiSupportedByClient(clientContext));
+        const view = { serverMode, clientContext };
+        // Re-compose from the retained sources, not the live `tools` map (composed for the
+        // instance's own view). Directly upserted tools are deliberately left out — carrying them
+        // over would re-add tools this view's gating just withheld.
+        const tools = new Map();
+        for (const source of this.toolSources.values()) {
+            for (const tool of this.composeToolsForClient(source, view)) {
+                const stored = this.toStoredTool(tool);
+                tools.set(stored.name, stored);
+            }
+        }
+        const availableWidgets = await this.resolveWidgetsForMode(serverMode);
+        return {
+            serverMode,
+            clientContext,
+            tools,
+            resourceService: createResourceService({
+                paymentProvider: this.options.paymentProvider,
+                getMode: () => serverMode,
+                getAvailableWidgets: () => availableWidgets,
+            }),
+            createApifyClient: (token) => this.createApifyClient(token, clientContext),
+        };
     }
     /** True once the connecting client is known (set in the initialize handler, or hydrated by a
      *  recovery path). Only client-gated tools wait for this so the per-client blocklist can be
@@ -306,37 +356,34 @@ export class ActorsMcpServer {
         return this.clientContext != null;
     }
     /**
-     * Compose the tool list for the current connection: resolve mode-specific tools, then drop
-     * report-problem unless it is currently servable (see {@link isReportProblemServable}).
-     * report-problem is a default-injected tool (via tools_loader) rather than a category member,
-     * gated here by servability. Every other tool composes eagerly, so a recovery/rehydration load
-     * without an initialize still restores them. report-problem is withheld until the client is known
-     * and re-added by the initialize flush. Used by every input-driven load path and the flush.
-     * (Actor tools are never gated, so they need no filtering.)
+     * Compose one source's tool list against `view`: resolve mode-specific tools, then drop
+     * report-problem unless servable for that view ({@link isReportProblemServable}). Load paths
+     * and the initialize flush pass the instance's own {@link servingContext};
+     * {@link createRequestSnapshot} passes a view derived from one stateless request.
      */
-    composeToolsForClient(input, actorTools) {
-        const tools = getToolsForServerMode(input, actorTools, this.serverMode);
-        if (this.isReportProblemServable())
+    composeToolsForClient(source, view) {
+        const tools = getToolsForServerMode(source.input, source.actorTools, view.serverMode);
+        if (this.isReportProblemServable(view))
             return tools;
         return tools.filter((tool) => tool.name !== HELPER_TOOLS.PROBLEM_REPORT);
     }
     /**
-     * Whether report-problem may be served on this connection right now:
-     * - Its only function is forwarding submissions via telemetry, so it is never servable when
-     *   telemetry is disabled (it would just fake an acknowledgement into the void).
-     * - It cannot be judged until the connecting client is known, so it is withheld until then;
-     *   the initialize flush re-composes and adds it if the client allows.
-     * Every other tool is unconditionally servable, so recovery loads compose them eagerly and they
-     * survive a load that never sees an initialize.
+     * Whether report-problem may be served against `view`. Never without telemetry (submissions
+     * would vanish into the void) and never before a client context exists — on a stateful
+     * connection the initialize flush re-adds it once the handshake supplies one.
+     *
+     * The stateless envelope requires protocol and capability metadata but not `clientInfo`. A
+     * request declaring no client name matches no blocked substring and is served the tool by
+     * policy.
      */
-    isReportProblemServable() {
-        return this.telemetryEnabled && this.clientKnown && !isReportProblemBlockedForClient(this.clientContext);
+    isReportProblemServable(view) {
+        return (this.telemetryEnabled && view.clientContext != null && !isReportProblemBlockedForClient(view.clientContext));
     }
     composePendingToolsForClient() {
-        if (this.pendingToolsUntilClientKnown.length === 0)
+        if (this.pendingToolsUntilClientKnown.size === 0)
             return;
-        const tools = this.pendingToolsUntilClientKnown.flatMap(({ input, actorTools }) => this.composeToolsForClient(input, actorTools));
-        this.pendingToolsUntilClientKnown = [];
+        const tools = [...this.pendingToolsUntilClientKnown.values()].flatMap((source) => this.composeToolsForClient(source, this.servingContext));
+        this.pendingToolsUntilClientKnown.clear();
         // Load paths already upserted the client-agnostic tools pre-init; re-upserting is
         // idempotent, and this pass adds the client-gated tools (e.g. report-problem) now that the
         // client is known.
@@ -382,25 +429,26 @@ export class ActorsMcpServer {
         return [...this.listInternalToolNames(), ...this.listActorToolNames(), ...this.listActorMcpServerToolIds()];
     }
     /**
-     * Buffer-or-compose gate shared by the actor-tools loaders. If the server mode isn't resolved
-     * yet ('auto' before initialize), queue the whole source for `composePendingToolsForClient` and
-     * (if non-empty) upsert the mode-agnostic actor tools immediately.
-     * Once the mode is resolved, compose the client-specific set via `composeToolsForClient` (which
-     * withholds report-problem until the client is known) and upsert it; if the client still isn't
-     * known, queue the source so the initialize flush re-composes and adds the client-gated tools.
+     * Buffer-or-compose gate shared by the actor-tools loaders. Mode not resolved yet: queue the
+     * source for the initialize flush, upserting the mode-agnostic actor tools immediately. Mode
+     * resolved: compose and upsert now; if the client is still unknown, also queue the source so
+     * the flush adds the client-gated tools.
      */
     registerFetchedActorTools(input, actorTools) {
+        const source = { input, actorTools };
+        const key = toolSourceKey(input);
+        this.toolSources.set(key, source);
         if (!this.serverModeResolved) {
-            this.pendingToolsUntilClientKnown.push({ input, actorTools });
+            this.pendingToolsUntilClientKnown.set(key, source);
             if (actorTools.length > 0)
                 this.upsertTools(actorTools);
             return;
         }
-        const tools = this.composeToolsForClient(input, actorTools);
+        const tools = this.composeToolsForClient(source, this.servingContext);
         if (tools.length > 0)
             this.upsertTools(tools);
         if (!this.clientKnown)
-            this.pendingToolsUntilClientKnown.push({ input, actorTools });
+            this.pendingToolsUntilClientKnown.set(key, source);
     }
     /**
      * Loads missing toolNames from a provided list of tool names.
@@ -429,14 +477,9 @@ export class ActorsMcpServer {
         this.registerFetchedActorTools(input, actorTools);
     }
     /**
-     * Two-phase: getActors (async, client-agnostic Apify fetch) then composeToolsForClient
-     * (sync compose + servability filter). If the mode isn't resolved yet ('auto' before initialize)
-     * the whole source is queued for the flush. Otherwise tools compose immediately; client-gated
-     * tools are withheld until the client is known, and the source is queued so the flush adds them.
-     *
-     * Don't move the getActors await into the initialize handler — clients time out
-     * waiting for InitializeResult. The queue buffers already-fetched data, not network
-     * work. See #721.
+     * Two-phase: getActors (async, client-agnostic fetch) then the buffer-or-compose gate.
+     * Don't move the getActors await into the initialize handler — clients time out waiting for
+     * InitializeResult; the queue buffers already-fetched data, not network work. See #721.
      */
     async loadToolsFromInput(input, apifyClient) {
         const actorTools = await getActors(input, apifyClient, {
@@ -445,86 +488,22 @@ export class ActorsMcpServer {
         });
         this.registerFetchedActorTools(input, actorTools);
     }
-    /** Delete tools from the server. */
-    removeToolsByName(toolNames) {
-        const removedTools = [];
-        for (const toolName of toolNames) {
-            if (this.removeToolByName(toolName)) {
-                removedTools.push(toolName);
-            }
-        }
-        return removedTools;
-    }
     /**
-     * Upsert new tools.
-     * @param tools - Array of tool wrappers to add or update
-     * @returns Array of added/updated tool wrappers
+     * Upsert new tools. Writes the shared tool map directly, bypassing the retained load sources,
+     * so a tool added only this way reaches no stateless snapshot. Load through `loadToolsFrom*` /
+     * `loadToolsByName` instead to serve a tool on both protocol eras.
      */
     upsertTools(tools) {
-        // Client gating (e.g. hiding report-problem from Anthropic surfaces) is applied earlier, in
-        // composeToolsForClient — the single compose choke point where the client is known. Do not
-        // filter here: this is a low-level commit point reached before the client is known too.
+        // Client gating happens earlier, in composeToolsForClient. Do not filter here: this is a
+        // low-level commit point reached before the client is known too.
         for (const tool of tools) {
-            const stored = this.options.paymentProvider ? this.options.paymentProvider.decorateToolSchema(tool) : tool;
+            const stored = this.toStoredTool(tool);
             this.tools.set(stored.name, stored);
         }
         return tools;
     }
-    removeToolByName(toolName) {
-        if (this.tools.has(toolName)) {
-            this.tools.delete(toolName);
-            log.debug('Deleted tool', { toolName });
-            return true;
-        }
-        return false;
-    }
-    setupErrorHandling(setupSIGINTHandler = true) {
-        this.server.onerror = (error) => {
-            var _a;
-            // Known client faults are expected noise, not server bugs — softFail so they don't
-            // flood Mezmo error alerts. The fault patterns live in utils/logging.ts.
-            const message = (_a = error.message) !== null && _a !== void 0 ? _a : '';
-            if (isMcpClientFaultMessage(message)) {
-                // Sanitize the errMessage value to preserve the soft-fail level (Mezmo promotes
-                // entries whose message contains "error").
-                log.softFail('MCP client fault, request could not be handled', {
-                    errMessage: sanitizeMezmoMessage(message),
-                });
-            }
-            else {
-                log.error('[MCP Error]', { error });
-            }
-        };
-        if (setupSIGINTHandler) {
-            const handler = async () => {
-                await this.server.close();
-                process.exit(0);
-            };
-            process.once('SIGINT', handler);
-            this.sigintHandler = handler;
-        }
-    }
-    setupLoggingProxy() {
-        const originalSendLoggingMessage = this.server.sendLoggingMessage.bind(this.server);
-        // Filter outgoing log messages below the client's requested level.
-        this.server.sendLoggingMessage = async (params) => {
-            var _a, _b;
-            const messageLevelValue = (_a = LOG_LEVEL_MAP[params.level]) !== null && _a !== void 0 ? _a : -1; // Unknown levels get -1, discard
-            const currentLevelValue = (_b = LOG_LEVEL_MAP[this.currentLogLevel]) !== null && _b !== void 0 ? _b : LOG_LEVEL_MAP.info; // Default to info if invalid
-            if (messageLevelValue >= currentLevelValue) {
-                await originalSendLoggingMessage(params);
-            }
-        };
-    }
-    setupLoggingHandlers() {
-        this.server.setRequestHandler(SetLevelRequestSchema, (request) => {
-            const { level } = request.params;
-            if (LOG_LEVEL_MAP[level] !== undefined) {
-                this.currentLogLevel = level;
-            }
-            // Sending empty result based on MCP spec
-            return {};
-        });
+    toStoredTool(tool) {
+        return this.options.paymentProvider ? this.options.paymentProvider.decorateToolSchema(tool) : tool;
     }
     /**
      * Token sources in order: per-request `_meta.apifyToken` (stdio inline) > server-instance
@@ -542,428 +521,54 @@ export class ActorsMcpServer {
      * Still carries the request-origin tag from the client context captured by this point.
      */
     resolveApifyClient(params) {
-        const token = this.resolveApifyToken(params._meta);
-        return token
-            ? new ApifyClient({ token, requestOrigin: getRequestOriginForClient(this.clientContext) })
-            : undefined;
+        return this.createApifyClient(this.resolveApifyToken(params._meta), this.clientContext);
     }
-    setupResourceHandlers() {
-        const resourceService = createResourceService({
-            paymentProvider: this.options.paymentProvider,
-            getMode: () => this.serverMode,
-            getAvailableWidgets: () => this.availableWidgets,
-        });
-        this.server.setRequestHandler(ListResourcesRequestSchema, async () => {
-            return await resourceService.listResources();
-        });
-        this.server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
-            try {
-                return await resourceService.readResource(request.params.uri, this.resolveApifyClient(request.params));
-            }
-            catch (error) {
-                throw toLegacyMcpError(error);
-            }
-        });
-        this.server.setRequestHandler(ListResourceTemplatesRequestSchema, async () => {
-            return await resourceService.listResourceTemplates();
-        });
+    /** The one place a request-scoped Apify client is constructed, on either protocol era. */
+    createApifyClient(token, clientContext) {
+        return token ? new ApifyClient({ token, requestOrigin: getRequestOriginForClient(clientContext) }) : undefined;
     }
     /**
-     * Sets up MCP request handlers for prompts. The prompt service throws domain errors; the
-     * boundary maps them to `McpError` so wire output is unchanged.
+     * Widgets servable in `mode`: none outside apps mode, otherwise the disk registry. A successful
+     * scan is memoized per facade (a widget file appearing later is not picked up); a failed one is
+     * dropped so the next caller retries. Touches no per-connection state, so a per-request caller
+     * cannot disturb a concurrent one.
      */
-    setupPromptHandlers() {
-        const promptService = createPromptService(prompts);
-        this.server.setRequestHandler(ListPromptsRequestSchema, () => promptService.listPrompts());
-        this.server.setRequestHandler(GetPromptRequestSchema, async (request) => {
-            try {
-                return promptService.getPrompt(request.params.name, request.params.arguments);
-            }
-            catch (error) {
-                throw toLegacyMcpError(error);
-            }
-        });
-    }
-    /**
-     * Fetches a task by ID, softFail-logging and throwing a client-facing McpError if it doesn't exist.
-     */
-    async getTaskOrThrow(taskId, mcpSessionId, logTag) {
-        const task = await this.taskStore.getTask(taskId, mcpSessionId);
-        if (!task) {
-            // Client error (invalid/unknown taskId) — softFail to avoid polluting error logs.
-            log.softFail(`[${logTag}] Task not found`, { taskId, mcpSessionId, statusCode: 404 });
-            throw new McpError(ErrorCode.InvalidParams, `Task "${taskId}" not found`);
-        }
-        return task;
-    }
-    /**
-     * Sets up MCP request handlers for long-running tasks.
-     * Each handler reads `_meta.mcpSessionId` (injected at the transport layer) to isolate
-     * per-session task stores.
-     */
-    setupTaskHandlers() {
-        // List tasks
-        this.server.setRequestHandler(ListTasksRequestSchema, async (request) => {
-            var _a;
-            const params = (request.params || {});
-            const { cursor } = params;
-            const mcpSessionId = (_a = params._meta) === null || _a === void 0 ? void 0 : _a.mcpSessionId;
-            log.debug('[ListTasksRequestSchema] Listing tasks', { mcpSessionId });
-            const result = await this.taskStore.listTasks(cursor, mcpSessionId);
-            return { tasks: result.tasks, nextCursor: result.nextCursor };
-        });
-        // Get task status
-        this.server.setRequestHandler(GetTaskRequestSchema, async (request) => {
-            var _a;
-            const params = (request.params || {});
-            const { taskId } = params;
-            const mcpSessionId = (_a = params._meta) === null || _a === void 0 ? void 0 : _a.mcpSessionId;
-            log.debug('[GetTaskRequestSchema] Getting task status', { taskId, mcpSessionId });
-            return await this.getTaskOrThrow(taskId, mcpSessionId, 'GetTaskRequestSchema');
-        });
-        // Get task result payload
-        this.server.setRequestHandler(GetTaskPayloadRequestSchema, async (request) => {
-            var _a;
-            const params = (request.params || {});
-            const { taskId } = params;
-            const mcpSessionId = (_a = params._meta) === null || _a === void 0 ? void 0 : _a.mcpSessionId;
-            log.debug('[GetTaskPayloadRequestSchema] Getting task result', { taskId, mcpSessionId });
-            const task = await this.getTaskOrThrow(taskId, mcpSessionId, 'GetTaskPayloadRequestSchema');
-            if (task.status !== 'completed' && task.status !== 'failed') {
-                throw new McpError(ErrorCode.InvalidParams, `Task "${taskId}" is not completed yet. Current status: ${task.status}`);
-            }
-            const result = await this.taskStore.getTaskResult(taskId, mcpSessionId);
-            // taskId is not in the result body — _meta.related-task lets clients correlate them
-            return {
-                ...result,
-                _meta: {
-                    ...result._meta,
-                    [RELATED_TASK_META_KEY]: { taskId },
-                },
-            };
-        });
-        // Cancel task
-        this.server.setRequestHandler(CancelTaskRequestSchema, async (request) => {
-            var _a;
-            const params = (request.params || {});
-            const { taskId } = params;
-            const mcpSessionId = (_a = params._meta) === null || _a === void 0 ? void 0 : _a.mcpSessionId;
-            log.debug('[CancelTaskRequestSchema] Cancelling task', { taskId, mcpSessionId });
-            const task = await this.getTaskOrThrow(taskId, mcpSessionId, 'CancelTaskRequestSchema');
-            if (task.status === 'completed' || task.status === 'failed' || task.status === 'cancelled') {
-                // Client error (cancel on terminal task) — softFail to avoid polluting error logs.
-                log.softFail('[CancelTaskRequestSchema] Task already in terminal state', {
-                    taskId,
-                    mcpSessionId,
-                    status: task.status,
-                    statusCode: 409,
-                });
-                throw new McpError(ErrorCode.InvalidParams, `Cannot cancel task "${taskId}" with status "${task.status}"`);
-            }
-            await this.taskStore.updateTaskStatus(taskId, 'cancelled', 'Cancelled by client', mcpSessionId);
-            const updatedTask = await this.taskStore.getTask(taskId, mcpSessionId);
-            log.debug('[CancelTaskRequestSchema] Task cancelled successfully', { taskId, mcpSessionId });
-            await emitTaskStatusNotification(taskId, mcpSessionId, this.taskStore, this.server);
-            return updatedTask;
-        });
-    }
-    setupToolHandlers() {
-        // Handles the request to list tools.
-        this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-            const tools = Array.from(this.tools.values()).map((tool) => getToolPublicFieldOnly(tool, {
-                mode: this.serverMode,
-                filterWidgetMeta: true,
-            }));
-            return { tools };
-        });
-        /**
-         * Handles the request to call a tool. `extra` carries request-scoped helpers such as
-         * `sendNotification`. Throws {@link McpError} to mirror the MCP SDK's McpServer error codes.
-         */
-        this.server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
-            var _a, _b, _c;
-            const params = request.params;
-            // Keep telemetry on the decoded arguments.
-            // eslint-disable-next-line prefer-const
-            let { name, arguments: args, _meta: meta } = params;
-            const progressToken = meta === null || meta === void 0 ? void 0 : meta.progressToken;
-            const apifyToken = this.resolveApifyToken(meta);
-            // Injected upstream; required for long-running tasks — the task store keys on it and
-            // there is no other channel to pass it.
-            const mcpSessionId = meta === null || meta === void 0 ? void 0 : meta.mcpSessionId;
-            if (!mcpSessionId) {
-                log.error('MCP Session ID is missing in tool call request. This should never happen.');
-                throw new Error('MCP Session ID is required for tool calls');
-            }
-            const startTime = Date.now();
-            let toolStatus = TOOL_STATUS.SUCCEEDED;
-            let callDiagnostics = {};
-            let shouldTrackTelemetry = true;
-            let resolvedToolName = name;
-            // Set only on the pre-flight task path — the one task-mode flow whose telemetry rides
-            // this handler's `finally` — so its `Tool call completed` log line keeps the taskId the
-            // async path logs via finishTaskTracking.
-            let preflightTaskId;
-            // The nudge must be included in the measured result.
-            let toolResult = null;
-            // Keep actor context available to the outer catch.
-            let actorName;
-            let actorId;
-            const { clientContext } = this;
-            // Start with the raw name so early failures still have telemetry.
-            const { telemetryData, userId } = await prepareTelemetryData({
-                toolName: name,
-                mcpSessionId,
-                apifyToken,
-                apifyMcpServer: this,
-                clientContext,
-            });
-            try {
-                const prepared = await prepareToolCall({
-                    apifyMcpServer: this,
-                    apifyToken,
-                    name,
-                    args,
-                    meta,
-                    requestHeaders: (_a = extra.requestInfo) === null || _a === void 0 ? void 0 : _a.headers,
-                    isTaskRequest: Boolean(request.params.task),
-                    mcpSessionId,
-                    telemetryData,
-                    clientContext,
-                    extra,
-                });
-                if ('result' in prepared) {
-                    // The engine already classified this post-resolution failure.
-                    resolvedToolName = prepared.resolvedToolName;
-                    args = prepared.decodedArgs;
-                    toolStatus = prepared.toolStatus;
-                    callDiagnostics = prepared.callDiagnostics;
-                    toolResult = prepared.result;
-                    return prepared.result;
-                }
-                if ('message' in prepared) {
-                    // Reproduce v1's invalid-params tail and preserve telemetry fields.
-                    resolvedToolName = (_b = prepared.resolvedToolName) !== null && _b !== void 0 ? _b : resolvedToolName;
-                    if (prepared.decodedArgs)
-                        args = prepared.decodedArgs;
-                    toolStatus = prepared.toolStatus;
-                    callDiagnostics = prepared.callDiagnostics;
-                    log.softFail(prepared.message, {
-                        mcpSessionId,
-                        failureCategory: prepared.callDiagnostics.failure_category,
-                        actorName: prepared.callDiagnostics.actor_name,
-                        validationKeyword: prepared.callDiagnostics.validation_keyword,
-                        validationPath: prepared.callDiagnostics.validation_path,
-                        validationMissingProperty: prepared.callDiagnostics.validation_missing_property,
-                        validationAdditionalProperty: prepared.callDiagnostics.validation_additional_property,
-                        ...prepared.logFields,
-                    });
-                    await this.server.sendLoggingMessage({ level: 'error', data: prepared.message });
-                    throw new McpError(ErrorCode.InvalidParams, prepared.message);
-                }
-                const { tool, toolArgs, logSafeArgs, apifyClient, standbyRejection, paymentRequiredResult } = prepared;
-                actorName = prepared.actorName;
-                actorId = prepared.actorId;
-                resolvedToolName = getToolFullName(tool);
-                // Telemetry uses the decoded arguments.
-                args = prepared.decodedArgs;
-                // TODO: we should split this huge method into smaller parts as it is slowly getting out of hand
-                // Handle long-running task request
-                if (request.params.task) {
-                    const task = await this.taskStore.createTask({
-                        ttl: request.params.task.ttl,
-                    }, `call-tool-${name}-${randomUUID()}`, request, mcpSessionId);
-                    log.debug('Created task for tool execution', {
-                        taskId: task.taskId,
-                        toolName: tool.name,
-                        mcpSessionId,
-                    });
-                    // Pre-flight failure is already known — the outcome needs no work. Resolve the
-                    // task synchronously: store the failure as the terminal `completed` result and emit
-                    // exactly one `completed` status notification (no `updateTaskStatus('working')`, so no
-                    // `working` notification). Standby rejection wins over the generic payment-required
-                    // short-circuit, matching the sync path's precedence. Telemetry rides the handler's
-                    // outer `finally` (shouldTrackTelemetry stays true), firing once with the sync-path
-                    // properties plus the taskId on the log line.
-                    const preflightResult = standbyRejection !== null && standbyRejection !== void 0 ? standbyRejection : paymentRequiredResult;
-                    if (preflightResult) {
-                        const outcome = buildPreflightFailureOutcome(standbyRejection, paymentRequiredResult, actorName, actorId);
-                        toolStatus = outcome.toolStatus;
-                        callDiagnostics = outcome.callDiagnostics;
-                        preflightTaskId = task.taskId;
-                        try {
-                            await storeTaskResultOrSkipIfExpired(this.taskStore, tool.name, task.taskId, 'completed', outcome.result, mcpSessionId);
-                        }
-                        catch (error) {
-                            // A store failure (not expiry) would otherwise fall through to the generic
-                            // catch and return a task-less tool result the client rejects as a
-                            // CreateTaskResult parse error; surface it as a protocol error instead.
-                            // The pre-flight outcome left toolStatus=SOFT_FAIL, but a genuine store
-                            // outage is a hard failure — correct it before throwing so the handler
-                            // `finally` logs FAILED/INTERNAL_ERROR, not the stale pre-flight SOFT_FAIL.
-                            toolStatus = TOOL_STATUS.FAILED;
-                            callDiagnostics = {
-                                failure_category: FAILURE_CATEGORY.INTERNAL_ERROR,
-                                ...buildActorFields(actorName, actorId),
-                            };
-                            throw new McpError(ErrorCode.InternalError, `Failed to store the pre-flight result for task "${task.taskId}": ${error instanceof Error ? error.message : String(error)}`);
-                        }
-                        // Defer so the client sees the CreateTaskResult (and learns the taskId) before
-                        // the terminal status notification — the async path's post-response ordering.
-                        // emitTaskStatusNotification never throws and no-ops if the task expired.
-                        setImmediate(() => {
-                            void emitTaskStatusNotification(task.taskId, mcpSessionId, this.taskStore, this.server);
-                        });
-                        // Measure the nudged result without changing the stored result.
-                        toolResult = withReportProblemNudge({
-                            result: outcome.result,
-                            tools: this.tools,
-                            failingToolName: resolvedToolName,
-                            failureCategory: callDiagnostics.failure_category,
-                            failureHttpStatus: callDiagnostics.failure_http_status,
-                        });
-                        // createTask returned status `working`; synthesize the terminal status instead of
-                        // re-fetching — if the task expired before the result store (the one case
-                        // storeTaskResultOrSkipIfExpired tolerates), a re-fetch would come back empty and a
-                        // `working` fallback would contradict the tasks/get 404 the client sees next.
-                        return { task: { ...task, status: 'completed' } };
-                    }
-                    // Execute the tool asynchronously and update task status
-                    setImmediate(() => {
-                        executeToolAndUpdateTask({
-                            taskId: task.taskId,
-                            tool,
-                            toolArgs,
-                            logSafeArgs,
-                            apifyClient,
-                            apifyToken,
-                            progressToken,
-                            extra,
-                            mcpSessionId,
-                            actorName,
-                            actorId,
-                            apifyMcpServer: this,
-                            clientContext,
-                        }).catch((error) => 
-                        // Benign task-expiry is handled in-method (see the catch block and
-                        // storeTaskResultOrSkipIfExpired); anything reaching here is genuinely unexpected.
-                        log.error('executeToolAndUpdateTask failed unexpectedly', { taskId: task.taskId, error }));
-                    });
-                    // Return the task immediately; execution continues asynchronously
-                    shouldTrackTelemetry = false;
-                    return { task };
-                }
-                // Sync path: run the shared dispatch tail and project its neutral outcome by identity.
-                const outcome = await executeSyncToolCall(prepared, {
-                    apifyMcpServer: this,
-                    apifyToken,
-                    toolName: name,
-                    mcpSessionId,
-                    progressToken,
-                    extra,
-                });
-                toolStatus = outcome.toolStatus;
-                callDiagnostics = outcome.callDiagnostics;
-                toolResult = outcome.result;
-                return outcome.result;
-            }
-            catch (error) {
-                // Match v1: classify task-creation failures, but re-throw protocol errors as JSON-RPC.
-                if (error instanceof McpError) {
-                    throw error;
-                }
-                const outcome = classifyToolCallError(error, {
-                    apifyMcpServer: this,
-                    toolName: name,
-                    failingToolName: resolvedToolName,
-                    actorName,
-                    actorId,
-                    isAborted: Boolean((_c = extra.signal) === null || _c === void 0 ? void 0 : _c.aborted),
-                    mcpSessionId,
-                });
-                toolStatus = outcome.toolStatus;
-                callDiagnostics = outcome.callDiagnostics;
-                toolResult = outcome.result;
-                return outcome.result;
-            }
-            finally {
-                if (shouldTrackTelemetry) {
-                    logToolCallAndTelemetry({
-                        toolName: resolvedToolName,
-                        mcpSessionId,
-                        toolStatus,
-                        startTime,
-                        telemetryData,
-                        userId,
-                        callDiagnostics,
-                        args,
-                        result: toolResult,
-                        taskId: preflightTaskId,
-                        apifyMcpServer: this,
-                    });
-                }
-            }
-        });
-    }
-    /**
-     * Resolves widgets and determines which ones are ready to be served.
-     */
-    async resolveWidgets() {
-        if (this.serverMode !== SERVER_MODE.APPS) {
-            return;
-        }
-        try {
-            const { fileURLToPath } = await import('node:url');
-            const path = await import('node:path');
-            const filename = fileURLToPath(import.meta.url);
-            const dirName = path.dirname(filename);
-            const resolved = await resolveAvailableWidgets(dirName);
-            this.availableWidgets = resolved;
-            const readyWidgets = [];
-            const missingWidgets = [];
-            for (const [uri, widget] of resolved.entries()) {
-                if (widget.exists) {
-                    readyWidgets.push(widget.name);
-                }
-                else {
-                    missingWidgets.push(widget.name);
-                    log.softFail(`Widget file not found: ${widget.jsPath} (widget: ${uri})`);
-                }
-            }
-            if (readyWidgets.length > 0) {
-                log.debug('Ready widgets', { widgets: readyWidgets });
-            }
-            if (missingWidgets.length > 0) {
-                log.softFail('Some widgets are not ready', {
-                    widgets: missingWidgets,
-                    note: 'These widgets will not be available. Ensure web/dist files are built and included in deployment.',
-                });
-            }
+    async resolveWidgetsForMode(mode) {
+        var _a;
+        if (mode !== SERVER_MODE.APPS) {
+            return new Map();
         }
-        catch (error) {
+        // Catch on the shared attempt, not per awaiter: N callers awaiting one rejected scan would
+        // otherwise report one root cause N times. Dropping the memo lets the next caller re-run it.
+        const resolution = ((_a = this.widgetsResolution) !== null && _a !== void 0 ? _a : (this.widgetsResolution = resolveServableWidgets().catch((error) => {
+            this.widgetsResolution = undefined;
             const errorMessage = error instanceof Error ? error.message : String(error);
             log.softFail(`Failed to resolve widgets: ${errorMessage}`);
             // Continue without widgets
-        }
+            return new Map();
+        })));
+        return await resolution;
+    }
+    /**
+     * Resolve the instance's own widget map for this connection's mode. The only writer of that
+     * field — per-request callers take the map `resolveWidgetsForMode` returns instead.
+     */
+    async resolveInstanceWidgets() {
+        this.availableWidgets = await this.resolveWidgetsForMode(this.serverMode);
     }
     async connect(transport) {
-        await this.resolveWidgets();
-        await this.server.connect(transport);
+        await this.resolveInstanceWidgets();
+        await this.legacyServer.connect(transport);
     }
     async close() {
-        if (this.sigintHandler) {
-            process.removeListener('SIGINT', this.sigintHandler);
-            this.sigintHandler = undefined;
-        }
-        // Clear all tools and null their compiled schemas.
-        for (const tool of this.tools.values()) {
-            if (tool.ajvValidate && typeof tool.ajvValidate === 'function') {
-                tool.ajvValidate = null;
-            }
-        }
+        // Transport/server down first, then everything this facade retains: the composed map plus
+        // both source maps, each holding every fetched `ToolEntry` with its compiled AJV validator.
+        // Close is the release point — a long-lived host churning sessions must not accumulate them
+        // — so a stateless snapshot taken after close composes no tools.
+        await this.legacyServer.close();
         this.tools.clear();
-        // Closing the server also removes its event handlers.
-        await this.server.close();
+        this.toolSources.clear();
+        this.pendingToolsUntilClientKnown.clear();
     }
 }
 //# sourceMappingURL=server.js.map