fix: address review — guard cancel() once response received (abort race during async result validation); add core to changeset; setNotificationHandler JSDoc notes 2nd arg

Author: felixweinberger

.changeset/custom-methods-minimal.md

@@ -1,4 +1,5 @@
 ---
+'@modelcontextprotocol/core': minor
 '@modelcontextprotocol/client': minor
 '@modelcontextprotocol/server': minor
 ---

packages/core/src/shared/protocol.ts

@@ -884,7 +884,12 @@ export abstract class Protocol<ContextT extends BaseContext> {
                 };
             }
 
+            let responseReceived = false;
+
             const cancel = (reason: unknown) => {
+                if (responseReceived) {
+                    return;
+                }
                 this._progressHandlers.delete(messageId);
 
                 this._transport
@@ -910,6 +915,7 @@ export abstract class Protocol<ContextT extends BaseContext> {
                 if (options?.signal?.aborted) {
                     return;
                 }
+                responseReceived = true;
 
                 if (response instanceof Error) {
                     return reject(response);
@@ -1143,7 +1149,8 @@ export abstract class Protocol<ContextT extends BaseContext> {
      * For spec methods, pass `(method, handler)`; the notification is parsed with the
      * spec schema. For custom (non-spec) methods, pass `(method, schemas, handler)`;
      * `params` are validated against `schemas.params` and the handler receives the
-     * parsed params object directly.
+     * parsed params object directly. The raw notification is passed as the second
+     * argument; `_meta` is recoverable via `notification.params?._meta`.
      */
     setNotificationHandler<M extends NotificationMethod>(
         method: M,

packages/core/test/shared/customMethods.test.ts

@@ -2,7 +2,7 @@ import { describe, expect, it } from 'vitest';
 import { z } from 'zod/v4';
 
 import { Protocol } from '../../src/shared/protocol.js';
-import type { BaseContext, JSONRPCRequest, Result } from '../../src/exports/public/index.js';
+import type { BaseContext, JSONRPCRequest, Result, StandardSchemaV1 } from '../../src/exports/public/index.js';
 import { ProtocolError, ProtocolErrorCode } from '../../src/types/index.js';
 import { InMemoryTransport } from '../../src/util/inMemory.js';
 
@@ -150,6 +150,34 @@ describe('Protocol custom-method support', () => {
                 code: ProtocolErrorCode.InternalError
             });
         });
+
+        it('returns the result (and sends no cancellation) if the signal aborts during async result-schema validation', async () => {
+            const [a, b] = await pair();
+            b.setRequestHandler('acme/echo', { params: z.object({}) }, async () => ({ echoed: 'ok' }));
+
+            const cancelled: unknown[] = [];
+            b.setNotificationHandler('notifications/cancelled', n => {
+                cancelled.push(n);
+            });
+
+            const ac = new AbortController();
+            const AsyncEcho: StandardSchemaV1<unknown, { echoed: string }> = {
+                '~standard': {
+                    version: 1,
+                    vendor: 'test',
+                    validate: value =>
+                        new Promise(r => {
+                            ac.abort();
+                            setTimeout(() => r({ value: value as { echoed: string } }), 0);
+                        })
+                }
+            };
+
+            const result = await a.request({ method: 'acme/echo', params: {} }, AsyncEcho, { signal: ac.signal });
+            expect(result).toEqual({ echoed: 'ok' });
+            await new Promise(r => setTimeout(r, 0));
+            expect(cancelled).toHaveLength(0);
+        });
     });
 
     describe('ctx.mcpReq.send schema overload', () => {