diff --git a/quiche/quic/moqt/moqt_integration_test.cc b/quiche/quic/moqt/moqt_integration_test.cc
index e3c05f4..0b2f572 100644
--- a/quiche/quic/moqt/moqt_integration_test.cc
+++ b/quiche/quic/moqt/moqt_integration_test.cc
@@ -94,11 +94,10 @@
                              MockSubscribeRemoteTrackVisitor* visitor) {
     bool received_ok = false;
     EXPECT_CALL(*visitor, OnReply)
-        .WillOnce(
-            [&](const FullTrackName&,
-                std::variant<SubscribeOkData, MoqtRequestError> response) {
-              received_ok = std::holds_alternative<SubscribeOkData>(response);
-            });
+        .WillOnce([&](const FullTrackName&,
+                      std::variant<SubscribeOkData, MoqtErrorPair> response) {
+          received_ok = std::holds_alternative<SubscribeOkData>(response);
+        });
     client_->session()->SubscribeCurrentObject(track_name, visitor,
                                                VersionSpecificParameters());
     bool success =
@@ -113,7 +112,7 @@
   MockSessionCallbacks server_callbacks_;
   MockSubscribeRemoteTrackVisitor subscribe_visitor_;
   testing::MockFunction<void(TrackNamespace track_namespace,
-                             std::optional<MoqtRequestError> error_message)>
+                             std::optional<MoqtErrorPair> error_message)>
       outgoing_publish_namespace_callback_;
   std::unique_ptr<MoqtClientEndpoint> client_;
   std::unique_ptr<MoqtServerEndpoint> server_;
@@ -177,9 +176,8 @@
                    MoqtResponseCallback callback) {
         std::move(callback)(std::nullopt);
       });
-  testing::MockFunction<void(
-      TrackNamespace track_namespace,
-      std::optional<MoqtPublishNamespaceErrorReason> error_message)>
+  testing::MockFunction<void(TrackNamespace track_namespace,
+                             std::optional<MoqtErrorPair> error_message)>
       publish_namespace_callback;
   client_->session()->PublishNamespace(
       TrackNamespace{"foo"}, publish_namespace_callback.AsStdFunction(),
@@ -187,7 +185,7 @@
   bool matches = false;
   EXPECT_CALL(publish_namespace_callback, Call(_, _))
       .WillOnce([&](TrackNamespace track_namespace,
-                    std::optional<MoqtPublishNamespaceErrorReason> error) {
+                    std::optional<MoqtErrorPair> error) {
         matches = true;
         EXPECT_EQ(track_namespace, TrackNamespace{"foo"});
         EXPECT_FALSE(error.has_value());
@@ -221,9 +219,8 @@
                    MoqtResponseCallback callback) {
         std::move(callback)(std::nullopt);
       });
-  testing::MockFunction<void(
-      TrackNamespace track_namespace,
-      std::optional<MoqtPublishNamespaceErrorReason> error_message)>
+  testing::MockFunction<void(TrackNamespace track_namespace,
+                             std::optional<MoqtErrorPair> error_message)>
       publish_namespace_callback;
   client_->session()->PublishNamespace(
       TrackNamespace{"foo"}, publish_namespace_callback.AsStdFunction(),
@@ -231,7 +228,7 @@
   bool matches = false;
   EXPECT_CALL(publish_namespace_callback, Call(_, _))
       .WillOnce([&](TrackNamespace track_namespace,
-                    std::optional<MoqtPublishNamespaceErrorReason> error) {
+                    std::optional<MoqtErrorPair> error) {
         matches = true;
         EXPECT_EQ(track_namespace, TrackNamespace{"foo"});
         EXPECT_FALSE(error.has_value());
@@ -242,7 +239,7 @@
   matches = false;
   EXPECT_CALL(publish_namespace_callback, Call(_, _))
       .WillOnce([&](TrackNamespace track_namespace,
-                    std::optional<MoqtPublishNamespaceErrorReason> error) {
+                    std::optional<MoqtErrorPair> error) {
         matches = true;
         EXPECT_EQ(track_namespace, TrackNamespace{"foo"});
         ASSERT_TRUE(error.has_value());
@@ -273,7 +270,7 @@
   bool matches = false;
   EXPECT_CALL(outgoing_publish_namespace_callback_, Call)
       .WillOnce([&](TrackNamespace track_namespace,
-                    std::optional<MoqtRequestError> error) {
+                    std::optional<MoqtErrorPair> error) {
         EXPECT_EQ(track_namespace, TrackNamespace{"foo"});
         FullTrackName track_name(track_namespace, "/catalog");
         EXPECT_FALSE(error.has_value());
@@ -281,7 +278,7 @@
             track_name, &subscribe_visitor_, VersionSpecificParameters());
       })
       .WillOnce([&](TrackNamespace track_namespace,
-                    std::optional<MoqtRequestError> error) {
+                    std::optional<MoqtErrorPair> error) {
         EXPECT_EQ(track_namespace, TrackNamespace{"foo"});
         EXPECT_TRUE(error.has_value());
       });
@@ -329,7 +326,7 @@
   });
   client_->session()->PublishNamespace(
       TrackNamespace{"test"},
-      [](TrackNamespace, std::optional<MoqtRequestError>) {}, *parameters);
+      [](TrackNamespace, std::optional<MoqtErrorPair>) {}, *parameters);
   bool success = test_harness_.RunUntilWithDefaultTimeout(
       [&]() { return received_subscribe_ok; });
   EXPECT_TRUE(success);
@@ -386,12 +383,11 @@
                                                VersionSpecificParameters());
     std::optional<Location> largest_id;
     EXPECT_CALL(subscribe_visitor_, OnReply)
-        .WillOnce(
-            [&](const FullTrackName&,
-                std::variant<SubscribeOkData, MoqtRequestError> response) {
-              EXPECT_TRUE(std::holds_alternative<SubscribeOkData>(response));
-              largest_id = std::get<SubscribeOkData>(response).largest_location;
-            });
+        .WillOnce([&](const FullTrackName&,
+                      std::variant<SubscribeOkData, MoqtErrorPair> response) {
+          EXPECT_TRUE(std::holds_alternative<SubscribeOkData>(response));
+          largest_id = std::get<SubscribeOkData>(response).largest_location;
+        });
     bool success = test_harness_.RunUntilWithDefaultTimeout([&]() {
       return largest_id.has_value() && *largest_id == Location(0, 2);
     });
@@ -528,9 +524,8 @@
 
 TEST_F(MoqtIntegrationTest, PublishNamespaceFailure) {
   EstablishSession();
-  testing::MockFunction<void(
-      TrackNamespace track_namespace,
-      std::optional<MoqtPublishNamespaceErrorReason> error_message)>
+  testing::MockFunction<void(TrackNamespace track_namespace,
+                             std::optional<MoqtErrorPair> error_message)>
       publish_namespace_callback;
   client_->session()->PublishNamespace(
       TrackNamespace{"foo"}, publish_namespace_callback.AsStdFunction(),
@@ -538,7 +533,7 @@
   bool matches = false;
   EXPECT_CALL(publish_namespace_callback, Call(_, _))
       .WillOnce([&](TrackNamespace track_namespace,
-                    std::optional<MoqtPublishNamespaceErrorReason> error) {
+                    std::optional<MoqtErrorPair> error) {
         matches = true;
         EXPECT_EQ(track_namespace, TrackNamespace{"foo"});
         ASSERT_TRUE(error.has_value());
@@ -570,7 +565,7 @@
       });
   EXPECT_CALL(subscribe_visitor_, OnReply)
       .WillOnce([&](const FullTrackName&,
-                    std::variant<SubscribeOkData, MoqtRequestError> response) {
+                    std::variant<SubscribeOkData, MoqtErrorPair> response) {
         received_ok = std::holds_alternative<SubscribeOkData>(response);
       });
   client_->session()->SubscribeAbsolute(
@@ -601,7 +596,7 @@
       });
   EXPECT_CALL(subscribe_visitor_, OnReply)
       .WillOnce([&](const FullTrackName&,
-                    std::variant<SubscribeOkData, MoqtRequestError> response) {
+                    std::variant<SubscribeOkData, MoqtErrorPair> response) {
         received_ok = std::holds_alternative<SubscribeOkData>(response);
       });
   client_->session()->SubscribeCurrentObject(
@@ -632,7 +627,7 @@
       });
   EXPECT_CALL(subscribe_visitor_, OnReply)
       .WillOnce([&](const FullTrackName&,
-                    std::variant<SubscribeOkData, MoqtRequestError> response) {
+                    std::variant<SubscribeOkData, MoqtErrorPair> response) {
         received_ok = std::holds_alternative<SubscribeOkData>(response);
       });
   client_->session()->SubscribeNextGroup(full_track_name, &subscribe_visitor_,
@@ -648,8 +643,8 @@
   bool received_ok = false;
   EXPECT_CALL(subscribe_visitor_, OnReply)
       .WillOnce([&](const FullTrackName&,
-                    std::variant<SubscribeOkData, MoqtRequestError> response) {
-        received_ok = std::holds_alternative<MoqtRequestError>(response);
+                    std::variant<SubscribeOkData, MoqtErrorPair> response) {
+        received_ok = std::holds_alternative<MoqtErrorPair>(response);
       });
   client_->session()->SubscribeCurrentObject(
       full_track_name, &subscribe_visitor_, VersionSpecificParameters());
@@ -698,8 +693,8 @@
       full_track_name, &subscribe_visitor_, VersionSpecificParameters()));
   EXPECT_CALL(subscribe_visitor_, OnReply)
       .WillOnce([](const FullTrackName&,
-                   std::variant<SubscribeOkData, MoqtRequestError> response) {
-        EXPECT_TRUE(std::holds_alternative<MoqtRequestError>(response));
+                   std::variant<SubscribeOkData, MoqtErrorPair> response) {
+        EXPECT_TRUE(std::holds_alternative<MoqtErrorPair>(response));
       });  // Teardown
 }
 
