@j0hanz/fetch-url-mcp 1.12.13 → 2.0.1

package/dist/tasks/manager.js

@@ -1,72 +1,13 @@
-import {} from '@modelcontextprotocol/sdk/server/mcp.js';
-import { CallToolRequestSchema, ErrorCode, McpError, } from '@modelcontextprotocol/sdk/types.js';
-import { hash, randomUUID } from 'node:crypto';
+import { ProtocolErrorCode, RELATED_TASK_META_KEY, } from '@modelcontextprotocol/server';
+import { hash } from 'node:crypto';
 import { z } from 'zod';
 import { config } from '../lib/config.js';
-import { getRequestId, logDebug, logError, Loggers, logInfo, logWarn, resolveMcpSessionOwnerKey, runWithRequestContext, runWithTraceContext, } from '../lib/core.js';
-import { getErrorMessage, handleToolError, stripMcpErrorPrefix, tryReadToolErrorMessage, } from '../lib/error/index.js';
-import { createMcpError, getSdkCallToolHandler, registerServerLifecycleCleanup, } from '../lib/mcp-interop.js';
-import { formatZodError, isObject } from '../lib/utils.js';
+import { logDebug, logError, Loggers, logWarn, resolveMcpSessionOwnerKey, } from '../lib/core.js';
+import { getErrorMessage } from '../lib/error/index.js';
+import { createProtocolError } from '../lib/mcp-interop.js';
+import { isObject } from '../lib/utils.js';
 import { decodeTaskCursor, encodeTaskCursor, taskManager, TaskWaiterRegistry, waitForTerminalTask, } from './store.js';
-/*
- * Module map:
- * - call-tool request parsing
- * - Abort-controller management for in-flight task executions
- * - Task notification and validation helpers
- * - Execution pipeline
- * - Task handler schemas and registration
- * - Handler extra parsing & owner-key resolution
- * Own task lifecycle and MCP task wiring here. Keep tool business logic and HTTP transport details elsewhere.
- */
-const MIN_TASK_KEEP_ALIVE_MS = 1_000;
-const MAX_TASK_KEEP_ALIVE_MS = 86_400_000;
-const RELATED_TASK_META_KEY = 'modelcontextprotocol.io/related-task';
-const taskMetaSchema = z.strictObject({
-    taskId: z.string().min(1, 'Task id required'),
-    keepAlive: z
-        .number()
-        .int()
-        .min(MIN_TASK_KEEP_ALIVE_MS, `Minimum ${MIN_TASK_KEEP_ALIVE_MS}ms`)
-        .max(MAX_TASK_KEEP_ALIVE_MS, `Maximum ${MAX_TASK_KEEP_ALIVE_MS}ms`)
-        .optional(),
-});
-const relatedTaskMetaSchema = z.strictObject({
-    taskId: z.string(),
-});
-const toolCallMetaSchema = z.looseObject({
-    progressToken: z.union([z.string(), z.number()]).optional(),
-    'modelcontextprotocol.io/task': taskMetaSchema.optional(),
-    [RELATED_TASK_META_KEY]: relatedTaskMetaSchema.optional(),
-});
-const sdkTaskParamsSchema = z.object({ ttl: z.number().optional() }).optional();
-export const extendedCallToolRequestSchema = z.looseObject({
-    method: z.literal('tools/call'),
-    params: z.strictObject({
-        name: z.string().min(1, 'Tool name required'),
-        arguments: z.record(z.string(), z.unknown()).optional(),
-        _meta: toolCallMetaSchema.optional(),
-        task: sdkTaskParamsSchema,
-    }),
-});
 export { decodeTaskCursor, encodeTaskCursor, taskManager, TaskWaiterRegistry, waitForTerminalTask, };
