@j0hanz/fetch-url-mcp 1.12.7 → 1.12.8

package/dist/lib/tool-errors.js

@@ -1,253 +0,0 @@
-import { ErrorCode, McpError, } from '@modelcontextprotocol/sdk/types.js';
-import { z } from 'zod';
-import { logError, logWarn } from './core.js';
-import { SystemErrors } from './error-codes.js';
-import { FetchError, isAbortError, isObject, isSystemError } from './utils.js';
-const toolErrorPayloadSchema = z.strictObject({
-    error: z.string(),
-    url: z.string(),
-    category: z.string().optional(),
-    code: z.union([z.string(), z.number()]).optional(),
-    statusCode: z.number().int().optional(),
-    upstreamMessage: z.string().optional(),
-    details: z.record(z.string(), z.unknown()).optional(),
-    data: z.unknown().optional(),
-});
-const PUBLIC_ERROR_REASONS = new Set([
-    'aborted',
-    SystemErrors.QUEUE_FULL,
-    'timeout',
-]);
-function sanitizeToolErrorDetails(details) {
-    const sanitized = {};
-    const { retryAfter, timeout, reason } = details;
-    if (typeof retryAfter === 'number' ||
-        typeof retryAfter === 'string' ||
-        retryAfter === null) {
-        sanitized['retryAfter'] = retryAfter;
-    }
-    if (typeof timeout === 'number' && Number.isFinite(timeout) && timeout >= 0) {
-        sanitized['timeout'] = timeout;
-    }
-    if (typeof reason === 'string' && PUBLIC_ERROR_REASONS.has(reason)) {
-        sanitized['reason'] = reason;
-    }
-    return Object.keys(sanitized).length > 0 ? sanitized : undefined;
-}
-export function createToolErrorResponse(message, url, extra) {
-    const errorContent = createToolErrorPayload(message, url, extra);
-    return {
-        content: [{ type: 'text', text: JSON.stringify(errorContent) }],
-        isError: true,
-    };
-}
-export function createToolErrorPayload(message, url, extra) {
-    const payload = {
-        error: message,
-        url,
-    };
-    if (extra?.category !== undefined)
-        payload.category = extra.category;
-    if (extra?.code !== undefined)
-        payload.code = extra.code;
-    if (extra?.statusCode !== undefined)
-        payload.statusCode = extra.statusCode;
-    if (extra?.upstreamMessage !== undefined) {
-        payload.upstreamMessage = extra.upstreamMessage;
-    }
-    if (extra?.details)
-        payload.details = extra.details;
-    if (extra?.data !== undefined)
-        payload.data = extra.data;
-    return payload;
-}
-function normalizeToolErrorPayload(value) {
-    return createToolErrorPayload(value.error, value.url, {
-        ...(value.category !== undefined ? { category: value.category } : {}),
-        ...(value.code !== undefined ? { code: value.code } : {}),
-        ...(value.statusCode !== undefined ? { statusCode: value.statusCode } : {}),
-        ...(value.upstreamMessage !== undefined
-            ? { upstreamMessage: value.upstreamMessage }
-            : {}),
-        ...(value.details ? { details: value.details } : {}),
-        ...(value.data !== undefined ? { data: value.data } : {}),
-    });
-}
-export function tryReadToolErrorPayload(value) {
-    if (!isObject(value))
-        return undefined;
-    const structuredContent = toolErrorPayloadSchema.safeParse(value['structuredContent']);
-    if (structuredContent.success) {
-        return normalizeToolErrorPayload(structuredContent.data);
-    }
-    const { content } = value;
-    if (!Array.isArray(content) || content.length === 0)
-        return undefined;
-    const firstBlock = content[0];
-    if (!isObject(firstBlock))
-        return undefined;
-    if (firstBlock['type'] !== 'text')
-        return undefined;
-    if (typeof firstBlock['text'] !== 'string')
-        return undefined;
-    try {
-        const payload = toolErrorPayloadSchema.safeParse(JSON.parse(firstBlock['text']));
-        return payload.success
-            ? normalizeToolErrorPayload(payload.data)
-            : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-export function tryReadToolErrorMessage(value) {
-    return tryReadToolErrorPayload(value)?.error;
-}
-function renderToolErrorResponse(presentation) {
-    return createToolErrorResponse(presentation.message, presentation.url, {
-        ...(presentation.category !== undefined
-            ? { category: presentation.category }
-            : {}),
-        ...(presentation.code !== undefined ? { code: presentation.code } : {}),
-        ...(presentation.statusCode !== undefined
-            ? { statusCode: presentation.statusCode }
-            : {}),
-        ...(presentation.upstreamMessage !== undefined
-            ? { upstreamMessage: presentation.upstreamMessage }
-            : {}),
-        ...(presentation.details ? { details: presentation.details } : {}),
-        ...(presentation.data !== undefined ? { data: presentation.data } : {}),
-    });
-}
-function isValidationError(error) {
-    return (error instanceof Error &&
-        isSystemError(error) &&
-        error.code === SystemErrors.VALIDATION_ERROR);
-}
-function buildUpstreamHttpMessage(error) {
-    const { statusCode } = error;
-    if (statusCode === 404) {
-        return `We couldn't find the resource at the target URL.`;
-    }
-    return `An error occurred when communicating with the target URL.`;
-}
-function mapFetchToolError(error, fallbackUrl) {
-    const { code: detailsCode, reason } = error.details;
-    let { code } = error;
-    if (typeof detailsCode === 'string') {
-        code = detailsCode;
-    }
-    else if (reason === SystemErrors.QUEUE_FULL) {
-        code = SystemErrors.QUEUE_FULL;
-    }
-    const url = error.url || fallbackUrl;
-    const details = sanitizeToolErrorDetails(error.details);
-    if (reason === 'timeout') {
-        return {
-            message: 'The request to the target timed out.',
-            url,
-            category: 'upstream_timeout',
-            code,
-            statusCode: error.statusCode,
-            upstreamMessage: error.message,
-            ...(details ? { details } : {}),
-        };
-    }
-    if (reason === 'aborted') {
-        return {
-            message: 'The request to the target was cancelled.',
-            url,
-            category: 'upstream_aborted',
-            code,
-            statusCode: error.statusCode,
-            upstreamMessage: error.message,
-            ...(details ? { details } : {}),
-        };
-    }
-    if (reason === SystemErrors.QUEUE_FULL) {
-        return {
-            message: error.message,
-            url,
-            category: 'queue_full',
-            code,
-            statusCode: error.statusCode,
-            ...(details ? { details } : {}),
-        };
-    }
-    const isRealHttpError = typeof error.details['httpStatus'] === 'number';
-    if (isRealHttpError && error.statusCode >= 400) {
-        return {
-            message: buildUpstreamHttpMessage(error),
-            url,
-            category: error.statusCode === 429
-                ? 'upstream_rate_limited'
-                : 'upstream_http_error',
-            code,
-            statusCode: error.statusCode,
-            upstreamMessage: error.message,
-            ...(details ? { details } : {}),
-        };
-    }
-    return {
-        message: error.message,
-        url,
-        category: 'fetch_error',
-        code,
-        statusCode: error.statusCode,
-        ...(details ? { details } : {}),
-    };
-}
-function mapGenericToolError(error, url, fallbackMessage) {
-    if (isValidationError(error)) {
-        return {
-            message: error.message,
-            url,
-            category: 'validation_error',
-            code: SystemErrors.VALIDATION_ERROR,
-        };
-    }
-    const isAborted = isAbortError(error);
-    return {
-        message: error instanceof Error
-            ? error.message
-            : `${fallbackMessage}: unknown error`,
-        url,
-        category: isAborted ? 'upstream_aborted' : 'fetch_error',
-        code: isAborted ? SystemErrors.ABORTED : SystemErrors.FETCH_ERROR,
-    };
-}
-function resolveToolErrorPresentation(error, url, fallbackMessage) {
-    if (error instanceof FetchError) {
-        return mapFetchToolError(error, url);
-    }
-    return mapGenericToolError(error, url, fallbackMessage);
-}
-export function handleToolError(error, url, fallbackMessage = 'Operation failed') {
-    return renderToolErrorResponse(resolveToolErrorPresentation(error, url, fallbackMessage));
-}
-export function classifyAndLogToolError(error, meta, loggerName, toolName, fallbackMessage) {
-    if (error instanceof McpError) {
-        if (error.code === ErrorCode.InvalidParams ||
-            error.code === ErrorCode.MethodNotFound) {
-            logError(`${toolName} tool protocol error`, { url: meta.url, durationMs: meta.durationMs, error }, loggerName);
-            throw error;
-        }
-        logWarn(`${toolName} tool domain error`, { url: meta.url, durationMs: meta.durationMs, error }, loggerName);
-        return handleToolError(error, meta.url, fallbackMessage);
-    }
-    if (error instanceof FetchError || isAbortError(error)) {
-        logWarn(`${toolName} request failed`, {
-            url: meta.url,
-            error: error instanceof Error ? error.message : String(error),
-            durationMs: meta.durationMs,
-        }, loggerName);
-    }
-    else {
-        logError(`${toolName} request failed unexpectedly`, {
-            url: meta.url,
-            error: error instanceof Error ? error.message : String(error),
-            durationMs: meta.durationMs,
-        }, loggerName);
-    }
-    return handleToolError(error, meta.url, fallbackMessage);
-}

package/dist/lib/url.d.ts.map

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

package/dist/lib/zod.d.ts

@@ -1,3 +0,0 @@
-import { z } from 'zod';
-export declare function formatZodError(error: z.ZodError): string;
-//# sourceMappingURL=zod.d.ts.map

package/dist/lib/zod.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"zod.d.ts","sourceRoot":"","sources":["../../src/lib/zod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAgBxB,wBAAgB,cAAc,CAAC,KAAK,EAAE,CAAC,CAAC,QAAQ,GAAG,MAAM,CAYxD"}

package/dist/lib/zod.js

@@ -1,27 +0,0 @@
-import { z } from 'zod';
-function formatPathSegment(segment) {
-    if (typeof segment === 'number')
-        return `[${segment}]`;
-    if (typeof segment === 'string')
-        return segment;
-    return segment.description ?? '<symbol>';
-}
-function formatIssuePath(path) {
-    return path.reduce((acc, segment) => {
-        const isNum = typeof segment === 'number';
-        const formatted = formatPathSegment(segment);
-        return acc ? `${acc}${isNum ? '' : '.'}${formatted}` : formatted;
-    }, '');
-}
-export function formatZodError(error) {
-    const parts = error.issues.map((issue) => {
-        const path = formatIssuePath(issue.path);
-        return path ? `${path}: ${issue.message}` : issue.message;
-    });
-    const uniqueParts = [
-        ...new Set(parts.filter((val) => val.trim().length > 0)),
-    ];
-    if (uniqueParts.length > 0)
-        return uniqueParts.join('; ');
-    return z.prettifyError(error).replace(/\s+/g, ' ').trim() || 'Invalid input';
-}

package/dist/tasks/call-contract.d.ts

@@ -1,25 +0,0 @@
-import type { ServerResult } from '@modelcontextprotocol/sdk/types.js';
-import { z } from 'zod';
-export declare const extendedCallToolRequestSchema: z.ZodObject<{
-    method: z.ZodLiteral<"tools/call">;
-    params: z.ZodObject<{
-        name: z.ZodString;
-        arguments: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        task: z.ZodOptional<z.ZodObject<{
-            ttl: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strict>>;
-        _meta: z.ZodOptional<z.ZodObject<{
-            progressToken: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
-            'io.modelcontextprotocol/related-task': z.ZodOptional<z.ZodObject<{
-                taskId: z.ZodString;
-            }, z.core.$strict>>;
-        }, z.core.$loose>>;
-    }, z.core.$strict>;
-}, z.core.$loose>;
-export type ExtendedCallToolRequest = z.infer<typeof extendedCallToolRequestSchema>;
-export type ToolCallRequestMeta = ExtendedCallToolRequest['params']['_meta'];
-export declare function parseExtendedCallToolRequest(request: unknown): ExtendedCallToolRequest;
-export declare function sanitizeToolCallMeta(meta?: ToolCallRequestMeta): ToolCallRequestMeta | undefined;
-export declare function buildRelatedTaskMeta(taskId: string, meta?: ToolCallRequestMeta): Record<string, unknown>;
-export declare function withRelatedTaskMeta(result: ServerResult, taskId: string): ServerResult;
-//# sourceMappingURL=call-contract.d.ts.map

package/dist/tasks/call-contract.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"call-contract.d.ts","sourceRoot":"","sources":["../../src/tasks/call-contract.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAC;AAEvE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAiBxB,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;iBAiBxC,CAAC;AAEH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAC3C,OAAO,6BAA6B,CACrC,CAAC;AACF,MAAM,MAAM,mBAAmB,GAAG,uBAAuB,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,CAAC;AAE7E,wBAAgB,4BAA4B,CAC1C,OAAO,EAAE,OAAO,GACf,uBAAuB,CAKzB;AAED,wBAAgB,oBAAoB,CAClC,IAAI,CAAC,EAAE,mBAAmB,GACzB,mBAAmB,GAAG,SAAS,CAMjC;AAED,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,MAAM,EACd,IAAI,CAAC,EAAE,mBAAmB,GACzB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAKzB;AAED,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,YAAY,EACpB,MAAM,EAAE,MAAM,GACb,YAAY,CAQd"}

package/dist/tasks/call-contract.js

@@ -1,59 +0,0 @@
-import { ErrorCode } from '@modelcontextprotocol/sdk/types.js';
-import { z } from 'zod';
-import { createMcpError } from '../lib/mcp-interop.js';
-import { formatZodError } from '../lib/zod.js';
-const MIN_TASK_TTL_MS = 1_000;
-const MAX_TASK_TTL_MS = 86_400_000;
-const relatedTaskMetaSchema = z.strictObject({
-    taskId: z.string(),
-});
-const toolCallMetaSchema = z.looseObject({
-    progressToken: z.union([z.string(), z.number()]).optional(),
-    'io.modelcontextprotocol/related-task': relatedTaskMetaSchema.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(),
-        task: z
-            .strictObject({
-            ttl: z
-                .number()
-                .int()
-                .min(MIN_TASK_TTL_MS, `Minimum ${MIN_TASK_TTL_MS}ms`)
-                .max(MAX_TASK_TTL_MS, `Maximum ${MAX_TASK_TTL_MS}ms`)
-                .optional(),
-        })
-            .optional(),
-        _meta: toolCallMetaSchema.optional(),
-    }),
-});
-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;
-    const sanitized = { ...meta };
-    delete sanitized['io.modelcontextprotocol/related-task'];
-    return Object.keys(sanitized).length > 0 ? sanitized : undefined;
-}
-export function buildRelatedTaskMeta(taskId, meta) {
-    return {
-        ...(sanitizeToolCallMeta(meta) ?? {}),
-        'io.modelcontextprotocol/related-task': { taskId },
-    };
-}
-export function withRelatedTaskMeta(result, taskId) {
-    return {
-        ...result,
-        _meta: {
-            ...result._meta,
-            'io.modelcontextprotocol/related-task': { taskId },
-        },
-    };
-}