@@ -730,7 +725,7 @@
       });
   EXPECT_CALL(subscribe_visitor_, OnReply)
       .WillOnce([&](const FullTrackName&,
-                    std::variant<SubscribeOkData, MoqtRequestError>) {
+                    std::variant<SubscribeOkData, MoqtErrorPair>) {
         ack_function(10, 20, quic::QuicTimeDelta::FromMicroseconds(-123));
         ack_function(100, 200, quic::QuicTimeDelta::FromMicroseconds(456));
       });
@@ -779,7 +774,7 @@
   bool received_ok = false;
   EXPECT_CALL(subscribe_visitor_, OnReply)
       .WillOnce([&](const FullTrackName&,
-                    std::variant<SubscribeOkData, MoqtRequestError> response) {
+                    std::variant<SubscribeOkData, MoqtErrorPair> response) {
         received_ok = std::holds_alternative<SubscribeOkData>(response);
       });
   VersionSpecificParameters parameters;
@@ -827,7 +822,7 @@
   bool received_ok = false;
   EXPECT_CALL(subscribe_visitor_, OnReply)
       .WillOnce([&](const FullTrackName&,
-                    std::variant<SubscribeOkData, MoqtRequestError> response) {
+                    std::variant<SubscribeOkData, MoqtErrorPair> response) {
         received_ok = std::holds_alternative<SubscribeOkData>(response);
       });
   VersionSpecificParameters parameters;
@@ -911,7 +906,7 @@
   bool subscribed = false;
   EXPECT_CALL(subscribe_visitor_, OnReply)
       .WillOnce([&](const FullTrackName&,
-                    std::variant<SubscribeOkData, MoqtRequestError>) {
+                    std::variant<SubscribeOkData, MoqtErrorPair>) {
         subscribed = true;
       });
   bool success =
diff --git a/quiche/quic/moqt/moqt_messages.h b/quiche/quic/moqt/moqt_messages.h
index 1ed2b9b..c6816b3 100644
--- a/quiche/quic/moqt/moqt_messages.h
+++ b/quiche/quic/moqt/moqt_messages.h
@@ -384,13 +384,10 @@
   kExpiredAuthToken = 0x12,
 };
 
