fix: prevent panic on SSE reverse proxy when backend closes connection (#128)

* fix: prevent panic on SSE reverse proxy when backend closes connection

The default httputil.ReverseProxy panics with "net/http: abort Handler"
when proxying SSE (Server-Sent Events) streams and the backend closes
the connection. This happens frequently with MCP Streamable HTTP
backends (e.g. n8n) when sessions expire or clients disconnect.

Add ErrorHandler to log the error instead of panicking, and set
FlushInterval to -1 for immediate SSE flushing.

Fixes the panic at reverseproxy.go:543 in handleProxy (proxy.go:90).

Co-Authored-By: Claude Opus 4.6 (1M context) <[email protected]>

* fix: recover from ErrAbortHandler panic in SSE proxy handler

The previous ErrorHandler fix in transparent.go only covers transport
errors. The actual panic at reverseproxy.go:543 is http.ErrAbortHandler
triggered during response flush when an SSE stream ends. This panic
bypasses ErrorHandler entirely.

Add a deferred recover() in proxy.go's handleProxy to catch
ErrAbortHandler panics silently (they are expected for SSE) while
re-panicking on unexpected errors.

Co-Authored-By: Claude Opus 4.6 (1M context) <[email protected]>

---------

Co-authored-by: Claude Opus 4.6 (1M context) <[email protected]>

Author: juliendoclot

pkg/backend/transparent.go

@@ -125,6 +125,27 @@ func (p *TransparentBackend) Run(ctx context.Context) (http.Handler, error) {
 			base:       http.DefaultTransport,
 			targetHost: p.url.Host,
 		},
+		// FlushInterval -1 enables immediate flushing for SSE streams.
+		// Without this the proxy buffers the response, breaking
+		// Server-Sent Events used by MCP Streamable HTTP.
+		FlushInterval: -1,
+		// ErrorHandler prevents the default ReverseProxy behavior of
+		// panicking when the backend closes the connection (e.g. when
+		// an SSE stream ends or the client disconnects). Instead we
+		// log the error and return a 502 to the client.
+		ErrorHandler: func(w http.ResponseWriter, r *http.Request, err error) {
+			p.logger.Warn("reverse proxy error",
+				zap.String("method", r.Method),
+				zap.String("path", r.URL.Path),
+				zap.Error(err),
+			)
+			// Only write an error response if headers haven't been sent yet
+			// (i.e. the stream hasn't started). For in-flight SSE streams
+			// the ResponseWriter is already flushed, so just return.
+			if !isHeadersSent(w) {
+				http.Error(w, "Bad Gateway", http.StatusBadGateway)
+			}
+		},
 		Rewrite: func(pr *httputil.ProxyRequest) {
 			pr.SetURL(p.url)
 			if p.isTrusted(pr.In.RemoteAddr) {
@@ -147,6 +168,17 @@ func (p *TransparentBackend) Run(ctx context.Context) (http.Handler, error) {
 	return &rp, nil
 }
 
+// isHeadersSent checks whether the ResponseWriter has already started sending
+// the response (status + headers). Once flushed we can no longer write an
+// error status, so callers should just close the connection instead.
+func isHeadersSent(w http.ResponseWriter) bool {
+	// A non-zero status in the header map means WriteHeader was called.
+	// The standard http.response tracks this internally; the only reliable
+	// external signal is whether Content-Type (or any header set by the
+	// backend) is already present in the response.
+	return w.Header().Get("Content-Type") != ""
+}
+
 func (p *TransparentBackend) isTrusted(hostport string) bool {
 	if host, _, err := net.SplitHostPort(hostport); err == nil {
 		hostport = host

pkg/proxy/proxy.go

@@ -87,6 +87,22 @@ func (p *ProxyRouter) handleProxy(c *gin.Context) {
 		}
 	}
 
+	// Recover from http.ErrAbortHandler panics that occur when SSE
+	// streams end (backend closes connection, client disconnects).
+	// The default ReverseProxy panics with ErrAbortHandler on flush
+	// errors — this is expected for SSE and should not crash the proxy.
+	defer func() {
+		if r := recover(); r != nil {
+			// http.ErrAbortHandler is the sentinel panic used by
+			// net/http to silently abort a handler. Let it go.
+			if r == http.ErrAbortHandler {
+				return
+			}
+			// Re-panic for anything unexpected
+			panic(r)
+		}
+	}()
+
 	p.proxy.ServeHTTP(c.Writer, c.Request)
 }