package/dist/tasks/execution.d.ts

@@ -1,16 +0,0 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { type ServerResult } from '@modelcontextprotocol/sdk/types.js';
-import { type ExtendedCallToolRequest } from './call-contract.js';
-import { type CreateTaskResult, type TaskState } from './manager.js';
-import { type ToolCallContext } from './owner.js';
-export declare function abortTaskExecution(taskId: string): void;
-export declare function cancelTasksForOwner(ownerKey: string, statusMessage?: string): number;
-export declare function abortAllTaskExecutions(): void;
-type TaskSummary = CreateTaskResult['task'];
-type TaskLifecycleProjection = Pick<TaskState, 'taskId' | 'status' | 'statusMessage' | 'progress' | 'total' | 'createdAt' | 'lastUpdatedAt' | 'ttl' | 'pollInterval'>;
-export declare function toTaskSummary(task: TaskLifecycleProjection): TaskSummary;
-export declare function emitTaskStatusNotification(server: McpServer, task: TaskState): void;
-export declare function throwTaskNotFound(): never;
-export declare function handleToolCallRequest(server: McpServer, request: ExtendedCallToolRequest, context: ToolCallContext): Promise<ServerResult>;
-export {};
-//# sourceMappingURL=execution.d.ts.map

package/dist/tasks/execution.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"execution.d.ts","sourceRoot":"","sources":["../../src/tasks/execution.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AACzE,OAAO,EAGL,KAAK,YAAY,EAClB,MAAM,oCAAoC,CAAC;AAiB5C,OAAO,EAEL,KAAK,uBAAuB,EAC7B,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,KAAK,gBAAgB,EAErB,KAAK,SAAS,EACf,MAAM,cAAc,CAAC;AACtB,OAAO,EAGL,KAAK,eAAe,EACrB,MAAM,YAAY,CAAC;AAkCpB,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAGvD;AAED,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,MAAM,EAChB,aAAa,SAA4D,GACxE,MAAM,CAOR;AAED,wBAAgB,sBAAsB,IAAI,IAAI,CAE7C;AAMD,KAAK,WAAW,GAAG,gBAAgB,CAAC,MAAM,CAAC,CAAC;AAC5C,KAAK,uBAAuB,GAAG,IAAI,CACjC,SAAS,EACP,QAAQ,GACR,QAAQ,GACR,eAAe,GACf,UAAU,GACV,OAAO,GACP,WAAW,GACX,eAAe,GACf,KAAK,GACL,cAAc,CACjB,CAAC;AAEF,wBAAgB,aAAa,CAAC,IAAI,EAAE,uBAAuB,GAAG,WAAW,CAYxE;AAED,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,SAAS,EACjB,IAAI,EAAE,SAAS,GACd,IAAI,CAmBN;AAED,wBAAgB,iBAAiB,IAAI,KAAK,CAEzC;AAgKD,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,SAAS,EACjB,OAAO,EAAE,uBAAuB,EAChC,OAAO,EAAE,eAAe,GACvB,OAAO,CAAC,YAAY,CAAC,CAwFvB"}