-struct MoqtRequestError {
+struct MoqtErrorPair {
   RequestErrorCode error_code;
   std::string reason_phrase;
 };
-// TODO(martinduke): These are deprecated. Replace them in the code.
-using MoqtSubscribeErrorReason = MoqtRequestError;
-using MoqtPublishNamespaceErrorReason = MoqtSubscribeErrorReason;
 
 // Location as defined in
 // https://moq-wg.github.io/moq-transport/draft-ietf-moq-transport.html#location-structure
diff --git a/quiche/quic/moqt/moqt_outgoing_queue_test.cc b/quiche/quic/moqt/moqt_outgoing_queue_test.cc
index 53b0833..014999e 100644
--- a/quiche/quic/moqt/moqt_outgoing_queue_test.cc
+++ b/quiche/quic/moqt/moqt_outgoing_queue_test.cc
@@ -98,8 +98,7 @@
               ());
   MOCK_METHOD(void, OnTrackPublisherGone, (), (override));
   MOCK_METHOD(void, OnSubscribeAccepted, (), (override));
-  MOCK_METHOD(void, OnSubscribeRejected, (MoqtSubscribeErrorReason reason),
-              (override));
+  MOCK_METHOD(void, OnSubscribeRejected, (MoqtErrorPair reason), (override));
 };
 
 absl::StatusOr<std::vector<std::string>> FetchToVector(
diff --git a/quiche/quic/moqt/moqt_publisher.h b/quiche/quic/moqt/moqt_publisher.h
index 3ed6a6f..6096799 100644
--- a/quiche/quic/moqt/moqt_publisher.h
+++ b/quiche/quic/moqt/moqt_publisher.h
@@ -31,7 +31,7 @@
   virtual void OnSubscribeAccepted() = 0;
   // Called when the publisher is sure that it cannot serve the subscription.
   // This could happen synchronously or asynchronously.
-  virtual void OnSubscribeRejected(MoqtSubscribeErrorReason reason) = 0;
+  virtual void OnSubscribeRejected(MoqtErrorPair reason) = 0;
 
   // Notifies that a new object is available on the track.  The object payload
   // itself may be retrieved via GetCachedObject method of the associated track
diff --git a/quiche/quic/moqt/moqt_relay_publisher_test.cc b/quiche/quic/moqt/moqt_relay_publisher_test.cc
index b844726..2ee9a8d 100644
--- a/quiche/quic/moqt/moqt_relay_publisher_test.cc
+++ b/quiche/quic/moqt/moqt_relay_publisher_test.cc
@@ -75,10 +75,10 @@
 
 TEST_F(MoqtRelayPublisherTest, PublishNamespaceLifecycle) {
   EXPECT_EQ(publisher_.GetTrack(FullTrackName("foo", "bar")), nullptr);
-  std::optional<MoqtRequestError> response;
+  std::optional<MoqtErrorPair> response;
   publisher_.OnPublishNamespace(
       TrackNamespace({"foo"}), VersionSpecificParameters(), &session_,
-      [&](std::optional<MoqtRequestError> error_response) {
+      [&](std::optional<MoqtErrorPair> error_response) {
         response = error_response;
       });
   EXPECT_EQ(response, std::nullopt);
diff --git a/quiche/quic/moqt/moqt_relay_track_publisher.cc b/quiche/quic/moqt/moqt_relay_track_publisher.cc
index 5ca8496..4b9e9e7 100644
--- a/quiche/quic/moqt/moqt_relay_track_publisher.cc
+++ b/quiche/quic/moqt/moqt_relay_track_publisher.cc
@@ -27,12 +27,12 @@
 
 void MoqtRelayTrackPublisher::OnReply(
     const FullTrackName&,
-    std::variant<SubscribeOkData, MoqtRequestError> response) {
+    std::variant<SubscribeOkData, MoqtErrorPair> response) {
   if (is_closing_) {
     return;
   }
-  if (std::holds_alternative<MoqtRequestError>(response)) {
-    auto request_error = std::get<MoqtRequestError>(response);
+  if (std::holds_alternative<MoqtErrorPair>(response)) {
+    auto request_error = std::get<MoqtErrorPair>(response);
     // Delete upstream_ to avoid sending UNSUBSCRIBE.
     upstream_ = quiche::QuicheWeakPtr<MoqtSessionInterface>();
     // Sessions will delete listeners, causing the track to delete itself.
@@ -301,7 +301,7 @@
     MoqtSessionInterface* session = upstream_.GetIfAvailable();
     if (session == nullptr) {
       // upstream went away, reject the subscribe.
-      listener->OnSubscribeRejected(MoqtRequestError{
+      listener->OnSubscribeRejected(MoqtErrorPair{
           RequestErrorCode::kInternalError,
           "The upstream session was closed before a subscription could be "
           "established."});
diff --git a/quiche/quic/moqt/moqt_relay_track_publisher.h b/quiche/quic/moqt/moqt_relay_track_publisher.h
index 0aa2c0c..7b77829 100644
--- a/quiche/quic/moqt/moqt_relay_track_publisher.h
+++ b/quiche/quic/moqt/moqt_relay_track_publisher.h
@@ -67,9 +67,8 @@
   MoqtRelayTrackPublisher& operator=(MoqtRelayTrackPublisher&&) = default;
 
   // SubscribeVisitor implementation.
-  void OnReply(
-      const FullTrackName& full_track_name,
-      std::variant<SubscribeOkData, MoqtRequestError> response) override;
+  void OnReply(const FullTrackName& full_track_name,
+               std::variant<SubscribeOkData, MoqtErrorPair> response) override;
   // TODO(vasilvv): Implement this if we want to support Object Acks across
   // relays.
   void OnCanAckObjects(MoqtObjectAckFunction /*ack_function*/) override {}
diff --git a/quiche/quic/moqt/moqt_relay_track_publisher_test.cc b/quiche/quic/moqt/moqt_relay_track_publisher_test.cc
index c5add6d..c75c70c 100644
--- a/quiche/quic/moqt/moqt_relay_track_publisher_test.cc
+++ b/quiche/quic/moqt/moqt_relay_track_publisher_test.cc
@@ -28,8 +28,7 @@
 class MockMoqtObjectListener : public MoqtObjectListener {
  public:
   MOCK_METHOD(void, OnSubscribeAccepted, (), (override));
-  MOCK_METHOD(void, OnSubscribeRejected, (MoqtSubscribeErrorReason reason),
-              (override));
+  MOCK_METHOD(void, OnSubscribeRejected, (MoqtErrorPair reason), (override));
   MOCK_METHOD(void, OnNewObjectAvailable,
               (Location sequence, uint64_t subgroup,
                MoqtPriority publisher_priority,
@@ -310,9 +309,8 @@
   EXPECT_CALL(listener_, OnSubscribeRejected).WillOnce([this] {
     publisher_.RemoveObjectListener(&listener_);
   });
-  publisher_.OnReply(
-      kTrackName,
-      MoqtRequestError{RequestErrorCode::kUnauthorized, "Unauthorized"});
+  publisher_.OnReply(kTrackName, MoqtErrorPair{RequestErrorCode::kUnauthorized,
+                                               "Unauthorized"});
   EXPECT_TRUE(track_deleted_);
 }
 
diff --git a/quiche/quic/moqt/moqt_session.cc b/quiche/quic/moqt/moqt_session.cc
index b1c1ef6..9017753 100644
--- a/quiche/quic/moqt/moqt_session.cc
+++ b/quiche/quic/moqt/moqt_session.cc
@@ -325,9 +325,8 @@
   if (outgoing_publish_namespaces_.contains(track_namespace)) {
     std::move(callback)(
         track_namespace,
-        MoqtRequestError{
-            RequestErrorCode::kInternalError,
-            "PUBLISH_NAMESPACE already outstanding for namespace"});
+        MoqtErrorPair{RequestErrorCode::kInternalError,
+                      "PUBLISH_NAMESPACE already outstanding for namespace"});
     return;
   }
   if (next_request_id_ >= peer_max_request_id_) {
@@ -735,8 +734,7 @@
   if (subscribe->ErrorIsAllowed()) {
     subscribe->visitor()->OnReply(
         subscribe->full_track_name(),
-        MoqtRequestError{RequestErrorCode::kNotSupported,
-                         "Subscription closed"});
+        MoqtErrorPair{RequestErrorCode::kNotSupported, "Subscription closed"});
   } else {
     subscribe->visitor()->OnPublishDone(subscribe->full_track_name());
   }
@@ -1169,7 +1167,7 @@
   if (subscribe->visitor() != nullptr) {
     subscribe->visitor()->OnReply(
         subscribe->full_track_name(),
-        MoqtRequestError{message.error_code, message.reason_phrase});
+        MoqtErrorPair{message.error_code, message.reason_phrase});
   }
   if (!session_->is_closing_) {
     // The visitor might have closed the session.
@@ -1236,7 +1234,7 @@
       session_->GetWeakPtr();
   session_->callbacks_.incoming_publish_namespace_callback(
       message.track_namespace, message.parameters,
-      [&](std::optional<MoqtRequestError> error) {
+      [&](std::optional<MoqtErrorPair> error) {
         MoqtSession* session =
             static_cast<MoqtSession*>(session_weakptr.GetIfAvailable());
         if (session == nullptr) {
@@ -1297,7 +1295,7 @@
   }
   std::move(it2->second)(
       track_namespace,
-      MoqtRequestError{message.error_code, std::string(message.error_reason)});
+      MoqtErrorPair{message.error_code, std::string(message.error_reason)});
   session_->outgoing_publish_namespaces_.erase(it2);
 }
 
@@ -1321,7 +1319,7 @@
   }
   std::move(it->second)(
       message.track_namespace,
-      MoqtRequestError{message.error_code, std::string(message.error_reason)});
+      MoqtErrorPair{message.error_code, std::string(message.error_reason)});
   session_->outgoing_publish_namespaces_.erase(it);
 }
 
@@ -1408,7 +1406,7 @@
   }
   (session_->callbacks_.incoming_subscribe_namespace_callback)(
       message.track_namespace, message.parameters,
-      [&](std::optional<MoqtRequestError> error) {
+      [&](std::optional<MoqtErrorPair> error) {
         if (error.has_value()) {
           MoqtSubscribeNamespaceError reply;
           reply.request_id = message.request_id;
@@ -2073,7 +2071,7 @@
 }
 
 void MoqtSession::PublishedSubscription::OnSubscribeRejected(
-    MoqtSubscribeErrorReason reason) {
+    MoqtErrorPair reason) {
   session_->GetControlStream()->SendSubscribeError(
       request_id_, reason.error_code, reason.reason_phrase);
   session_->published_subscriptions_.erase(request_id_);
@@ -2573,8 +2571,8 @@
                                                    std::nullopt, nullptr);
   }
   for (auto& [track_namespace, callback] : outgoing_publish_namespaces_) {
-    callback(track_namespace, MoqtRequestError{RequestErrorCode::kUninterested,
-                                               "Session closed"});
+    callback(track_namespace,
+             MoqtErrorPair{RequestErrorCode::kUninterested, "Session closed"});
   }
   while (!upstream_by_id_.empty()) {
     auto upstream = upstream_by_id_.begin();
diff --git a/quiche/quic/moqt/moqt_session.h b/quiche/quic/moqt/moqt_session.h
index 710e543..8c8f17f 100644
--- a/quiche/quic/moqt/moqt_session.h
+++ b/quiche/quic/moqt/moqt_session.h
@@ -372,7 +372,7 @@
 
     // MoqtObjectListener implementation.
     void OnSubscribeAccepted() override;
-    void OnSubscribeRejected(MoqtSubscribeErrorReason reason) override;
+    void OnSubscribeRejected(MoqtErrorPair reason) override;
     // This is only called for objects that have just arrived.
     void OnNewObjectAvailable(
         Location location, uint64_t subgroup, MoqtPriority publisher_priority,
@@ -648,7 +648,7 @@
       // No class access below this line!
     }
 
-    void OnSubscribeRejected(MoqtSubscribeErrorReason error_reason) override {
+    void OnSubscribeRejected(MoqtErrorPair error_reason) override {
       MoqtTrackStatusError track_status_error;
       track_status_error.request_id = request_id_;
       track_status_error.error_code = error_reason.error_code;
@@ -669,8 +669,8 @@
     void OnGroupAbandoned(uint64_t /*group_id*/) override {}
     void OnTrackPublisherGone() override {
       publisher_ = nullptr;
-      OnSubscribeRejected(MoqtSubscribeErrorReason(
-          RequestErrorCode::kTrackDoesNotExist, "Track publisher gone"));
+      OnSubscribeRejected(MoqtErrorPair(RequestErrorCode::kTrackDoesNotExist,
+                                        "Track publisher gone"));
     }
 
    private:
diff --git a/quiche/quic/moqt/moqt_session_callbacks.h b/quiche/quic/moqt/moqt_session_callbacks.h
index e8a238d..541308a 100644
--- a/quiche/quic/moqt/moqt_session_callbacks.h
+++ b/quiche/quic/moqt/moqt_session_callbacks.h
@@ -20,7 +20,7 @@
 // once; if the argument is nullopt, an OK response was received. Otherwise, an
 // ERROR response was received.
 using MoqtResponseCallback =
-    quiche::SingleUseCallback<void(std::optional<MoqtRequestError>)>;
+    quiche::SingleUseCallback<void(std::optional<MoqtErrorPair>)>;
 
 // Called when the SETUP message from the peer is received.
 using MoqtSessionEstablishedCallback = quiche::SingleUseCallback<void()>;
@@ -59,7 +59,7 @@
   if (callback == nullptr) {
     return;
   }
-  return std::move(callback)(MoqtRequestError{
+  return std::move(callback)(MoqtErrorPair{
       RequestErrorCode::kNotSupported,
       "This endpoint does not support incoming SUBSCRIBE_NAMESPACE messages"});
 };
diff --git a/quiche/quic/moqt/moqt_session_interface.h b/quiche/quic/moqt/moqt_session_interface.h
index 677ba61..3e6736b 100644
--- a/quiche/quic/moqt/moqt_session_interface.h
+++ b/quiche/quic/moqt/moqt_session_interface.h
@@ -41,7 +41,7 @@
   // automatically retry.
   virtual void OnReply(
       const FullTrackName& full_track_name,
-      std::variant<SubscribeOkData, MoqtRequestError> response) = 0;
+      std::variant<SubscribeOkData, MoqtErrorPair> response) = 0;
   // Called when the subscription process is far enough that it is possible to
   // send OBJECT_ACK messages; provides a callback to do so. The callback is
   // valid for as long as the session is valid.
@@ -79,9 +79,8 @@
 // PUBLISH_NAMESPACE state immediately after calling this callback.
 // Alternatively, the application can call PublishNamespaceDone() to delete the
 // state.
-using MoqtOutgoingPublishNamespaceCallback =
-    quiche::MultiUseCallback<void(const TrackNamespace& track_namespace,
-                                  std::optional<MoqtRequestError> error)>;
+using MoqtOutgoingPublishNamespaceCallback = quiche::MultiUseCallback<void(
+    const TrackNamespace& track_namespace, std::optional<MoqtErrorPair> error)>;
 
 using MoqtOutgoingSubscribeNamespaceCallback = quiche::SingleUseCallback<void(
     TrackNamespace track_namespace, std::optional<RequestErrorCode> error,
diff --git a/quiche/quic/moqt/moqt_session_test.cc b/quiche/quic/moqt/moqt_session_test.cc
index 6ec6709..887debc 100644
--- a/quiche/quic/moqt/moqt_session_test.cc
+++ b/quiche/quic/moqt/moqt_session_test.cc
@@ -392,7 +392,7 @@
 
 TEST_F(MoqtSessionTest, PublishNamespaceWithOkAndCancel) {
   testing::MockFunction<void(TrackNamespace track_namespace,
-                             std::optional<MoqtRequestError> error_message)>
+                             std::optional<MoqtErrorPair> error_message)>
       publish_namespace_resolved_callback;
   std::unique_ptr<MoqtControlParserVisitor> stream_input =
       MoqtSessionPeer::CreateControlStream(&session_, &mock_stream_);
@@ -409,7 +409,7 @@
   };
   EXPECT_CALL(publish_namespace_resolved_callback, Call(_, _))
       .WillOnce([&](TrackNamespace track_namespace,
-                    std::optional<MoqtRequestError> error) {
+                    std::optional<MoqtErrorPair> error) {
         EXPECT_EQ(track_namespace, TrackNamespace("foo"));
         EXPECT_FALSE(error.has_value());
       });
@@ -422,7 +422,7 @@
   };
   EXPECT_CALL(publish_namespace_resolved_callback, Call(_, _))
       .WillOnce([&](TrackNamespace track_namespace,
-                    std::optional<MoqtRequestError> error) {
+                    std::optional<MoqtErrorPair> error) {
         EXPECT_EQ(track_namespace, TrackNamespace("foo"));
         ASSERT_TRUE(error.has_value());
         EXPECT_EQ(error->error_code, RequestErrorCode::kInternalError);
@@ -435,7 +435,7 @@
 
 TEST_F(MoqtSessionTest, PublishNamespaceWithOkAndPublishNamespaceDone) {
   testing::MockFunction<void(TrackNamespace track_namespace,
-                             std::optional<MoqtRequestError> error_message)>
+                             std::optional<MoqtErrorPair> error_message)>
       publish_namespace_resolved_callback;
   std::unique_ptr<MoqtControlParserVisitor> stream_input =
       MoqtSessionPeer::CreateControlStream(&session_, &mock_stream_);
@@ -452,7 +452,7 @@
   };
   EXPECT_CALL(publish_namespace_resolved_callback, Call(_, _))
       .WillOnce([&](TrackNamespace track_namespace,
-                    std::optional<MoqtRequestError> error) {
+                    std::optional<MoqtErrorPair> error) {
         EXPECT_EQ(track_namespace, TrackNamespace{"foo"});
         EXPECT_FALSE(error.has_value());
       });
@@ -469,7 +469,7 @@
 
 TEST_F(MoqtSessionTest, PublishNamespaceWithError) {
   testing::MockFunction<void(TrackNamespace track_namespace,
-                             std::optional<MoqtRequestError> error_message)>
+                             std::optional<MoqtErrorPair> error_message)>
       publish_namespace_resolved_callback;
   std::unique_ptr<MoqtControlParserVisitor> stream_input =
       MoqtSessionPeer::CreateControlStream(&session_, &mock_stream_);
@@ -488,7 +488,7 @@
   };
   EXPECT_CALL(publish_namespace_resolved_callback, Call(_, _))
       .WillOnce([&](TrackNamespace track_namespace,
-                    std::optional<MoqtRequestError> error) {
+                    std::optional<MoqtErrorPair> error) {
         EXPECT_EQ(track_namespace, TrackNamespace{"foo"});
         ASSERT_TRUE(error.has_value());
         EXPECT_EQ(error->error_code, RequestErrorCode::kInternalError);
@@ -531,7 +531,7 @@
       mock_stream_,
       Writev(ControlMessageOfType(MoqtMessageType::kSubscribeError), _));
   listener->OnSubscribeRejected(
-      MoqtSubscribeErrorReason(RequestErrorCode::kInternalError, "Test error"));
+      MoqtErrorPair(RequestErrorCode::kInternalError, "Test error"));
   EXPECT_EQ(MoqtSessionPeer::GetSubscription(&session_, kDefaultPeerRequestId),
             nullptr);
 }
@@ -547,8 +547,8 @@
             mock_stream_,
             Writev(ControlMessageOfType(MoqtMessageType::kSubscribeError), _));
         EXPECT_CALL(*track, RemoveObjectListener);
-        listener->OnSubscribeRejected(MoqtSubscribeErrorReason(
-            RequestErrorCode::kInternalError, "Test error"));
+        listener->OnSubscribeRejected(
+            MoqtErrorPair(RequestErrorCode::kInternalError, "Test error"));
       });
   stream_input->OnSubscribeMessage(request);
   EXPECT_EQ(MoqtSessionPeer::GetSubscription(&session_, kDefaultPeerRequestId),
@@ -745,7 +745,7 @@
   };
   EXPECT_CALL(remote_track_visitor_, OnReply)
       .WillOnce([&](const FullTrackName& ftn,
-                    std::variant<SubscribeOkData, MoqtRequestError> response) {
+                    std::variant<SubscribeOkData, MoqtErrorPair> response) {
         EXPECT_EQ(ftn, FullTrackName("foo", "bar"));
         EXPECT_TRUE(std::holds_alternative<SubscribeOkData>(response));
       });
@@ -780,7 +780,7 @@
   };
   EXPECT_CALL(remote_track_visitor_, OnReply)
       .WillOnce([&](const FullTrackName& ftn,
-                    std::variant<SubscribeOkData, MoqtRequestError> response) {
+                    std::variant<SubscribeOkData, MoqtErrorPair> response) {
         EXPECT_EQ(ftn, FullTrackName("foo", "bar"));
         EXPECT_TRUE(std::holds_alternative<SubscribeOkData>(response));
       });
@@ -918,10 +918,10 @@
   };
   EXPECT_CALL(remote_track_visitor_, OnReply)
       .WillOnce([&](const FullTrackName& ftn,
-                    std::variant<SubscribeOkData, MoqtRequestError> response) {
+                    std::variant<SubscribeOkData, MoqtErrorPair> response) {
         EXPECT_EQ(ftn, FullTrackName("foo", "bar"));
-        EXPECT_TRUE(std::holds_alternative<MoqtRequestError>(response) &&
-                    std::get<MoqtRequestError>(response).reason_phrase ==
+        EXPECT_TRUE(std::holds_alternative<MoqtErrorPair>(response) &&
+                    std::get<MoqtErrorPair>(response).reason_phrase ==
                         "deadbeef");
       });
   stream_input->OnSubscribeErrorMessage(error);
@@ -1022,7 +1022,7 @@
       track_namespace,
       *parameters,
   };
-  MoqtRequestError error = {
+  MoqtErrorPair error = {
       RequestErrorCode::kNotSupported,
       "deadbeef",
   };
@@ -2814,7 +2814,7 @@
                    std::optional<VersionSpecificParameters>,
                    MoqtResponseCallback callback) {
         std::move(callback)(
-            MoqtSubscribeErrorReason{RequestErrorCode::kUnauthorized, "foo"});
+            MoqtErrorPair{RequestErrorCode::kUnauthorized, "foo"});
       });
   EXPECT_CALL(
       control_stream,
@@ -3492,7 +3492,7 @@
   session_.PublishNamespace(
       TrackNamespace{"foo"},
       +[](TrackNamespace /*track_namespace*/,
-          std::optional<MoqtRequestError> /*error*/) {},
+          std::optional<MoqtErrorPair> /*error*/) {},
       VersionSpecificParameters());
   EXPECT_FALSE(session_.Fetch(
       FullTrackName{TrackNamespace("foo"), "bar"},
@@ -3558,7 +3558,7 @@
   session_.PublishNamespace(
       TrackNamespace{"foo"},
       +[](TrackNamespace /*track_namespace*/,
-          std::optional<MoqtRequestError> /*error*/) {},
+          std::optional<MoqtErrorPair> /*error*/) {},
       VersionSpecificParameters());
   EXPECT_FALSE(session_.Fetch(
       FullTrackName(TrackNamespace("foo"), "bar"),
@@ -3953,8 +3953,8 @@
             Writev(ControlMessageOfType(MoqtMessageType::kTrackStatusError),
                    _));
         EXPECT_CALL(*track, RemoveObjectListener);
-        listener->OnSubscribeRejected(MoqtSubscribeErrorReason(
-            RequestErrorCode::kInternalError, "Test error"));
+        listener->OnSubscribeRejected(
+            MoqtErrorPair(RequestErrorCode::kInternalError, "Test error"));
         executed_AddObjectListener = true;
       });
   stream_input->OnTrackStatusMessage(track_status);
@@ -3978,7 +3978,7 @@
       Writev(ControlMessageOfType(MoqtMessageType::kTrackStatusError), _));
   EXPECT_CALL(*track, RemoveObjectListener(listener));
   listener->OnSubscribeRejected(
-      MoqtSubscribeErrorReason(RequestErrorCode::kInternalError, "Test error"));
+      MoqtErrorPair(RequestErrorCode::kInternalError, "Test error"));
 }
 
 TEST_F(MoqtSessionTest, FinReportedToVisitor) {
@@ -3998,7 +3998,7 @@
   };
   EXPECT_CALL(remote_track_visitor_, OnReply)
       .WillOnce([&](const FullTrackName& ftn,
-                    std::variant<SubscribeOkData, MoqtRequestError> response) {
+                    std::variant<SubscribeOkData, MoqtErrorPair> response) {
         EXPECT_EQ(ftn, FullTrackName("foo", "bar"));
         EXPECT_TRUE(std::holds_alternative<SubscribeOkData>(response));
       });
