fix(client): McpSubscription.close() is transport-agnostic — always abort + send notifications/cancelled

The close path branched on detectProbeTransportKind(), which detects child-
process transports, not 'honors requestSignal'. On InMemoryTransport, SSE,
or any custom transport, close() resolved without ever telling the server,
leaving the subscription open server-side.

close() now unconditionally aborts the listen request's requestSignal AND
sends notifications/cancelled for the listen id. The abort closes the SSE
stream where the transport honors it; the cancelled notification reaches the
stdio listen router and any spec-compliant server. Idempotent over HTTP,
correct on every other transport. detectProbeTransportKind is no longer in
the close path.

Author: felixweinberger

packages/client/src/client/client.ts

@@ -1228,10 +1228,12 @@ export class Client extends Protocol<ClientContext> {
      * 2025-era unsolicited notifications fire on a legacy connection — so
      * `listen()` is era-transparent for consumers that already register those.
      *
-     * `close()` tears the subscription down: on Streamable HTTP it closes the
-     * listen request's SSE stream; on stdio it sends `notifications/cancelled`
-     * referencing the listen request id. No automatic re-listen — call
-     * `listen()` again to re-establish.
+     * `close()` tears the subscription down by aborting the listen request's
+     * `requestSignal` (closes the SSE stream where the transport honors it)
+     * AND sending `notifications/cancelled` referencing the listen request id
+     * — both, unconditionally, so any spec-compliant server on any transport
+     * sees the cancel. No automatic re-listen — call `listen()` again to
+     * re-establish.
      *
      * On a 2025-era connection this throws a typed
      * {@linkcode SdkErrorCode.MethodNotSupportedByProtocolVersion} steering to
@@ -1263,7 +1265,6 @@ export class Client extends Protocol<ClientContext> {
         }
 
         const requestAbort = new AbortController();
-        const transportKind = detectProbeTransportKind(this.transport);
 
         // Explicit `opening → open → closed` state machine. Every termination
         // path — ack-arrives, ack-timeout, server-cancelled, user-close,
@@ -1310,17 +1311,21 @@ export class Client extends Protocol<ClientContext> {
         };
 
         // Wire-level teardown for a locally-initiated close (user close or ack
-        // timeout): HTTP closes the request's SSE stream; stdio sends
-        // notifications/cancelled referencing the listen id. Not called when
-        // the server already terminated (error / server-cancelled).
+        // timeout). Transport-agnostic: ALWAYS abort the request signal (closes
+        // the SSE stream where the transport honors `requestSignal` — HTTP does,
+        // stdio does not) AND send `notifications/cancelled` referencing the
+        // listen id (which the stdio listen router and any spec-compliant
+        // server honor). Idempotent over HTTP — the cancelled notification is
+        // a no-op once the stream is gone; correct on every other transport.
+        // Not called when the server already terminated (error / server-
+        // cancelled).
         const wireTeardown = async (): Promise<void> => {
+            requestAbort.abort();
             const id = parked?.messageId;
-            if (transportKind === 'stdio' && id !== undefined) {
+            if (id !== undefined) {
                 await this.transport
                     ?.send({ jsonrpc: '2.0', method: 'notifications/cancelled', params: { requestId: id } })
                     .catch(() => {});
-            } else {
-                requestAbort.abort();
             }
         };
 

packages/client/test/client/listen.test.ts

@@ -2,8 +2,9 @@
  * `Client.listen()` — the `subscriptions/listen` driver (protocol revision
  * 2026-07-28). Covers ack-resolved-promise, change-notification dispatch to
  * existing setNotificationHandler registrations, the F-12 legacy-era steer,
- * stdio-style close (sends notifications/cancelled), inbound server-side
- * cancel, and ClientOptions.listChanged auto-open on a modern connection.
+ * transport-agnostic close (always sends notifications/cancelled), inbound
+ * server-side cancel, and ClientOptions.listChanged auto-open on a modern
+ * connection.
  */
 import type { JSONRPCMessage, JSONRPCNotification } from '@modelcontextprotocol/core';
 import { InMemoryTransport, LATEST_PROTOCOL_VERSION, SdkError, SdkErrorCode, SUBSCRIPTION_ID_META_KEY } from '@modelcontextprotocol/core';
@@ -103,10 +104,12 @@ describe('Client.listen()', () => {
         await client.close();
     });
 
-    it('close() on a stdio-style transport sends notifications/cancelled referencing the listen id', async () => {
+    it('close() sends notifications/cancelled referencing the listen id on any transport', async () => {
+        // Plain InMemoryTransport (neither child-process nor SSE-stream
+        // semantics): close() must NOT depend on transport-kind detection —
+        // it always sends notifications/cancelled, so a spec-compliant server
+        // on InMemory / SSE / a custom transport tears the subscription down.
         const { clientTx, written } = await scriptedModern();
-        // Make the in-memory transport quack like a stdio child-process transport.
-        Object.assign(clientTx, { stderr: null, pid: 1 });
         const client = new Client({ name: 'c', version: '1' }, { versionNegotiation: { mode: 'auto' } });
         await client.connect(clientTx);
         const sub = await client.listen({ toolsListChanged: true });