package/dist/tasks/execution.js

@@ -1,241 +0,0 @@
-import { ErrorCode, McpError, } from '@modelcontextprotocol/sdk/types.js';
-import { config } from '../lib/core.js';
-import { logDebug, logError, logInfo, logWarn, runWithRequestContext, } from '../lib/core.js';
-import { Loggers } from '../lib/logger-names.js';
-import { createMcpError } from '../lib/mcp-interop.js';
-import {} from '../lib/mcp-interop.js';
-import { tryReadToolErrorMessage } from '../lib/tool-errors.js';
-import { getErrorMessage } from '../lib/utils.js';
-import { isObject } from '../lib/utils.js';
-import { buildRelatedTaskMeta, } from './call-contract.js';
-import { taskManager, } from './manager.js';
-import { buildToolHandlerExtra, compact, } from './owner.js';
-import { getTaskCapableTool, getTaskCapableToolSupport, } from './registry.js';
-/* -------------------------------------------------------------------------------------------------
- * Abort-controller management for in-flight task executions
- * ------------------------------------------------------------------------------------------------- */
-// 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 attachAbortController(taskId) {
-    taskAbortControllers.get(taskId)?.abort();
-    if (taskAbortControllers.size >= config.tasks.maxTotal) {
-        logWarn('Abort controller map reached task capacity — possible leak', {
-            size: taskAbortControllers.size,
-            maxTotal: config.tasks.maxTotal,
-        }, Loggers.LOG_TASKS);
-    }
-    const controller = new AbortController();
-    taskAbortControllers.set(taskId, controller);
-    return controller;
-}
-export function abortTaskExecution(taskId) {
-    taskAbortControllers.get(taskId)?.abort();
-    taskAbortControllers.delete(taskId);
-}
-export function cancelTasksForOwner(ownerKey, statusMessage = 'The task was cancelled because its owner session ended.') {
-    if (!ownerKey)
-        return 0;
-    const cancelled = taskManager.cancelTasksByOwner(ownerKey, statusMessage);
-    for (const task of cancelled) {
-        abortTaskExecution(task.taskId);
-    }
-    return cancelled.length;
-}
-export function abortAllTaskExecutions() {
-    for (const taskId of taskAbortControllers.keys())
-        abortTaskExecution(taskId);
-}
-export function toTaskSummary(task) {
-    return {
-        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,
-        ttl: task.ttl,
-        pollInterval: task.pollInterval,
-    };
-}
-export function emitTaskStatusNotification(server, task) {
-    if (!config.tasks.emitStatusNotifications || !server.isConnected())
-        return;
-    void server.server
-        .notification({
-        method: 'notifications/tasks/status',
-        params: { ...toTaskSummary(task) },
-    })
-        .catch((error) => {
-        logError('Failed to send task status notification', {
-            taskId: task.taskId,
-            status: task.status,
-            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
-        ? (/^(?:MCP )?[Ee]rror -?\d+:\s*(.*)$/s.exec(error.message)?.[1] ??
-            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;
-    return {
-        status: isError ? 'failed' : 'completed',
-        statusMessage: isError
-            ? (tryReadToolErrorMessage(result) ?? 'Execution failed')
-            : (tool.getCompletionStatusMessage?.(result) ??
-                'Task completed successfully.'),
-        result,
-    };
-}
-async function runTaskToolExecution(params) {
-    const { server, taskId, args, tool, meta, sessionId, sendNotification } = params;
-    return runWithRequestContext({
-        requestId: taskId,
-        operationId: taskId,
-        ...(sessionId ? { sessionId } : {}),
-    }, async () => {
-        const controller = attachAbortController(taskId);
-        const progressState = { closed: false };
-        try {
-            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;
-            taskAbortControllers.delete(taskId);
-        }
-    });
-}
-export async function handleToolCallRequest(server, request, context) {
-    const { params } = request;
-    // 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}`);
-    }
-    if (params.task) {
-        if (getTaskCapableToolSupport(server, params.name) === 'forbidden') {
-            throw createMcpError(ErrorCode.MethodNotFound, `Task mode is not supported for tool: ${params.name}`);
-        }
-        const args = tool.parseArguments(params.arguments);
-        const task = taskManager.createTask(params.task.ttl !== undefined ? { ttl: params.task.ttl } : undefined, 'Task started', context.ownerKey);
-        logInfo('Task execution queued', {
-            taskId: task.taskId,
-            tool: params.name,
-            ...(params.task.ttl !== undefined ? { ttl: params.task.ttl } : {}),
-        }, Loggers.LOG_TASKS);
-        void runTaskToolExecution({
-            server,
-            taskId: task.taskId,
-            args,
-            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,
-                    },
-                }
-                : {}),
-        };
-    }
-    if (getTaskCapableToolSupport(server, params.name) === 'required') {
-        throw createMcpError(ErrorCode.MethodNotFound, `Task mode is required for tool: ${params.name}`);
-    }
-    const args = tool.parseArguments(params.arguments);
-    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(args, {
-            ...buildToolHandlerExtra(context, params._meta),
-            progressState,
-        });
-    }
-    finally {
-        progressState.closed = true;
-    }
-}

package/dist/tasks/handlers.d.ts

@@ -1,11 +0,0 @@
-import { type McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-export { cancelTasksForOwner, abortAllTaskExecutions } from './execution.js';
-interface TaskHandlerRegistrationOptions {
-    requireInterception?: boolean;
-}
-interface TaskHandlerRegistrationResult {
-    interceptedToolsCall: boolean;
-    taskCapableToolsRegistered: boolean;
-}
-export declare function registerTaskHandlers(server: McpServer, options?: TaskHandlerRegistrationOptions): TaskHandlerRegistrationResult;
-//# sourceMappingURL=handlers.d.ts.map

package/dist/tasks/handlers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"handlers.d.ts","sourceRoot":"","sources":["../../src/tasks/handlers.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAmCzE,OAAO,EAAE,mBAAmB,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAC;AA4D7E,UAAU,8BAA8B;IACtC,mBAAmB,CAAC,EAAE,OAAO,CAAC;CAC/B;AAED,UAAU,6BAA6B;IACrC,oBAAoB,EAAE,OAAO,CAAC;IAC9B,0BAA0B,EAAE,OAAO,CAAC;CACrC;AAkBD,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,SAAS,EACjB,OAAO,CAAC,EAAE,8BAA8B,GACvC,6BAA6B,CAoK/B"}