fix: resolve CI lint failures

- Remove duplicate exports (taskManager.ts exported from both protocol.ts
  and index.ts). Keep only index.ts export, use type-only import in protocol.ts
- Remove unused imports (RelatedTaskMetadata in taskManager.ts, RequestTaskStore
  in interfaces.ts)
- Fix import sorting and formatting (auto-fixed by eslint/prettier)
- Remove isTaskAugmentedRequestParams unused import from protocol.ts

Author: felixweinberger

packages/client/src/experimental/tasks/client.ts

@@ -6,6 +6,7 @@
  */
 
 import type {
+    AnyObjectSchema,
     CallToolRequest,
     CancelTaskResult,
     ClientRequest,
@@ -20,7 +21,6 @@ import type {
     SchemaOutput
 } from '@modelcontextprotocol/core';
 import { CallToolResultSchema, ErrorCode, McpError } from '@modelcontextprotocol/core';
-import type { AnyObjectSchema } from '@modelcontextprotocol/core';
 
 import type { Client } from '../../client/client.js';
 
@@ -75,11 +75,7 @@ export class ExperimentalClientTasks<
             task: options?.task ?? (clientInternal.isToolTask(params.name) ? {} : undefined)
         };
 
-        const stream = tasks.requestStream(
-            { method: 'tools/call', params } as ClientRequest | RequestT,
-            resultSchema,
-            optionsWithTask
-        );
+        const stream = tasks.requestStream({ method: 'tools/call', params } as ClientRequest | RequestT, resultSchema, optionsWithTask);
 
         // Get the validator for this tool (if it has an output schema)
         const validator = clientInternal.getToolOutputValidator(params.name);

packages/core/src/experimental/tasks/interfaces.ts

@@ -4,7 +4,7 @@
  */
 
 import type { RequestHandlerExtra } from '../../shared/protocol.js';
