@apify/actors-mcp-server 0.11.7-beta.9 → 0.11.8-beta.0

package/dist/mcp/server.js

@@ -19,28 +19,28 @@ import { prompts } from '../prompts/index.js';
 import { createResourceService } from '../resources/resource_service.js';
 import { resolveAvailableWidgets } from '../resources/widgets.js';
 import { getServerInfo } from '../server_card.js';
-import { buildReportedProblemProperties, getTelemetryEnv, trackReportedProblem, trackToolCall } from '../telemetry.js';
+import { getTelemetryEnv } from '../telemetry.js';
 import { decodeDotPropertyNames } from '../tools/actor_input_schema.js';
 import { legacyToolNameToNew } from '../tools/actor_tool_naming.js';
 import { checkPaymentProviderStandbyConflict } from '../tools/actors/call_actor.js';
-import { appendReportProblemNudge } from '../tools/dev/report_problem.js';
+import { withReportProblemNudge } from '../tools/dev/report_problem.js';
 import { getActorsAsTools } from '../tools/index.js';
 import { SERVER_MODE, TOOL_TYPE } from '../types.js';
 import { isMcpClientFaultMessage, logHttpError, sanitizeMezmoMessage } from '../utils/logging.js';
-import { computeToolResponseBytes, respondOk } from '../utils/mcp.js';
+import { respondOk } from '../utils/mcp.js';
 import { isReportProblemBlockedForClient } from '../utils/mcp_clients.js';
 import { createProgressTracker } from '../utils/progress.js';
 import { getServerInstructions } from '../utils/server-instructions/index.js';
 import { parseServerMode, resolveServerMode } from '../utils/server_mode.js';
-import { deriveResourceIds, extractAjvErrorDetails } from '../utils/tool_status.js';
+import { extractAjvErrorDetails } from '../utils/tool_status.js';
 import { buildActorFields, extractActorId, extractActorName, getToolFullName, getToolPublicFieldOnly, } from '../utils/tools.js';
 import { getActors, getToolsForServerMode, toolNamesToInput } from '../utils/tools_loader.js';
-import { getUserInfoCached } from '../utils/userid_cache.js';
-import { getPackageVersion } from '../utils/version.js';
 import { LOG_LEVEL_MAP } from './const.js';
+import { emitTaskStatusNotification, executeToolAndUpdateTask } from './task_execution.js';
 import { buildToolCallErrorResult, TOOL_CALL_ERROR_KIND } from './tool_call_error_mapper.js';
+import { logToolCallAndTelemetry, prepareTelemetryData } from './tool_call_telemetry.js';
 import { dispatchToolCall } from './tool_dispatch.js';
-import { createTaskCancellationWatcher, isTaskCancelled, isTaskNotFoundError, parseInputParamsFromUrl, storeTaskResultOrSkipIfExpired, } from './utils.js';
+import { parseInputParamsFromUrl, storeTaskResultOrSkipIfExpired } from './utils.js';
 /**
  * Returns true when the initialize request advertises the MCP Apps UI extension
  * with the widget MIME type. Used to resolve `'auto'` server mode.
@@ -54,33 +54,6 @@ function isUiSupportedByClient(request) {
     const uiCap = getUiCapability((_a = request === null || request === void 0 ? void 0 : request.params) === null || _a === void 0 ? void 0 : _a.capabilities);
     return (_c = (_b = uiCap === null || uiCap === void 0 ? void 0 : uiCap.mimeTypes) === null || _b === void 0 ? void 0 : _b.includes(RESOURCE_MIME_TYPE)) !== null && _c !== void 0 ? _c : false;
 }
-/** Send notifications/tasks/status for taskId. Routes via session transport (no relatedRequestId).
- *  Swallows errors — notifications are advisory. */
-export async function emitTaskStatusNotification(taskId, mcpSessionId, taskStore, server) {
-    try {
-        const task = await taskStore.getTask(taskId, mcpSessionId);
-        if (!task)
-            return;
-        // Per spec: notifications/tasks/status MUST NOT carry _meta.related-task (task ID is in params).
-        // Called without options so the notification routes through the session transport,
-        // not the request-scoped stream (which closes once the initial { task } response is flushed).
-        await server.notification({
-            method: 'notifications/tasks/status',
-            params: {
-                taskId: task.taskId,
-                status: task.status,
-                createdAt: task.createdAt,
-                lastUpdatedAt: task.lastUpdatedAt,
-                ttl: task.ttl,
-                ...(task.statusMessage != null && { statusMessage: task.statusMessage }),
-                ...(task.pollInterval != null && { pollInterval: task.pollInterval }),
-            },
-        });
-    }
-    catch {
-        // Silent fail — notifications are advisory
-    }
-}
 /**
  * Shared diagnostics for a pre-flight failure (standby-provider conflict or missing/invalid payment
  * signature) — a call outcome already known before any Actor runs. Standby rejection wins over the
@@ -197,18 +170,18 @@ export class ActorsMcpServer {
             writable: true,
             value: []
         });
-        // Telemetry configuration (resolved from options and env vars in setupTelemetry)
+        // Telemetry configuration (resolved from options and env vars, see setupTelemetry)
         Object.defineProperty(this, "telemetryEnabled", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: null
+            value: void 0
         });
         Object.defineProperty(this, "telemetryEnv", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: DEFAULT_TELEMETRY_ENV
+            value: void 0
         });
         // List of widgets that are ready to be served
         Object.defineProperty(this, "availableWidgets", {
@@ -265,17 +238,16 @@ export class ActorsMcpServer {
                         },
                     },
                 },
-                /**
-                 * Declaring resources even though we are not using them
-                 * to prevent clients like Claude desktop from failing.
-                 */
+                // Declared but unused — some clients (e.g. Claude Desktop) fail without it.
                 resources: {},
                 prompts: {},
                 logging: {},
             },
             instructions: getServerInstructions(),
         });
