feat: enhance SSE support in MCP server and proxy by preventing timeouts and ensuring connection persistence

Author: regenrek

packages/mcp/src/index.ts

@@ -481,6 +481,32 @@ export async function ensureLocalHttpServer(): Promise<void> {
     }
   });
 
+  // --- NEW: Prevent SSE connections from being terminated by default Node timeouts ---
+  try {
+    // Disable per-request inactivity timeout (prevents ~2-5 min server-side termination across Node versions)
+    // @ts-expect-error - requestTimeout exists on http.Server in Node, but TS may not include in some lib targets
+    localHttpServer.requestTimeout = 0;
+
+    // Disable header timeout to avoid premature close before stream fully established on slow environments
+    // @ts-expect-error - headersTimeout exists on http.Server in Node
+    localHttpServer.headersTimeout = 0;
+
+    // Also set legacy/general socket timeout to 0 (no timeout)
+    // @ts-expect-error - setTimeout on http.Server sets the socket timeout
+    typeof localHttpServer.setTimeout === 'function' && localHttpServer.setTimeout(0);
+
+    // Keep TCP connection alive to maintain long-lived SSE streams; send probes every 60s
+    localHttpServer.on('connection', (socket: any) => {
+      try {
+        socket.setKeepAlive?.(true, 60_000);
+        socket.setNoDelay?.(true);
+      } catch {}
+    });
+  } catch {
+    // Best-effort hardening; ignore if any of the props/methods are unavailable in the host Node
+  }
+  // -------------------------------------------------------------------------------
+
   await new Promise<void>((resolve, reject) => {
     localHttpServer!.listen(0, '127.0.0.1', () => resolve());
     localHttpServer!.once('error', reject);

packages/next/src/mcp-route.ts

@@ -44,10 +44,23 @@ async function proxy(method: string, req: NextRequest): Promise<Response> {
   const qs = req.nextUrl.search;
   if (qs) upstreamUrl.search = qs;
 
+  // Prepare headers to forward; nuke hop-by-hop headers
+  const forwardHeaders = copyHeaders(req.headers);
+
+  // Ensure SSE friendliness on GET (defensive in case a client omits Accept)
+  if (method === 'GET') {
+    const accept = forwardHeaders.get('accept') || '';
+    if (!/\btext\/event-stream\b/i.test(accept)) {
+      forwardHeaders.set('accept', accept ? `${accept}, text/event-stream` : 'text/event-stream');
+    }
+    forwardHeaders.set('connection', 'keep-alive');
+    // Clients are recommended to include MCP-Protocol-Version; we simply forward what we received.
+  }
+
   // Build init for fetch
   const init: RequestInit = {
     method,
-    headers: copyHeaders(req.headers)
+    headers: forwardHeaders
   };
 
   if (method === 'POST' || method === 'PUT' || method === 'PATCH') {
@@ -57,10 +70,23 @@ async function proxy(method: string, req: NextRequest): Promise<Response> {
 
   // Stream response back to the client
   const upstream = await fetch(upstreamUrl, init);
-  const headers = copyHeaders(upstream.headers);
+
+  // Copy upstream response headers, then harden for SSE responses
+  const respHeaders = copyHeaders(upstream.headers);
+  const ct = upstream.headers.get('content-type') || '';
+
+  if (/^text\/event-stream\b/i.test(ct)) {
+    // Prevent buffering and keep the connection alive for SSE
+    respHeaders.set('content-type', 'text/event-stream');
+    respHeaders.set('cache-control', 'no-cache, no-transform');
+    respHeaders.set('connection', 'keep-alive');
+    // Disable proxy buffering where applicable (e.g., nginx)
+    respHeaders.set('x-accel-buffering', 'no');
+  }
+
   return new Response(upstream.body, {
     status: upstream.status,
-    headers
+    headers: respHeaders
   });
 }