@j0hanz/fetch-url-mcp 1.10.2 → 1.10.4

package/dist/lib/progress.js

@@ -19,6 +19,9 @@ class ToolProgressReporter {
     canReportProgress;
     isTerminal = false;
     lastProgress = -1;
+    lastMessage;
+    pendingNotification;
+    isDispatching = false;
     constructor(token, sendNotification, relatedTaskMeta, onProgress, canReportProgress) {
         this.token = token;
         this.sendNotification = sendNotification;
@@ -50,13 +53,13 @@ class ToolProgressReporter {
             return;
         const effectiveProgress = Math.max(progress, this.lastProgress);
         const isIncreasing = effectiveProgress > this.lastProgress;
+        const isMessageChanged = message !== this.lastMessage;
         this.lastProgress = effectiveProgress;
+        this.lastMessage = message;
         if (effectiveProgress >= FETCH_PROGRESS_TOTAL) {
             this.isTerminal = true;
         }
-        // Only fire onProgress when progress actually increases to avoid duplicate
-        // task status updates (onProgress drives updateWorkingTaskStatus in task mode).
-        if (isIncreasing && this.onProgress) {
+        if ((isIncreasing || isMessageChanged) && this.onProgress) {
             try {
                 this.onProgress(effectiveProgress, message);
             }
@@ -70,44 +73,68 @@ class ToolProgressReporter {
         }
         if (!isIncreasing || this.token === null || !this.sendNotification)
             return;
-        const { sendNotification } = this;
-        const notification = this.createProgressNotification(this.token, effectiveProgress, message);
-        // Fire without chaining to avoid queue buildup and delayed reports
-        // that could fire after the task reaches a terminal state.
+        this.pendingNotification = this.createProgressNotification(this.token, effectiveProgress, message);
+        this.flushNotifications();
+    }
+    flushNotifications() {
+        if (this.isDispatching || !this.sendNotification)
+            return;
+        this.isDispatching = true;
         void (async () => {
-            let timeoutId;
-            const timeoutPromise = new Promise((resolve) => {
-                timeoutId = setTimeout(() => {
-                    resolve({ timeout: true });
-                }, PROGRESS_NOTIFICATION_TIMEOUT_MS);
-                timeoutId.unref();
-            });
             try {
-                const outcome = await Promise.race([
-                    sendNotification(notification).then(() => ({ ok: true })),
-                    timeoutPromise,
-                ]);
-                if ('timeout' in outcome) {
-                    logWarn('Progress notification timed out', {
-                        progress: effectiveProgress,
-                        message,
-                    });
+                while (this.pendingNotification) {
+                    if (this.canReportProgress && !this.canReportProgress()) {
+                        this.pendingNotification = undefined;
+                        return;
+                    }
+                    const notification = this.pendingNotification;
+                    this.pendingNotification = undefined;
+                    await this.sendWithTimeout(notification);
                 }
             }
-            catch (error) {
-                logWarn('Failed to send progress notification', {
-                    error: getErrorMessage(error),
-                    progress: effectiveProgress,
-                    message,
-                });
-            }
             finally {
-                if (timeoutId) {
-                    clearTimeout(timeoutId);
+                this.isDispatching = false;
+                if (this.pendingNotification) {
+                    this.flushNotifications();
                 }
             }
         })();
     }
+    async sendWithTimeout(notification) {
+        if (!this.sendNotification)
+            return;
+        let timeoutId;
+        const timeoutPromise = new Promise((resolve) => {
+            timeoutId = setTimeout(() => {
+                resolve({ timeout: true });
+            }, PROGRESS_NOTIFICATION_TIMEOUT_MS);
+            timeoutId.unref();
+        });
+        try {
+            const outcome = await Promise.race([
+                this.sendNotification(notification).then(() => ({ ok: true })),
+                timeoutPromise,
+            ]);
+            if ('timeout' in outcome) {
+                logWarn('Progress notification timed out', {
+                    progress: notification.params.progress,
+                    message: notification.params.message,
+                });
+            }
+        }
+        catch (error) {
+            logWarn('Failed to send progress notification', {
+                error: getErrorMessage(error),
+                progress: notification.params.progress,
+                message: notification.params.message,
+            });
+        }
+        finally {
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+            }
+        }
+    }
     createProgressNotification(token, progress, message) {
         return {
             method: 'notifications/progress',

package/dist/lib/sdk-interop.d.ts

@@ -0,0 +1,8 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+type CleanupCallback = () => void;
+type RequestHandlerFn = (request: unknown, extra?: unknown) => Promise<unknown>;
+export declare function registerServerLifecycleCleanup(server: McpServer, callback: CleanupCallback): void;
+export declare function getSdkCallToolHandler(server: McpServer): RequestHandlerFn | null;
+export declare function setTaskToolCallCapability(server: McpServer, enabled: boolean): void;
+export {};
+//# sourceMappingURL=sdk-interop.d.ts.map

package/dist/lib/sdk-interop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sdk-interop.d.ts","sourceRoot":"","sources":["../../src/lib/sdk-interop.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAKzE,KAAK,eAAe,GAAG,MAAM,IAAI,CAAC;AAClC,KAAK,gBAAgB,GAAG,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,CAAC,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;AA8ChF,wBAAgB,8BAA8B,CAC5C,MAAM,EAAE,SAAS,EACjB,QAAQ,EAAE,eAAe,GACxB,IAAI,CAGN;AAED,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,SAAS,GAChB,gBAAgB,GAAG,IAAI,CAMzB;AAED,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,SAAS,EACjB,OAAO,EAAE,OAAO,GACf,IAAI,CAoBN"}

package/dist/lib/sdk-interop.js

@@ -0,0 +1,73 @@
+import { logWarn } from './core.js';
+import { isObject } from './utils.js';
+const patchedCleanupServers = new WeakSet();
+const serverCleanupCallbacks = new WeakMap();
+function getServerCleanupCallbackSet(server) {
+    let callbacks = serverCleanupCallbacks.get(server);
+    if (!callbacks) {
+        callbacks = new Set();
+        serverCleanupCallbacks.set(server, callbacks);
+    }
+    return callbacks;
+}
+function drainServerCleanupCallbacks(server) {
+    const callbacks = serverCleanupCallbacks.get(server);
+    if (!callbacks || callbacks.size === 0)
+        return;
+    const pending = [...callbacks];
+    callbacks.clear();
+    for (const callback of pending) {
+        try {
+            callback();
+        }
+        catch (error) {
+            logWarn('Server cleanup callback failed', { error });
+        }
+    }
+}
+function ensureServerCleanupHooks(server) {
+    if (patchedCleanupServers.has(server))
+        return;
+    patchedCleanupServers.add(server);
+    const originalOnClose = server.server.onclose;
+    server.server.onclose = () => {
+        drainServerCleanupCallbacks(server);
+        originalOnClose?.();
+    };
+    const originalClose = server.close.bind(server);
+    server.close = async () => {
+        drainServerCleanupCallbacks(server);
+        await originalClose();
+    };
+}
+export function registerServerLifecycleCleanup(server, callback) {
+    ensureServerCleanupHooks(server);
+    getServerCleanupCallbackSet(server).add(callback);
+}
+export function getSdkCallToolHandler(server) {
+    const maybeHandlers = Reflect.get(server.server, '_requestHandlers');
+    if (!(maybeHandlers instanceof Map))
+        return null;
+    const handler = maybeHandlers.get('tools/call');
+    return typeof handler === 'function' ? handler : null;
+}
+export function setTaskToolCallCapability(server, enabled) {
+    const capabilities = Reflect.get(server.server, '_capabilities');
+    if (!isObject(capabilities))
+        return;
+    const tasks = isObject(capabilities.tasks)
+        ? capabilities.tasks
+        : undefined;
+    if (!tasks)
+        return;
+    const requests = isObject(tasks.requests)
+        ? tasks.requests
+        : undefined;
+    if (!requests)
+        return;
+    if (enabled) {
+        requests.tools = { call: {} };
+        return;
+    }
+    delete requests.tools;
+}

package/dist/lib/task-handlers.d.ts

@@ -1,6 +1,4 @@
 import { type McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-type CleanupCallback = () => void;
-export declare function registerServerLifecycleCleanup(server: McpServer, callback: CleanupCallback): void;
 export { cancelTasksForOwner, abortAllTaskExecutions, } from '../tasks/execution.js';
 interface TaskHandlerRegistrationOptions {
     requireInterception?: boolean;

package/dist/lib/task-handlers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"task-handlers.d.ts","sourceRoot":"","sources":["../../src/lib/task-handlers.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,yCAAyC,CAAC;AA0CzE,KAAK,eAAe,GAAG,MAAM,IAAI,CAAC;AAyClC,wBAAgB,8BAA8B,CAC5C,MAAM,EAAE,SAAS,EACjB,QAAQ,EAAE,eAAe,GACxB,IAAI,CAGN;AAED,OAAO,EACL,mBAAmB,EACnB,sBAAsB,GACvB,MAAM,uBAAuB,CAAC;AA+E/B,UAAU,8BAA8B;IACtC,mBAAmB,CAAC,EAAE,OAAO,CAAC;CAC/B;AAED,UAAU,6BAA6B;IACrC,oBAAoB,EAAE,OAAO,CAAC;IAC9B,0BAA0B,EAAE,OAAO,CAAC;CACrC;AAUD,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,SAAS,EACjB,OAAO,CAAC,EAAE,8BAA8B,GACvC,6BAA6B,CAuJ/B"}
+{"version":3,"file":"task-handlers.d.ts","sourceRoot":"","sources":["../../src/lib/task-handlers.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAkCzE,OAAO,EACL,mBAAmB,EACnB,sBAAsB,GACvB,MAAM,uBAAuB,CAAC;AAoC/B,UAAU,8BAA8B;IACtC,mBAAmB,CAAC,EAAE,OAAO,CAAC;CAC/B;AAED,UAAU,6BAA6B;IACrC,oBAAoB,EAAE,OAAO,CAAC;IAC9B,0BAA0B,EAAE,OAAO,CAAC;CACrC;AACD,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,SAAS,EACjB,OAAO,CAAC,EAAE,8BAA8B,GACvC,6BAA6B,CA0J/B"}

package/dist/lib/task-handlers.js

@@ -2,56 +2,13 @@ import { randomUUID } from 'node:crypto';
 import {} from '@modelcontextprotocol/sdk/server/mcp.js';
 import { CallToolRequestSchema, ErrorCode, McpError, } from '@modelcontextprotocol/sdk/types.js';
 import { z } from 'zod';
-import { abortTaskExecution, emitTaskStatusNotification, handleToolCallRequest, throwTaskNotFound, toTaskSummary, withRelatedTaskMeta, } from '../tasks/execution.js';
+import { parseExtendedCallToolRequest, withRelatedTaskMeta, } from '../tasks/call-contract.js';
+import { abortTaskExecution, emitTaskStatusNotification, handleToolCallRequest, throwTaskNotFound, toTaskSummary, } from '../tasks/execution.js';
 import { taskManager } from '../tasks/manager.js';
 import { isServerResult, parseHandlerExtra, resolveTaskOwnerKey, resolveToolCallContext, } from '../tasks/owner.js';
 import { hasRegisteredTaskCapableTools, hasTaskCapableTool, } from '../tasks/tool-registry.js';
 import { logWarn, runWithRequestContext } from './core.js';
-import { formatZodError } from './zod.js';
-const patchedCleanupServers = new WeakSet();
-const serverCleanupCallbacks = new WeakMap();
-function getServerCleanupCallbackSet(server) {
-    let callbacks = serverCleanupCallbacks.get(server);
-    if (!callbacks) {
-        callbacks = new Set();
-        serverCleanupCallbacks.set(server, callbacks);
-    }
-    return callbacks;
-}
-function drainServerCleanupCallbacks(server) {
-    const callbacks = serverCleanupCallbacks.get(server);
-    if (!callbacks || callbacks.size === 0)
-        return;
-    const pending = [...callbacks];
-    callbacks.clear();
-    for (const callback of pending) {
-        try {
-            callback();
-        }
-        catch (error) {
-            logWarn('Server cleanup callback failed', { error });
-        }
-    }
-}
-function ensureServerCleanupHooks(server) {
-    if (patchedCleanupServers.has(server))
-        return;
-    patchedCleanupServers.add(server);
-    const originalOnClose = server.server.onclose;
-    server.server.onclose = () => {
-        drainServerCleanupCallbacks(server);
-        originalOnClose?.();
-    };
-    const originalClose = server.close.bind(server);
-    server.close = async () => {
-        drainServerCleanupCallbacks(server);
-        await originalClose();
-    };
-}
-export function registerServerLifecycleCleanup(server, callback) {
-    ensureServerCleanupHooks(server);
-    getServerCleanupCallbackSet(server).add(callback);
-}
+import { getSdkCallToolHandler } from './sdk-interop.js';
 export { cancelTasksForOwner, abortAllTaskExecutions, } from '../tasks/execution.js';
 /* -------------------------------------------------------------------------------------------------
  * Task handler schemas and registration
@@ -76,41 +33,6 @@ const TaskResultSchema = z.looseObject({
     method: z.literal('tasks/result'),
     params: z.looseObject({ taskId: z.string() }),
 });
-const MIN_TASK_TTL_MS = 1_000;
-const MAX_TASK_TTL_MS = 86_400_000;
-const ExtendedCallToolRequestSchema = z.looseObject({
-    method: z.literal('tools/call'),
-    params: z.strictObject({
-        name: z.string().min(1),
-        arguments: z.record(z.string(), z.unknown()).optional(),
-        task: z
-            .strictObject({
-            ttl: z
-                .number()
-                .int()
-                .min(MIN_TASK_TTL_MS)
-                .max(MAX_TASK_TTL_MS)
-                .optional(),
-        })
-            .optional(),
-        _meta: z
-            .looseObject({
-            progressToken: z.union([z.string(), z.number()]).optional(),
-            'io.modelcontextprotocol/related-task': z
-                .strictObject({
-                taskId: z.string(),
-            })
-                .optional(),
-        })
-            .optional(),
-    }),
-});
-function parseExtendedCallToolRequest(request) {
-    const parsed = ExtendedCallToolRequestSchema.safeParse(request);
-    if (parsed.success)
-        return parsed.data;
-    throw new McpError(ErrorCode.InvalidParams, `Invalid tool request params: ${formatZodError(parsed.error)}`);
-}
 function resolveOwnerScopedExtra(extra) {
     const parsedExtra = parseHandlerExtra(extra);
     return {
@@ -118,14 +40,6 @@ function resolveOwnerScopedExtra(extra) {
         ownerKey: resolveTaskOwnerKey(parsedExtra),
     };
 }
-function getSdkCallToolHandler(server) {
-    // S-2: see tests/sdk-compat-guard.test.ts
-    const maybeHandlers = Reflect.get(server.server, '_requestHandlers');
-    if (!(maybeHandlers instanceof Map))
-        return null;
-    const handler = maybeHandlers.get('tools/call');
-    return typeof handler === 'function' ? handler : null;
-}
 export function registerTaskHandlers(server, options) {
     const sdkCallToolHandler = getSdkCallToolHandler(server);
     const taskCapableToolsRegistered = hasRegisteredTaskCapableTools();
@@ -139,15 +53,15 @@ export function registerTaskHandlers(server, options) {
     if (sdkCallToolHandler) {
         server.server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
             const parsedExtra = parseHandlerExtra(extra);
-            const context = resolveToolCallContext(parsedExtra);
-            const requestId = context.requestId !== undefined
-                ? String(context.requestId)
+            const requestId = parsedExtra?.requestId !== undefined
+                ? String(parsedExtra.requestId)
                 : randomUUID();
-            const sessionId = parsedExtra?.sessionId;
             return runWithRequestContext({
                 requestId,
                 operationId: requestId,
-                ...(sessionId ? { sessionId } : {}),
+                ...(parsedExtra?.sessionId
+                    ? { sessionId: parsedExtra.sessionId }
+                    : {}),
             }, () => {
                 const toolName = request.params.name;
                 // Only intercept task-capable tools managed by the local task registry.
@@ -156,6 +70,7 @@ export function registerTaskHandlers(server, options) {
                     return sdkCallToolHandler(request, extra);
                 }
                 const parsed = parseExtendedCallToolRequest(request);
+                const context = resolveToolCallContext(parsedExtra, parsed.params._meta);
                 return handleToolCallRequest(server, parsed, context);
             });
         });

package/dist/resources/index.js

@@ -2,7 +2,7 @@ import { ResourceTemplate, } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { ErrorCode, McpError, SubscribeRequestSchema, UnsubscribeRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
 import { get as getCacheEntry, getEntryMeta, keys as listCacheKeys, onCacheUpdate, parseCacheKey, } from '../lib/core.js';
 import { logWarn } from '../lib/core.js';
-import { registerServerLifecycleCleanup } from '../lib/task-handlers.js';
+import { registerServerLifecycleCleanup } from '../lib/sdk-interop.js';
 import { buildOptionalIcons } from '../lib/types.js';
 import { isObject } from '../lib/utils.js';
 import { parseCachedPayload, resolveCachedPayloadContent } from '../schemas.js';

package/dist/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAkGpE,wBAAsB,eAAe,IAAI,OAAO,CAAC,SAAS,CAAC,CAE1D;AA8CD,wBAAsB,6BAA6B,IAAI,OAAO,CAAC,SAAS,CAAC,CAExE;AAkFD,wBAAsB,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC,CAMtD"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AA0GpE,wBAAsB,eAAe,IAAI,OAAO,CAAC,SAAS,CAAC,CAE1D;AAiDD,wBAAsB,6BAA6B,IAAI,OAAO,CAAC,SAAS,CAAC,CAExE;AAkFD,wBAAsB,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC,CAMtD"}

package/dist/server.js

@@ -5,12 +5,13 @@ import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import { SetLevelRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import { config } from './lib/core.js';
 import { getSessionId, logError, logInfo, setLogLevel, setMcpServer, } from './lib/core.js';
+import { setTaskToolCallCapability } from './lib/sdk-interop.js';
 import { abortAllTaskExecutions, registerTaskHandlers, } from './lib/task-handlers.js';
 import { toError } from './lib/utils.js';
 import { registerGetHelpPrompt } from './prompts/index.js';
 import { registerCacheResourceTemplate, registerInstructionResource, } from './resources/index.js';
 import { buildServerInstructions } from './resources/instructions.js';
-import { registerAllTools } from './tools/index.js';
+import { registerTools as registerFetchUrlTool } from './tools/fetch-url.js';
 import { shutdownTransformWorkerPool } from './transform/transform.js';
 /* -------------------------------------------------------------------------------------------------
  * Icons + server info
@@ -50,6 +51,9 @@ function createServerCapabilities() {
         },
     };
 }
+function syncTaskCapabilityAdvertisement(server, taskToolCallEnabled) {
+    setTaskToolCallCapability(server, taskToolCallEnabled);
+}
 function createServerInfo(icons) {
     return {
         name: config.server.name,
@@ -83,13 +87,16 @@ async function createMcpServerWithOptions(options) {
     if (shouldRegisterObservabilityServer(options)) {
         setMcpServer(server);
     }
-    registerAllTools(server);
+    const toolControls = registerFetchUrlTool(server);
     registerGetHelpPrompt(server, serverInstructions, localIcon);
     registerInstructionResource(server, serverInstructions, localIcon);
     registerCacheResourceTemplate(server, localIcon);
-    registerTaskHandlers(server, {
+    const taskRegistration = registerTaskHandlers(server, {
         requireInterception: config.tasks.requireInterception,
     });
+    const taskToolCallEnabled = taskRegistration.interceptedToolsCall;
+    toolControls.setTaskSupport(taskToolCallEnabled ? 'optional' : 'forbidden');
+    syncTaskCapabilityAdvertisement(server, taskToolCallEnabled);
     registerLoggingSetLevelHandler(server);
     attachServerErrorHandler(server);
     return server;

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

@@ -0,0 +1,25 @@
+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

@@ -0,0 +1 @@
+{"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;AAgBxB,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,CAQzB;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

@@ -0,0 +1,58 @@
+import { ErrorCode, McpError } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+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),
+        arguments: z.record(z.string(), z.unknown()).optional(),
+        task: z
+            .strictObject({
+            ttl: z
+                .number()
+                .int()
+                .min(MIN_TASK_TTL_MS)
+                .max(MAX_TASK_TTL_MS)
+                .optional(),
+        })
+            .optional(),
+        _meta: toolCallMetaSchema.optional(),
+    }),
+});
+export function parseExtendedCallToolRequest(request) {
+    const parsed = extendedCallToolRequestSchema.safeParse(request);
+    if (parsed.success)
+        return parsed.data;
+    throw new McpError(ErrorCode.InvalidParams, `Invalid tool request params: ${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/cursor-codec.d.ts

@@ -0,0 +1,5 @@
+export declare function encodeTaskCursor(anchorTaskId: string): string;
+export declare function decodeTaskCursor(cursor: string): {
+    anchorTaskId: string;
+} | null;
+//# sourceMappingURL=cursor-codec.d.ts.map

package/dist/tasks/cursor-codec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cursor-codec.d.ts","sourceRoot":"","sources":["../../src/tasks/cursor-codec.ts"],"names":[],"mappings":"AAkBA,wBAAgB,gBAAgB,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAO7D;AAED,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,MAAM,GACb;IAAE,YAAY,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAuBjC"}

package/dist/tasks/cursor-codec.js

@@ -0,0 +1,41 @@
+import { createHmac, randomBytes, timingSafeEqual } from 'node:crypto';
+const MAX_CURSOR_LENGTH = 256;
+const CURSOR_SECRET = randomBytes(32);
+function signPayload(payload) {
+    return createHmac('sha256', CURSOR_SECRET)
+        .update(payload)
+        .digest('base64url');
+}
+function safeCompare(left, right) {
+    const leftBuffer = Buffer.from(left);
+    const rightBuffer = Buffer.from(right);
+    if (leftBuffer.length !== rightBuffer.length)
+        return false;
+    return timingSafeEqual(leftBuffer, rightBuffer);
+}
+export function encodeTaskCursor(anchorTaskId) {
+    const payload = Buffer.from(JSON.stringify({ anchorTaskId }), 'utf8').toString('base64url');
+    const signature = signPayload(payload);
+    return `${payload}.${signature}`;
+}
+export function decodeTaskCursor(cursor) {
+    if (!cursor || cursor.length > MAX_CURSOR_LENGTH)
+        return null;
+    const [payload, signature, ...rest] = cursor.split('.');
+    if (!payload || !signature || rest.length > 0)
+        return null;
+    if (!safeCompare(signPayload(payload), signature))
+        return null;
+    try {
+        const decoded = JSON.parse(Buffer.from(payload, 'base64url').toString('utf8'));
+        if (typeof decoded.anchorTaskId !== 'string' ||
+            decoded.anchorTaskId.length === 0 ||
+            decoded.anchorTaskId.length > 128) {
+            return null;
+        }
+        return { anchorTaskId: decoded.anchorTaskId };
+    }
+    catch {
+        return null;
+    }
+}

package/dist/tasks/execution.d.ts

@@ -1,26 +1,8 @@
 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 interface ExtendedCallToolRequest {
-    method: 'tools/call';
-    params: {
-        name: string;
-        arguments?: Record<string, unknown> | undefined;
-        task?: {
-            ttl?: number | undefined;
-        } | undefined;
-        _meta?: {
-            progressToken?: string | number | undefined;
-            'io.modelcontextprotocol/related-task'?: {
-                taskId: string;
-            } | undefined;
-            [key: string]: unknown;
-        } | undefined;
-        [key: string]: unknown;
-    };
-    [key: string]: unknown;
-}
 export declare function abortTaskExecution(taskId: string): void;
 export declare function cancelTasksForOwner(ownerKey: string, statusMessage?: string): number;
 export declare function abortAllTaskExecutions(): void;
@@ -34,7 +16,6 @@ export declare function toTaskSummary(task: {
     ttl: number;
     pollInterval: number;
 }): TaskSummary;
-export declare function withRelatedTaskMeta(result: ServerResult, taskId: string): ServerResult;
 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>;

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

@@ -1 +1 @@
-{"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;AAW5C,OAAO,EACL,KAAK,gBAAgB,EAErB,KAAK,SAAS,EACf,MAAM,cAAc,CAAC;AACtB,OAAO,EAEL,KAAK,eAAe,EAErB,MAAM,YAAY,CAAC;AAapB,MAAM,WAAW,uBAAuB;IACtC,MAAM,EAAE,YAAY,CAAC;IACrB,MAAM,EAAE;QACN,IAAI,EAAE,MAAM,CAAC;QACb,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAC;QAChD,IAAI,CAAC,EACD;YACE,GAAG,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;SAC1B,GACD,SAAS,CAAC;QACd,KAAK,CAAC,EACF;YACE,aAAa,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;YAC5C,sCAAsC,CAAC,EACnC;gBAAE,MAAM,EAAE,MAAM,CAAA;aAAE,GAClB,SAAS,CAAC;YACd,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;SACxB,GACD,SAAS,CAAC;QACd,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;KACxB,CAAC;IACF,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAyBD,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAKvD;AAMD,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,MAAM,EAChB,aAAa,SAA4D,GACxE,MAAM,CASR;AAED,wBAAgB,sBAAsB,IAAI,IAAI,CAE7C;AAgBD,KAAK,WAAW,GAAG,gBAAgB,CAAC,MAAM,CAAC,CAAC;AAE5C,wBAAgB,aAAa,CAAC,IAAI,EAAE;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,SAAS,CAAC,QAAQ,CAAC,CAAC;IAC5B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC;IACtB,GAAG,EAAE,MAAM,CAAC;IACZ,YAAY,EAAE,MAAM,CAAC;CACtB,GAAG,WAAW,CAUd;AAED,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,YAAY,EACpB,MAAM,EAAE,MAAM,GACb,YAAY,CAYd;AAED,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,SAAS,EACjB,IAAI,EAAE,SAAS,GACd,IAAI,CAmBN;AAoBD,wBAAgB,iBAAiB,IAAI,KAAK,CAEzC;AAmND,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,SAAS,EACjB,OAAO,EAAE,uBAAuB,EAChC,OAAO,EAAE,eAAe,GACvB,OAAO,CAAC,YAAY,CAAC,CAYvB"}
+{"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;AAQ5C,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,EAErB,MAAM,YAAY,CAAC;AAgCpB,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAKvD;AAMD,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,MAAM,EAChB,aAAa,SAA4D,GACxE,MAAM,CASR;AAED,wBAAgB,sBAAsB,IAAI,IAAI,CAE7C;AAgBD,KAAK,WAAW,GAAG,gBAAgB,CAAC,MAAM,CAAC,CAAC;AAE5C,wBAAgB,aAAa,CAAC,IAAI,EAAE;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,SAAS,CAAC,QAAQ,CAAC,CAAC;IAC5B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC;IACtB,GAAG,EAAE,MAAM,CAAC;IACZ,YAAY,EAAE,MAAM,CAAC;CACtB,GAAG,WAAW,CAUd;AAED,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,SAAS,EACjB,IAAI,EAAE,SAAS,GACd,IAAI,CAmBN;AAoBD,wBAAgB,iBAAiB,IAAI,KAAK,CAEzC;AA+LD,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,SAAS,EACjB,OAAO,EAAE,uBAAuB,EAChC,OAAO,EAAE,eAAe,GACvB,OAAO,CAAC,YAAY,CAAC,CAYvB"}