-import type { RequestTaskStore, TaskContext } from '../../shared/taskManager.js';
+import type { TaskContext } from '../../shared/taskManager.js';
 import type {
     JSONRPCErrorResponse,
     JSONRPCNotification,

packages/core/src/index.ts

@@ -4,8 +4,8 @@ export * from './shared/authUtils.js';
 export * from './shared/metadataUtils.js';
 export * from './shared/protocol.js';
 export * from './shared/responseMessage.js';
-export * from './shared/taskManager.js';
 export * from './shared/stdio.js';
+export * from './shared/taskManager.js';
 export * from './shared/toolNameValidation.js';
 export * from './shared/transport.js';
 export * from './shared/uriTemplate.js';

packages/core/src/shared/protocol.ts

@@ -30,7 +30,6 @@ import {
     isJSONRPCNotification,
     isJSONRPCRequest,
     isJSONRPCResultResponse,
-    isTaskAugmentedRequestParams,
     ListTasksRequestSchema,
     McpError,
     PingRequestSchema,
@@ -40,14 +39,9 @@ import {
 import type { AnyObjectSchema, AnySchema, SchemaOutput } from '../util/zodCompat.js';
 import { safeParse } from '../util/zodCompat.js';
 import { getMethodLiteral, parseWithCompat } from '../util/zodJsonSchemaCompat.js';
-import type { TaskContext } from './taskManager.js';
-import { TaskManager } from './taskManager.js';
+import type { TaskContext, TaskManager } from './taskManager.js';
 import type { Transport, TransportSendOptions } from './transport.js';
 
-// Re-export TaskManager types for backwards compatibility
-export type { RequestTaskStore, TaskContext, TaskManagerHost, TaskManagerOptions, TaskRequestOptions } from './taskManager.js';
-export { TaskManager } from './taskManager.js';
-
 /**
  * Callback for progress notifications.
  */
@@ -194,7 +188,11 @@ export type RequestHandlerExtra<SendRequestT extends Request, SendNotificationT
      *
      * This is used by certain transports to correctly associate related messages.
      */
-    sendRequest: <U extends AnySchema>(request: SendRequestT, resultSchema: U, options?: Omit<RequestOptions, 'relatedTask'>) => Promise<SchemaOutput<U>>;
+    sendRequest: <U extends AnySchema>(
+        request: SendRequestT,
+        resultSchema: U,
+        options?: Omit<RequestOptions, 'relatedTask'>
+    ) => Promise<SchemaOutput<U>>;
 
     /**
      * Closes the SSE stream for this request, triggering client reconnection.
@@ -267,7 +265,10 @@ export abstract class Protocol<SendRequestT extends Request, SendNotificationT e
      */
     fallbackNotificationHandler?: (notification: Notification) => Promise<void>;
 
-    constructor(private _options?: ProtocolOptions, taskManager?: TaskManager) {
+    constructor(
+        private _options?: ProtocolOptions,
+        taskManager?: TaskManager
+    ) {
         this.setNotificationHandler(CancelledNotificationSchema, notification => {
             this._oncancel(notification);
         });
@@ -288,8 +289,8 @@ export abstract class Protocol<SendRequestT extends Request, SendNotificationT e
             taskManager.bind({
                 request: (request, resultSchema, options) => this.request(request as SendRequestT, resultSchema, options),
                 notification: (notification, options) => this.notification(notification as SendNotificationT, options),
-                reportError: (error) => this._onerror(error),
-                removeProgressHandler: (token) => this._progressHandlers.delete(token)
+                reportError: error => this._onerror(error),
+                removeProgressHandler: token => this._progressHandlers.delete(token)
             });
             // Only register task handlers if a task store is configured
             if (taskManager.taskStore) {
@@ -484,7 +485,8 @@ export abstract class Protocol<SendRequestT extends Request, SendNotificationT e
 
             // Route error response: queue if task-related, otherwise send directly
             if (relatedTaskId && this._taskManager) {
-                this._taskManager.routeResponse(relatedTaskId, errorResponse, capturedTransport?.sessionId)
+                this._taskManager
+                    .routeResponse(relatedTaskId, errorResponse, capturedTransport?.sessionId)
                     .catch(error => this._onerror(new Error(`Failed to enqueue error response: ${error}`)));
             } else {
                 capturedTransport
@@ -502,9 +504,8 @@ export abstract class Protocol<SendRequestT extends Request, SendNotificationT e
             await this.notification(notification, { relatedRequestId: request.id });
         };
         if (relatedTaskId && this._taskManager) {
-            sendNotification = this._taskManager.wrapSendNotification(
-                relatedTaskId,
-                (n, opts) => this.notification(n as SendNotificationT, { ...opts, relatedRequestId: request.id })
+            sendNotification = this._taskManager.wrapSendNotification(relatedTaskId, (n, opts) =>
+                this.notification(n as SendNotificationT, { ...opts, relatedRequestId: request.id })
             ) as (notification: SendNotificationT) => Promise<void>;
         }
 
@@ -792,7 +793,7 @@ export abstract class Protocol<SendRequestT extends Request, SendNotificationT e
             // Delegate to TaskManager for task param augmentation and queue routing
             if (this._taskManager) {
                 const responseHandler = this._responseHandlers.get(messageId)!;
-                const queued = this._taskManager.prepareOutboundRequest(jsonrpcRequest, options, messageId, responseHandler, (error) => {
+                const queued = this._taskManager.prepareOutboundRequest(jsonrpcRequest, options, messageId, responseHandler, error => {
                     this._cleanupTimeout(messageId);
                     reject(error);
                 });

packages/core/src/shared/taskManager.ts

@@ -10,7 +10,6 @@ import type {
     JSONRPCResponse,
     JSONRPCResultResponse,
     Notification,
-    RelatedTaskMetadata,
     Request,
     RequestId,
     Result,
@@ -33,8 +32,8 @@ import {
     TaskStatusNotificationSchema
 } from '../types/types.js';
 import type { AnySchema, SchemaOutput } from '../util/zodCompat.js';
-import type { ResponseMessage } from './responseMessage.js';
 import type { NotificationOptions, RequestOptions } from './protocol.js';
+import type { ResponseMessage } from './responseMessage.js';
 
 // ============================================================================
 // Types
@@ -217,12 +216,14 @@ export class TaskManager {
                             yield { type: 'result', result };
                             break;
                         }
-                        case 'failed':
+                        case 'failed': {
                             yield { type: 'error', error: new McpError(ErrorCode.InternalError, `Task ${taskId} failed`) };
                             break;
-                        case 'cancelled':
+                        }
+                        case 'cancelled': {
                             yield { type: 'error', error: new McpError(ErrorCode.InternalError, `Task ${taskId} was cancelled`) };
                             break;
+                        }
                     }
                     return;
                 }
@@ -299,11 +300,7 @@ export class TaskManager {
                                 resolver(message as JSONRPCResultResponse);
                             } else {
                                 const errorMessage = message as JSONRPCErrorResponse;
-                                resolver(new McpError(
-                                    errorMessage.error.code,
-                                    errorMessage.error.message,
-                                    errorMessage.error.data
-                                ));
+                                resolver(new McpError(errorMessage.error.code, errorMessage.error.message, errorMessage.error.data));
                             }
                         } else {
                             const messageType = queuedMessage.type === 'response' ? 'Response' : 'Error';
@@ -345,15 +342,15 @@ export class TaskManager {
         return await handleTaskResult();
     }
 
-    async handleListTasks(cursor: string | undefined, sessionId?: string): Promise<{ tasks: Task[]; nextCursor?: string; _meta: Record<string, unknown> }> {
+    async handleListTasks(
+        cursor: string | undefined,
+        sessionId?: string
+    ): Promise<{ tasks: Task[]; nextCursor?: string; _meta: Record<string, unknown> }> {
         try {
             const { tasks, nextCursor } = await this._requireTaskStore.listTasks(cursor, sessionId);
             return { tasks, nextCursor, _meta: {} };
         } catch (error) {
-            throw new McpError(
-                ErrorCode.InvalidParams,
-                `Failed to list tasks: ${error instanceof Error ? error.message : String(error)}`
-            );
+            throw new McpError(ErrorCode.InvalidParams, `Failed to list tasks: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
 
@@ -445,7 +442,10 @@ export class TaskManager {
     /**
      * Extracts task-related context from an inbound request.
      */
-    extractInboundTaskContext(request: JSONRPCRequest, sessionId?: string): {
+    extractInboundTaskContext(
+        request: JSONRPCRequest,
+        sessionId?: string
+    ): {
         relatedTaskId?: string;
         taskCreationParams?: TaskCreationParams;
         taskContext?: TaskContext;
@@ -484,8 +484,7 @@ export class TaskManager {
         originalSendNotification: (notification: Notification, options?: NotificationOptions) => Promise<void>
     ): (notification: Notification) => Promise<void> {
         return async (notification: Notification) => {
-            const notificationOptions: NotificationOptions = {};
-            notificationOptions.relatedTask = { taskId: relatedTaskId };
+            const notificationOptions: NotificationOptions = { relatedTask: { taskId: relatedTaskId } };
             await originalSendNotification(notification, notificationOptions);
         };
     }
@@ -590,19 +589,13 @@ export class TaskManager {
     ): Promise<boolean> {
         if (!relatedTaskId || !this._taskMessageQueue) return false;
 
-        if (isJSONRPCErrorResponse(message)) {
-            await this._enqueueTaskMessage(
-                relatedTaskId,
-                { type: 'error', message, timestamp: Date.now() },
-                sessionId
-            );
-        } else {
-            await this._enqueueTaskMessage(
-                relatedTaskId,
-                { type: 'response', message: message as JSONRPCResultResponse, timestamp: Date.now() },
-                sessionId
-            );
-        }
+        await (isJSONRPCErrorResponse(message)
+            ? this._enqueueTaskMessage(relatedTaskId, { type: 'error', message, timestamp: Date.now() }, sessionId)
+            : this._enqueueTaskMessage(
+                  relatedTaskId,
+                  { type: 'response', message: message as JSONRPCResultResponse, timestamp: Date.now() },
+                  sessionId
+              ));
         return true;
     }
 
@@ -616,9 +609,7 @@ export class TaskManager {
         return {
             createTask: async taskParams => {
                 if (!request) throw new Error('No request provided');
-                return await taskStore.createTask(
-                    taskParams, request.id, { method: request.method, params: request.params }, sessionId
-                );
+                return await taskStore.createTask(taskParams, request.id, { method: request.method, params: request.params }, sessionId);
             },
             getTask: async taskId => {
                 const task = await taskStore.getTask(taskId, sessionId);
@@ -630,7 +621,8 @@ export class TaskManager {
                 const task = await taskStore.getTask(taskId, sessionId);
                 if (task) {
                     const notification: TaskStatusNotification = TaskStatusNotificationSchema.parse({
-                        method: 'notifications/tasks/status', params: task
+                        method: 'notifications/tasks/status',
+                        params: task
                     });
                     await host?.notification(notification as Notification);
                     if (isTerminal(task.status)) {
@@ -654,7 +646,8 @@ export class TaskManager {
                 const updatedTask = await taskStore.getTask(taskId, sessionId);
                 if (updatedTask) {
                     const notification: TaskStatusNotification = TaskStatusNotificationSchema.parse({
-                        method: 'notifications/tasks/status', params: updatedTask
+                        method: 'notifications/tasks/status',
+                        params: updatedTask
                     });
                     await host?.notification(notification as Notification);
                     if (isTerminal(updatedTask.status)) {
@@ -714,10 +707,14 @@ export class TaskManager {
                 return;
             }
             const timeoutId = setTimeout(resolve, interval);
-            signal.addEventListener('abort', () => {
-                clearTimeout(timeoutId);
-                reject(new McpError(ErrorCode.InvalidRequest, 'Request cancelled'));
-            }, { once: true });
+            signal.addEventListener(
+                'abort',
+                () => {
+                    clearTimeout(timeoutId);
+                    reject(new McpError(ErrorCode.InvalidRequest, 'Request cancelled'));
+                },
+                { once: true }
+            );
         });
     }
 

packages/core/test/shared/protocol.test.ts

@@ -4795,11 +4795,14 @@ describe('Error handling for missing resolvers', () => {
             protected assertCapabilityForMethod(_method: string): void {}
             protected assertNotificationCapability(_method: string): void {}
             protected assertRequestHandlerCapability(_method: string): void {}
-        })({}, new TaskManager({
-            taskStore,
-            taskMessageQueue,
-            defaultTaskPollInterval: 100
-        }));
+        })(
+            {},
+            new TaskManager({
+                taskStore,
+                taskMessageQueue,
+                defaultTaskPollInterval: 100
+            })
+        );
 
         // @ts-expect-error deliberately overriding error handler with mock
         protocol.onerror = errorHandler;

packages/server/src/server/mcp.ts

@@ -9,9 +9,9 @@ import type {
     CompleteResult,
     CreateTaskRequestHandlerExtra,
     CreateTaskResult,
-    JSONRPCRequest,
     GetPromptResult,
     Implementation,
+    JSONRPCRequest,
     ListPromptsResult,
     ListResourcesResult,
     ListToolsResult,
@@ -369,10 +369,12 @@ export class McpServer {
     ): Promise<CallToolResult> {
         // For automatic polling, we need a task store. Use the one from extra.task if available,
         // otherwise create one from the server's TaskManager (auto-poll creates tasks internally).
-        const taskStore = extra.task?.taskStore ?? this.server.tasks?.createRequestTaskStore(
-            { jsonrpc: '2.0', id: extra.requestId, method: request.method, params: request.params } as JSONRPCRequest,
-            extra.sessionId
-        );
+        const taskStore =
+            extra.task?.taskStore ??
+            this.server.tasks?.createRequestTaskStore(
+                { jsonrpc: '2.0', id: extra.requestId, method: request.method, params: request.params } as JSONRPCRequest,
+                extra.sessionId
+            );
         if (!taskStore) {
             throw new Error('No task store provided for task-capable tool.');
         }