mcp: bump protocol version from 2026-06-30 to 2026-07-28 (#1015)

The new official date for the protocol version has been moved to
'2026-07-28'. Update all the references in the code of the old version.

Author: guglielmo-san

mcp/client.go

@@ -165,7 +165,7 @@ type ClientOptions struct {
 	// If non-zero, defines an interval for regular "ping" requests.
 	// If the peer fails to respond to pings originating from the keepalive check,
 	// the session is automatically closed.
-	// NOTE: The keepalive feature is only available for protocol versions < 2026-06-30
+	// NOTE: The keepalive feature is only available for protocol versions < 2026-07-28
 	KeepAlive time.Duration
 	// KeepAliveFailureThreshold is the number of consecutive keepalive ping
 	// failures tolerated before the session is closed. A value of 0 or 1
@@ -285,7 +285,7 @@ func (c *Client) Connect(ctx context.Context, t Transport, opts *ClientSessionOp
 		protocolVersion = opts.protocolVersion
 	}
 
-	if protocolVersion >= protocolVersion20260630 {
+	if protocolVersion >= protocolVersion20260728 {
 		// Per SEP-2575, try the stateless server/discover RPC first. If the server
 		// signals it doesn't support it, fall back to the legacy initialize
 		// handshake.
@@ -309,7 +309,7 @@ func (c *Client) Connect(ctx context.Context, t Transport, opts *ClientSessionOp
 			if errors.As(err, &werr) && werr.Code == CodeUnsupportedProtocolVersion && werr.Data != nil {
 				var data UnsupportedProtocolVersionData
 				if err := json.Unmarshal(werr.Data, &data); err == nil {
-					if negotiatedVersion := negotiateMutuallySupportedVersion(data.Supported); negotiatedVersion != "" && negotiatedVersion >= protocolVersion20260630 {
+					if negotiatedVersion := negotiateMutuallySupportedVersion(data.Supported); negotiatedVersion != "" && negotiatedVersion >= protocolVersion20260728 {
 						discoverCtx = context.WithValue(ctx, protocolVersionContextKey{}, negotiatedVersion)
 						continue
 					}
@@ -381,7 +381,7 @@ func (c *Client) discover(ctx context.Context, cs *ClientSession) (*InitializeRe
 	} else {
 		negotiated = negotiateMutuallySupportedVersion(res.SupportedVersions)
 	}
-	if negotiated == "" || negotiated < protocolVersion20260630 {
+	if negotiated == "" || negotiated < protocolVersion20260728 {
 		// If there is no overlap, fall back to initialize so version
 		// negotiation can happen via the legacy path.
 		return nil, jsonrpc2.ErrUnsupportedProtocolVersion
@@ -436,11 +436,11 @@ type clientSessionState struct {
 func (cs *ClientSession) InitializeResult() *InitializeResult { return cs.state.InitializeResult }
 
 // usesNewProtocol reports whether this session has negotiated a protocol
-// version >= 2026-06-30, which requires the SEP-2575 per-request `_meta`
+// version >= 2026-07-28, which requires the SEP-2575 per-request `_meta`
 // triple on every outgoing request.
 func (cs *ClientSession) usesNewProtocol() bool {
 	res := cs.state.InitializeResult
-	return res != nil && res.ProtocolVersion >= protocolVersion20260630
+	return res != nil && res.ProtocolVersion >= protocolVersion20260728
 }
 
 // injectRequestMeta populates the SEP-2575 per-request `_meta` triple

mcp/client_test.go

@@ -642,9 +642,9 @@ 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-06-30 support in the SDK for this test
+	// Temporarily enable 2026-07-28 support in the SDK for this test
 	oldSupported := supportedProtocolVersions
-	supportedProtocolVersions = append([]string{protocolVersion20260630}, supportedProtocolVersions...)
+	supportedProtocolVersions = append([]string{protocolVersion20260728}, supportedProtocolVersions...)
 	t.Cleanup(func() {
 		supportedProtocolVersions = oldSupported
 	})
@@ -668,15 +668,15 @@ func TestClientConnectDiscover(t *testing.T) {
 			name: "discover success skips initialize",
 			discoverHandler: func() (Result, error) {
 				return &DiscoverResult{
-					SupportedVersions: []string{protocolVersion20260630},
+					SupportedVersions: []string{protocolVersion20260728},
 					Capabilities: &ServerCapabilities{
 						Tools: &ToolCapabilities{ListChanged: true},
 					},
 					ServerInfo: &Implementation{Name: "discoverServer", Version: "v1.0.0"},
 				}, nil
 			},
 			wantInitialize: false,
-			wantVersion:    protocolVersion20260630,
+			wantVersion:    protocolVersion20260728,
 		},
 		{
 			name: "method not found falls back to initialize",
@@ -742,7 +742,7 @@ func TestClientConnectDiscover(t *testing.T) {
 			defer ss.Close()
 
 			c := NewClient(testImpl, nil)
-			cs, err := c.Connect(ctx, ct, &ClientSessionOptions{protocolVersion: protocolVersion20260630})
+			cs, err := c.Connect(ctx, ct, &ClientSessionOptions{protocolVersion: protocolVersion20260728})
 			if err != nil {
 				t.Fatalf("Connect: %v", err)
 			}
@@ -770,7 +770,7 @@ func TestClientConnectDiscover(t *testing.T) {
 // protocolVersion, clientInfo, and clientCapabilities.
 func TestClientConnectDiscover_RequestContents(t *testing.T) {
 	orig := supportedProtocolVersions
-	supportedProtocolVersions = append([]string{protocolVersion20260630}, slices.Clone(orig)...)
+	supportedProtocolVersions = append([]string{protocolVersion20260728}, slices.Clone(orig)...)
 	t.Cleanup(func() { supportedProtocolVersions = orig })
 
 	ctx := context.Background()
@@ -811,7 +811,7 @@ func TestClientConnectDiscover_RequestContents(t *testing.T) {
 			return nil, nil
 		},
 	})
-	cs, err := c.Connect(ctx, ct, &ClientSessionOptions{protocolVersion: protocolVersion20260630})
+	cs, err := c.Connect(ctx, ct, &ClientSessionOptions{protocolVersion: protocolVersion20260728})
 	if err != nil {
 		t.Fatalf("Connect: %v", err)
 	}
@@ -822,8 +822,8 @@ func TestClientConnectDiscover_RequestContents(t *testing.T) {
 	}
 
 	meta := got.params.GetMeta()
-	if v, _ := meta[MetaKeyProtocolVersion].(string); v != protocolVersion20260630 {
-		t.Errorf("_meta[%s] = %q, want %q", MetaKeyProtocolVersion, v, protocolVersion20260630)
+	if v, _ := meta[MetaKeyProtocolVersion].(string); v != protocolVersion20260728 {
+		t.Errorf("_meta[%s] = %q, want %q", MetaKeyProtocolVersion, v, protocolVersion20260728)
 	}
 	// _meta values round-trip through JSON, so on the server side they
 	// arrive as map[string]any rather than the typed Go pointers we sent.
@@ -849,7 +849,7 @@ func TestInMemory_E2E_DiscoverSuccess(t *testing.T) {
 	ctx := context.Background()
 
 	orig := supportedProtocolVersions
-	supportedProtocolVersions = append([]string{protocolVersion20260630}, slices.Clone(orig)...)
+	supportedProtocolVersions = append([]string{protocolVersion20260728}, slices.Clone(orig)...)
 	t.Cleanup(func() { supportedProtocolVersions = orig })
 
 	server := NewServer(&Implementation{Name: "stdio-like-server", Version: "v1"}, nil)
@@ -861,7 +861,7 @@ func TestInMemory_E2E_DiscoverSuccess(t *testing.T) {
 	defer ss.Close()
 
 	client := NewClient(&Implementation{Name: "stdio-like-client", Version: "v1"}, nil)
-	cs, err := client.Connect(ctx, ct, &ClientSessionOptions{protocolVersion: protocolVersion20260630})
+	cs, err := client.Connect(ctx, ct, &ClientSessionOptions{protocolVersion: protocolVersion20260728})
 	if err != nil {
 		t.Fatalf("client.Connect: %v", err)
 	}
@@ -871,9 +871,9 @@ func TestInMemory_E2E_DiscoverSuccess(t *testing.T) {
 	if ir == nil {
 		t.Fatal("InitializeResult is nil; discover should have populated it")
 	}
-	if ir.ProtocolVersion != protocolVersion20260630 {
+	if ir.ProtocolVersion != protocolVersion20260728 {
 		t.Errorf("InitializeResult.ProtocolVersion = %q, want %q (negotiated via discover, no initialize)",
-			ir.ProtocolVersion, protocolVersion20260630)
+			ir.ProtocolVersion, protocolVersion20260728)
 	}
 	if ir.ServerInfo == nil || ir.ServerInfo.Name != "stdio-like-server" {
 		t.Errorf("InitializeResult.ServerInfo = %+v, want name=stdio-like-server", ir.ServerInfo)
@@ -887,13 +887,13 @@ 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-06-30, but the server's supported list does
+// _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).
 func TestInMemory_E2E_DiscoverFallback_NoOverlap(t *testing.T) {
 	ctx := context.Background()
 	orig := supportedProtocolVersions
-	supportedProtocolVersions = append([]string{protocolVersion20260630}, slices.Clone(orig)...)
+	supportedProtocolVersions = append([]string{protocolVersion20260728}, slices.Clone(orig)...)
 	t.Cleanup(func() { supportedProtocolVersions = orig })
 
 	server := NewServer(&Implementation{Name: "vpre-like-server", Version: "v1"}, nil)
@@ -920,7 +920,7 @@ func TestInMemory_E2E_DiscoverFallback_NoOverlap(t *testing.T) {
 	defer ss.Close()
 
 	client := NewClient(&Implementation{Name: "new-client", Version: "v1"}, nil)
-	cs, err := client.Connect(ctx, ct, &ClientSessionOptions{protocolVersion: protocolVersion20260630})
+	cs, err := client.Connect(ctx, ct, &ClientSessionOptions{protocolVersion: protocolVersion20260728})
 	if err != nil {
 		t.Fatalf("client.Connect: %v", err)
 	}
@@ -948,7 +948,7 @@ func TestInMemory_E2E_DiscoverFallback_MethodNotFound(t *testing.T) {
 	ctx := context.Background()
 
 	orig := supportedProtocolVersions
-	supportedProtocolVersions = append([]string{protocolVersion20260630}, slices.Clone(orig)...)
+	supportedProtocolVersions = append([]string{protocolVersion20260728}, slices.Clone(orig)...)
 	t.Cleanup(func() { supportedProtocolVersions = orig })
 
 	server := NewServer(&Implementation{Name: "vpre-server", Version: "v1"}, nil)
@@ -969,7 +969,7 @@ func TestInMemory_E2E_DiscoverFallback_MethodNotFound(t *testing.T) {
 	defer ss.Close()
 
 	client := NewClient(&Implementation{Name: "new-client", Version: "v1"}, nil)
-	cs, err := client.Connect(ctx, ct, &ClientSessionOptions{protocolVersion: protocolVersion20260630})
+	cs, err := client.Connect(ctx, ct, &ClientSessionOptions{protocolVersion: protocolVersion20260728})
 	if err != nil {
 		t.Fatalf("client.Connect: %v", err)
 	}
@@ -997,7 +997,7 @@ func TestInMemory_E2E_DiscoverFallback_UnsupportedProtocolVersion(t *testing.T)
 	ctx := context.Background()
 
 	orig := supportedProtocolVersions
-	supportedProtocolVersions = append([]string{protocolVersion20260630}, slices.Clone(orig)...)
+	supportedProtocolVersions = append([]string{protocolVersion20260728}, slices.Clone(orig)...)
 	t.Cleanup(func() { supportedProtocolVersions = orig })
 
 	server := NewServer(&Implementation{Name: "strict-server", Version: "v1"}, nil)
@@ -1021,7 +1021,7 @@ func TestInMemory_E2E_DiscoverFallback_UnsupportedProtocolVersion(t *testing.T)
 	defer ss.Close()
 
 	client := NewClient(&Implementation{Name: "new-client", Version: "v1"}, nil)
-	cs, err := client.Connect(ctx, ct, &ClientSessionOptions{protocolVersion: protocolVersion20260630})
+	cs, err := client.Connect(ctx, ct, &ClientSessionOptions{protocolVersion: protocolVersion20260728})
 	if err != nil {
 		t.Fatalf("client.Connect: %v", err)
 	}
@@ -1044,7 +1044,7 @@ func TestInMemory_E2E_DiscoverFallback_UnsupportedProtocolVersion(t *testing.T)
 // selects a mutually supported version from that list and retries.
 func TestClientConnectDiscover_UnsupportedVersionNegotiation(t *testing.T) {
 	oldSupported := supportedProtocolVersions
-	supportedProtocolVersions = append([]string{protocolVersion20260630}, slices.Clone(oldSupported)...)
+	supportedProtocolVersions = append([]string{protocolVersion20260728}, slices.Clone(oldSupported)...)
 	t.Cleanup(func() { supportedProtocolVersions = oldSupported })
 
 	ctx := context.Background()
@@ -1095,8 +1095,8 @@ func TestClientConnectDiscover_UnsupportedVersionNegotiation(t *testing.T) {
 	if got, want := discoverCalls.Load(), int32(1); got != want {
 		t.Errorf("server/discover handler call count = %d, want %d (first probe is rejected by the dispatcher; only the retry reaches the handler)", got, want)
 	}
-	if got, _ := observedDiscoverVersion.Load().(string); got != protocolVersion20260630 {
-		t.Errorf("retry discover requested version = %q, want %q (highest mutually supported version)", got, protocolVersion20260630)
+	if got, _ := observedDiscoverVersion.Load().(string); got != protocolVersion20260728 {
+		t.Errorf("retry discover requested version = %q, want %q (highest mutually supported version)", got, protocolVersion20260728)
 	}
 	if gotInitialize.Load() {
 		t.Error("legacy initialize handshake ran, but negotiated discover should have succeeded")
@@ -1106,7 +1106,7 @@ func TestClientConnectDiscover_UnsupportedVersionNegotiation(t *testing.T) {
 	if ir == nil {
 		t.Fatal("InitializeResult is nil after Connect")
 	}
-	if got, want := ir.ProtocolVersion, protocolVersion20260630; got != want {
+	if got, want := ir.ProtocolVersion, protocolVersion20260728; got != want {
 		t.Errorf("InitializeResult.ProtocolVersion = %q, want %q", got, want)
 	}
 }

mcp/mrtr.go

@@ -67,7 +67,7 @@ func clientSupportsMultiRoundTrip(ss *ServerSession) bool {
 	if iparams := ss.InitializeParams(); iparams != nil {
 		protocolVersion = iparams.ProtocolVersion
 	}
-	return protocolVersion >= protocolVersion20260630
+	return protocolVersion >= protocolVersion20260728
 }
 
 func clientMultiRoundTripMiddleware() Middleware {

mcp/mrtr_test.go

@@ -22,7 +22,7 @@ func TestMultiRoundTrip_ManualRetry(t *testing.T) {
 	}
 
 	orig := supportedProtocolVersions
-	supportedProtocolVersions = append(slices.Clone(orig), protocolVersion20260630)
+	supportedProtocolVersions = append(slices.Clone(orig), protocolVersion20260728)
 	t.Cleanup(func() { supportedProtocolVersions = orig })
 
 	ctx := context.Background()
@@ -94,7 +94,7 @@ func TestMultiRoundTrip_ManualRetry(t *testing.T) {
 
 func TestMultiRoundTrip_AutoRetry(t *testing.T) {
 	orig := supportedProtocolVersions
-	supportedProtocolVersions = append(slices.Clone(orig), protocolVersion20260630)
+	supportedProtocolVersions = append(slices.Clone(orig), protocolVersion20260728)
 	t.Cleanup(func() { supportedProtocolVersions = orig })
 
 	tests := []struct {
@@ -219,7 +219,7 @@ func TestMultiRoundTrip_MaxRetries(t *testing.T) {
 		},
 	}
 	orig := supportedProtocolVersions
-	supportedProtocolVersions = append(slices.Clone(orig), protocolVersion20260630)
+	supportedProtocolVersions = append(slices.Clone(orig), protocolVersion20260728)
 	t.Cleanup(func() { supportedProtocolVersions = orig })
 
 	for _, tc := range testCases {
@@ -339,7 +339,7 @@ func TestMultiRoundTrip_ServerMiddleware(t *testing.T) {
 
 func TestMultiRoundTrip_GetPrompt_AutoRetry(t *testing.T) {
 	orig := supportedProtocolVersions
-	supportedProtocolVersions = append(slices.Clone(orig), protocolVersion20260630)
+	supportedProtocolVersions = append(slices.Clone(orig), protocolVersion20260728)
 	t.Cleanup(func() { supportedProtocolVersions = orig })
 
 	ctx := context.Background()
@@ -381,7 +381,7 @@ func TestMultiRoundTrip_GetPrompt_AutoRetry(t *testing.T) {
 
 func TestMultiRoundTrip_GetPrompt_ManualRetry(t *testing.T) {
 	orig := supportedProtocolVersions
-	supportedProtocolVersions = append(slices.Clone(orig), protocolVersion20260630)
+	supportedProtocolVersions = append(slices.Clone(orig), protocolVersion20260728)
 	t.Cleanup(func() { supportedProtocolVersions = orig })
 
 	ctx := context.Background()
@@ -433,7 +433,7 @@ func TestMultiRoundTrip_GetPrompt_ManualRetry(t *testing.T) {
 
 func TestMultiRoundTrip_ReadResource_AutoRetry(t *testing.T) {
 	orig := supportedProtocolVersions
-	supportedProtocolVersions = append(slices.Clone(orig), protocolVersion20260630)
+	supportedProtocolVersions = append(slices.Clone(orig), protocolVersion20260728)
 	t.Cleanup(func() { supportedProtocolVersions = orig })
 
 	ctx := context.Background()
@@ -474,7 +474,7 @@ func TestMultiRoundTrip_ReadResource_AutoRetry(t *testing.T) {
 
 func TestMultiRoundTrip_ReadResource_ManualRetry(t *testing.T) {
 	orig := supportedProtocolVersions
-	supportedProtocolVersions = append(slices.Clone(orig), protocolVersion20260630)
+	supportedProtocolVersions = append(slices.Clone(orig), protocolVersion20260728)
 	t.Cleanup(func() { supportedProtocolVersions = orig })
 
 	ctx := context.Background()
@@ -536,7 +536,7 @@ func mustConnect(t *testing.T, s *Server, clientOpts *ClientOptions) *ClientSess
 	})
 
 	c := NewClient(testImpl, clientOpts)
-	cs, err := c.Connect(t.Context(), ct, &ClientSessionOptions{protocolVersion: protocolVersion20260630})
+	cs, err := c.Connect(t.Context(), ct, &ClientSessionOptions{protocolVersion: protocolVersion20260728})
 	if err != nil {
 		t.Fatalf("client.Connect() error = %v", err)
 	}

mcp/protocol.go

@@ -2138,7 +2138,7 @@ const (
 	methodUnsubscribe               = "resources/unsubscribe"
 )
 
-// Per-request _meta field names for the >= 2026-06-30 protocol version.
+// Per-request _meta field names for the >= 2026-07-28 protocol version.
 //
 // These keys appear inside a Params._meta map and carry information that
 // previously came from the initialization handshake (SEP-2575).

mcp/server.go

@@ -1441,7 +1441,7 @@ func (ss *ServerSession) Elicit(ctx context.Context, params *ElicitParams) (*Eli
 
 // logLevelContextKey carries the per-request log level from
 // [ServerSession.handle] to [ServerSession.Log] for new-protocol
-// (>= 2026-06-30) requests. The level is scoped to a single in-flight request
+// (>= 2026-07-28) requests. The level is scoped to a single in-flight request
 // — including handler goroutines that call [ServerSession.Log] concurrently —
 // rather than to the session, which avoids races between concurrent requests
 // and aligns with SEP-2575's per-request opt-in model. The value type is
@@ -1450,7 +1450,7 @@ type logLevelContextKey struct{}
 
 // Log sends a log message to the client.
 //
-// For new-protocol (>= 2026-06-30) requests, the level is taken from the
+// For new-protocol (>= 2026-07-28) requests, the level is taken from the
 // originating request's `_meta` field (SEP-2575); an absent or empty value
 // suppresses the message per spec. For old-protocol requests, the level is
 // taken from the session state set via `logging/setLevel`.
@@ -1609,7 +1609,7 @@ func (ss *ServerSession) handle(ctx context.Context, req *jsonrpc.Request) (any,
 	case methodDiscover:
 		// In case of methodDiscover call the state.initializeParams is populated
 		// within the discover handle function to make sure the method is supported
-		// when the user is probing a pre-2026-06-30 server.
+		// when the user is probing a pre-2026-07-28 server.
 	default:
 		if !initialized && !validatedMeta.usesNewProtocol {
 			ss.server.opts.Logger.Error("method invalid during initialization", "method", req.Method)