diff --git a/quiche/quic/moqt/moqt_framer.cc b/quiche/quic/moqt/moqt_framer.cc
index 803ab62..769c51c 100644
--- a/quiche/quic/moqt/moqt_framer.cc
+++ b/quiche/quic/moqt/moqt_framer.cc
@@ -648,6 +648,7 @@
     return quiche::QuicheBuffer();
   }
   return SerializeControlMessage(MoqtMessageType::kSubscribeAnnounces,
+                                 WireVarInt62(message.request_id),
                                  WireTrackNamespace(message.track_namespace),
                                  WireKeyValuePairList(parameters));
 }
@@ -655,16 +656,15 @@
 quiche::QuicheBuffer MoqtFramer::SerializeSubscribeAnnouncesOk(
     const MoqtSubscribeAnnouncesOk& message) {
   return SerializeControlMessage(MoqtMessageType::kSubscribeAnnouncesOk,
-                                 WireTrackNamespace(message.track_namespace));
+                                 WireVarInt62(message.request_id));
 }
 
 quiche::QuicheBuffer MoqtFramer::SerializeSubscribeAnnouncesError(
     const MoqtSubscribeAnnouncesError& message) {
   return SerializeControlMessage(
       MoqtMessageType::kSubscribeAnnouncesError,
-      WireTrackNamespace(message.track_namespace),
-      WireVarInt62(message.error_code),
-      WireStringWithVarInt62Length(message.reason_phrase));
+      WireVarInt62(message.request_id), WireVarInt62(message.error_code),
+      WireStringWithVarInt62Length(message.error_reason));
 }
 
 quiche::QuicheBuffer MoqtFramer::SerializeUnsubscribeAnnounces(
diff --git a/quiche/quic/moqt/moqt_messages.h b/quiche/quic/moqt/moqt_messages.h
index 455ad9b..2e6960d 100644
--- a/quiche/quic/moqt/moqt_messages.h
+++ b/quiche/quic/moqt/moqt_messages.h
@@ -686,18 +686,19 @@
 };
 
 struct QUICHE_EXPORT MoqtSubscribeAnnounces {
+  uint64_t request_id;
   TrackNamespace track_namespace;
   VersionSpecificParameters parameters;
 };
 
 struct QUICHE_EXPORT MoqtSubscribeAnnouncesOk {
-  TrackNamespace track_namespace;
+  uint64_t request_id;
 };
 
 struct QUICHE_EXPORT MoqtSubscribeAnnouncesError {
-  TrackNamespace track_namespace;
+  uint64_t request_id;
   RequestErrorCode error_code;
-  std::string reason_phrase;
+  std::string error_reason;
 };
 
 struct QUICHE_EXPORT MoqtUnsubscribeAnnounces {
diff --git a/quiche/quic/moqt/moqt_parser.cc b/quiche/quic/moqt/moqt_parser.cc
index d8d96b6..968a9e5 100644
--- a/quiche/quic/moqt/moqt_parser.cc
+++ b/quiche/quic/moqt/moqt_parser.cc
@@ -720,7 +720,8 @@
 size_t MoqtControlParser::ProcessSubscribeAnnounces(
     quic::QuicDataReader& reader) {
   MoqtSubscribeAnnounces subscribe_announces;
-  if (!ReadTrackNamespace(reader, subscribe_announces.track_namespace)) {
+  if (!reader.ReadVarInt62(&subscribe_announces.request_id) ||
+      !ReadTrackNamespace(reader, subscribe_announces.track_namespace)) {
     return 0;
   }
   KeyValuePairList parameters;
@@ -743,7 +744,7 @@
 size_t MoqtControlParser::ProcessSubscribeAnnouncesOk(
     quic::QuicDataReader& reader) {
   MoqtSubscribeAnnouncesOk subscribe_namespace_ok;
-  if (!ReadTrackNamespace(reader, subscribe_namespace_ok.track_namespace)) {
+  if (!reader.ReadVarInt62(&subscribe_namespace_ok.request_id)) {
     return 0;
   }
   visitor_.OnSubscribeAnnouncesOkMessage(subscribe_namespace_ok);
@@ -754,9 +755,9 @@
     quic::QuicDataReader& reader) {
   MoqtSubscribeAnnouncesError subscribe_namespace_error;
   uint64_t error_code;
-  if (!ReadTrackNamespace(reader, subscribe_namespace_error.track_namespace) ||
+  if (!reader.ReadVarInt62(&subscribe_namespace_error.request_id) ||
       !reader.ReadVarInt62(&error_code) ||
-      !reader.ReadStringVarInt62(subscribe_namespace_error.reason_phrase)) {
+      !reader.ReadStringVarInt62(subscribe_namespace_error.error_reason)) {
     return 0;
   }
   subscribe_namespace_error.error_code =
diff --git a/quiche/quic/moqt/moqt_session.cc b/quiche/quic/moqt/moqt_session.cc
index e58a988..2a202ed 100644
--- a/quiche/quic/moqt/moqt_session.cc
+++ b/quiche/quic/moqt/moqt_session.cc
@@ -264,13 +264,37 @@
                     << "Tried to send SUBSCRIBE_ANNOUNCES after GOAWAY";
     return false;
   }
+  if (next_request_id_ >= peer_max_request_id_) {
+    if (!last_requests_blocked_sent_.has_value() ||
+        peer_max_request_id_ > *last_requests_blocked_sent_) {
+      MoqtRequestsBlocked requests_blocked;
+      requests_blocked.max_request_id = peer_max_request_id_;
+      SendControlMessage(framer_.SerializeRequestsBlocked(requests_blocked));
+      last_requests_blocked_sent_ = peer_max_request_id_;
+    }
+    QUIC_DLOG(INFO) << ENDPOINT << "Tried to send SUBSCRIBE_ANNOUNCES with ID "
+                    << next_request_id_
+                    << " which is greater than the maximum ID "
+                    << peer_max_request_id_;
+    return false;
+  }
+  if (outgoing_subscribe_announces_.contains(track_namespace)) {
+    std::move(callback)(
+        track_namespace, RequestErrorCode::kInternalError,
+        "SUBSCRIBE_ANNOUNCES already outstanding for namespace");
+    return false;
+  }
   MoqtSubscribeAnnounces message;
+  message.request_id = next_request_id_;
+  next_request_id_ += 2;
   message.track_namespace = track_namespace;
   message.parameters = parameters;
   SendControlMessage(framer_.SerializeSubscribeAnnounces(message));
   QUIC_DLOG(INFO) << ENDPOINT << "Sent SUBSCRIBE_ANNOUNCES message for "
                   << message.track_namespace;
-  outgoing_subscribe_announces_[track_namespace] = std::move(callback);
+  pending_outgoing_subscribe_announces_[message.request_id] =
+      PendingSubscribeAnnouncesData{track_namespace, std::move(callback)};
+  outgoing_subscribe_announces_.emplace(track_namespace);
   return true;
 }
 
@@ -1322,14 +1346,17 @@
 
 void MoqtSession::ControlStream::OnSubscribeAnnouncesMessage(
     const MoqtSubscribeAnnounces& message) {
+  if (!session_->ValidateRequestId(message.request_id)) {
+    return;
+  }
   // TODO(martinduke): Handle authentication.
   if (session_->sent_goaway_) {
     QUIC_DLOG(INFO) << ENDPOINT
                     << "Received a SUBSCRIBE_ANNOUNCES after GOAWAY";
     MoqtSubscribeAnnouncesError error;
-    error.track_namespace = message.track_namespace;
+    error.request_id = message.request_id;
     error.error_code = RequestErrorCode::kUnauthorized;
-    error.reason_phrase = "SUBSCRIBE_ANNOUNCES after GOAWAY";
+    error.error_reason = "SUBSCRIBE_ANNOUNCES after GOAWAY";
     SendOrBufferMessage(
         session_->framer_.SerializeSubscribeAnnouncesError(error));
     return;
@@ -1339,49 +1366,45 @@
           message.track_namespace, message.parameters);
   if (result.has_value()) {
     MoqtSubscribeAnnouncesError error;
-    error.track_namespace = message.track_namespace;
+    error.request_id = message.request_id;
     error.error_code = result->error_code;
-    error.reason_phrase = result->reason_phrase;
+    error.error_reason = result->reason_phrase;
     SendOrBufferMessage(
         session_->framer_.SerializeSubscribeAnnouncesError(error));
     return;
   }
   MoqtSubscribeAnnouncesOk ok;
-  ok.track_namespace = message.track_namespace;
+  ok.request_id = message.request_id;
   SendOrBufferMessage(session_->framer_.SerializeSubscribeAnnouncesOk(ok));
 }
 
 void MoqtSession::ControlStream::OnSubscribeAnnouncesOkMessage(
     const MoqtSubscribeAnnouncesOk& message) {
   auto it =
-      session_->outgoing_subscribe_announces_.find(message.track_namespace);
-  if (it == session_->outgoing_subscribe_announces_.end()) {
+      session_->pending_outgoing_subscribe_announces_.find(message.request_id);
+  if (it == session_->pending_outgoing_subscribe_announces_.end()) {
+    session_->Error(MoqtError::kProtocolViolation,
+                    "Received SUBSCRIBE_ANNOUNCES_OK for unknown request_id");
     return;  // UNSUBSCRIBE_ANNOUNCES may already have deleted the entry.
   }
-  if (it->second == nullptr) {
-    session_->Error(MoqtError::kProtocolViolation,
-                    "Two responses to SUBSCRIBE_ANNOUNCES");
-    return;
-  }
-  std::move(it->second)(message.track_namespace, std::nullopt, "");
-  it->second = nullptr;
+  std::move(it->second.callback)(it->second.track_namespace, std::nullopt, "");
+  session_->pending_outgoing_subscribe_announces_.erase(it);
 }
 
 void MoqtSession::ControlStream::OnSubscribeAnnouncesErrorMessage(
     const MoqtSubscribeAnnouncesError& message) {
   auto it =
-      session_->outgoing_subscribe_announces_.find(message.track_namespace);
-  if (it == session_->outgoing_subscribe_announces_.end()) {
+      session_->pending_outgoing_subscribe_announces_.find(message.request_id);
+  if (it == session_->pending_outgoing_subscribe_announces_.end()) {
+    session_->Error(
+        MoqtError::kProtocolViolation,
+        "Received SUBSCRIBE_ANNOUNCES_ERROR for unknown request_id");
     return;  // UNSUBSCRIBE_ANNOUNCES may already have deleted the entry.
   }
-  if (it->second == nullptr) {
-    session_->Error(MoqtError::kProtocolViolation,
-                    "Two responses to SUBSCRIBE_ANNOUNCES");
-    return;
-  }
-  std::move(it->second)(message.track_namespace, message.error_code,
-                        absl::string_view(message.reason_phrase));
-  session_->outgoing_subscribe_announces_.erase(it);
+  std::move(it->second.callback)(it->second.track_namespace, message.error_code,
+                                 absl::string_view(message.error_reason));
+  session_->outgoing_subscribe_announces_.erase(it->second.track_namespace);
+  session_->pending_outgoing_subscribe_announces_.erase(it);
 }
 
 void MoqtSession::ControlStream::OnUnsubscribeAnnouncesMessage(
diff --git a/quiche/quic/moqt/moqt_session.h b/quiche/quic/moqt/moqt_session.h
index d88742a..924674f 100644
--- a/quiche/quic/moqt/moqt_session.h
+++ b/quiche/quic/moqt/moqt_session.h
@@ -829,8 +829,13 @@
   // when sending UNSUBSCRIBE_ANNOUNCES, to make sure the application doesn't
   // unsubscribe from something that it isn't subscribed to. ANNOUNCEs that
   // result from this subscription use incoming_announce_callback.
-  absl::flat_hash_map<TrackNamespace, MoqtOutgoingSubscribeAnnouncesCallback>
-      outgoing_subscribe_announces_;
+  struct PendingSubscribeAnnouncesData {
+    TrackNamespace track_namespace;
+    MoqtOutgoingSubscribeAnnouncesCallback callback;
+  };
+  absl::flat_hash_map<uint64_t, PendingSubscribeAnnouncesData>
+      pending_outgoing_subscribe_announces_;
+  absl::flat_hash_set<TrackNamespace> outgoing_subscribe_announces_;
 
   // The minimum request ID the peer can use that is monotonically increasing.
   uint64_t next_incoming_request_id_ = 0;
diff --git a/quiche/quic/moqt/moqt_session_test.cc b/quiche/quic/moqt/moqt_session_test.cc
index 03cb3ae..32400fc 100644
--- a/quiche/quic/moqt/moqt_session_test.cc
+++ b/quiche/quic/moqt/moqt_session_test.cc
@@ -55,12 +55,14 @@
 
 constexpr webtransport::StreamId kIncomingUniStreamId = 15;
 constexpr webtransport::StreamId kOutgoingUniStreamId = 14;
+constexpr uint64_t kDefaultLocalRequestId = 0;
+constexpr uint64_t kDefaultPeerRequestId = 1;
 
 FullTrackName kDefaultTrackName() { return FullTrackName("foo", "bar"); }
 
-MoqtSubscribe DefaultSubscribe() {
+MoqtSubscribe DefaultSubscribe(uint64_t request_id) {
   MoqtSubscribe subscribe = {
-      /*request_id=*/1,
+      request_id,
       /*track_alias=*/2,
       kDefaultTrackName(),
       /*subscriber_priority=*/0x80,
@@ -74,13 +76,24 @@
   return subscribe;
 }
 
+// The usual test case is that a SUBSCRIBE is coming in.
+MoqtSubscribe DefaultSubscribe() {
+  return DefaultSubscribe(kDefaultPeerRequestId);
+}
+
+// Used when a test sets up a remote track.
+MoqtSubscribe DefaultLocalSubscribe() {
+  return DefaultSubscribe(kDefaultLocalRequestId);
+}
+
 MoqtFetch DefaultFetch() {
   MoqtFetch fetch = {
-      /*request_id=*/1,
+      kDefaultPeerRequestId,
       /*subscriber_priority=*/0x80,
       /*group_order=*/std::nullopt,
       /*fetch=*/
-      StandaloneFetch(kDefaultTrackName(), Location(0, 0), 1, std::nullopt),
+      StandaloneFetch(kDefaultTrackName(), Location(0, 0),
+                      kDefaultPeerRequestId, std::nullopt),
       /*parameters=*/VersionSpecificParameters(),
   };
   return fetch;
@@ -471,7 +484,8 @@
   EXPECT_CALL(mock_stream_,
               Writev(ControlMessageOfType(MoqtMessageType::kSubscribeOk), _));
   listener->OnSubscribeAccepted();
-  EXPECT_NE(MoqtSessionPeer::GetSubscription(&session_, 1), nullptr);
+  EXPECT_NE(MoqtSessionPeer::GetSubscription(&session_, kDefaultPeerRequestId),
+            nullptr);
 }
 
 TEST_F(MoqtSessionTest, AsynchronousSubscribeReturnsError) {
@@ -490,7 +504,8 @@
   listener->OnSubscribeRejected(
       MoqtSubscribeErrorReason(RequestErrorCode::kInternalError, "Test error"),
       request.track_alias);
-  EXPECT_EQ(MoqtSessionPeer::GetSubscription(&session_, 1), nullptr);
+  EXPECT_EQ(MoqtSessionPeer::GetSubscription(&session_, kDefaultPeerRequestId),
+            nullptr);
 }
 
 TEST_F(MoqtSessionTest, SubscribeForPast) {
@@ -579,7 +594,7 @@
 
   // Peer unsubscribes.
   MoqtUnsubscribe unsubscribe = {
-      /*request_id=*/1,
+      kDefaultPeerRequestId,
   };
   stream_input->OnUnsubscribeMessage(unsubscribe);
   EXPECT_EQ(MoqtSessionPeer::GetSubscription(&session_, 1), nullptr);
@@ -893,15 +908,17 @@
   auto parameters = std::make_optional<VersionSpecificParameters>(
       AuthTokenType::kOutOfBand, "foo");
   MoqtAnnounce announce = {
-      /*request_id=*/1,
+      kDefaultPeerRequestId,
       track_namespace,
       *parameters,
   };
   EXPECT_CALL(session_callbacks_.incoming_announce_callback,
               Call(track_namespace, parameters))
       .WillOnce(Return(std::nullopt));
-  EXPECT_CALL(mock_stream_,
-              Writev(SerializedControlMessage(MoqtAnnounceOk{1}), _));
+  EXPECT_CALL(
+      mock_stream_,
+      Writev(SerializedControlMessage(MoqtAnnounceOk{kDefaultPeerRequestId}),
+             _));
   stream_input->OnAnnounceMessage(announce);
   MoqtUnannounce unannounce = {
       track_namespace,
@@ -920,15 +937,17 @@
   auto parameters = std::make_optional<VersionSpecificParameters>(
       AuthTokenType::kOutOfBand, "foo");
   MoqtAnnounce announce = {
-      /*request_id=*/1,
+      kDefaultPeerRequestId,
       track_namespace,
       *parameters,
   };
   EXPECT_CALL(session_callbacks_.incoming_announce_callback,
               Call(track_namespace, parameters))
       .WillOnce(Return(std::nullopt));
-  EXPECT_CALL(mock_stream_,
-              Writev(SerializedControlMessage(MoqtAnnounceOk{1}), _));
+  EXPECT_CALL(
+      mock_stream_,
+      Writev(SerializedControlMessage(MoqtAnnounceOk{kDefaultPeerRequestId}),
+             _));
   stream_input->OnAnnounceMessage(announce);
   EXPECT_CALL(mock_stream_,
               Writev(SerializedControlMessage(MoqtAnnounceCancel{
@@ -947,7 +966,7 @@
   auto parameters = std::make_optional<VersionSpecificParameters>(
       AuthTokenType::kOutOfBand, "foo");
   MoqtAnnounce announce = {
-      /*request_id=*/1,
+      kDefaultPeerRequestId,
       track_namespace,
       *parameters,
   };
@@ -958,10 +977,11 @@
   EXPECT_CALL(session_callbacks_.incoming_announce_callback,
               Call(track_namespace, parameters))
       .WillOnce(Return(error));
-  EXPECT_CALL(mock_stream_,
-              Writev(SerializedControlMessage(MoqtAnnounceError{
-                         1, error.error_code, error.reason_phrase}),
-                     _));
+  EXPECT_CALL(
+      mock_stream_,
+      Writev(SerializedControlMessage(MoqtAnnounceError{
+                 kDefaultPeerRequestId, error.error_code, error.reason_phrase}),
+             _));
   stream_input->OnAnnounceMessage(announce);
 }
 
@@ -984,7 +1004,7 @@
       },
       VersionSpecificParameters());
   MoqtSubscribeAnnouncesOk ok = {
-      /*track_namespace=*/track_namespace,
+      kDefaultLocalRequestId,
   };
   stream_input->OnSubscribeAnnouncesOkMessage(ok);
   EXPECT_TRUE(got_callback);
@@ -1015,7 +1035,7 @@
       },
       VersionSpecificParameters());
   MoqtSubscribeAnnouncesError error = {
-      track_namespace,
+      kDefaultLocalRequestId,
       RequestErrorCode::kInvalidRange,
       /*reason_phrase=*/"deadbeef",
   };
@@ -1111,7 +1131,8 @@
   MockSubscribeRemoteTrackVisitor visitor_;
   FullTrackName ftn("foo", "bar");
   std::string payload = "deadbeef";
-  MoqtSessionPeer::CreateRemoteTrack(&session_, DefaultSubscribe(), &visitor_);
+  MoqtSessionPeer::CreateRemoteTrack(&session_, DefaultLocalSubscribe(),
+                                     &visitor_);
   MoqtObject object = {
       /*track_alias=*/2,
       /*group_sequence=*/0,
@@ -1140,7 +1161,7 @@
 
   // SUBSCRIBE_OK arrives
   MoqtSubscribeOk ok = {
-      /*request_id=*/1,
+      kDefaultLocalRequestId,
       /*expires=*/quic::QuicTimeDelta::FromMilliseconds(0),
       /*group_order=*/MoqtDeliveryOrder::kAscending,
       /*largest_location=*/std::nullopt,
@@ -1156,7 +1177,8 @@
   MockSubscribeRemoteTrackVisitor visitor;
   FullTrackName ftn("foo", "bar");
   std::string payload = "deadbeef";
-  MoqtSessionPeer::CreateRemoteTrack(&session_, DefaultSubscribe(), &visitor);
+  MoqtSessionPeer::CreateRemoteTrack(&session_, DefaultLocalSubscribe(),
+                                     &visitor);
   MoqtObject object = {
       /*track_alias=*/2,
       /*group_sequence=*/0,
@@ -1185,7 +1207,7 @@
 
   // SUBSCRIBE_ERROR arrives
   MoqtSubscribeError subscribe_error = {
-      /*request_id=*/1,
+      kDefaultLocalRequestId,
       /*error_code=*/RequestErrorCode::kRetryTrackAlias,
       /*reason_phrase=*/"foo",
       /*track_alias =*/3,
@@ -1203,11 +1225,12 @@
 
 TEST_F(MoqtSessionTest, SubscribeErrorWithTrackAlias) {
   MockSubscribeRemoteTrackVisitor visitor;
-  MoqtSessionPeer::CreateRemoteTrack(&session_, DefaultSubscribe(), &visitor);
+  MoqtSessionPeer::CreateRemoteTrack(&session_, DefaultLocalSubscribe(),
+                                     &visitor);
 
   // SUBSCRIBE_ERROR arrives
   MoqtSubscribeError subscribe_error = {
-      /*request_id=*/1,
+      kDefaultLocalRequestId,
       /*error_code=*/RequestErrorCode::kRetryTrackAlias,
       /*reason_phrase=*/"foo",
       /*track_alias =*/3,
@@ -1223,11 +1246,12 @@
 
 TEST_F(MoqtSessionTest, SubscribeErrorWithBadTrackAlias) {
   MockSubscribeRemoteTrackVisitor visitor;
-  MoqtSessionPeer::CreateRemoteTrack(&session_, DefaultSubscribe(), &visitor);
+  MoqtSessionPeer::CreateRemoteTrack(&session_, DefaultLocalSubscribe(),
+                                     &visitor);
 
   // SUBSCRIBE_ERROR arrives
   MoqtSubscribeError subscribe_error = {
-      /*request_id=*/1,
+      kDefaultLocalRequestId,
       /*error_code=*/RequestErrorCode::kRetryTrackAlias,
       /*reason_phrase=*/"foo",
       /*track_alias =*/2,
@@ -2572,6 +2596,7 @@
   auto parameters = std::make_optional<VersionSpecificParameters>(
       AuthTokenType::kOutOfBand, "foo");
   MoqtSubscribeAnnounces announces = {
+      /*request_id=*/1,
       track_namespace,
       *parameters,
   };
@@ -2599,6 +2624,7 @@
   auto parameters = std::make_optional<VersionSpecificParameters>(
       AuthTokenType::kOutOfBand, "foo");
   MoqtSubscribeAnnounces announces = {
+      /*request_id=*/1,
       track_namespace,
       *parameters,
   };
@@ -3206,8 +3232,7 @@
       mock_stream_,
       Writev(ControlMessageOfType(MoqtMessageType::kSubscribeAnnouncesError),
              _));
-  stream_input->OnSubscribeAnnouncesMessage(
-      MoqtSubscribeAnnounces(TrackNamespace("foo")));
+  stream_input->OnSubscribeAnnouncesMessage(MoqtSubscribeAnnounces(7));
   // Block all outgoing SUBSCRIBE, ANNOUNCE, GOAWAY,etc.
   EXPECT_CALL(mock_stream_, Writev).Times(0);
   MockSubscribeRemoteTrackVisitor remote_track_visitor;
diff --git a/quiche/quic/moqt/test_tools/moqt_test_message.h b/quiche/quic/moqt/test_tools/moqt_test_message.h
index cee1e60..1039053 100644
--- a/quiche/quic/moqt/test_tools/moqt_test_message.h
+++ b/quiche/quic/moqt/test_tools/moqt_test_message.h
@@ -1133,6 +1133,10 @@
 
   bool EqualFieldValues(MessageStructuredData& values) const override {
     auto cast = std::get<MoqtSubscribeAnnounces>(values);
+    if (cast.request_id != subscribe_namespace_.request_id) {
+      QUIC_LOG(INFO) << "SUBSCRIBE_NAMESPACE request_id mismatch";
+      return false;
+    }
     if (cast.track_namespace != subscribe_namespace_.track_namespace) {
       QUIC_LOG(INFO) << "SUBSCRIBE_NAMESPACE track namespace mismatch";
       return false;
@@ -1144,20 +1148,22 @@
     return true;
   }
 
-  void ExpandVarints() override { ExpandVarintsImpl("vv---vvv-----"); }
+  void ExpandVarints() override { ExpandVarintsImpl("vvv---vvv-----"); }
 
   MessageStructuredData structured_data() const override {
     return TestMessageBase::MessageStructuredData(subscribe_namespace_);
   }
 
  private:
-  uint8_t raw_packet_[16] = {
-      0x11, 0x00, 0x0d, 0x01, 0x03, 0x66, 0x6f, 0x6f,  // namespace = "foo"
-      0x01,                                            // 1 parameter
+  uint8_t raw_packet_[17] = {
+      0x11, 0x00, 0x0e, 0x01,                    // request_id = 1
+      0x01, 0x03, 0x66, 0x6f, 0x6f,              // namespace = "foo"
+      0x01,                                      // 1 parameter
       0x01, 0x05, 0x03, 0x00, 0x62, 0x61, 0x72,  // authorization_tag = "bar"
   };
 
   MoqtSubscribeAnnounces subscribe_namespace_ = {
+      /*request_id=*/1,
       TrackNamespace("foo"),
       VersionSpecificParameters(AuthTokenType::kOutOfBand, "bar"),
   };
@@ -1171,26 +1177,26 @@
 
   bool EqualFieldValues(MessageStructuredData& values) const override {
     auto cast = std::get<MoqtSubscribeAnnouncesOk>(values);
-    if (cast.track_namespace != subscribe_namespace_ok_.track_namespace) {
-      QUIC_LOG(INFO) << "SUBSCRIBE_NAMESPACE_OK track namespace mismatch";
+    if (cast.request_id != subscribe_namespace_ok_.request_id) {
+      QUIC_LOG(INFO) << "SUBSCRIBE_NAMESPACE_OK request_id mismatch";
       return false;
     }
     return true;
   }
 
-  void ExpandVarints() override { ExpandVarintsImpl("vv---"); }
+  void ExpandVarints() override { ExpandVarintsImpl("v"); }
 
   MessageStructuredData structured_data() const override {
     return TestMessageBase::MessageStructuredData(subscribe_namespace_ok_);
   }
 
  private:
-  uint8_t raw_packet_[8] = {
-      0x12, 0x00, 0x05, 0x01, 0x03, 0x66, 0x6f, 0x6f,  // namespace = "foo"
+  uint8_t raw_packet_[4] = {
+      0x12, 0x00, 0x01, 0x01,  // request_id = 1
   };
 
   MoqtSubscribeAnnouncesOk subscribe_namespace_ok_ = {
-      TrackNamespace("foo"),
+      /*request_id=*/1,
   };
 };
 
@@ -1202,39 +1208,38 @@
 
   bool EqualFieldValues(MessageStructuredData& values) const override {
     auto cast = std::get<MoqtSubscribeAnnouncesError>(values);
-    if (cast.track_namespace != subscribe_namespace_error_.track_namespace) {
-      QUIC_LOG(INFO) << "SUBSCRIBE_NAMESPACE_ERROR track namespace mismatch";
+    if (cast.request_id != subscribe_namespace_error_.request_id) {
+      QUIC_LOG(INFO) << "SUBSCRIBE_NAMESPACE_ERROR request_id mismatch";
       return false;
     }
     if (cast.error_code != subscribe_namespace_error_.error_code) {
       QUIC_LOG(INFO) << "SUBSCRIBE_NAMESPACE_ERROR error code mismatch";
       return false;
     }
-    if (cast.reason_phrase != subscribe_namespace_error_.reason_phrase) {
-      QUIC_LOG(INFO) << "SUBSCRIBE_NAMESPACE_ERROR reason phrase mismatch";
+    if (cast.error_reason != subscribe_namespace_error_.error_reason) {
+      QUIC_LOG(INFO) << "SUBSCRIBE_NAMESPACE_ERROR error reason mismatch";
       return false;
     }
     return true;
   }
 
-  void ExpandVarints() override { ExpandVarintsImpl("vv---vv---"); }
+  void ExpandVarints() override { ExpandVarintsImpl("vvv---"); }
 
   MessageStructuredData structured_data() const override {
     return TestMessageBase::MessageStructuredData(subscribe_namespace_error_);
   }
 
  private:
-  uint8_t raw_packet_[13] = {
-      0x13, 0x00, 0x0a, 0x01,
-      0x03, 0x66, 0x6f, 0x6f,  // track_namespace = "foo"
+  uint8_t raw_packet_[9] = {
+      0x13, 0x00, 0x06, 0x01,  // request_id = 1
       0x01,                    // error_code = 1
-      0x03, 0x62, 0x61, 0x72,  // reason_phrase = "bar"
+      0x03, 0x62, 0x61, 0x72,  // error_reason = "bar"
   };
 
   MoqtSubscribeAnnouncesError subscribe_namespace_error_ = {
-      TrackNamespace("foo"),
+      /*request_id=*/1,
       /*error_code=*/RequestErrorCode::kUnauthorized,
-      /*reason_phrase=*/"bar",
+      /*error_reason=*/"bar",
   };
 };