-function getTaskMeta(params) {
-    const legacyMeta = params._meta?.['modelcontextprotocol.io/task'];
-    if (legacyMeta)
-        return legacyMeta;
-    if (params.task) {
-        return {
-            taskId: randomUUID(),
-            ...(params.task.ttl !== undefined ? { keepAlive: params.task.ttl } : {}),
-        };
-    }
-    return undefined;
-}
-export function parseExtendedCallToolRequest(request) {
-    const parsed = extendedCallToolRequestSchema.safeParse(request);
-    if (parsed.success)
-        return parsed.data;
-    throw createMcpError(ErrorCode.InvalidParams, formatZodError(parsed.error));
-}
 export function sanitizeToolCallMeta(meta) {
     if (!meta)
         return undefined;
@@ -103,14 +44,14 @@ function withRelatedTaskSummaryMeta(payload, taskId) {
 // Intentionally process-global (not session-scoped): abortAllTaskExecutions() is called
 // during SIGTERM/SIGINT shutdown to cancel every in-flight task across all sessions.
 const taskAbortControllers = new Map();
-function detachAbortController(taskId) {
+export function detachAbortController(taskId) {
     const controller = taskAbortControllers.get(taskId);
     if (controller) {
         taskAbortControllers.delete(taskId);
     }
     return controller;
 }
-function attachAbortController(taskId) {
+export function attachAbortController(taskId) {
     detachAbortController(taskId)?.abort();
     if (taskAbortControllers.size >= config.tasks.maxTotal) {
         logWarn('Abort controller map reached task capacity — possible leak', {
@@ -143,14 +84,10 @@ export function toTaskSummary(task) {
         taskId: task.taskId,
         status: task.status,
         ...(task.statusMessage ? { statusMessage: task.statusMessage } : {}),
-        ...(task.progress !== undefined ? { progress: task.progress } : {}),
-        ...(task.total !== undefined ? { total: task.total } : {}),
         createdAt: task.createdAt,
         lastUpdatedAt: task.lastUpdatedAt,
-        keepAlive: task.keepAlive,
-        pollFrequency: task.pollFrequency,
-        ttl: task.keepAlive,
-        pollInterval: task.pollFrequency,
+        ttl: task.ttl,
+        pollInterval: task.pollInterval,
     };
 }
 export function emitTaskStatusNotification(server, task) {
@@ -169,444 +106,51 @@ export function emitTaskStatusNotification(server, task) {
         }, Loggers.LOG_TASKS);
     });
 }
-function emitTaskCreatedNotification(server, task) {
-    if (!config.tasks.emitStatusNotifications || !server.isConnected())
-        return;
-    void server.server
-        .notification({
-        method: 'notifications/tasks/created',
-        params: {
-            _meta: {
-                [RELATED_TASK_META_KEY]: { taskId: task.taskId },
-            },
-        },
-    })
-        .catch((error) => {
-        logError('Failed to send task created notification', {
-            taskId: task.taskId,
-            error: getErrorMessage(error),
-        }, Loggers.LOG_TASKS);
-    });
-}
 export function throwTaskNotFound() {
-    throw createMcpError(ErrorCode.InvalidParams, 'Task not found');
-}
-/* -------------------------------------------------------------------------------------------------
- * Execution pipeline
- * ------------------------------------------------------------------------------------------------- */
-function updateTaskAndEmitStatus(server, taskId, update) {
-    taskManager.updateTask(taskId, update);
-    const task = taskManager.getTask(taskId);
-    if (task)
-        emitTaskStatusNotification(server, task);
-}
-function buildTaskFailureState(error) {
-    const mcpErrorMessage = error instanceof McpError ? stripMcpErrorPrefix(error.message) : undefined;
-    const statusMessage = mcpErrorMessage ?? getErrorMessage(error);
-    if (error instanceof McpError) {
-        return {
-            status: 'failed',
-            statusMessage,
-            error: {
-                code: error.code,
-                ...(error.data !== undefined ? { data: error.data } : {}),
-                message: statusMessage,
-            },
-        };
-    }
-    return {
-        status: 'failed',
-        statusMessage,
-        error: {
-            code: ErrorCode.InternalError,
-            message: statusMessage,
-        },
-    };
-}
-function buildTaskCompletionUpdate(result, tool) {
-    const isError = isObject(result) && 'isError' in result && result.isError === true;
-    const errorMessage = tryReadToolErrorMessage(result) ?? 'Execution failed';
-    return {
-        status: isError ? 'failed' : 'completed',
-        statusMessage: isError
-            ? errorMessage
-            : (tool.getCompletionStatusMessage?.(result) ??
-                'Task completed successfully.'),
-        result,
-        ...(isError
-            ? {
-                error: {
-                    code: ErrorCode.InternalError,
-                    message: errorMessage,
-                },
-            }
-            : {}),
-    };
-}
-async function runTaskToolExecution(params) {
-    const { server, taskId, args, tool, meta, sessionId, sendNotification } = params;
-    return runWithRequestContext({
-        requestId: taskId,
-        operationId: taskId,
-        ...(sessionId ? { sessionId } : {}),
-    }, () => runWithTraceContext(meta, async () => {
-        const controller = attachAbortController(taskId);
-        const progressState = { closed: false };
-        try {
-            updateTaskAndEmitStatus(server, taskId, {
-                status: 'working',
-                statusMessage: 'Task started',
-            });
-            logInfo('Task execution started', { taskId, tool: tool.name }, Loggers.LOG_TASKS);
-            const relatedMeta = buildRelatedTaskMeta(taskId, meta);
-            const result = await tool.execute(args, {
-                signal: controller.signal,
-                requestId: taskId,
-                _meta: relatedMeta,
-                progressState,
-                canReportProgress: () => taskManager.getTask(taskId)?.status === 'working',
-                ...compact({ sendNotification }),
-                onProgress: (progress, message, total) => {
-                    const current = taskManager.getTask(taskId);
-                    if (current?.status === 'working' &&
-                        (current.statusMessage !== message ||
-                            current.progress !== progress ||
-                            (total !== undefined && current.total !== total))) {
-                        updateTaskAndEmitStatus(server, taskId, {
-                            statusMessage: message,
-                            progress,
-                            ...(total !== undefined ? { total } : {}),
-                        });
-                    }
-                },
-            });
-            const completionUpdate = buildTaskCompletionUpdate(result, tool);
-            updateTaskAndEmitStatus(server, taskId, completionUpdate);
-            if (completionUpdate.status === 'completed') {
-                logInfo('Task execution completed', { taskId, tool: tool.name }, Loggers.LOG_TASKS);
-            }
-            else {
-                logWarn('Task execution completed with tool error result', { taskId, tool: tool.name }, Loggers.LOG_TASKS);
-            }
-        }
-        catch (error) {
-            logError('Task execution failed', {
-                taskId,
-                tool: tool.name,
-                error: getErrorMessage(error),
-            }, Loggers.LOG_TASKS);
-            updateTaskAndEmitStatus(server, taskId, buildTaskFailureState(error));
-        }
-        finally {
-            progressState.closed = true;
-            detachAbortController(taskId);
-        }
-    }));
-}
-function extractRawUrl(args) {
-    const url = args?.['url'];
-    return typeof url === 'string' ? url : 'unknown';
-}
-function tryParseArguments(tool, args) {
-    try {
-        return { ok: true, value: tool.parseArguments(args) };
-    }
-    catch (error) {
-        if (error instanceof McpError) {
-            return {
-                ok: false,
-                response: handleToolError(error, extractRawUrl(args)),
-            };
-        }
-        throw error;
-    }
-}
-function validateTaskSupport(server, toolName, isTaskMode) {
-    const support = getTaskCapableToolSupport(server, toolName);
-    if (isTaskMode && support === 'forbidden') {
-        throw createMcpError(ErrorCode.MethodNotFound, `Task mode is not supported for tool: ${toolName}`);
-    }
-    if (!isTaskMode && support === 'required') {
-        throw createMcpError(ErrorCode.MethodNotFound, `Task mode is required for tool: ${toolName}`);
-    }
-}
-function enqueueTaskToolExecution(server, tool, params, taskMeta, context, parsedArgs) {
-    const task = taskManager.createTask({
-        taskId: taskMeta.taskId,
-        ...(taskMeta.keepAlive !== undefined
-            ? { keepAlive: taskMeta.keepAlive }
-            : {}),
-    }, 'Task submitted', context.ownerKey);
-    emitTaskCreatedNotification(server, task);
-    logInfo('Task execution queued', {
-        taskId: task.taskId,
-        tool: params.name,
-        ...(taskMeta.keepAlive !== undefined
-            ? { keepAlive: taskMeta.keepAlive }
-            : {}),
-    }, Loggers.LOG_TASKS);
-    void runTaskToolExecution({
-        server,
-        taskId: task.taskId,
-        args: parsedArgs,
-        tool,
-        ...compact({
-            meta: params._meta,
-            sessionId: context.sessionId,
-            sendNotification: context.sendNotification,
-        }),
-    });
-    return {
-        task: toTaskSummary(task),
-        ...(tool.immediateResponse
-            ? {
-                _meta: {
-                    'io.modelcontextprotocol/model-immediate-response': tool.immediateResponse,
-                },
-            }
-            : {}),
-    };
-}
-export async function handleToolCallRequest(server, request, context) {
-    const { params } = request;
-    return runWithTraceContext(params._meta, async () => {
-        // Validate the tool name first so an unknown tool always produces MethodNotFound
-        const tool = getTaskCapableTool(server, params.name);
-        if (!tool) {
-            throw createMcpError(ErrorCode.MethodNotFound, `Unknown tool: ${params.name}`);
-        }
-        const taskMeta = getTaskMeta(params);
-        validateTaskSupport(server, params.name, !!taskMeta);
-        const parsed = tryParseArguments(tool, params.arguments);
-        if (!parsed.ok)
-            return parsed.response;
-        if (taskMeta) {
-            return enqueueTaskToolExecution(server, tool, params, taskMeta, context, parsed.value);
-        }
-        const progressState = { closed: false };
-        logDebug('Executing task-capable tool inline', {
-            tool: params.name,
-            hasProgressToken: params._meta?.progressToken !== undefined,
-        }, Loggers.LOG_TASKS);
-        try {
-            return await tool.execute(parsed.value, {
-                ...buildToolHandlerExtra(context, params._meta),
-                progressState,
-            });
-        }
-        finally {
-            progressState.closed = true;
-        }
-    });
+    throw createProtocolError(ProtocolErrorCode.ResourceNotFound, 'Task not found');
 }
 /* -------------------------------------------------------------------------------------------------
  * Task handler schemas and registration
  * ------------------------------------------------------------------------------------------------- */
-const TaskGetSchema = z.looseObject({
-    method: z.literal('tasks/get', 'Expected "tasks/get"'),
-    params: z.looseObject({ taskId: z.string('Expected string') }, 'Expected object'),
-}, 'Invalid request');
-const TaskListSchema = z.looseObject({
-    method: z.literal('tasks/list', 'Expected "tasks/list"'),
-    params: z
-        .looseObject({
-        cursor: z.string('Expected string').optional(),
-    }, 'Expected object')
-        .optional(),
-}, 'Invalid request');
-const TaskCancelSchema = z.looseObject({
-    method: z.literal('tasks/cancel', 'Expected "tasks/cancel"'),
-    params: z.looseObject({ taskId: z.string('Expected string') }, 'Expected object'),
-}, 'Invalid request');
 const TaskDeleteSchema = z.looseObject({
     method: z.literal('tasks/delete', 'Expected "tasks/delete"'),
     params: z.looseObject({ taskId: z.string('Expected string') }, 'Expected object'),
 }, 'Invalid request');
-const TaskResultSchema = z.looseObject({
-    method: z.literal('tasks/result', 'Expected "tasks/result"'),
-    params: z.looseObject({ taskId: z.string('Expected string') }, 'Expected object'),
-}, 'Invalid request');
-function resolveOwnerScopedExtra(extra) {
-    const parsedExtra = parseHandlerExtra(extra);
-    return {
-        parsedExtra,
-        ownerKey: resolveTaskOwnerKey(parsedExtra),
-    };
-}
-function throwStoredTaskError(task) {
-    if (task.error) {
-        throw createMcpError(task.error.code, task.error.message, task.error.data);
-    }
-    throw createMcpError(ErrorCode.InternalError, task.statusMessage ?? 'Execution failed', { taskId: task.taskId });
-}
-export function registerTaskHandlers(server, options) {
-    const sdkCallToolHandler = getSdkCallToolHandler(server);
-    const taskCapableToolsRegistered = hasRegisteredTaskCapableTools(server);
-    const requireInterception = options?.requireInterception ?? true;
-    if (!sdkCallToolHandler) {
-        if (taskCapableToolsRegistered && requireInterception) {
-            throw Error('Task-capable tools are registered but SDK tools/call interception is unavailable. Upgrade compatibility or disable strict interception with TASKS_REQUIRE_INTERCEPTION=false.');
-        }
-        logWarn('Task call interception disabled: SDK tools/call handler unavailable; task-capable tools require MCP SDK compatibility update', { sdkVersion: 'unknown' }, Loggers.LOG_TASKS);
-    }
-    if (sdkCallToolHandler) {
-        server.server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
-            const parsedExtra = parseHandlerExtra(extra);
-            const requestId = parsedExtra?.requestId !== undefined
-                ? String(parsedExtra.requestId)
-                : randomUUID();
-            return runWithRequestContext({
-                requestId,
-                operationId: requestId,
-                ...(parsedExtra?.sessionId
-                    ? { sessionId: parsedExtra.sessionId }
-                    : {}),
-            }, () => {
-                const toolName = request.params.name;
-                // Only intercept task-capable tools managed by the local task registry.
-                // Delegate all other tools to the SDK handler to avoid shadowing future tools.
-                if (!hasTaskCapableTool(server, toolName)) {
-                    return sdkCallToolHandler(request, extra);
-                }
-                const parsed = parseExtendedCallToolRequest(request);
-                const context = resolveToolCallContext(parsedExtra, parsed.params._meta);
-                logDebug('Intercepted task-capable tool call', {
-                    tool: toolName,
-                    taskRequested: getTaskMeta(parsed.params) !== undefined,
-                    hasProgressToken: parsed.params._meta?.progressToken !== undefined,
-                }, Loggers.LOG_TASKS);
-                return handleToolCallRequest(server, parsed, context);
-            });
-        });
-    }
-    server.server.setRequestHandler(TaskGetSchema, (request, extra) => {
-        const { taskId } = request.params;
-        const { ownerKey } = resolveOwnerScopedExtra(extra);
-        logDebug('tasks/get requested', { taskId }, Loggers.LOG_TASKS);
-        const task = taskManager.getTask(taskId, ownerKey);
-        if (!task)
-            throwTaskNotFound();
-        return withRelatedTaskSummaryMeta(toTaskSummary(task), task.taskId);
-    });
-    server.server.setRequestHandler(TaskResultSchema, (request, extra) => {
-        const { taskId } = request.params;
-        const { ownerKey } = resolveOwnerScopedExtra(extra);
-        logDebug('tasks/result requested', { taskId }, Loggers.LOG_TASKS);
-        const task = taskManager.getTask(taskId, ownerKey);
-        if (!task)
-            throwTaskNotFound();
-        if (task.status === 'submitted' || task.status === 'working') {
-            throw createMcpError(ErrorCode.InvalidParams, 'Task result is not available until the task completes', { taskId, status: task.status });
-        }
-        if (task.status === 'input_required') {
-            throw createMcpError(ErrorCode.InvalidParams, 'Task result is not available while the task is waiting for input', { taskId, status: task.status });
-        }
-        try {
-            if (task.status === 'cancelled') {
-                throwStoredTaskError(task);
-            }
-            if (task.status === 'failed') {
-                throwStoredTaskError(task);
-            }
-            const result = isServerResult(task.result)
-                ? task.result
-                : { content: [] };
-            return withRelatedTaskMeta(result, task.taskId);
-        }
-        finally {
-            // Shrink keepAlive only after the result has been fully constructed
-            // and is about to be delivered — avoids premature expiry if result
-            // construction throws.
-            taskManager.shrinkKeepAliveAfterDelivery(taskId);
+export function registerTaskHandlers(server) {
+    const taskCapableToolsRegistered = config.tools.enabled.includes('fetch-url');
+    server.server.fallbackRequestHandler = (request, ctx) => {
+        if (request.method !== 'tasks/delete') {
+            throw createProtocolError(ProtocolErrorCode.MethodNotFound, `Method not found: ${request.method}`);
         }
-    });
-    server.server.setRequestHandler(TaskListSchema, (request, extra) => {
-        const { ownerKey } = resolveOwnerScopedExtra(extra);
-        const cursor = request.params?.cursor;
-        logDebug('tasks/list requested', { hasCursor: cursor !== undefined }, Loggers.LOG_TASKS);
-        const { tasks, nextCursor } = taskManager.listTasks(cursor === undefined ? { ownerKey } : { ownerKey, cursor });
-        return {
-            tasks: tasks.map((task) => withRelatedTaskSummaryMeta(toTaskSummary(task), task.taskId)),
-            nextCursor,
-        };
-    });
-    server.server.setRequestHandler(TaskCancelSchema, (request, extra) => {
-        const { taskId } = request.params;
-        const { ownerKey } = resolveOwnerScopedExtra(extra);
-        logDebug('tasks/cancel requested', { taskId }, Loggers.LOG_TASKS);
-        const task = taskManager.cancelTask(taskId, ownerKey);
-        if (!task)
-            throwTaskNotFound();
-        abortTaskExecution(taskId);
-        emitTaskStatusNotification(server, task);
-        return withRelatedTaskSummaryMeta(toTaskSummary(task), task.taskId);
-    });
-    server.server.setRequestHandler(TaskDeleteSchema, (request, extra) => {
-        const { taskId } = request.params;
-        const { ownerKey } = resolveOwnerScopedExtra(extra);
+        const parsedRequest = TaskDeleteSchema.parse(request);
+        const { taskId } = parsedRequest.params;
+        const ownerKey = resolveOwnerKeyFromContext(ctx);
         logDebug('tasks/delete requested', { taskId }, Loggers.LOG_TASKS);
         const deleted = taskManager.deleteTask(taskId, ownerKey);
         if (!deleted)
             throwTaskNotFound();
-        return {};
-    });
+        return Promise.resolve({});
+    };
     return {
-        interceptedToolsCall: sdkCallToolHandler !== null,
         taskCapableToolsRegistered,
     };
 }
-export function compact(obj) {
-    const result = {};
-    for (const key of Object.keys(obj)) {
-        if (obj[key] !== undefined) {
-            result[key] = obj[key];
-        }
-    }
-    return result;
-}
-function normalizeSendNotification(sendNotification) {
-    if (typeof sendNotification !== 'function')
+function resolveAuthenticatedSubject(authInfo) {
+    const extra = isObject(authInfo?.extra) ? authInfo.extra : undefined;
+    if (!extra)
         return undefined;
-    const notify = sendNotification;
-    return async (notification) => {
-        await Promise.resolve(notify(notification));
-    };
-}
-function normalizeAuthInfo(authInfo) {
-    if (!isObject(authInfo))
-        return undefined;
-    const { clientId, token } = authInfo;
-    const normalized = {};
-    if (typeof clientId === 'string')
-        normalized.clientId = clientId;
-    if (typeof token === 'string')
-        normalized.token = token;
-    return normalized.clientId || normalized.token ? normalized : undefined;
-}
-export function parseHandlerExtra(extra) {
-    if (!isObject(extra))
-        return undefined;
-    const parsed = {};
-    const { authInfo, signal, requestId, sendNotification } = extra;
-    const sessionId = resolveSessionIdFromExtra(extra);
-    if (sessionId)
-        parsed.sessionId = sessionId;
-    const normalizedAuthInfo = normalizeAuthInfo(authInfo);
-    if (normalizedAuthInfo) {
-        parsed.authInfo = normalizedAuthInfo;
+    const { subject, sub } = extra;
+    if (typeof subject === 'string' && subject.length > 0) {
+        return subject;
     }
-    if (signal instanceof AbortSignal)
-        parsed.signal = signal;
-    if (typeof requestId === 'string' || typeof requestId === 'number') {
-        parsed.requestId = requestId;
-    }
-    const normalizedSendNotification = normalizeSendNotification(sendNotification);
-    if (normalizedSendNotification) {
-        parsed.sendNotification = normalizedSendNotification;
-    }
-    return parsed;
+    return typeof sub === 'string' && sub.length > 0 ? sub : undefined;
 }
 export function buildAuthenticatedOwnerKey(authInfo) {
+    const authSubject = resolveAuthenticatedSubject(authInfo);
+    if (authSubject) {
+        const hashInput = `subject:${authSubject}`;
+        return `auth:${hash('sha256', hashInput, 'hex')}`;
+    }
     const authClientId = typeof authInfo?.clientId === 'string' ? authInfo.clientId : '';
     const authToken = typeof authInfo?.token === 'string' ? authInfo.token : '';
     if (authClientId || authToken) {
@@ -615,127 +159,24 @@ export function buildAuthenticatedOwnerKey(authInfo) {
     }
     return undefined;
 }
-export function resolveTaskOwnerKey(extra) {
-    const authenticatedOwnerKey = buildAuthenticatedOwnerKey(extra?.authInfo);
-    if (authenticatedOwnerKey)
-        return authenticatedOwnerKey;
-    if (extra?.sessionId) {
-        return (resolveMcpSessionOwnerKey(extra.sessionId) ?? `session:${extra.sessionId}`);
+export function resolveOwnerKeyFromContext(ctx) {
+    const authInfo = ctx.http?.authInfo;
+    if (authInfo) {
+        const identity = {
+            clientId: authInfo.clientId,
+            token: authInfo.token,
+            ...(authInfo.extra ? { extra: authInfo.extra } : {}),
+        };
+        const authenticatedOwnerKey = buildAuthenticatedOwnerKey(identity);
+        if (authenticatedOwnerKey)
+            return authenticatedOwnerKey;
+    }
+    const { sessionId } = ctx;
+    if (typeof sessionId === 'string' && sessionId.length > 0) {
+        return resolveMcpSessionOwnerKey(sessionId) ?? `session:${sessionId}`;
     }
     return 'default';
 }
-function resolveRequestIdFromExtra(extra) {
-    if (!isObject(extra))
-        return undefined;
-    const { requestId } = extra;
-    if (typeof requestId === 'string')
-        return requestId;
-    if (typeof requestId === 'number')
-        return String(requestId);
-    return undefined;
-}
-function getHeaderString(headers, name) {
-    const value = headers[name];
-    if (typeof value === 'string')
-        return value;
-    if (!Array.isArray(value))
-        return undefined;
-    return value.find((entry) => typeof entry === 'string');
-}
-function resolveSessionIdFromExtra(extra) {
-    if (!isObject(extra))
-        return undefined;
-    const { sessionId } = extra;
-    if (typeof sessionId === 'string')
-        return sessionId;
-    const { requestInfo } = extra;
-    if (!isObject(requestInfo))
-        return undefined;
-    const { headers } = requestInfo;
-    if (!isObject(headers))
-        return undefined;
-    return (getHeaderString(headers, 'mcp-session-id') ??
-        getHeaderString(headers, 'x-mcp-session-id'));
-}
-function resolveToolExecutionContext(extra, requestMeta) {
-    return compact({
-        ownerKey: resolveTaskOwnerKey(extra),
-        sessionId: extra?.sessionId,
-        signal: extra?.signal,
-        requestId: extra?.requestId,
-        sendNotification: extra?.sendNotification,
-        requestMeta: sanitizeToolCallMeta(requestMeta),
-    });
-}
-export function resolveToolCallContext(extra, requestMeta) {
-    return resolveToolExecutionContext(extra, requestMeta);
-}
-export function buildToolHandlerExtra(context, requestMeta) {
-    return compact({
-        signal: context.signal,
-        requestId: context.requestId,
-        sendNotification: context.sendNotification,
-        _meta: sanitizeToolCallMeta(requestMeta ?? context.requestMeta),
-    });
-}
-export function withRequestContextIfMissing(handler) {
-    return async (params, extra) => {
-        const existingRequestId = getRequestId();
-        if (existingRequestId) {
-            const traceMeta = isObject(extra) && isObject(extra['_meta'])
-                ? extra['_meta']
-                : undefined;
-            return runWithTraceContext(traceMeta, () => handler(params, extra));
-        }
-        const derivedRequestId = resolveRequestIdFromExtra(extra) ?? randomUUID();
-        const derivedSessionId = resolveSessionIdFromExtra(extra);
-        const traceMeta = isObject(extra) && isObject(extra['_meta']) ? extra['_meta'] : undefined;
-        return runWithRequestContext({
-            requestId: derivedRequestId,
-            operationId: derivedRequestId,
-            ...(derivedSessionId ? { sessionId: derivedSessionId } : {}),
-        }, () => runWithTraceContext(traceMeta, () => handler(params, extra)));
-    };
-}
 export function isServerResult(value) {
     return isObject(value) && Array.isArray(value['content']);
 }
-const taskCapableToolsByServer = new WeakMap();
-function getServerToolMap(server) {
-    let toolMap = taskCapableToolsByServer.get(server);
-    if (toolMap)
-        return toolMap;
-    toolMap = new Map();
-    taskCapableToolsByServer.set(server, toolMap);
-    registerServerLifecycleCleanup(server, () => {
-        taskCapableToolsByServer.delete(server);
-    });
-    return toolMap;
-}
-export function registerTaskCapableTool(server, descriptor) {
-    getServerToolMap(server).set(descriptor.name, {
-        ...descriptor,
-        taskSupport: descriptor.taskSupport ?? 'optional',
-    });
-}
-export function unregisterTaskCapableTool(server, name) {
-    getServerToolMap(server).delete(name);
-}
-export function getTaskCapableTool(server, name) {
-    return getServerToolMap(server).get(name);
-}
-export function getTaskCapableToolSupport(server, name) {
-    return getServerToolMap(server).get(name)?.taskSupport;
-}
-export function hasTaskCapableTool(server, name) {
-    return getServerToolMap(server).has(name);
-}
-export function hasRegisteredTaskCapableTools(server) {
-    return getServerToolMap(server).size > 0;
-}
-export function setTaskCapableToolSupport(server, name, support) {
-    const descriptor = getServerToolMap(server).get(name);
-    if (!descriptor)
-        return;
-    descriptor.taskSupport = support;
-}