-        this.setupTelemetry();
+        const { telemetryEnabled, telemetryEnv } = this.setupTelemetry();
+        this.telemetryEnabled = telemetryEnabled;
+        this.telemetryEnv = telemetryEnv;
         this.setupInitializeHandler();
         this.setupLoggingProxy();
         this.tools = new Map();
@@ -283,9 +255,7 @@ export class ActorsMcpServer {
         this.setupLoggingHandlers();
         this.setupToolHandlers();
         this.setupPromptHandlers();
-        /**
-         * We need to handle resource requests to prevent clients like Claude desktop from failing.
-         */
+        // Handle resource requests so clients like Claude Desktop don't fail.
         this.setupResourceHandlers();
         this.setupTaskHandlers();
     }
@@ -294,18 +264,21 @@ export class ActorsMcpServer {
      */
     setupTelemetry() {
         var _a, _b, _c;
+        let telemetryEnabled;
         const explicitEnabled = parseBooleanOrNull((_a = this.options.telemetry) === null || _a === void 0 ? void 0 : _a.enabled);
         if (explicitEnabled !== null) {
-            this.telemetryEnabled = explicitEnabled;
+            telemetryEnabled = explicitEnabled;
         }
         else {
             const envEnabled = parseBooleanOrNull(process.env.TELEMETRY_ENABLED);
-            this.telemetryEnabled = envEnabled !== null && envEnabled !== void 0 ? envEnabled : DEFAULT_TELEMETRY_ENABLED;
+            telemetryEnabled = envEnabled !== null && envEnabled !== void 0 ? envEnabled : DEFAULT_TELEMETRY_ENABLED;
         }
         // Configure telemetryEnv: explicit option > env var > default ('PROD')
-        if (this.telemetryEnabled) {
-            this.telemetryEnv = getTelemetryEnv((_c = (_b = this.options.telemetry) === null || _b === void 0 ? void 0 : _b.env) !== null && _c !== void 0 ? _c : process.env.TELEMETRY_ENV);
+        let telemetryEnv = DEFAULT_TELEMETRY_ENV;
+        if (telemetryEnabled) {
+            telemetryEnv = getTelemetryEnv((_c = (_b = this.options.telemetry) === null || _b === void 0 ? void 0 : _b.env) !== null && _c !== void 0 ? _c : process.env.TELEMETRY_ENV);
         }
+        return { telemetryEnabled, telemetryEnv };
     }
     /**
      * Override the SDK's `initialize` request handler to run mode resolution and
@@ -387,23 +360,10 @@ export class ActorsMcpServer {
      * survive a load that never sees an initialize.
      */
     isReportProblemServable() {
-        return (!!this.telemetryEnabled &&
+        return (this.telemetryEnabled &&
             this.clientKnown &&
             !isReportProblemBlockedForClient(this.options.initializeRequestData));
     }
-    /**
-     * Append the report-problem nudge to a failed tool result. Thin wrapper over
-     * {@link appendReportProblemNudge} that fills in whether report-problem is served on this
-     * connection; suppression by category/402 is handled inside the helper.
-     */
-    withReportProblemNudge(result, failingToolName, failureCategory, failureHttpStatus) {
-        return appendReportProblemNudge(result, {
-            failingToolName,
-            available: this.tools.has(HELPER_TOOLS.PROBLEM_REPORT),
-            failureCategory,
-            failureHttpStatus,
-        });
-    }
     composePendingToolsForClient() {
         if (this.pendingToolsUntilClientKnown.length === 0)
             return;
@@ -418,7 +378,6 @@ export class ActorsMcpServer {
     }
     /**
      * Returns an array of tool names.
-     * @returns {string[]} - An array of tool names.
      */
     listToolNames() {
         return Array.from(this.tools.keys());
@@ -448,8 +407,7 @@ export class ActorsMcpServer {
         this.toolsChangedHandler = undefined;
     }
     /**
-     * Returns the list of all internal tool names
-     * @returns {string[]} - Array of loaded tool IDs (e.g., 'apify/rag-web-browser')
+     * Returns the list of all internal tool names (e.g., 'call-actor', 'search-actors').
      */
     listInternalToolNames() {
         return Array.from(this.tools.values())
@@ -457,8 +415,7 @@ export class ActorsMcpServer {
             .map((tool) => tool.name);
     }
     /**
-     * Returns the list of all currently loaded Actor tool IDs.
-     * @returns {string[]} - Array of loaded Actor tool IDs (e.g., 'apify/rag-web-browser')
+     * Returns the currently loaded Actor tool full names (e.g., 'apify/rag-web-browser').
      */
     listActorToolNames() {
         return Array.from(this.tools.values())
@@ -466,19 +423,17 @@ export class ActorsMcpServer {
             .map((tool) => tool.actorFullName);
     }
     /**
-     * Returns a list of Actor IDs that are registered as MCP servers.
-     * @returns {string[]} - An array of Actor MCP server Actor IDs (e.g., 'apify/actors-mcp-server').
+     * Returns the unique Actor IDs registered as MCP servers (e.g., 'apify/actors-mcp-server').
      */
     listActorMcpServerToolIds() {
         const ids = Array.from(this.tools.values())
             .filter((tool) => tool.type === TOOL_TYPE.ACTOR_MCP)
             .map((tool) => tool.actorId);
-        // Ensure uniqueness
         return Array.from(new Set(ids));
     }
     /**
-     * Returns a list of Actor name and MCP server tool IDs.
-     * @returns {string[]} - An array of Actor MCP server Actor IDs (e.g., 'apify/actors-mcp-server').
+     * Returns the combined internal tool names, Actor full names, and Actor-MCP server Actor IDs
+     * currently loaded.
      */
     listAllToolNames() {
         return [...this.listInternalToolNames(), ...this.listActorToolNames(), ...this.listActorMcpServerToolIds()];
@@ -512,7 +467,6 @@ export class ActorsMcpServer {
      * Loads missing toolNames from a provided list of tool names.
      * Skips toolNames that are already loaded and loads only the missing ones.
      * @param toolNames - Array of tool names to ensure are loaded
-     * @param apifyClient
      */
     async loadToolsByName(toolNames, apifyClient) {
         const loadedTools = new Set(this.listAllToolNames());
@@ -603,10 +557,8 @@ export class ActorsMcpServer {
         return tools;
     }
     notifyToolsChangedHandler() {
-        // If no handler is registered, do nothing
         if (!this.toolsChangedHandler)
             return;
-        // Get the list of tool names
         this.toolsChangedHandler(this.listAllToolNames());
     }
     removeToolByName(toolName) {
@@ -640,13 +592,12 @@ export class ActorsMcpServer {
                 process.exit(0);
             };
             process.once('SIGINT', handler);
-            this.sigintHandler = handler; // Store the actual handler
+            this.sigintHandler = handler;
         }
     }
     setupLoggingProxy() {
-        // Store original sendLoggingMessage
         const originalSendLoggingMessage = this.server.sendLoggingMessage.bind(this.server);
-        // Proxy sendLoggingMessage to filter logs
+        // 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
@@ -750,12 +701,13 @@ export class ActorsMcpServer {
     }
     /**
      * 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;
-            // mcpSessionId is injected at transport layer for session isolation in task stores
             const params = (request.params || {});
             const { cursor } = params;
             const mcpSessionId = (_a = params._meta) === null || _a === void 0 ? void 0 : _a.mcpSessionId;
@@ -766,7 +718,6 @@ export class ActorsMcpServer {
         // Get task status
         this.server.setRequestHandler(GetTaskRequestSchema, async (request) => {
             var _a;
-            // mcpSessionId is injected at transport layer for session isolation in task stores
             const params = (request.params || {});
             const { taskId } = params;
             const mcpSessionId = (_a = params._meta) === null || _a === void 0 ? void 0 : _a.mcpSessionId;
@@ -776,7 +727,6 @@ export class ActorsMcpServer {
         // Get task result payload
         this.server.setRequestHandler(GetTaskPayloadRequestSchema, async (request) => {
             var _a;
-            // mcpSessionId is injected at transport layer for session isolation in task stores
             const params = (request.params || {});
             const { taskId } = params;
             const mcpSessionId = (_a = params._meta) === null || _a === void 0 ? void 0 : _a.mcpSessionId;
@@ -798,7 +748,6 @@ export class ActorsMcpServer {
         // Cancel task
         this.server.setRequestHandler(CancelTaskRequestSchema, async (request) => {
             var _a;
-            // mcpSessionId is injected at transport layer for session isolation in task stores
             const params = (request.params || {});
             const { taskId } = params;
             const mcpSessionId = (_a = params._meta) === null || _a === void 0 ? void 0 : _a.mcpSessionId;
@@ -822,11 +771,7 @@ export class ActorsMcpServer {
         });
     }
     setupToolHandlers() {
-        /**
-         * Handles the request to list tools.
-         * @param {object} request - The request object.
-         * @returns {object} - The response object containing the tools.
-         */
+        // 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,
@@ -835,10 +780,8 @@ export class ActorsMcpServer {
             return { tools };
         });
         /**
-         * Handles the request to call a tool.
-         * @param {object} request - The request object containing tool name and arguments.
-         * @param {object} extra - Extra data given to the request handler, such as sendNotification function.
-         * @throws {McpError} - based on the McpServer class code from the typescript MCP SDK
+         * 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, _d, _e;
@@ -847,7 +790,8 @@ export class ActorsMcpServer {
             let { name, arguments: args, _meta: meta } = params;
             const progressToken = meta === null || meta === void 0 ? void 0 : meta.progressToken;
             const apifyToken = this.resolveApifyToken(meta);
-            // mcpSessionId was injected upstream it is important and required for long running tasks as the store uses it and there is not other way to pass it
+            // 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.');
@@ -868,7 +812,13 @@ export class ActorsMcpServer {
                 // On a failed result, nudge the agent to report the blocker via report-problem at the
                 // moment it decides what to do next. Gated on the tool actually being served (see
                 // isReportProblemServable), so clients where it is blocklisted or telemetry is off never see it.
-                const augmented = this.withReportProblemNudge(r, resolvedToolName, callDiagnostics.failure_category, callDiagnostics.failure_http_status);
+                const augmented = withReportProblemNudge({
+                    result: r,
+                    tools: this.tools,
+                    failingToolName: resolvedToolName,
+                    failureCategory: callDiagnostics.failure_category,
+                    failureHttpStatus: callDiagnostics.failure_http_status,
+                });
                 toolResult = augmented;
                 return augmented;
             };
@@ -890,7 +840,12 @@ export class ActorsMcpServer {
             };
             // Initialize telemetry with raw tool name — updated below once the tool is resolved.
             // This ensures telemetry is available even for early failures (missing token, tool not found).
-            const { telemetryData, userId } = await this.prepareTelemetryData(name, mcpSessionId, apifyToken);
+            const { telemetryData, userId } = await prepareTelemetryData({
+                toolName: name,
+                mcpSessionId,
+                apifyToken,
+                apifyMcpServer: this,
+            });
             // actorName/actorId are declared here so they're available in the catch block for telemetry.
             // Set after tool resolution (inside the try block).
             let actorName;
@@ -1058,7 +1013,7 @@ export class ActorsMcpServer {
                     }
                     // Execute the tool asynchronously and update task status
                     setImmediate(() => {
-                        this.executeToolAndUpdateTask({
+                        executeToolAndUpdateTask({
                             taskId: task.taskId,
                             tool,
                             toolArgs: toolArgs,
@@ -1070,6 +1025,7 @@ export class ActorsMcpServer {
                             mcpSessionId,
                             actorName,
                             actorId,
+                            apifyMcpServer: this,
                         }).catch((error) => 
                         // Benign task-expiry is handled in-method (see the catch block and
                         // storeTaskResultOrSkipIfExpired); anything reaching here is genuinely unexpected.
@@ -1182,7 +1138,7 @@ export class ActorsMcpServer {
             }
             finally {
                 if (shouldTrackTelemetry) {
-                    this.logToolCallAndTelemetry({
+                    logToolCallAndTelemetry({
                         toolName: resolvedToolName,
                         mcpSessionId,
                         toolStatus,
@@ -1193,340 +1149,12 @@ export class ActorsMcpServer {
                         args,
                         result: toolResult,
                         taskId: preflightTaskId,
+                        apifyMcpServer: this,
                     });
                 }
             }
         });
     }
-    /**
-     * Logs tool call completion at INFO level and tracks telemetry.
-     * Computes duration once so both the log line and telemetry event use the same value.
-     * Response bytes and resource ids are derived here from the raw `result` (+ `args`) so every
-     * call site stays a plain hand-off — no path can forget to compute or strip them.
-     */
-    logToolCallAndTelemetry(params) {
-        const durationMs = Date.now() - params.startTime;
-        // `result` is undefined only on short-circuit paths that never produced a payload (e.g. a
-        // cancelled task); skip byte accounting there. `null`/`{}` still measure as zero bytes.
-        const responseBytes = params.result === undefined ? undefined : computeToolResponseBytes(params.result);
-        log.info('Tool call completed', {
-            toolName: params.toolName,
-            mcpSessionId: params.mcpSessionId,
-            toolStatus: params.toolStatus,
-            durationMs,
-            ...(responseBytes !== undefined && {
-                responseContentBytes: responseBytes.contentBytes,
-                responseStructuredContentBytes: responseBytes.structuredContentBytes,
-                responseFileBytes: responseBytes.fileBytes,
-            }),
-            ...(params.taskId !== undefined && { taskId: params.taskId }),
-        });
-        if (params.telemetryData) {
-            const finalizedTelemetryData = {
-                ...params.telemetryData,
-                tool_status: params.toolStatus,
-                tool_exec_time_ms: durationMs,
-                ...(responseBytes && {
-                    tool_response_content_bytes: responseBytes.contentBytes,
-                    tool_response_structured_content_bytes: responseBytes.structuredContentBytes,
-                    tool_response_file_bytes: responseBytes.fileBytes,
-                }),
-                // Always include actor_name/actor_id; failure-specific fields are only present when callDiagnostics has them.
-                ...params.callDiagnostics,
-                // Resource ids are read once here from the args + the tool's public output; no tool
-                // threads them back. Applied uniformly, last. See deriveResourceIds.
-                ...deriveResourceIds(params.args, params.result),
-            };
-            trackToolCall(params.userId, this.telemetryEnv, finalizedTelemetryData);
-            // A successful report-problem call also emits a dedicated feedback event carrying the
-            // submission. A downstream Segment destination fans it out to Slack/GitHub.
-            if (params.toolName === HELPER_TOOLS.PROBLEM_REPORT &&
-                params.toolStatus === TOOL_STATUS.SUCCEEDED &&
-                params.args) {
-                trackReportedProblem(params.userId, this.telemetryEnv, buildReportedProblemProperties(finalizedTelemetryData, params.args));
-            }
-        }
-    }
-    // TODO: outer orchestration here (pre-flight, telemetry bookkeeping, task-store handling) still duplicates the CallToolRequestSchema handler's logic; the dispatch ladder is now shared. Refactor.
-    /**
-     * Executes a tool asynchronously for a long-running task and updates task status.
-     *
-     * @param params - Tool execution parameters
-     * @param params.taskId - The task identifier
-     * @param params.tool - The tool to execute
-     * @param params.args - Tool arguments
-     * @param params.apifyToken - Apify API token
-     * @param params.progressToken - Progress token for notifications
-     * @param params.extra - Extra request handler context
-     * @param params.mcpSessionId - MCP session ID for telemetry
-     */
-    async executeToolAndUpdateTask(params) {
-        const { taskId, tool, toolArgs, logSafeArgs, apifyClient, apifyToken, progressToken, extra, mcpSessionId, actorName, actorId, } = params;
-        let toolStatus = TOOL_STATUS.SUCCEEDED;
-        // Always populate actor fields so they're tracked on both success and failure paths.
-        let callDiagnostics = { ...buildActorFields(actorName, actorId) };
-        const startTime = Date.now();
-        log.debug('[executeToolAndUpdateTask] Starting task execution', {
-            taskId,
-            toolName: tool.name,
-            mcpSessionId,
-        });
-        // Prepare telemetry before try-catch so it's accessible to both paths.
-        // This avoids re-fetching user data in the error handler.
-        const { telemetryData, userId } = await this.prepareTelemetryData(getToolFullName(tool), mcpSessionId, apifyToken);
-        const finishTaskTracking = (status, diagnostics, result) => {
-            this.logToolCallAndTelemetry({
-                toolName: tool.name,
-                mcpSessionId,
-                toolStatus: status,
-                startTime,
-                taskId,
-                telemetryData,
-                userId,
-                callDiagnostics: diagnostics,
-                args: toolArgs,
-                result,
-            });
-        };
-        // Terminal step shared by every task outcome: store the result (expiry-tolerant),
-        // emit the status notification, record telemetry.
-        const completeTask = async (storeStatus, taskResult, status, diagnostics) => {
-            await storeTaskResultOrSkipIfExpired(this.taskStore, tool.name, taskId, storeStatus, taskResult, mcpSessionId);
-            await emitTaskStatusNotification(taskId, mcpSessionId, this.taskStore, this.server);
-            finishTaskTracking(status, diagnostics, taskResult);
-        };
-        // Once a task is cancelled the spec forbids writing a result; every storage path
-        // must short-circuit here. `logSuffix` is concatenated after "Task was cancelled"
-        // so we keep the existing log format and the existing telemetry status per path.
-        const skipIfTaskCancelled = async (logSuffix, status, diagnostics) => {
-            if (!(await isTaskCancelled(taskId, mcpSessionId, this.taskStore)))
-                return false;
-            log.debug(`[executeToolAndUpdateTask] Task was cancelled${logSuffix}`, { taskId, mcpSessionId });
-            finishTaskTracking(status, diagnostics);
-            return true;
-        };
-        // Bridges MCP `tasks/cancel` to the running handler: when the client
-        // explicitly cancels the task, this signal aborts so the underlying
-        // Actor run stops instead of consuming compute until natural completion.
-        // Per MCP tasks spec, request-level aborts (client disconnect,
-        // notifications/cancelled for the original request ID) MUST NOT cancel
-        // the task — `extra.signal` is intentionally not chained here.
-        const cancelWatcher = createTaskCancellationWatcher({
-            taskId,
-            mcpSessionId,
-            taskStore: this.taskStore,
-        });
-        const taskExtra = { ...extra, signal: cancelWatcher.signal };
-        try {
-            log.debug('[executeToolAndUpdateTask] Updating task status to working', {
-                taskId,
-                mcpSessionId,
-            });
-            // The store rejects terminal → 'working' transitions. If `tasks/cancel` raced
-            // with us (between handler dispatch and the first watcher tick at ~500 ms),
-            // updateTaskStatus throws — re-check the store to tell a clean cancel-race
-            // apart from a genuine store error.
-            // noinspection ExceptionCaughtLocallyJS
-            try {
-                await this.taskStore.updateTaskStatus(taskId, 'working', undefined, mcpSessionId);
-            }
-            catch (err) {
-                if (await skipIfTaskCancelled(' before execution started, skipping', TOOL_STATUS.ABORTED, {
-                    ...buildActorFields(actorName, actorId),
-                }))
-                    return;
-                throw err;
-            }
-            await emitTaskStatusNotification(taskId, mcpSessionId, this.taskStore, this.server);
-            // Execute the tool and get the result
-            let result = {};
-            // Callback to propagate Actor run statusMessage into the task store and emit a push notification.
-            // TODO(TC-3): cancel arriving while this is scheduled throws cancelled → working;
-            // currently swallowed by progress.ts's tick catch — guard or catch explicitly.
-            const onStatusMessage = async (message) => {
-                await this.taskStore.updateTaskStatus(taskId, 'working', message, mcpSessionId);
-                await emitTaskStatusNotification(taskId, mcpSessionId, this.taskStore, this.server);
-            };
-            // ACTOR_MCP never reads the tracker (matching the sync path, which passes null for it);
-            // INTERNAL/ACTOR get one built from taskId + onStatusMessage, which dispatch consumes
-            // and stops.
-            const progressTracker = tool.type === TOOL_TYPE.ACTOR_MCP
-                ? null
-                : createProgressTracker(progressToken, extra.sendNotification, taskId, onStatusMessage);
-            const dispatchResult = await dispatchToolCall({
-                tool,
-                toolArgs,
-                logSafeArgs,
-                apifyToken,
-                apifyClient,
-                apifyMcpServer: this,
-                mcpSessionId,
-                progressToken,
-                progressTracker,
-                shouldForwardNotifications: false,
-                extra: taskExtra,
-                actorName,
-                actorId,
-                taskMode: true,
-                logContext: { messageSuffix: ' for task', fields: { taskId } },
-            });
-            result = dispatchResult.result;
-            toolStatus = dispatchResult.toolStatus;
-            callDiagnostics = dispatchResult.callDiagnostics;
-            // Check if task was cancelled before storing result
-            if (await skipIfTaskCancelled(', skipping result storage', toolStatus))
-                return;
-            // On a failed result, nudge the agent to report the blocker via report-problem (mirrors the
-            // synchronous CallTool path, which task-mode calls like call-actor bypass).
-            result = this.withReportProblemNudge(result, tool.name, callDiagnostics.failure_category, callDiagnostics.failure_http_status);
-            // Store the result in the task store
-            log.debug('[executeToolAndUpdateTask] Storing completed result', {
-                taskId,
-                mcpSessionId,
-            });
-            await completeTask('completed', result, toolStatus, callDiagnostics);
-            log.debug('Task completed successfully', { taskId, toolName: tool.name, mcpSessionId });
-        }
-        catch (error) {
-            // Reached only when the task expired before the `working` transition (updateTaskStatus
-            // above rethrows the store's unknown-taskId error). The tool never ran and the task is
-            // gone, so soft-fail, record telemetry, and stop. Every result store (success and error
-            // paths) tolerates expiry via storeTaskResultOrSkipIfExpired, so they don't reach here.
-            if (isTaskNotFoundError(error)) {
-                log.softFail('Task expired before execution started', {
-                    taskId,
-                    toolName: tool.name,
-                    mcpSessionId,
-                });
-                finishTaskTracking(TOOL_STATUS.SOFT_FAIL, {
-                    failure_category: FAILURE_CATEGORY.INTERNAL_ERROR,
-                    ...buildActorFields(actorName, actorId),
-                });
-                return;
-            }
-            const errorResult = buildToolCallErrorResult(error, {
-                toolName: tool.name,
-                actorName,
-                actorId,
-                isAborted: Boolean(cancelWatcher.signal.aborted),
-            });
-            // Handle 402 Payment Required — return structured x402 result so clients can auto-pay
-            if (errorResult.kind === TOOL_CALL_ERROR_KIND.PAYMENT) {
-                logHttpError(error, 'Payment required while calling tool (task mode)', { toolName: tool.name });
-                // Per MCP tasks spec: once a task is cancelled it MUST remain cancelled,
-                // so guard storeTaskResult against a cancel that raced with this 402.
-                if (await skipIfTaskCancelled(', skipping 402 result storage', TOOL_STATUS.ABORTED, {
-                    ...buildActorFields(actorName, actorId),
-                }))
-                    return;
-                await completeTask('completed', errorResult.response, errorResult.toolStatus, errorResult.callDiagnostics);
-                return;
-            }
-            if (errorResult.kind === TOOL_CALL_ERROR_KIND.APPROVAL) {
-                logHttpError(error, 'Permission approval required while calling tool (task mode)', {
-                    toolName: tool.name,
-                });
-                // Per MCP tasks spec: once a task is cancelled it MUST remain cancelled,
-                // so guard storeTaskResult against a cancel that raced with this approval error.
-                if (await skipIfTaskCancelled(', skipping permission-approval result storage', TOOL_STATUS.ABORTED, {
-                    ...buildActorFields(actorName, actorId),
-                }))
-                    return;
-                await completeTask('completed', errorResult.response, errorResult.toolStatus, errorResult.callDiagnostics);
-                return;
-            }
-            toolStatus = errorResult.toolStatus;
-            callDiagnostics = errorResult.callDiagnostics;
-            // Log level follows the already-classified toolStatus:
-            //   SOFT_FAIL (e.g. 402/403 user quota, client-side issues) → softFail
-            //   FAILED/ABORTED/other                                    → error
-            if (toolStatus === TOOL_STATUS.SOFT_FAIL) {
-                // Mezmo promotes on "error" in message/keys — use errMessage key, sanitized.
-                const errMessage = sanitizeMezmoMessage(error instanceof Error ? error.message : String(error));
-                log.softFail('Tool execution soft-failed for task', {
-                    taskId,
-                    toolName: tool.name,
-                    toolStatus,
-                    mcpSessionId,
-                    failureCategory: callDiagnostics.failure_category,
-                    failureHttpStatus: callDiagnostics.failure_http_status,
-                    actorName: callDiagnostics.actor_name,
-                    errMessage,
-                });
-            }
-            else {
-                log.error('Error executing tool for task', {
-                    taskId,
-                    toolName: tool.name,
-                    toolStatus,
-                    mcpSessionId,
-                    failureCategory: callDiagnostics.failure_category,
-                    failureHttpStatus: callDiagnostics.failure_http_status,
-                    actorName: callDiagnostics.actor_name,
-                    error,
-                });
-            }
-            const { userText } = errorResult;
-            // Check if task was cancelled before storing result
-            if (await skipIfTaskCancelled(', skipping result storage', toolStatus, callDiagnostics))
-                return;
-            log.debug('[executeToolAndUpdateTask] Storing failed result', {
-                taskId,
-                mcpSessionId,
-            });
-            // Nudge on a genuinely-failed task result (mirrors the completed path and the sync
-            // captureResult). INTERNAL_ERROR and an unknown category get the full nudge; a genuine
-            // INVALID_INPUT gets the softer nudge; payment (402) is suppressed via the HTTP status and
-            // AUTH / PERMISSION_APPROVAL_REQUIRED via NON_NUDGE_FAILURE_CATEGORIES. The 402 branch above
-            // returns before reaching here, so this only sees non-payment failures.
-            const failedResult = this.withReportProblemNudge({
-                content: [
-                    {
-                        type: 'text',
-                        text: userText,
-                    },
-                ],
-                isError: true,
-                internalToolStatus: toolStatus,
-            }, tool.name, callDiagnostics.failure_category, callDiagnostics.failure_http_status);
-            await completeTask('failed', failedResult, toolStatus, callDiagnostics);
-        }
-        finally {
-            cancelWatcher.dispose();
-        }
-    }
-    /*
-     * Creates telemetry data for a tool call.
-     */
-    async prepareTelemetryData(toolName, mcpSessionId, apifyToken) {
-        var _a, _b, _c, _d, _e;
-        if (!this.telemetryEnabled) {
-            return { telemetryData: null, userId: null };
-        }
-        // Get userId from cache or fetch from API
-        let userId = null;
-        if (apifyToken) {
-            const apifyClient = new ApifyClient({ token: apifyToken });
-            ({ userId } = await getUserInfoCached(apifyToken, apifyClient));
-            log.debug('Telemetry: fetched userId', { userId, mcpSessionId });
-        }
-        const capabilities = (_b = (_a = this.options.initializeRequestData) === null || _a === void 0 ? void 0 : _a.params) === null || _b === void 0 ? void 0 : _b.capabilities;
-        const params = (_c = this.options.initializeRequestData) === null || _c === void 0 ? void 0 : _c.params;
-        const telemetryData = {
-            app: 'mcp',
-            app_version: getPackageVersion() || '',
-            mcp_client_name: ((_d = params === null || params === void 0 ? void 0 : params.clientInfo) === null || _d === void 0 ? void 0 : _d.name) || '',
-            mcp_client_version: ((_e = params === null || params === void 0 ? void 0 : params.clientInfo) === null || _e === void 0 ? void 0 : _e.version) || '',
-            mcp_protocol_version: (params === null || params === void 0 ? void 0 : params.protocolVersion) || '',
-            mcp_client_capabilities: capabilities || null,
-            mcp_session_id: mcpSessionId || '',
-            transport_type: this.options.transportType || '',
-            tool_name: toolName,
-            tool_status: TOOL_STATUS.SUCCEEDED, // Will be updated in finally
-            tool_exec_time_ms: 0, // Will be calculated in finally
-        };
-        return { telemetryData, userId };
-    }
     /**
      * Resolves widgets and determines which ones are ready to be served.
      */
@@ -1573,23 +1201,21 @@ export class ActorsMcpServer {
         await this.server.connect(transport);
     }
     async close() {
-        // Remove SIGINT handler
         if (this.sigintHandler) {
             process.removeListener('SIGINT', this.sigintHandler);
             this.sigintHandler = undefined;
         }
-        // Clear all tools and their compiled schemas
+        // 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;
             }
         }
         this.tools.clear();
-        // Unregister tools changed handler
         if (this.toolsChangedHandler) {
             this.unregisterToolsChangedHandler();
         }
-        // Close server (which should also remove its event handlers)
+        // Closing the server also removes its event handlers.
         await this.server.close();
     }
 }