feat: Add Host header override support for manual DNS resolution (#674)

* feat: Add Host header override support for manual DNS resolution

* feat: Add Host header override support for manual DNS resolution

* feat: Add Host header override support for manual DNS resolution

Author: ComingCL

client/sse.go

@@ -20,6 +20,13 @@ func WithHTTPClient(httpClient *http.Client) transport.ClientOption {
 	return transport.WithHTTPClient(httpClient)
 }
 
+// WithHTTPHost sets a custom Host header for the SSE client, enabling manual DNS resolution.
+// This allows connecting to an IP address while sending a specific Host header to the server.
+// For example, connecting to "http://192.168.1.100:8080/sse" but sending Host: "api.example.com"
+func WithHTTPHost(host string) transport.ClientOption {
+	return transport.WithHTTPHost(host)
+}
+
 // NewSSEMCPClient creates a new SSE-based MCP client with the given base URL.
 // Returns an error if the URL is invalid.
 func NewSSEMCPClient(baseURL string, options ...transport.ClientOption) (*Client, error) {

client/transport/sse.go

@@ -34,6 +34,7 @@ type SSE struct {
 	endpointChan   chan struct{}
 	headers        map[string]string
 	headerFunc     HTTPHeaderFunc
+	host           string
 	logger         util.Logger
 
 	started          atomic.Bool
@@ -80,6 +81,15 @@ func WithOAuth(config OAuthConfig) ClientOption {
 	}
 }
 
+// WithHTTPHost sets a custom Host header for the SSE client, enabling manual DNS resolution.
+// This allows connecting to an IP address while sending a specific Host header to the server.
+// For example, connecting to "http://192.168.1.100:8080/sse" but sending Host: "api.example.com"
+func WithHTTPHost(host string) ClientOption {
+	return func(sc *SSE) {
+		sc.host = host
+	}
+}
+
 // NewSSE creates a new SSE-based MCP client with the given base URL.
 // Returns an error if the URL is invalid.
 func NewSSE(baseURL string, options ...ClientOption) (*SSE, error) {
@@ -126,6 +136,11 @@ func (c *SSE) Start(ctx context.Context) error {
 		return fmt.Errorf("failed to create request: %w", err)
 	}
 
+	// Set custom Host header if provided
+	if c.host != "" {
+		req.Host = c.host
+	}
+
 	req.Header.Set("Accept", "text/event-stream")
 	req.Header.Set("Cache-Control", "no-cache")
 	req.Header.Set("Connection", "keep-alive")
@@ -387,6 +402,11 @@ func (c *SSE) SendRequest(
 		}
 	}
 
+	// Set custom Host header if provided
+	if c.host != "" {
+		req.Host = c.host
+	}
+
 	// Add OAuth authorization if configured
 	if c.oauthHandler != nil {
 		authHeader, err := c.oauthHandler.GetAuthorizationHeader(ctx)
@@ -578,6 +598,11 @@ func (c *SSE) SendNotification(ctx context.Context, notification mcp.JSONRPCNoti
 		}
 	}
 
+	// Set custom Host header if provided
+	if c.host != "" {
+		req.Host = c.host
+	}
+
 	resp, err := c.httpClient.Do(req)
 	if err != nil {
 		return fmt.Errorf("failed to send notification: %w", err)

client/transport/sse_test.go

@@ -8,6 +8,7 @@ import (
 	"io"
 	"net/http"
 	"net/http/httptest"
+	"net/url"
 	"strings"
 	"sync"
 	"testing"
@@ -1078,6 +1079,146 @@ func TestSSE_SendNotification_Unauthorized_StaticToken(t *testing.T) {
 	transport.Close()
 }
 
+// TestSSEHostOverride tests the Host header override functionality
+func TestSSEHostOverride(t *testing.T) {
+	// Create a test server that captures the Host header
+	var capturedHost string
+	var mu sync.Mutex
+
+	sseHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		mu.Lock()
+		capturedHost = r.Host
+		mu.Unlock()
+
+		w.Header().Set("Content-Type", "text/event-stream")
+		flusher, ok := w.(http.Flusher)
+		if !ok {
+			http.Error(w, "Streaming unsupported", http.StatusInternalServerError)
+			return
+		}
+
+		// Send initial endpoint event
+		fmt.Fprintf(w, "event: endpoint\ndata: %s\n\n", "/message")
+		flusher.Flush()
+
+		// Keep connection open
+		<-r.Context().Done()
+	})
+
+	messageHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.Method != http.MethodPost {
+			http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
+			return
+		}
+
+		response := JSONRPCResponse{
+			JSONRPC: "2.0",
+			ID:      mcp.NewRequestId(1),
+			Result:  []byte("test"),
+		}
+
+		w.Header().Set("Content-Type", "application/json")
+		if err := json.NewEncoder(w).Encode(response); err != nil {
+			http.Error(w, "Failed to encode response", http.StatusInternalServerError)
+			return
+		}
+	})
+
+	mux := http.NewServeMux()
+	mux.Handle("/", sseHandler)
+	mux.Handle("/message", messageHandler)
+
+	testServer := httptest.NewServer(mux)
+	defer testServer.Close()
+
+	// Parse test server URL to get the actual host
+	serverURL, _ := url.Parse(testServer.URL)
+	actualHost := serverURL.Host
+
+	t.Run("Default Host (no override)", func(t *testing.T) {
+		capturedHost = ""
+		trans, err := NewSSE(testServer.URL)
+		require.NoError(t, err)
+
+		ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+		defer cancel()
+
+		err = trans.Start(ctx)
+		require.NoError(t, err)
+		defer trans.Close()
+
+		// Host should match the actual server host
+		mu.Lock()
+		require.Equal(t, actualHost, capturedHost)
+		mu.Unlock()
+	})
+
+	t.Run("Custom Host override", func(t *testing.T) {
+		capturedHost = ""
+		customHost := "api.example.com"
+
+		trans, err := NewSSE(testServer.URL, WithHTTPHost(customHost))
+		require.NoError(t, err)
+
+		ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+		defer cancel()
+
+		err = trans.Start(ctx)
+		require.NoError(t, err)
+		defer trans.Close()
+
+		// Host should be the custom host, not the actual server host
+		mu.Lock()
+		require.Equal(t, customHost, capturedHost)
+		require.NotEqual(t, actualHost, capturedHost)
+		mu.Unlock()
+	})
+
+	t.Run("Custom Host with port", func(t *testing.T) {
+		capturedHost = ""
+		customHost := "backend.internal.com:8443"
+
+		trans, err := NewSSE(testServer.URL, WithHTTPHost(customHost))
+		require.NoError(t, err)
+
+		ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+		defer cancel()
+
+		err = trans.Start(ctx)
+		require.NoError(t, err)
+		defer trans.Close()
+
+		// Host should be the custom host with port
+		mu.Lock()
+		require.Equal(t, customHost, capturedHost)
+		mu.Unlock()
+	})
+
+	// Test WithHTTPHost function directly (unit test)
+	t.Run("WithHTTPHost function", func(t *testing.T) {
+		sse := &SSE{}
+		customHost := "test.example.com"
+
+		option := WithHTTPHost(customHost)
+		option(sse)
+
+		require.Equal(t, customHost, sse.host)
+
+		// Test overwrite
+		newHost := "new.example.com"
+		option = WithHTTPHost(newHost)
+		option(sse)
+
+		require.Equal(t, newHost, sse.host)
+
+		// Test empty string
+		option = WithHTTPHost("")
+		option(sse)
+
+		require.Equal(t, "", sse.host)
+	})
+}
+
 func TestSSE_SendRequest_Timeout(t *testing.T) {
 	t.Run("TimeoutWhenServerNeverResponds", func(t *testing.T) {
 		server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {

client/transport/streamable_http.go

@@ -87,6 +87,15 @@ func WithSession(sessionID string) StreamableHTTPCOption {
 	}
 }
 
+// WithStreamableHTTPHost sets a custom Host header for the StreamableHTTP client, enabling manual DNS resolution.
+// This allows connecting to an IP address while sending a specific Host header to the server.
+// For example, connecting to "http://192.168.1.100:8080/mcp" but sending Host: "api.example.com"
+func WithStreamableHTTPHost(host string) StreamableHTTPCOption {
+	return func(sc *StreamableHTTP) {
+		sc.host = host
+	}
+}
+
 // StreamableHTTP implements Streamable HTTP transport.
 //
 // It transmits JSON-RPC messages over individual HTTP requests. One message per request.
@@ -103,6 +112,7 @@ type StreamableHTTP struct {
 	httpClient          *http.Client
 	headers             map[string]string
 	headerFunc          HTTPHeaderFunc
+	host                string
 	logger              util.Logger
 	getListeningEnabled bool
 
@@ -217,6 +227,11 @@ func (c *StreamableHTTP) Close() error {
 					req.Header.Set(HeaderKeyProtocolVersion, version)
 				}
 			}
+
+			// Set custom Host header if provided
+			if c.host != "" {
+				req.Host = c.host
+			}
 			res, err := c.httpClient.Do(req)
 			if err != nil {
 				c.logger.Errorf("failed to send close request: %v", err)
@@ -379,6 +394,11 @@ func (c *StreamableHTTP) sendHTTP(
 		req.Header.Set(k, v)
 	}
 
+	// Set custom Host header if provided
+	if c.host != "" {
+		req.Host = c.host
+	}
+
 	// Add OAuth authorization if configured
 	if c.oauthHandler != nil {
 		authHeader, err := c.oauthHandler.GetAuthorizationHeader(ctx)