fix(core): never send notifications/cancelled for the initialize hand…

.changeset/no-cancel-notification-for-initialize.md

@@ -0,0 +1,9 @@
+---
+'@modelcontextprotocol/core-internal': patch
+'@modelcontextprotocol/client': patch
+'@modelcontextprotocol/server': patch
+---
+
+Stop sending `notifications/cancelled` for the `initialize` handshake. The spec is explicit that a client MUST NOT attempt to cancel its `initialize` request, but the outbound cancel path fired for any in-flight request: aborting the `AbortSignal` passed to `connect()`, or letting the handshake hit its timeout, put a forbidden cancellation on the wire naming the initialize request id.
+
+The local behaviour is unchanged — the caller's promise still rejects with the same abort/timeout error, and `connect()` still tears the connection down. Only the wire notification is suppressed. Every other method keeps the existing cancellation path.

packages/core-internal/src/shared/protocol.ts

@@ -1453,19 +1453,29 @@ export abstract class Protocol<ContextT extends BaseContext> {
                 this._progressHandlers.delete(messageId);
 
                 if (requestAbort === undefined) {
-                    this._transport
-                        ?.send(
-                            this._envelopeOutbound({
-                                jsonrpc: '2.0',
-                                method: 'notifications/cancelled',
-                                params: {
-                                    requestId: messageId,
-                                    reason: String(reason)
-                                }
-                            }),
-                            { relatedRequestId, resumptionToken, onresumptiontoken }
-                        )
-                        .catch(error => this._onerror(new Error(`Failed to send cancellation: ${error}`)));
+                    // "A client MUST NOT attempt to cancel its `initialize`
+                    // request" (spec basic/lifecycle, mirrored on
+                    // `CancelledNotification`). The handshake is the one request
+                    // whose cancellation is forbidden outright, so an abort or
+                    // timeout on it settles purely locally: the promise still
+                    // rejects below, but nothing goes on the wire. Only the
+                    // legacy era can reach this — `initialize` is absent from the
+                    // modern registry, which negotiates via `server/discover`.
+                    if (request.method !== 'initialize') {
+                        this._transport
+                            ?.send(
+                                this._envelopeOutbound({
+                                    jsonrpc: '2.0',
+                                    method: 'notifications/cancelled',
+                                    params: {
+                                        requestId: messageId,
+                                        reason: String(reason)
+                                    }
+                                }),
+                                { relatedRequestId, resumptionToken, onresumptiontoken }
+                            )
+                            .catch(error => this._onerror(new Error(`Failed to send cancellation: ${error}`)));
+                    }
                 } else {
                     // Modern-era per-request-stream transport: aborting the
                     // request's underlying stream IS the spec cancel signal.

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

@@ -937,6 +937,74 @@ describe('protocol tests', () => {
             expect(tx.lastRequestSignal?.aborted).toBe(true);
             expect(cancelledSent(tx.sent)).toHaveLength(0);
         });
+
+        // "A client MUST NOT attempt to cancel its `initialize` request." The
+        // handshake is exempt from the POST path above on every transport: an
+        // abort or timeout rejects the caller locally and sends nothing. Both
+        // triggers are covered because they reach cancel() by different routes
+        // (the caller's signal vs the timeout handler).
+        describe('the initialize handshake is never cancelled on the wire', () => {
+            test('aborting an in-flight initialize sends NO notifications/cancelled', async () => {
+                // ARRANGE
+                const sent: JSONRPCMessage[] = [];
+                const tx = new MockTransport();
+                tx.send = async (m: JSONRPCMessage, _opts?: TransportSendOptions) => {
+                    sent.push(m);
+                };
+                const proto = createTestProtocol();
+                await proto.connect(tx);
+                setNegotiatedProtocolVersion(proto, '2025-11-25');
+
+                // ACT
+                const ac = new AbortController();
+                const pending = testRequest(proto, { method: 'initialize', params: {} }, z.object({}), { signal: ac.signal });
+                ac.abort('user cancel');
+
+                // ASSERT — rejects locally, wire stays clean
+                await expect(pending).rejects.toThrow();
+                expect(cancelledSent(sent)).toHaveLength(0);
+            });
+
+            test('timing out an in-flight initialize sends NO notifications/cancelled', async () => {
+                // ARRANGE
+                const sent: JSONRPCMessage[] = [];
+                const tx = new MockTransport();
+                tx.send = async (m: JSONRPCMessage, _opts?: TransportSendOptions) => {
+                    sent.push(m);
+                };
+                const proto = createTestProtocol();
+                await proto.connect(tx);
+                setNegotiatedProtocolVersion(proto, '2025-11-25');
+
+                // ACT
+                const pending = testRequest(proto, { method: 'initialize', params: {} }, z.object({}), { timeout: 0 });
+
+                // ASSERT
+                await expect(pending).rejects.toThrow();
+                expect(cancelledSent(sent)).toHaveLength(0);
+            });
+
+            test('every other method still POSTs notifications/cancelled (regression guard)', async () => {
+                // ARRANGE
+                const sent: JSONRPCMessage[] = [];
+                const tx = new MockTransport();
+                tx.send = async (m: JSONRPCMessage, _opts?: TransportSendOptions) => {
+                    sent.push(m);
+                };
+                const proto = createTestProtocol();
+                await proto.connect(tx);
+                setNegotiatedProtocolVersion(proto, '2025-11-25');
+
+                // ACT
+                const ac = new AbortController();
+                const pending = testRequest(proto, { method: 'example', params: {} }, z.object({}), { signal: ac.signal });
+                ac.abort('user cancel');
+
+                // ASSERT
+                await expect(pending).rejects.toThrow();
+                expect(cancelledSent(sent)).toHaveLength(1);
+            });
+        });
     });
 });
 

test/e2e/requirements.ts

@@ -143,12 +143,7 @@ export const REQUIREMENTS: Record<string, Requirement> = {
         transports: STATEFUL_TRANSPORTS,
         source: 'https://modelcontextprotocol.io/specification/2025-11-25/basic/utilities/cancellation#behavior-requirements',
         behavior: 'The client never sends notifications/cancelled for the initialize request.',
-        note: 'Stateless hosting creates a fresh server per request and has no standalone GET stream, so there is no server→client channel to deliver/observe these.',
-        knownFailures: [
-            {
-                note: 'SDK sends notifications/cancelled for initialize when connect() is aborted; spec says initialize MUST NOT be cancelled.'
-            }
-        ]
+        note: 'Stateless hosting creates a fresh server per request and has no standalone GET stream, so there is no server→client channel to deliver/observe these.'
     },
     'protocol:cancel:late-response-ignored': {
         source: 'https://modelcontextprotocol.io/specification/2025-11-25/basic/utilities/cancellation#timing-considerations',