@@ -4043,7 +4043,7 @@
   };
   EXPECT_CALL(remote_track_visitor_, OnReply)
       .WillOnce([&](const FullTrackName& ftn,
-                    std::variant<SubscribeOkData, MoqtRequestError> response) {
+                    std::variant<SubscribeOkData, MoqtErrorPair> response) {
         EXPECT_EQ(ftn, FullTrackName("foo", "bar"));
         EXPECT_TRUE(std::holds_alternative<SubscribeOkData>(response));
       });
diff --git a/quiche/quic/moqt/relay_namespace_tree.h b/quiche/quic/moqt/relay_namespace_tree.h
index bdee98e..e755bd0 100644
--- a/quiche/quic/moqt/relay_namespace_tree.h
+++ b/quiche/quic/moqt/relay_namespace_tree.h
@@ -157,7 +157,7 @@
     if (!node->publishers.empty()) {
       subscriber->PublishNamespace(
           track_namespace,
-          [](const TrackNamespace&, std::optional<MoqtRequestError>) {},
+          [](const TrackNamespace&, std::optional<MoqtErrorPair>) {},
           // TODO(martinduke): Add parameters.
           VersionSpecificParameters());
     }
@@ -189,7 +189,7 @@
         if (adding) {
           subscriber->PublishNamespace(
               track_namespace,
-              [](const TrackNamespace&, std::optional<MoqtRequestError>) {},
+              [](const TrackNamespace&, std::optional<MoqtErrorPair>) {},
               // TODO(martinduke): Add parameters.
               VersionSpecificParameters());
         } else {
diff --git a/quiche/quic/moqt/test_tools/moqt_mock_visitor.h b/quiche/quic/moqt/test_tools/moqt_mock_visitor.h
index 7ac2412..164a69e 100644
--- a/quiche/quic/moqt/test_tools/moqt_mock_visitor.h
+++ b/quiche/quic/moqt/test_tools/moqt_mock_visitor.h
@@ -188,7 +188,7 @@
  public:
   MOCK_METHOD(void, OnReply,
               (const FullTrackName& full_track_name,
-               (std::variant<SubscribeOkData, MoqtRequestError> response)),
+               (std::variant<SubscribeOkData, MoqtErrorPair> response)),
               (override));
   MOCK_METHOD(void, OnCanAckObjects, (MoqtObjectAckFunction ack_function),
               (override));
