fix(mcp): set transport=streamable-http in wire-mcp; revert GET SSE (#20)

The wire-mcp gateway RPC was writing mcp.servers.<name> = {url} without
a transport field. openclaw's pi-bundle-mcp-runtime defaults to the
legacy SSEClientTransport in that case, which requires a long-lived
GET SSE stream and blocks on an initial "event: endpoint" message.
sluice's gateway is Streamable HTTP (POST-only, no server-initiated
events), so the client hung for 30s and gave up. Explicitly setting
transport: "streamable-http" makes bundle-mcp use
StreamableHTTPClientTransport which does POST-only init and works
cleanly.

Also revert the GET SSE handler added earlier in this series: the
keepalive-comments-only stream caused bundle-mcp to block because the
legacy SSE transport was waiting for an "event: endpoint" frame. With
the transport fix above, the client no longer hits the GET path; 405
on GET is spec-valid for Streamable HTTP and produces no warnings in
the bundle-mcp runtime when the client uses Streamable HTTP directly.

Author: nnemirovsky

internal/container/gateway_rpc.js

@@ -319,12 +319,23 @@ req.on("upgrade", (_res, socket) => {
           clearTimeout(deadline);
           fail("config.get response missing hash");
         }
-        // Step 2 of wire-mcp: merge-patch mcp.servers.<name> = {url}.
+        // Step 2 of wire-mcp: merge-patch mcp.servers.<name>. We must
+        // set transport: "streamable-http" explicitly because openclaw's
+        // pi-bundle-mcp-runtime defaults to the legacy SSE transport
+        // when the field is omitted, and the SSE transport requires a
+        // long-lived GET stream that sluice's gateway does not expose.
         // restartDelayMs gives us time to receive the response and exit
         // cleanly before the gateway restarts and kills our docker exec
         // (which would otherwise result in exit code 137).
         const raw = JSON.stringify({
-          mcp: { servers: { [wireMcpName]: { url: wireMcpURL } } },
+          mcp: {
+            servers: {
+              [wireMcpName]: {
+                transport: "streamable-http",
+                url: wireMcpURL,
+              },
+            },
+          },
         });
         step = "sent-method";
         socket.write(

internal/mcp/server_http.go

@@ -33,59 +33,25 @@ func NewMCPHTTPHandler(gw *Gateway) *MCPHTTPHandler {
 	return &MCPHTTPHandler{gw: gw}
 }
 
-// ServeHTTP dispatches POST, GET, and DELETE requests for the MCP
-// Streamable HTTP protocol.
+// ServeHTTP dispatches POST and DELETE requests for the MCP Streamable
+// HTTP protocol. GET returns 405 explicitly: the MCP spec allows servers
+// to optionally expose a GET SSE stream for server-initiated events,
+// but openclaw's bundle-mcp client blocks waiting for events on the
+// stream. Returning 405 tells the client to use POST-only mode, which
+// matches how sluice's gateway actually works (request-response, no
+// unsolicited events).
 func (h *MCPHTTPHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	switch r.Method {
 	case http.MethodPost:
 		h.handlePost(w, r)
-	case http.MethodGet:
-		h.handleGet(w, r)
 	case http.MethodDelete:
 		h.handleDelete(w, r)
 	default:
-		w.Header().Set("Allow", "POST, GET, DELETE")
+		w.Header().Set("Allow", "POST, DELETE")
 		http.Error(w, "Method Not Allowed", http.StatusMethodNotAllowed)
 	}
 }
 
-// handleGet opens a long-lived SSE stream for server-initiated events.
-// The MCP Streamable HTTP spec optionally allows clients to open a GET
-// connection for server-to-client events. Sluice does not currently
-// produce unsolicited events, so this handler keeps the stream open
-// with periodic SSE comments as keepalives until the client closes it
-// or the request context is cancelled.
-//
-// Without this, clients that probe with GET (e.g. openclaw's bundle-mcp
-// SSE transport) see HTTP 405 and log warnings on every probe.
-func (h *MCPHTTPHandler) handleGet(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("Content-Type", "text/event-stream")
-	w.Header().Set("Cache-Control", "no-cache")
-	w.Header().Set("Connection", "keep-alive")
-	w.WriteHeader(http.StatusOK)
-	flusher, ok := w.(http.Flusher)
-	if !ok {
-		return
-	}
-	// Initial keepalive comment so the client sees the stream open.
-	_, _ = w.Write([]byte(": sluice mcp sse\n\n"))
-	flusher.Flush()
-
-	ticker := time.NewTicker(30 * time.Second)
-	defer ticker.Stop()
-	for {
-		select {
-		case <-r.Context().Done():
-			return
-		case <-ticker.C:
-			if _, err := w.Write([]byte(": keepalive\n\n")); err != nil {
-				return
-			}
-			flusher.Flush()
-		}
-	}
-}
-
 func (h *MCPHTTPHandler) handlePost(w http.ResponseWriter, r *http.Request) {
 	ct := r.Header.Get("Content-Type")
 	if ct != "" && !strings.HasPrefix(ct, "application/json") {

internal/mcp/server_http_test.go

@@ -2,7 +2,6 @@ package mcp
 
 import (
 	"bufio"
-	"context"
 	"encoding/json"
 	"fmt"
 	"io"
@@ -290,8 +289,7 @@ func TestMCPHTTPNotificationReturns202(t *testing.T) {
 func TestMCPHTTPMethodNotAllowed(t *testing.T) {
 	handler := newTestMCPHandler(t)
 
-	// PUT is not a valid MCP method; GET is handled as SSE stream.
-	req := httptest.NewRequest(http.MethodPut, "/mcp", nil)
+	req := httptest.NewRequest(http.MethodGet, "/mcp", nil)
 	rec := httptest.NewRecorder()
 	handler.ServeHTTP(rec, req)
 
@@ -300,38 +298,8 @@ func TestMCPHTTPMethodNotAllowed(t *testing.T) {
 	}
 
 	allow := rec.Header().Get("Allow")
-	if !strings.Contains(allow, "POST") || !strings.Contains(allow, "GET") || !strings.Contains(allow, "DELETE") {
-		t.Errorf("expected Allow header with POST, GET, and DELETE, got %q", allow)
-	}
-}
-
-func TestMCPHTTPGetOpensSSEStream(t *testing.T) {
-	handler := newTestMCPHandler(t)
-
-	// GET should open an SSE stream and return immediately when the
-	// request context is cancelled.
-	ctx, cancel := context.WithTimeout(context.Background(), 500*time.Millisecond)
-	defer cancel()
-	req := httptest.NewRequest(http.MethodGet, "/mcp", nil).WithContext(ctx)
-	rec := httptest.NewRecorder()
-	done := make(chan struct{})
-	go func() {
-		handler.ServeHTTP(rec, req)
-		close(done)
-	}()
-	select {
-	case <-done:
-	case <-time.After(3 * time.Second):
-		t.Fatal("handler did not return after context cancel")
-	}
-	if rec.Code != http.StatusOK {
-		t.Errorf("expected 200, got %d", rec.Code)
-	}
-	if ct := rec.Header().Get("Content-Type"); ct != "text/event-stream" {
-		t.Errorf("expected text/event-stream, got %q", ct)
-	}
-	if !strings.Contains(rec.Body.String(), "sluice mcp sse") {
-		t.Errorf("expected initial SSE comment, got %q", rec.Body.String())
+	if !strings.Contains(allow, "POST") || !strings.Contains(allow, "DELETE") {
+		t.Errorf("expected Allow header with POST and DELETE, got %q", allow)
 	}
 }
 

scripts/openclaw-gateway-rpc.js

@@ -319,12 +319,23 @@ req.on("upgrade", (_res, socket) => {
           clearTimeout(deadline);
           fail("config.get response missing hash");
         }
-        // Step 2 of wire-mcp: merge-patch mcp.servers.<name> = {url}.
+        // Step 2 of wire-mcp: merge-patch mcp.servers.<name>. We must
+        // set transport: "streamable-http" explicitly because openclaw's
+        // pi-bundle-mcp-runtime defaults to the legacy SSE transport
+        // when the field is omitted, and the SSE transport requires a
+        // long-lived GET stream that sluice's gateway does not expose.
         // restartDelayMs gives us time to receive the response and exit
         // cleanly before the gateway restarts and kills our docker exec
         // (which would otherwise result in exit code 137).
         const raw = JSON.stringify({
-          mcp: { servers: { [wireMcpName]: { url: wireMcpURL } } },
+          mcp: {
+            servers: {
+              [wireMcpName]: {
+                transport: "streamable-http",
+                url: wireMcpURL,
+              },
+            },
+          },
         });
         step = "sent-method";
         socket.write(