mcp: add 2026-07-28 to the supported protocol versions (#1020)

This PR adds the protocol version `2026-07-28` to the list of supported
protocol versions and fixes legacy tests hardcoding the legacy protocol
version for those use cases.

Author: guglielmo-san

mcp/capabilities_test.go

@@ -27,8 +27,12 @@ func TestServerListChangedNotifications(t *testing.T) {
 		wantNotifyCount int64
 	}{
 		{
-			name:            "Default: notification sent",
-			serverOpts:      nil,
+			name: "Default: notification sent",
+			serverOpts: &ServerOptions{
+				Capabilities: &ServerCapabilities{
+					Tools: &ToolCapabilities{ListChanged: true},
+				},
+			},
 			wantNotifyCount: 1,
 		},
 		{

mcp/client.go

@@ -403,7 +403,7 @@ func (c *Client) discover(ctx context.Context, cs *ClientSession) (*InitializeRe
 		Meta: Meta{
 			MetaKeyProtocolVersion:    protocolVersion,
 			MetaKeyClientInfo:         c.impl,
-			MetaKeyClientCapabilities: caps,
+			MetaKeyClientCapabilities: caps.toV2(),
 		},
 	}
 	req := &DiscoverRequest{Session: cs, Params: params}
@@ -518,7 +518,7 @@ func injectRequestMeta[T any, P interface {
 		m[MetaKeyClientInfo] = cs.client.impl
 	}
 	if _, ok := m[MetaKeyClientCapabilities]; !ok {
-		m[MetaKeyClientCapabilities] = cs.client.capabilities(res.ProtocolVersion)
+		m[MetaKeyClientCapabilities] = cs.client.capabilities(res.ProtocolVersion).toV2()
 	}
 	params.SetMeta(m)
 	return params

mcp/client_test.go

@@ -10,7 +10,6 @@ import (
 	"context"
 	"fmt"
 	"log/slog"
-	"slices"
 	"sync/atomic"
 	"testing"
 
@@ -644,13 +643,6 @@ func TestClientCapabilitiesOverWire(t *testing.T) {
 // don't overlap with the SDK. The test then asserts the resulting session
 // state and whether the legacy initialize handshake ran.
 func TestClientConnectDiscover(t *testing.T) {
-	// Temporarily enable 2026-07-28 support in the SDK for this test
-	oldSupported := supportedProtocolVersions
-	supportedProtocolVersions = append([]string{protocolVersion20260728}, supportedProtocolVersions...)
-	t.Cleanup(func() {
-		supportedProtocolVersions = oldSupported
-	})
-
 	const otherVersionsOnly = "1999-01-01"
 
 	tests := []struct {
@@ -686,7 +678,7 @@ func TestClientConnectDiscover(t *testing.T) {
 				return nil, jsonrpc2.ErrMethodNotFound
 			},
 			wantInitialize: true,
-			wantVersion:    latestProtocolVersion,
+			wantVersion:    protocolVersion20251125,
 		},
 		{
 			name: "unsupported protocol version falls back to initialize",
@@ -697,7 +689,7 @@ func TestClientConnectDiscover(t *testing.T) {
 				}
 			},
 			wantInitialize: true,
-			wantVersion:    latestProtocolVersion,
+			wantVersion:    protocolVersion20251125,
 		},
 		{
 			name: "no overlapping supported version falls back to initialize",
@@ -709,7 +701,7 @@ func TestClientConnectDiscover(t *testing.T) {
 				}, nil
 			},
 			wantInitialize: true,
-			wantVersion:    latestProtocolVersion,
+			wantVersion:    protocolVersion20251125,
 		},
 	}
 
@@ -771,10 +763,6 @@ func TestClientConnectDiscover(t *testing.T) {
 // request sent by Client.Connect carries the SEP-2575 per-request _meta triple:
 // protocolVersion, clientInfo, and clientCapabilities.
 func TestClientConnectDiscover_RequestContents(t *testing.T) {
-	orig := supportedProtocolVersions
-	supportedProtocolVersions = append([]string{protocolVersion20260728}, slices.Clone(orig)...)
-	t.Cleanup(func() { supportedProtocolVersions = orig })
-
 	ctx := context.Background()
 
 	type captured struct {
@@ -850,10 +838,6 @@ func TestClientConnectDiscover_RequestContents(t *testing.T) {
 func TestInMemory_E2E_DiscoverSuccess(t *testing.T) {
 	ctx := context.Background()
 
-	orig := supportedProtocolVersions
-	supportedProtocolVersions = append([]string{protocolVersion20260728}, slices.Clone(orig)...)
-	t.Cleanup(func() { supportedProtocolVersions = orig })
-
 	server := NewServer(&Implementation{Name: "stdio-like-server", Version: "v1"}, nil)
 	ct, st := NewInMemoryTransports()
 	ss, err := server.Connect(ctx, st, nil)
@@ -889,15 +873,11 @@ func TestInMemory_E2E_DiscoverSuccess(t *testing.T) {
 
 // TestInMemory_E2E_DiscoverFallback_NoOverlap verifies the fallback path
 // over an InMemory (STDIO-equivalent) transport: the client probes with
-// _meta.protocolVersion = 2026-07-28, but the server's supported list does
-// NOT include that version (the default for an SDK server that hasn't
-// shimmed supportedProtocolVersions).
+// _meta.protocolVersion = 2026-07-28, but the server overrides discover via
+// middleware to advertise only legacy versions, so the client must fall
+// back to the legacy initialize handshake.
 func TestInMemory_E2E_DiscoverFallback_NoOverlap(t *testing.T) {
 	ctx := context.Background()
-	orig := supportedProtocolVersions
-	supportedProtocolVersions = append([]string{protocolVersion20260728}, slices.Clone(orig)...)
-	t.Cleanup(func() { supportedProtocolVersions = orig })
-
 	server := NewServer(&Implementation{Name: "vpre-like-server", Version: "v1"}, nil)
 	// Intercept discover and reply as if we were a server that only
 	// supports legacy versions.
@@ -932,9 +912,11 @@ func TestInMemory_E2E_DiscoverFallback_NoOverlap(t *testing.T) {
 	if ir == nil {
 		t.Fatal("InitializeResult is nil after fallback initialize")
 	}
-	if ir.ProtocolVersion != latestProtocolVersion {
+	// The fallback initialize explicitly requests protocolVersion20251125
+	// (see client.go), so the server negotiates that version.
+	if ir.ProtocolVersion != protocolVersion20251125 {
 		t.Errorf("InitializeResult.ProtocolVersion = %q, want %q (legacy fallback after no-overlap discover)",
-			ir.ProtocolVersion, latestProtocolVersion)
+			ir.ProtocolVersion, protocolVersion20251125)
 	}
 
 	// Prove the session is usable after fallback.
@@ -949,10 +931,6 @@ func TestInMemory_E2E_DiscoverFallback_NoOverlap(t *testing.T) {
 func TestInMemory_E2E_DiscoverFallback_MethodNotFound(t *testing.T) {
 	ctx := context.Background()
 
-	orig := supportedProtocolVersions
-	supportedProtocolVersions = append([]string{protocolVersion20260728}, slices.Clone(orig)...)
-	t.Cleanup(func() { supportedProtocolVersions = orig })
-
 	server := NewServer(&Implementation{Name: "vpre-server", Version: "v1"}, nil)
 	server.AddReceivingMiddleware(func(next MethodHandler) MethodHandler {
 		return func(ctx context.Context, method string, req Request) (Result, error) {
@@ -981,9 +959,11 @@ func TestInMemory_E2E_DiscoverFallback_MethodNotFound(t *testing.T) {
 	if ir == nil {
 		t.Fatal("InitializeResult is nil after fallback initialize")
 	}
-	if ir.ProtocolVersion != latestProtocolVersion {
+	// The fallback initialize explicitly requests protocolVersion20251125
+	// (see client.go), so the server negotiates that version.
+	if ir.ProtocolVersion != protocolVersion20251125 {
 		t.Errorf("InitializeResult.ProtocolVersion = %q, want %q (legacy fallback after MethodNotFound)",
-			ir.ProtocolVersion, latestProtocolVersion)
+			ir.ProtocolVersion, protocolVersion20251125)
 	}
 
 	if _, err := cs.ListTools(ctx, nil); err != nil {
@@ -998,10 +978,6 @@ func TestInMemory_E2E_DiscoverFallback_MethodNotFound(t *testing.T) {
 func TestInMemory_E2E_DiscoverFallback_UnsupportedProtocolVersion(t *testing.T) {
 	ctx := context.Background()
 
-	orig := supportedProtocolVersions
-	supportedProtocolVersions = append([]string{protocolVersion20260728}, slices.Clone(orig)...)
-	t.Cleanup(func() { supportedProtocolVersions = orig })
-
 	server := NewServer(&Implementation{Name: "strict-server", Version: "v1"}, nil)
 	server.AddReceivingMiddleware(func(next MethodHandler) MethodHandler {
 		return func(ctx context.Context, method string, req Request) (Result, error) {
@@ -1033,9 +1009,11 @@ func TestInMemory_E2E_DiscoverFallback_UnsupportedProtocolVersion(t *testing.T)
 	if ir == nil {
 		t.Fatal("InitializeResult is nil after fallback initialize")
 	}
-	if ir.ProtocolVersion != latestProtocolVersion {
+	// The fallback initialize explicitly requests protocolVersion20251125
+	// (see client.go), so the server negotiates that version.
+	if ir.ProtocolVersion != protocolVersion20251125 {
 		t.Errorf("InitializeResult.ProtocolVersion = %q, want %q (legacy fallback after UnsupportedProtocolVersion)",
-			ir.ProtocolVersion, latestProtocolVersion)
+			ir.ProtocolVersion, protocolVersion20251125)
 	}
 }
 
@@ -1045,10 +1023,6 @@ func TestInMemory_E2E_DiscoverFallback_UnsupportedProtocolVersion(t *testing.T)
 // UnsupportedProtocolVersionError carries Data.Supported, and the client
 // selects a mutually supported version from that list and retries.
 func TestClientConnectDiscover_UnsupportedVersionNegotiation(t *testing.T) {
-	oldSupported := supportedProtocolVersions
-	supportedProtocolVersions = append([]string{protocolVersion20260728}, slices.Clone(oldSupported)...)
-	t.Cleanup(func() { supportedProtocolVersions = oldSupported })
-
 	ctx := context.Background()
 
 	const unsupportedClientVersion = "2099-12-31"

mcp/conformance_test.go

@@ -143,6 +143,31 @@ func incTool(_ context.Context, _ *CallToolRequest, args incInput) (*CallToolRes
 	return nil, incOutput{args.X + 1}, nil
 }
 
+// confirmThenGreet exercises the multi-round-trip pattern in
+// conformance fixtures.
+func confirmThenGreet(_ context.Context, req *CallToolRequest, _ struct{}) (*CallToolResult, any, error) {
+	if len(req.Params.InputResponses) == 0 {
+		return &CallToolResult{
+			InputRequests: InputRequestMap{
+				"who": &ElicitParams{
+					Message: "What is your name?",
+					RequestedSchema: &jsonschema.Schema{
+						Type: "object",
+						Properties: map[string]*jsonschema.Schema{
+							"name": {Type: "string"},
+						},
+					},
+				},
+			},
+			RequestState: "step=1",
+		}, nil, nil
+	}
+	name := req.Params.InputResponses["who"].(*ElicitResult).Content["name"].(string)
+	return &CallToolResult{
+		Content: []Content{&TextContent{Text: "hello " + name}},
+	}, nil, nil
+}
+
 var iconObj = Icon{
 	Source:   "foobar",
 	MIMEType: "image/png",
@@ -193,6 +218,11 @@ func runServerTest(t *testing.T, test *conformanceTest) {
 				Title:       "contentTool",
 				Description: "return resourceLink content with Icon",
 			}, contentTool)
+		case "confirmThenGreet":
+			AddTool(s, &Tool{
+				Name:        "confirmThenGreet",
+				Description: "ask the user for their name via elicitation, then greet them",
+			}, confirmThenGreet)
 		default:
 			t.Fatalf("unknown tool %q", tn)
 		}

mcp/mcp_example_test.go

@@ -19,19 +19,13 @@ import (
 func Example_lifecycle() {
 	ctx := context.Background()
 
-	// Create a client and server.
-	// Wait for the client to initialize the session.
+	// Create a client and server. Under protocol version 2026-07-28, there
+	// is no dedicated initialize/initialized handshake: the session is
+	// implicitly live the moment the client issues its first request.
 	client := mcp.NewClient(&mcp.Implementation{Name: "client", Version: "v0.0.1"}, nil)
-	server := mcp.NewServer(&mcp.Implementation{Name: "server", Version: "v0.0.1"}, &mcp.ServerOptions{
-		InitializedHandler: func(context.Context, *mcp.InitializedRequest) {
-			fmt.Println("initialized!")
-		},
-	})
+	server := mcp.NewServer(&mcp.Implementation{Name: "server", Version: "v0.0.1"}, nil)
 
 	// Connect the server and client using in-memory transports.
-	//
-	// Connect the server first so that it's ready to receive initialization
-	// messages from the client.
 	t1, t2 := mcp.NewInMemoryTransports()
 	serverSession, err := server.Connect(ctx, t1, nil)
 	if err != nil {
@@ -50,7 +44,7 @@ func Example_lifecycle() {
 	if err := serverSession.Wait(); err != nil {
 		log.Fatal(err)
 	}
-	// Output: initialized!
+	// Output:
 }
 
 // !-lifecycle