@@ -275,7 +275,7 @@
 class MockMoqtObjectListener : public MoqtObjectListener {
  public:
   MOCK_METHOD(void, OnSubscribeAccepted, (), (override));
-  MOCK_METHOD(void, OnSubscribeRejected, (MoqtRequestError), (override));
+  MOCK_METHOD(void, OnSubscribeRejected, (MoqtErrorPair), (override));
   MOCK_METHOD(void, OnNewObjectAvailable,
               (Location, uint64_t, MoqtPriority, MoqtForwardingPreference),
               (override));
diff --git a/quiche/quic/moqt/test_tools/moqt_simulator.cc b/quiche/quic/moqt/test_tools/moqt_simulator.cc
index 80fac10..7853ca0 100644
--- a/quiche/quic/moqt/test_tools/moqt_simulator.cc
+++ b/quiche/quic/moqt/test_tools/moqt_simulator.cc
@@ -196,10 +196,10 @@
 
 void ObjectReceiver::OnReply(
     const FullTrackName& full_track_name,
-    std::variant<SubscribeOkData, MoqtRequestError> response) {
+    std::variant<SubscribeOkData, MoqtErrorPair> response) {
   QUICHE_CHECK(full_track_name == TrackName());
-  if (std::holds_alternative<MoqtRequestError>(response)) {
-    MoqtRequestError error = std::get<MoqtRequestError>(response);
+  if (std::holds_alternative<MoqtErrorPair>(response)) {
+    MoqtErrorPair error = std::get<MoqtErrorPair>(response);
     QUICHE_CHECK(!error.reason_phrase.empty()) << error.reason_phrase;
   }
 }
diff --git a/quiche/quic/moqt/test_tools/moqt_simulator.h b/quiche/quic/moqt/test_tools/moqt_simulator.h
index af88bb7..d8e8b91 100644
--- a/quiche/quic/moqt/test_tools/moqt_simulator.h
+++ b/quiche/quic/moqt/test_tools/moqt_simulator.h
@@ -155,9 +155,8 @@
                           quic::QuicTimeDelta deadline)
       : clock_(clock), deadline_(deadline) {}
 
-  void OnReply(
-      const FullTrackName& full_track_name,
-      std::variant<SubscribeOkData, MoqtRequestError> response) override;
+  void OnReply(const FullTrackName& full_track_name,
+               std::variant<SubscribeOkData, MoqtErrorPair> response) override;
 
   void OnCanAckObjects(MoqtObjectAckFunction ack_function) override {
     object_ack_function_ = std::move(ack_function);
diff --git a/quiche/quic/moqt/tools/chat_client.cc b/quiche/quic/moqt/tools/chat_client.cc
index c355631..fee47e8 100644
--- a/quiche/quic/moqt/tools/chat_client.cc
+++ b/quiche/quic/moqt/tools/chat_client.cc
@@ -68,7 +68,7 @@
   std::cout << "PUBLISH_NAMESPACE for " << track_namespace.ToString() << "\n";
   if (!track_name.has_value()) {
     std::cout << "PUBLISH_NAMESPACE rejected, invalid namespace\n";
-    std::move(callback)(std::make_optional<MoqtPublishNamespaceErrorReason>(
+    std::move(callback)(std::make_optional<MoqtErrorPair>(
         RequestErrorCode::kTrackDoesNotExist, "Not a subscribed namespace"));
     return;
   }
@@ -185,7 +185,7 @@
 
 void ChatClient::RemoteTrackVisitor::OnReply(
     const FullTrackName& full_track_name,
-    std::variant<SubscribeOkData, MoqtRequestError> response) {
+    std::variant<SubscribeOkData, MoqtErrorPair> response) {
   auto it = client_->other_users_.find(full_track_name);
   if (it == client_->other_users_.end()) {
     std::cout << "Error: received reply for unknown user "
@@ -197,9 +197,9 @@
   if (std::holds_alternative<SubscribeOkData>(response)) {
     std::cout << "ACCEPTED\n";
   } else {
-    auto request_error = std::get<MoqtRequestError>(response);
+    auto request_error = std::get<MoqtErrorPair>(response);
     std::cout << "REJECTED, reason = "
-              << std::get<MoqtRequestError>(response).reason_phrase << "\n";
+              << std::get<MoqtErrorPair>(response).reason_phrase << "\n";
     client_->other_users_.erase(it);
   }
 }
@@ -247,7 +247,7 @@
   session_->set_publisher(&publisher_);
   MoqtOutgoingPublishNamespaceCallback publish_namespace_callback =
       [this](TrackNamespace track_namespace,
-             std::optional<MoqtPublishNamespaceErrorReason> reason) {
+             std::optional<MoqtErrorPair> reason) {
         if (reason.has_value()) {
           std::cout << "PUBLISH_NAMESPACE rejected, " << reason->reason_phrase
                     << "\n";
diff --git a/quiche/quic/moqt/tools/chat_client.h b/quiche/quic/moqt/tools/chat_client.h
index e71baca..a26a7a6 100644
--- a/quiche/quic/moqt/tools/chat_client.h
+++ b/quiche/quic/moqt/tools/chat_client.h
@@ -100,7 +100,7 @@
 
     void OnReply(
         const moqt::FullTrackName& full_track_name,
-        std::variant<SubscribeOkData, MoqtRequestError> response) override;
+        std::variant<SubscribeOkData, MoqtErrorPair> response) override;
 
     void OnCanAckObjects(MoqtObjectAckFunction) override {}
 
diff --git a/quiche/quic/moqt/tools/moqt_ingestion_server_bin.cc b/quiche/quic/moqt/tools/moqt_ingestion_server_bin.cc
index dd7757e..2a61655 100644
--- a/quiche/quic/moqt/tools/moqt_ingestion_server_bin.cc
+++ b/quiche/quic/moqt/tools/moqt_ingestion_server_bin.cc
@@ -129,9 +129,9 @@
           << "Rejected remote publish_namespace as it contained "
              "disallowed characters; namespace: "
           << track_namespace;
-      std::move(callback)(MoqtPublishNamespaceErrorReason{
-          RequestErrorCode::kInternalError,
-          "Track namespace contains disallowed characters"});
+      std::move(callback)(
+          MoqtErrorPair{RequestErrorCode::kInternalError,
+                        "Track namespace contains disallowed characters"});
       return;
     }
 
@@ -151,9 +151,8 @@
       subscribed_namespaces_.erase(it);
       QUICHE_LOG(ERROR) << "Failed to create directory " << directory_path
                         << "; " << status;
-      std::move(callback)(
-          MoqtPublishNamespaceErrorReason{RequestErrorCode::kInternalError,
-                                          "Failed to create output directory"});
+      std::move(callback)(MoqtErrorPair{RequestErrorCode::kInternalError,
+                                        "Failed to create output directory"});
       return;
     }
 
@@ -176,11 +175,11 @@
 
     void OnReply(
         const FullTrackName& full_track_name,
-        std::variant<SubscribeOkData, MoqtRequestError> response) override {
-      if (std::holds_alternative<MoqtRequestError>(response)) {
+        std::variant<SubscribeOkData, MoqtErrorPair> response) override {
+      if (std::holds_alternative<MoqtErrorPair>(response)) {
         QUICHE_LOG(ERROR) << "Failed to subscribe to the peer track "
                           << full_track_name << ": "
-                          << std::get<MoqtRequestError>(response).reason_phrase;
+                          << std::get<MoqtErrorPair>(response).reason_phrase;
       }
     }
 
diff --git a/quiche/quic/moqt/tools/moqt_relay_test.cc b/quiche/quic/moqt/tools/moqt_relay_test.cc
index ddb4928..e50b1f4 100644
--- a/quiche/quic/moqt/tools/moqt_relay_test.cc
+++ b/quiche/quic/moqt/tools/moqt_relay_test.cc
@@ -131,7 +131,7 @@
   // relay_ publishes a namespace, so upstream_ will route to relay_.
   relay_.client_session()->PublishNamespace(
       TrackNamespace({"foo"}),
-      [](TrackNamespace, std::optional<MoqtRequestError>) {},
+      [](TrackNamespace, std::optional<MoqtErrorPair>) {},
       VersionSpecificParameters());
   upstream_.RunOneEvent();
   // There is now an upstream session for "Foo".
@@ -187,7 +187,7 @@
   // Downstream publishes a namespace. It's stored in relay_ but upstream_
   // hasn't been notified.
   downstream_.client_session()->PublishNamespace(
-      foobar, [](TrackNamespace, std::optional<MoqtRequestError>) {},
+      foobar, [](TrackNamespace, std::optional<MoqtErrorPair>) {},
       VersionSpecificParameters());
   relay_.RunOneEvent();
   upstream_.RunOneEvent();
@@ -205,7 +205,7 @@
 
   // Downstream publishes another namespace. Everyone is notified.
   downstream_.client_session()->PublishNamespace(
-      foobaz, [](TrackNamespace, std::optional<MoqtRequestError>) {},
+      foobaz, [](TrackNamespace, std::optional<MoqtErrorPair>) {},
       VersionSpecificParameters());
   relay_.RunOneEvent();
   upstream_.RunOneEvent();