Client received "no session ID or not initialization request" when server restart

[Bacra]

How can the server request the client to re-initialize when server restart?
The client is currently experiencing a recurring server error from "no session ID or not initialization request".

typescript-sdk/examples/server/src/simpleStreamableHttp.ts

Line 589 in faeb03e

res.status(400).json({

[naji247]

We're seeing something similar... I'm noticing MCP servers on Claude Desktop are NOT re-using the same Session ID and they are generating a new one over and over again when interacting with a Cloudflare worker based MCP deployment. This is affecting a few of our customers (we work for MCPcat).
@modelcontextprotocol/sdk: 1.24.0
@cloudflare/agents: 0.2.24

[mcp-claude]

confirmed spec non-compliance: client throws SdkError(ClientHttpNotImplemented) on 404 instead of clearing the session and re-initializing. present on both main and v1.x.

workaround: callers can catch the error, call client.close(), then client.connect(transport) again to force re-initialization.

the fix needs two parts:

1. in StreamableHTTPClientTransport._send, add a 404 handler that clears this._sessionId (analogous to how 401/403 are handled today, ~line 563)
2. the transport needs to signal the Client layer to re-run initialization — simplest approach is a new onsessionexpired callback on the transport that the Client.connect path wires up, or the transport stores the last initialize request and replays it

repro script, output, and code path

repro script (repro.ts, run from repo root):

import { StreamableHTTPClientTransport } from './packages/client/dist/index.mjs';

let fetchCallCount = 0;
const SESSION_ID = 'old-session-id-from-before-restart';

const mockFetch = async (url, init) => {
    fetchCallCount++;
    const body = init?.body ? JSON.parse(init.body) : null;
    if (fetchCallCount === 1) {
        return new Response(JSON.stringify({ jsonrpc:'2.0', result:{ protocolVersion:'2024-11-05', capabilities:{}, serverInfo:{name:'s',version:'1'} }, id:body?.id }), {
            status: 200, headers: { 'content-type':'application/json', 'mcp-session-id': SESSION_ID }
        });
    }
    // Server restarted — 404 for stale session
    return new Response('Session not found', { status: 404, headers: { 'content-type':'text/plain' } });
};

const transport = new StreamableHTTPClientTransport(new URL('http://localhost:1234/mcp'), { fetch: mockFetch });
await transport.send({ jsonrpc:'2.0', method:'initialize', params:{ protocolVersion:'2024-11-05', capabilities:{}, clientInfo:{name:'c',version:'1'} }, id:'init-1' });
console.log('session after init:', transport.sessionId); // old-session-id-from-before-restart

await transport.send({ jsonrpc:'2.0', method:'tools/call', params:{ name:'echo', arguments:{} }, id:'call-1' });
// ↑ throws instead of re-initializing

command and output:

$ npx tsx repro.ts
session after init: old-session-id-from-before-restart
SdkError: Error POSTing to endpoint: Session not found   (code: CLIENT_HTTP_NOT_IMPLEMENTED)

code path:

• _send() in packages/client/src/client/streamableHttp.ts
• line 555: POST sent with mcp-session-id: old-session-id-from-before-restart
• line 563: if (!response.ok) — enters error branch
• line 564: 401 check — skipped
• line 591: reads response text
• line 593: 403 check — skipped
• line 632: throw new SdkError(ClientHttpNotImplemented, ...) — falls through, never clears session, never re-initializes

same path on v1.x: src/client/streamableHttp.ts line 551 (throw new StreamableHTTPError(...)).

spec reference — draft spec, session management section 4:

When a client receives HTTP 404 in response to a request containing an MCP-Session-Id, it MUST start a new session by sending a new InitializeRequest without a session ID attached.

suggested fix

// packages/client/src/client/streamableHttp.ts

+    onsessionexpired?: () => void | Promise<void>;

     // in _send(), after reading response text and before the 403 block:
+                if (response.status === 404 && this._sessionId) {
+                    this._sessionId = undefined;
+                    await this.onsessionexpired?.();
+                }

// packages/client/src/client/client.ts

     override async connect(transport: Transport, options?: RequestOptions): Promise<void> {
         await super.connect(transport);
+
+        if ('onsessionexpired' in transport) {
+            (transport as { onsessionexpired: () => Promise<void> }).onsessionexpired = async () => {
+                this._serverCapabilities = undefined;
+                this._serverVersion = undefined;
+                this._negotiatedProtocolVersion = undefined;
+                await this._doInitialize(transport, options);
+            };
+        }
+
         // existing reconnect-skip logic unchanged
         if (transport.sessionId !== undefined) { ... }
-        try {
-            const result = await this._requestWithSchema(/* initialize */);
-            // ... store result ...
-        } catch (error) { void this.close(); throw error; }
+        try { await this._doInitialize(transport, options); }
+        catch (error) { void this.close(); throw error; }
     }

+    private async _doInitialize(transport: Transport, options?: RequestOptions): Promise<void> {
+        // identical to the old try-block body, minus the catch
+    }

test to verify: send() on a transport with sessionId: 'existing-session-id' that receives a 404 response — asserts transport.sessionId is undefined afterward and the onsessionexpired spy was called exactly once.