refactor(client): centralize per-connection state reset

A new private `_resetConnectionState()` clears every per-connection field
in one place — `_negotiatedProtocolVersion`, server capabilities/identity/
instructions, the auto-opened listen subscription, the listen-state map and
the cached output validators. The two ad-hoc fresh-connect resets and
`close()` now route through it, so a stale `autoOpenedSubscription` (or
any other per-connection field) cannot survive a reconnect or outlive the
connection it was opened on.

Author: felixweinberger

packages/client/src/client/client.ts

@@ -332,6 +332,27 @@ export class Client extends Protocol<ClientContext> {
     /** The auto-opened subscription backing ClientOptions.listChanged on a modern connection. */
     private _autoOpenedSubscription?: McpSubscription;
 
+    /**
+     * Clears every per-connection field in one place. Called at the start of
+     * each fresh (non-resuming) connect and from `close()`, so a stale
+     * negotiated era / server identity / auto-opened subscription cannot
+     * survive a reconnect.
+     */
+    private _resetConnectionState(): void {
+        this._negotiatedProtocolVersion = undefined;
+        this._serverCapabilities = undefined;
+        this._serverVersion = undefined;
+        this._instructions = undefined;
+        this._autoOpenedSubscription = undefined;
+        this._listenState.clear();
+        this._cachedToolOutputValidators.clear();
+    }
+
+    override async close(): Promise<void> {
+        await super.close();
+        this._resetConnectionState();
+    }
+
     /**
      * Initializes this client with the given name and version information.
      */
@@ -689,15 +710,15 @@ export class Client extends Protocol<ClientContext> {
             }
             return;
         }
-        // Fresh connect: the negotiated protocol version is connection state —
-        // a value left over from a previous connection must not survive into a
-        // new handshake. Clearing it puts the instance back in the
-        // pre-negotiation phase, so the initialize exchange below rides the
-        // bootstrap method pins (legacy era) instead of a dead session's era.
-        // Without this, an instance that once negotiated a modern era could
-        // never re-run a fresh handshake: `initialize` is physically absent
-        // from the modern registry. (The resume branch above keeps it instead.)
-        this._negotiatedProtocolVersion = undefined;
+        // Fresh connect: per-connection state left over from a previous
+        // connection must not survive into a new handshake. Clearing it puts
+        // the instance back in the pre-negotiation phase, so the initialize
+        // exchange below rides the bootstrap method pins (legacy era) instead
+        // of a dead session's era. Without this, an instance that once
+        // negotiated a modern era could never re-run a fresh handshake:
+        // `initialize` is physically absent from the modern registry. (The
+        // resume branch above keeps it instead.)
+        this._resetConnectionState();
         await this._legacyHandshake(transport, options);
     }
 
@@ -797,7 +818,7 @@ export class Client extends Protocol<ClientContext> {
 
         // Fresh connect: stale connection state must not survive into a new
         // negotiation — every fresh negotiated connect re-runs the probe.
-        this._negotiatedProtocolVersion = undefined;
+        this._resetConnectionState();
 
         let result: Awaited<ReturnType<typeof negotiateEra>>;
         try {

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

@@ -195,6 +195,22 @@ describe('Client.listen()', () => {
         await client.close();
     });
 
+    it('autoOpenedSubscription is cleared on close() and on a fresh reconnect', async () => {
+        const onChanged = () => {};
+        const client = new Client(
+            { name: 'c', version: '1' },
+            { versionNegotiation: { mode: 'auto' }, listChanged: { tools: { onChanged } } }
+        );
+        const { clientTx } = await scriptedModern();
+        await client.connect(clientTx);
+        expect(client.autoOpenedSubscription).toBeDefined();
+        await client.close();
+        // close() clears every per-connection field.
+        expect(client.autoOpenedSubscription).toBeUndefined();
+        expect(client.getServerCapabilities()).toBeUndefined();
+        expect(client.getNegotiatedProtocolVersion()).toBeUndefined();
+    });
+
     it('a failed auto-open surfaces via onerror and does NOT fail connect', async () => {
         const [clientTx, serverTx] = InMemoryTransport.createLinkedPair();
         serverTx.onmessage = m => {