remove result generic and notification generic, align types with Task types from 2025-11-25 spec

Author: KKonstantinov

src/client/index.ts

@@ -46,8 +46,8 @@ import {
     ListChangedOptions,
     ListChangedOptionsBaseSchema,
     type ListChangedHandlers,
-    type RequestGeneric,
-    type NotificationGeneric,
+    type Request,
+    type Notification,
     type Result
 } from '../types.js';
 import { AjvJsonSchemaValidator } from '../validation/ajv-provider.js';
@@ -231,8 +231,8 @@ export type ClientOptions = ProtocolOptions & {
  * ```
  */
 export class Client<
-    RequestT extends RequestGeneric = RequestGeneric,
-    NotificationT extends NotificationGeneric = NotificationGeneric,
+    RequestT extends Request = Request,
+    NotificationT extends Notification = Notification,
     ResultT extends Result = Result
 > extends Protocol<ClientRequest | RequestT, ClientNotification | NotificationT, ClientResult | ResultT> {
     private _serverCapabilities?: ServerCapabilities;

src/client/streamableHttp.ts

@@ -1,5 +1,5 @@
 import { Transport, FetchLike, createFetchWithInit, normalizeHeaders } from '../shared/transport.js';
-import { isInitializedNotification, isJSONRPCRequest, isJSONRPCResponse, JSONRPCMessage, JSONRPCMessageSchema } from '../types.js';
+import { isInitializedNotification, isJSONRPCRequest, isJSONRPCResultResponse, JSONRPCMessage, JSONRPCMessageSchema } from '../types.js';
 import { auth, AuthResult, extractWWWAuthenticateParams, OAuthClientProvider, UnauthorizedError } from './auth.js';
 import { EventSourceParserStream } from 'eventsource-parser/stream';
 
@@ -350,7 +350,7 @@ export class StreamableHTTPClientTransport implements Transport {
                     if (!event.event || event.event === 'message') {
                         try {
                             const message = JSONRPCMessageSchema.parse(JSON.parse(event.data));
-                            if (isJSONRPCResponse(message)) {
+                            if (isJSONRPCResultResponse(message)) {
                                 // Mark that we received a response - no need to reconnect for this request
                                 receivedResponse = true;
                                 if (replayMessageId !== undefined) {

src/experimental/tasks/interfaces.ts

@@ -9,14 +9,14 @@ import {
     Result,
     JSONRPCRequest,
     JSONRPCNotification,
-    JSONRPCResponse,
-    JSONRPCError,
+    JSONRPCResultResponse,
+    JSONRPCErrorResponse,
     ServerRequest,
     ServerNotification,
     CallToolResult,
     GetTaskResult,
     ToolExecution,
-    RequestGeneric
+    Request
 } from '../../types.js';
 import { CreateTaskResult } from './types.js';
 import type { RequestHandlerExtra, RequestTaskStore } from '../../shared/protocol.js';
@@ -124,13 +124,13 @@ export interface QueuedNotification extends BaseQueuedMessage {
 export interface QueuedResponse extends BaseQueuedMessage {
     type: 'response';
     /** The actual JSONRPC response */
-    message: JSONRPCResponse;
+    message: JSONRPCResultResponse;
 }
 
 export interface QueuedError extends BaseQueuedMessage {
     type: 'error';
     /** The actual JSONRPC error */
-    message: JSONRPCError;
+    message: JSONRPCErrorResponse;
 }
 
 /**
@@ -226,7 +226,7 @@ export interface TaskStore {
      * @param sessionId - Optional session ID for binding the task to a specific session
      * @returns The created task object
      */
-    createTask(taskParams: CreateTaskOptions, requestId: RequestId, request: RequestGeneric, sessionId?: string): Promise<Task>;
+    createTask(taskParams: CreateTaskOptions, requestId: RequestId, request: Request, sessionId?: string): Promise<Task>;
 
     /**
      * Gets the current status of a task.

src/experimental/tasks/stores/in-memory.ts

@@ -5,13 +5,13 @@
  * @experimental
  */
 
-import { Task, RequestId, Result, RequestGeneric } from '../../../types.js';
+import { Task, RequestId, Result, Request } from '../../../types.js';
 import { TaskStore, isTerminal, TaskMessageQueue, QueuedMessage, CreateTaskOptions } from '../interfaces.js';
 import { randomBytes } from 'node:crypto';
 
 interface StoredTask {
     task: Task;
-    request: RequestGeneric;
+    request: Request;
     requestId: RequestId;
     result?: Result;
 }
@@ -39,7 +39,7 @@ export class InMemoryTaskStore implements TaskStore {
         return randomBytes(16).toString('hex');
     }
 
-    async createTask(taskParams: CreateTaskOptions, requestId: RequestId, request: RequestGeneric, _sessionId?: string): Promise<Task> {
+    async createTask(taskParams: CreateTaskOptions, requestId: RequestId, request: Request, _sessionId?: string): Promise<Task> {
         // Generate a unique task ID
         const taskId = this.generateTaskId();
 

src/server/index.ts

@@ -38,8 +38,8 @@ import {
     CallToolRequestSchema,
     CallToolResultSchema,
     CreateTaskResultSchema,
-    type RequestGeneric,
-    type NotificationGeneric,
+    type Request,
+    type Notification,
     type Result
 } from '../types.js';
 import { AjvJsonSchemaValidator } from '../validation/ajv-provider.js';
@@ -127,8 +127,8 @@ export type ServerOptions = ProtocolOptions & {
  * @deprecated Use `McpServer` instead for the high-level API. Only use `Server` for advanced use cases.
  */
 export class Server<
-    RequestT extends RequestGeneric = RequestGeneric,
-    NotificationT extends NotificationGeneric = NotificationGeneric,
+    RequestT extends Request = Request,
+    NotificationT extends Notification = Notification,
     ResultT extends Result = Result
 > extends Protocol<ServerRequest | RequestT, ServerNotification | NotificationT, ServerResult | ResultT> {
     private _clientCapabilities?: ClientCapabilities;

src/server/streamableHttp.ts

@@ -4,14 +4,14 @@ import {
     MessageExtraInfo,
     RequestInfo,
     isInitializeRequest,
-    isJSONRPCError,
     isJSONRPCRequest,
-    isJSONRPCResponse,
+    isJSONRPCResultResponse,
     JSONRPCMessage,
     JSONRPCMessageSchema,
     RequestId,
     SUPPORTED_PROTOCOL_VERSIONS,
-    DEFAULT_NEGOTIATED_PROTOCOL_VERSION
+    DEFAULT_NEGOTIATED_PROTOCOL_VERSION,
+    isJSONRPCErrorResponse
 } from '../types.js';
 import getRawBody from 'raw-body';
 import contentType from 'content-type';
@@ -858,7 +858,7 @@ export class StreamableHTTPServerTransport implements Transport {
 
     async send(message: JSONRPCMessage, options?: { relatedRequestId?: RequestId }): Promise<void> {
         let requestId = options?.relatedRequestId;
-        if (isJSONRPCResponse(message) || isJSONRPCError(message)) {
+        if (isJSONRPCResultResponse(message) || isJSONRPCErrorResponse(message)) {
             // If the message is a response, use the request ID from the message
             requestId = message.id;
         }
@@ -868,7 +868,7 @@ export class StreamableHTTPServerTransport implements Transport {
         // Those will be sent via dedicated response SSE streams
         if (requestId === undefined) {
             // For standalone SSE streams, we can only send requests and notifications
-            if (isJSONRPCResponse(message) || isJSONRPCError(message)) {
+            if (isJSONRPCResultResponse(message) || isJSONRPCErrorResponse(message)) {
                 throw new Error('Cannot send a response on a standalone SSE stream unless resuming a previous client request');
             }
 
@@ -911,7 +911,7 @@ export class StreamableHTTPServerTransport implements Transport {
             }
         }
 
-        if (isJSONRPCResponse(message) || isJSONRPCError(message)) {
+        if (isJSONRPCResultResponse(message) || isJSONRPCErrorResponse(message)) {
             this._requestResponseMap.set(requestId, message);
             const relatedIds = Array.from(this._requestToStreamMapping.entries())
                 .filter(([_, streamId]) => this._streamMapping.get(streamId) === response)

src/shared/protocol.ts

@@ -13,11 +13,11 @@ import {
     ListTasksResultSchema,
     CancelTaskRequestSchema,
     CancelTaskResultSchema,
-    isJSONRPCError,
+    isJSONRPCErrorResponse,
     isJSONRPCRequest,
-    isJSONRPCResponse,
+    isJSONRPCResultResponse,
     isJSONRPCNotification,
-    JSONRPCError,
+    JSONRPCErrorResponse,
     JSONRPCNotification,
     JSONRPCRequest,
     JSONRPCResponse,
@@ -40,8 +40,10 @@ import {
     Task,
     TaskStatusNotification,
     TaskStatusNotificationSchema,
-    RequestGeneric,
-    NotificationGeneric
+    Request,
+    Notification,
+    JSONRPCResultResponse,
+    isTaskAugmentedRequestParams
 } from '../types.js';
 import { Transport, TransportSendOptions } from './transport.js';
 import { AuthInfo } from '../server/auth/types.js';
@@ -232,7 +234,7 @@ export interface RequestTaskStore {
 /**
  * Extra data given to request handlers.
  */
-export type RequestHandlerExtra<SendRequestT extends RequestGeneric, SendNotificationT extends NotificationGeneric> = {
+export type RequestHandlerExtra<SendRequestT extends Request, SendNotificationT extends Notification> = {
     /**
      * An abort signal used to communicate if the request was cancelled from the sender's side.
      */
@@ -315,11 +317,7 @@ type TimeoutInfo = {
  * Implements MCP protocol framing on top of a pluggable transport, including
  * features like request/response linking, notifications, and progress.
  */
-export abstract class Protocol<
-    SendRequestT extends RequestGeneric,
-    SendNotificationT extends NotificationGeneric,
-    SendResultT extends Result
-> {
+export abstract class Protocol<SendRequestT extends Request, SendNotificationT extends Notification, SendResultT extends Result> {
     private _transport?: Transport;
     private _requestMessageId = 0;
     private _requestHandlers: Map<
@@ -328,7 +326,7 @@ export abstract class Protocol<
     > = new Map();
     private _requestHandlerAbortControllers: Map<RequestId, AbortController> = new Map();
     private _notificationHandlers: Map<string, (notification: JSONRPCNotification) => Promise<void>> = new Map();
-    private _responseHandlers: Map<number, (response: JSONRPCResponse | Error) => void> = new Map();
+    private _responseHandlers: Map<number, (response: JSONRPCResultResponse | Error) => void> = new Map();
     private _progressHandlers: Map<number, ProgressCallback> = new Map();
     private _timeoutInfo: Map<number, TimeoutInfo> = new Map();
     private _pendingDebouncedNotifications = new Set<string>();
@@ -339,7 +337,7 @@ export abstract class Protocol<
     private _taskStore?: TaskStore;
     private _taskMessageQueue?: TaskMessageQueue;
 
-    private _requestResolvers: Map<RequestId, (response: JSONRPCResponse | Error) => void> = new Map();
+    private _requestResolvers: Map<RequestId, (response: JSONRPCResultResponse | Error) => void> = new Map();
 
     /**
      * Callback for when the connection is closed for any reason.
@@ -363,7 +361,7 @@ export abstract class Protocol<
     /**
      * A handler to invoke for any notification types that do not have their own handler installed.
      */
-    fallbackNotificationHandler?: (notification: NotificationGeneric) => Promise<void>;
+    fallbackNotificationHandler?: (notification: Notification) => Promise<void>;
 
     constructor(private _options?: ProtocolOptions) {
         this.setNotificationHandler(CancelledNotificationSchema, notification => {
@@ -412,18 +410,18 @@ export abstract class Protocol<
                                 const requestId = message.id;
 
                                 // Lookup resolver in _requestResolvers map
-                                const resolver = this._requestResolvers.get(requestId);
+                                const resolver = this._requestResolvers.get(requestId as RequestId);
 
                                 if (resolver) {
                                     // Remove resolver from map after invocation
-                                    this._requestResolvers.delete(requestId);
+                                    this._requestResolvers.delete(requestId as RequestId);
 
                                     // Invoke resolver with response or error
                                     if (queuedMessage.type === 'response') {
-                                        resolver(message as JSONRPCResponse);
+                                        resolver(message as JSONRPCResultResponse);
                                     } else {
                                         // Convert JSONRPCError to McpError
-                                        const errorMessage = message as JSONRPCError;
+                                        const errorMessage = message as JSONRPCErrorResponse;
                                         const error = new McpError(
                                             errorMessage.error.code,
                                             errorMessage.error.message,
@@ -550,6 +548,9 @@ export abstract class Protocol<
     }
 
     private async _oncancel(notification: CancelledNotification): Promise<void> {
+        if (!notification.params.requestId) {
+            return;
+        }
         // Handle request cancellation
         const controller = this._requestHandlerAbortControllers.get(notification.params.requestId);
         controller?.abort(notification.params.reason);
@@ -620,7 +621,7 @@ export abstract class Protocol<
         const _onmessage = this._transport?.onmessage;
         this._transport.onmessage = (message, extra) => {
             _onmessage?.(message, extra);
-            if (isJSONRPCResponse(message) || isJSONRPCError(message)) {
+            if (isJSONRPCResultResponse(message) || isJSONRPCErrorResponse(message)) {
                 this._onresponse(message);
             } else if (isJSONRPCRequest(message)) {
                 this._onrequest(message, extra);
@@ -679,7 +680,7 @@ export abstract class Protocol<
         const relatedTaskId = request.params?._meta?.[RELATED_TASK_META_KEY]?.taskId;
 
         if (handler === undefined) {
-            const errorResponse: JSONRPCError = {
+            const errorResponse: JSONRPCErrorResponse = {
                 jsonrpc: '2.0',
                 id: request.id,
                 error: {
@@ -710,7 +711,7 @@ export abstract class Protocol<
         const abortController = new AbortController();
         this._requestHandlerAbortControllers.set(request.id, abortController);
 
-        const taskCreationParams = request.params?.task;
+        const taskCreationParams = isTaskAugmentedRequestParams(request.params) ? request.params.task : undefined;
         const taskStore = this._taskStore ? this.requestTaskStore(request, capturedTransport?.sessionId) : undefined;
 
         const fullExtra: RequestHandlerExtra<SendRequestT, SendNotificationT> = {
@@ -795,7 +796,7 @@ export abstract class Protocol<
                         return;
                     }
 
-                    const errorResponse: JSONRPCError = {
+                    const errorResponse: JSONRPCErrorResponse = {
                         jsonrpc: '2.0',
                         id: request.id,
                         error: {
@@ -856,14 +857,14 @@ export abstract class Protocol<
         handler(params);
     }
 
-    private _onresponse(response: JSONRPCResponse | JSONRPCError): void {
+    private _onresponse(response: JSONRPCResponse | JSONRPCErrorResponse): void {
         const messageId = Number(response.id);
 
         // Check if this is a response to a queued request
         const resolver = this._requestResolvers.get(messageId);
         if (resolver) {
             this._requestResolvers.delete(messageId);
-            if (isJSONRPCResponse(response)) {
+            if (isJSONRPCResultResponse(response)) {
                 resolver(response);
             } else {
                 const error = new McpError(response.error.code, response.error.message, response.error.data);
@@ -883,7 +884,7 @@ export abstract class Protocol<
 
         // Keep progress handler alive for CreateTaskResult responses
         let isTaskResponse = false;
-        if (isJSONRPCResponse(response) && response.result && typeof response.result === 'object') {
+        if (isJSONRPCResultResponse(response) && response.result && typeof response.result === 'object') {
             const result = response.result as Record<string, unknown>;
             if (result.task && typeof result.task === 'object') {
                 const task = result.task as Record<string, unknown>;
@@ -898,7 +899,7 @@ export abstract class Protocol<
             this._progressHandlers.delete(messageId);
         }
 
-        if (isJSONRPCResponse(response)) {
+        if (isJSONRPCResultResponse(response)) {
             handler(response);
         } else {
             const error = McpError.fromError(response.error.code, response.error.message, response.error.data);
@@ -1195,7 +1196,7 @@ export abstract class Protocol<
             const relatedTaskId = relatedTask?.taskId;
             if (relatedTaskId) {
                 // Store the response resolver for this request so responses can be routed back
-                const responseResolver = (response: JSONRPCResponse | Error) => {
+                const responseResolver = (response: JSONRPCResultResponse | Error) => {
                     const handler = this._responseHandlers.get(messageId);
                     if (handler) {
                         handler(response);