diff --git a/quiche/quic/moqt/moqt_error.cc b/quiche/quic/moqt/moqt_error.cc
index 97dbae5..4e46e5f 100644
--- a/quiche/quic/moqt/moqt_error.cc
+++ b/quiche/quic/moqt/moqt_error.cc
@@ -21,7 +21,7 @@
     case absl::StatusCode::kUnimplemented:
       return RequestErrorCode::kNotSupported;
     case absl::StatusCode::kNotFound:
-      return RequestErrorCode::kTrackDoesNotExist;
+      return RequestErrorCode::kDoesNotExist;
     case absl::StatusCode::kOutOfRange:
       return RequestErrorCode::kInvalidRange;
     case absl::StatusCode::kInvalidArgument:
@@ -43,15 +43,10 @@
       return absl::StatusCode::kDeadlineExceeded;
     case RequestErrorCode::kNotSupported:
       return absl::StatusCode::kUnimplemented;
-    case RequestErrorCode::kTrackDoesNotExist:
-      // Equivalently, kUninterested and kNamespacePrefixUnknown.
+    case RequestErrorCode::kDoesNotExist:
       return absl::StatusCode::kNotFound;
     case RequestErrorCode::kInvalidRange:
-      // Equivalently, kNamespacePrefixOverlap.
       return absl::StatusCode::kOutOfRange;
-    case RequestErrorCode::kNoObjects:
-      // Equivalently, kRetryTrackAlias.
-      return absl::StatusCode::kNotFound;
     case RequestErrorCode::kInvalidJoiningRequestId:
     case RequestErrorCode::kMalformedAuthToken:
       return absl::StatusCode::kInvalidArgument;
@@ -70,12 +65,18 @@
 absl::Status MoqtStreamErrorToStatus(webtransport::StreamErrorCode error_code,
                                      absl::string_view reason_phrase) {
   switch (error_code) {
-    case kResetCodeCanceled:
+    case kResetCodeInternalError:
+      return absl::InternalError(reason_phrase);
+    case kResetCodeCancelled:
       return absl::CancelledError(reason_phrase);
     case kResetCodeDeliveryTimeout:
       return absl::DeadlineExceededError(reason_phrase);
     case kResetCodeSessionClosed:
       return absl::AbortedError(reason_phrase);
+    case kResetCodeUnknownObjectStatus:
+      return absl::FailedPreconditionError(reason_phrase);
+    case kResetCodeTooFarBehind:
+      return absl::DeadlineExceededError(reason_phrase);
     case kResetCodeMalformedTrack:
       return absl::InvalidArgumentError(reason_phrase);
     default:
diff --git a/quiche/quic/moqt/moqt_error.h b/quiche/quic/moqt/moqt_error.h
index 085af18..7542832 100644
--- a/quiche/quic/moqt/moqt_error.h
+++ b/quiche/quic/moqt/moqt_error.h
@@ -43,13 +43,14 @@
 };
 
 // Error codes used by MoQT to reset streams.
-inline constexpr webtransport::StreamErrorCode kResetCodeUnknown = 0x00;
-inline constexpr webtransport::StreamErrorCode kResetCodeCanceled = 0x01;
+inline constexpr webtransport::StreamErrorCode kResetCodeInternalError = 0x00;
+inline constexpr webtransport::StreamErrorCode kResetCodeCancelled = 0x01;
 inline constexpr webtransport::StreamErrorCode kResetCodeDeliveryTimeout = 0x02;
 inline constexpr webtransport::StreamErrorCode kResetCodeSessionClosed = 0x03;
-// TODO(martinduke): This is not in the spec, but is needed. The number might
-// change.
-inline constexpr webtransport::StreamErrorCode kResetCodeMalformedTrack = 0x04;
+inline constexpr webtransport::StreamErrorCode kResetCodeUnknownObjectStatus =
+    0x04;
+inline constexpr webtransport::StreamErrorCode kResetCodeMalformedTrack = 0x12;
+// Proposed in a PR post draft-16.
 inline constexpr webtransport::StreamErrorCode kResetCodeTooFarBehind = 0x05;
 
 // Used for SUBSCRIBE_ERROR, PUBLISH_NAMESPACE_ERROR, PUBLISH_NAMESPACE_CANCEL,
@@ -59,20 +60,28 @@
   kUnauthorized = 0x1,
   kTimeout = 0x2,
   kNotSupported = 0x3,
-  kTrackDoesNotExist = 0x4,  // SUBSCRIBE_ERROR and FETCH_ERROR only.
-  kUninterested =
-      0x4,  // PUBLISH_NAMESPACE_ERROR and PUBLISH_NAMESPACE_CANCEL only.
-  kNamespacePrefixUnknown = 0x4,   // SUBSCRIBE_NAMESPACE_ERROR only.
-  kInvalidRange = 0x5,             // SUBSCRIBE_ERROR and FETCH_ERROR only.
-  kNamespacePrefixOverlap = 0x5,   // SUBSCRIBE_NAMESPACE_ERROR only.
-  kNoObjects = 0x6,                // FETCH_ERROR only.
-  kInvalidJoiningRequestId = 0x7,  // FETCH_ERROR only.
-  kUnknownStatusInRange = 0x8,     // FETCH_ERROR only.
-  kMalformedTrack = 0x9,
-  kMalformedAuthToken = 0x10,
-  kExpiredAuthToken = 0x12,
+  kMalformedAuthToken = 0x4,
+  kExpiredAuthToken = 0x5,
+  kDoesNotExist = 0x10,
+  kInvalidRange = 0x11,
+  kMalformedTrack = 0x12,
   kDuplicateSubscription = 0x19,
+  kUninterested = 0x20,
+  kNamespacePrefixUnknown = 0x21,
   kPrefixOverlap = 0x30,
+  kInvalidJoiningRequestId = 0x32,
+};
+
+enum class QUICHE_EXPORT PublishDoneCode : uint64_t {
+  kInternalError = 0x0,
+  kUnauthorized = 0x1,
+  kTrackEnded = 0x2,
+  kSubscriptionEnded = 0x3,
+  kGoingAway = 0x4,
+  kExpired = 0x5,
+  kTooFarBehind = 0x6,
+  kUpdateFailed = 0x8,
+  kMalformedTrack = 0x12,
 };
 
 struct MoqtRequestErrorInfo {
diff --git a/quiche/quic/moqt/moqt_messages.h b/quiche/quic/moqt/moqt_messages.h
index a05b7d7..fdb35e5 100644
--- a/quiche/quic/moqt/moqt_messages.h
+++ b/quiche/quic/moqt/moqt_messages.h
@@ -368,17 +368,6 @@
   uint64_t request_id;
 };
 
-enum class QUICHE_EXPORT PublishDoneCode : uint64_t {
-  kInternalError = 0x0,
-  kUnauthorized = 0x1,
-  kTrackEnded = 0x2,
-  kSubscriptionEnded = 0x3,
-  kGoingAway = 0x4,
-  kExpired = 0x5,
-  kTooFarBehind = 0x6,
-  kMalformedTrack = 0x7,
-};
-
 struct QUICHE_EXPORT MoqtPublishDone {
   uint64_t request_id;
   PublishDoneCode status_code;
diff --git a/quiche/quic/moqt/moqt_namespace_stream.cc b/quiche/quic/moqt/moqt_namespace_stream.cc
index 206d04c..3ac34a3 100644
--- a/quiche/quic/moqt/moqt_namespace_stream.cc
+++ b/quiche/quic/moqt/moqt_namespace_stream.cc
@@ -165,7 +165,7 @@
 
 MoqtNamespaceSubscriberStream::NamespaceTask::~NamespaceTask() {
   if (state_ != nullptr) {
-    state_->Reset(kResetCodeCanceled);
+    state_->Reset(kResetCodeCancelled);
   }
 }
 
@@ -336,7 +336,7 @@
         };
         return;
       case kError:
-        Reset(kResetCodeCanceled);
+        Reset(kResetCodeCancelled);
         return;
       case kSuccess: {
         switch (type) {
diff --git a/quiche/quic/moqt/moqt_relay_track_publisher.cc b/quiche/quic/moqt/moqt_relay_track_publisher.cc
index 05df4a7..1b44c8d 100644
--- a/quiche/quic/moqt/moqt_relay_track_publisher.cc
+++ b/quiche/quic/moqt/moqt_relay_track_publisher.cc
@@ -221,7 +221,7 @@
   for (auto& [group, group_data] : queue_) {
     for (auto& [subgroup, subgroup_data] : group_data.subgroups) {
       for (MoqtObjectListener* listener : listeners_) {
-        listener->OnSubgroupAbandoned(group, subgroup, kResetCodeCanceled);
+        listener->OnSubgroupAbandoned(group, subgroup, kResetCodeCancelled);
       }
     }
   }
@@ -265,7 +265,7 @@
   }
   for (MoqtObjectListener* listener : listeners_) {
     listener->OnSubgroupAbandoned(stream.group, stream.subgroup,
-                                  kResetCodeCanceled);
+                                  kResetCodeCancelled);
   }
 }
 
diff --git a/quiche/quic/moqt/moqt_relay_track_publisher_test.cc b/quiche/quic/moqt/moqt_relay_track_publisher_test.cc
index 37075b0..fc1cb5a 100644
--- a/quiche/quic/moqt/moqt_relay_track_publisher_test.cc
+++ b/quiche/quic/moqt/moqt_relay_track_publisher_test.cc
@@ -446,7 +446,7 @@
 TEST_F(MoqtRelayTrackPublisherTest, Reset) {
   SubscribeAndOk();
 
-  EXPECT_CALL(listener_, OnSubgroupAbandoned(2, 0, kResetCodeCanceled));
+  EXPECT_CALL(listener_, OnSubgroupAbandoned(2, 0, kResetCodeCancelled));
   publisher_.OnStreamReset(kTrackName, DataStreamIndex{2, 0});
 }
 
diff --git a/quiche/quic/moqt/moqt_session.cc b/quiche/quic/moqt/moqt_session.cc
index 441b52e..fff6197 100644
--- a/quiche/quic/moqt/moqt_session.cc
+++ b/quiche/quic/moqt/moqt_session.cc
@@ -108,8 +108,6 @@
   }
   if (parameters_.perspective == Perspective::IS_SERVER) {
     next_request_id_ = 1;
-  } else {
-    next_incoming_request_id_ = 1;
   }
   QUICHE_DCHECK(parameters_.moqt_implementation.empty());
   parameters_.moqt_implementation = kImplementationName;
@@ -712,26 +710,19 @@
   }
 
   PublishedSubscription& subscription = *it->second;
-  std::vector<webtransport::StreamId> streams_to_reset =
-      subscription.GetAllStreams();
 
   MoqtPublishDone publish_done;
   publish_done.request_id = request_id;
   publish_done.status_code = code;
   publish_done.stream_count = subscription.streams_opened();
   publish_done.error_reason = error_reason;
-  SendControlMessage(framer_.SerializePublishDone(publish_done));
-  QUIC_DLOG(INFO) << ENDPOINT << "Sent PUBLISH_DONE message for "
+  // TODO(martinduke): It is technically correct, but not good, to simply
+  // reset all the streams in order to send PUBLISH_DONE. It's better to wait
+  // until streams FIN naturally, where possible.
+  QUIC_DLOG(INFO) << ENDPOINT << "Sending PUBLISH_DONE message for "
                   << subscription.publisher().GetTrackName();
-  // Clean up the subscription
   published_subscriptions_.erase(it);
-  for (webtransport::StreamId stream_id : streams_to_reset) {
-    webtransport::Stream* stream = session_->GetStreamById(stream_id);
-    if (stream == nullptr) {
-      continue;
-    }
-    stream->ResetWithUserCode(kResetCodeCanceled);
-  }
+  SendControlMessage(framer_.SerializePublishDone(publish_done));
   return true;
 }
 
@@ -904,20 +895,27 @@
     Error(MoqtError::kTooManyRequests, "Received request with too large ID");
     return false;
   }
-  if (request_id != next_incoming_request_id_) {
-    QUICHE_DLOG(INFO) << ENDPOINT << "Request ID not monotonically increasing";
-    Error(MoqtError::kInvalidRequestId,
-          "Request ID not monotonically increasing");
+  if ((request_id % 2 == 0) !=
+      (parameters_.perspective == Perspective::IS_SERVER)) {
+    QUICHE_DLOG(INFO) << ENDPOINT << "Request ID evenness incorrect";
+    Error(MoqtError::kInvalidRequestId, "Request ID evenness incorrect");
     return false;
   }
-  next_incoming_request_id_ = request_id + 2;
+  if (published_subscriptions_.contains(request_id) ||
+      incoming_fetches_.contains(request_id) ||
+      incoming_track_status_.contains(request_id) ||
+      incoming_publish_namespaces_by_id_.contains(request_id)) {
+    QUICHE_DLOG(INFO) << ENDPOINT << "Duplicate request ID";
+    Error(MoqtError::kInvalidRequestId, "Duplicate request ID");
+    return false;
+  }
   return true;
 }
 
 void MoqtSession::UnknownBidiStream::OnCanRead() {
   if (!parser_.ReadUntilMessageTypeKnown()) {
     // Got an early FIN.
-    stream_->ResetWithUserCode(kResetCodeCanceled);
+    stream_->ResetWithUserCode(kResetCodeCancelled);
     return;
   }
   if (!parser_.message_type().has_value()) {
@@ -1030,8 +1028,9 @@
     return;
   }
   if (session_->subscribed_track_names_.contains(message.full_track_name)) {
-    session_->Error(MoqtError::kProtocolViolation,
-                    "Duplicate subscribe for track");
+    SendRequestError(message.request_id,
+                     RequestErrorCode::kDuplicateSubscription, std::nullopt,
+                     "");
     return;
   }
   const FullTrackName& track_name = message.full_track_name;
@@ -1040,7 +1039,7 @@
   if (track_publisher == nullptr) {
     QUIC_DLOG(INFO) << ENDPOINT << "SUBSCRIBE for " << track_name
                     << " rejected by the application: does not exist";
-    SendRequestError(message.request_id, RequestErrorCode::kTrackDoesNotExist,
+    SendRequestError(message.request_id, RequestErrorCode::kDoesNotExist,
                      std::nullopt, "not found");
     return;
   }
@@ -1137,9 +1136,9 @@
   if (ru_it != session_->pending_subscribe_updates_.end()) {
     auto sub_it = session_->subscribe_by_name_.find(ru_it->second.name);
     if (sub_it == session_->subscribe_by_name_.end()) {
-      std::move(ru_it->second.response_callback)(MoqtRequestErrorInfo{
-          RequestErrorCode::kTrackDoesNotExist, std::nullopt,
-          "subscription does not exist anymore"});
+      std::move(ru_it->second.response_callback)(
+          MoqtRequestErrorInfo{RequestErrorCode::kDoesNotExist, std::nullopt,
+                               "subscription does not exist anymore"});
       session_->pending_subscribe_updates_.erase(ru_it);
       return;
     }
@@ -1391,7 +1390,7 @@
   std::shared_ptr<MoqtTrackPublisher> track =
       session_->publisher_->GetTrack(message.full_track_name);
   if (track == nullptr) {
-    SendRequestError(message.request_id, RequestErrorCode::kTrackDoesNotExist,
+    SendRequestError(message.request_id, RequestErrorCode::kDoesNotExist,
                      std::nullopt, "Track does not exist");
     return;
   }
@@ -1454,7 +1453,7 @@
     if (track_publisher == nullptr) {
       QUIC_DLOG(INFO) << ENDPOINT << "FETCH for " << track_name
                       << " rejected by the application: not found";
-      SendRequestError(message.request_id, RequestErrorCode::kTrackDoesNotExist,
+      SendRequestError(message.request_id, RequestErrorCode::kDoesNotExist,
                        std::nullopt, "not found");
       return;
     }
@@ -1650,7 +1649,7 @@
                 ? session_->RemoteTrackById(message.track_alias)
                 : session_->RemoteTrackByAlias(message.track_alias);
     if (track == nullptr) {
-      stream_->SendStopSending(kResetCodeCanceled);
+      stream_->SendStopSending(kResetCodeCancelled);
       // Received object for nonexistent track.
       return;
     }
@@ -1712,7 +1711,7 @@
     UpstreamFetch::UpstreamFetchTask* task = fetch->task();
     if (task == nullptr) {
       // The application killed the FETCH.
-      stream_->SendStopSending(kResetCodeCanceled);
+      stream_->SendStopSending(kResetCodeCancelled);
       return;
     }
     if (!task->HasObject()) {
@@ -1811,7 +1810,7 @@
                         << "Received object for a track with no SUBSCRIBE";
         // This is a not a session error because there might be an UNSUBSCRIBE
         // or SUBSCRIBE_OK (containing the track alias) in flight.
-        stream_->SendStopSending(kResetCodeCanceled);
+        stream_->SendStopSending(kResetCodeCancelled);
         return;
       }
       it->second->OnStreamOpened();
@@ -1826,7 +1825,7 @@
     QUIC_DLOG(INFO) << ENDPOINT << "Received object for a track with no FETCH";
     // This is a not a session error because there might be an UNSUBSCRIBE in
     // flight.
-    stream_->SendStopSending(kResetCodeCanceled);
+    stream_->SendStopSending(kResetCodeCancelled);
     return;
   }
   if (it->second == nullptr) {
@@ -1880,8 +1879,18 @@
 }
 
 MoqtSession::PublishedSubscription::~PublishedSubscription() {
-  session_->subscribed_track_names_.erase(track_publisher_->GetTrackName());
   track_publisher_->RemoveObjectListener(this);
+  if (session_->is_closing_) {
+    return;
+  }
+  session_->subscribed_track_names_.erase(track_publisher_->GetTrackName());
+  // Reset all streams.
+  for (const webtransport::StreamId stream_id : stream_map().GetAllStreams()) {
+    webtransport::Stream* stream = session_->session_->GetStreamById(stream_id);
+    if (stream != nullptr) {
+      stream->ResetWithUserCode(kResetCodeCancelled);
+    }
+  }
 }
 
 SendStreamMap& MoqtSession::PublishedSubscription::stream_map() {
@@ -2287,7 +2296,7 @@
 MoqtSession::OutgoingDataStream::GetSubscriptionIfValid() {
   auto it = session_->published_subscriptions_.find(subscription_id_);
   if (it == session_->published_subscriptions_.end()) {
-    stream_->ResetWithUserCode(kResetCodeCanceled);
+    stream_->ResetWithUserCode(kResetCodeCancelled);
     return nullptr;
   }
 
diff --git a/quiche/quic/moqt/moqt_session.h b/quiche/quic/moqt/moqt_session.h
index b134910..d7289dd 100644
--- a/quiche/quic/moqt/moqt_session.h
+++ b/quiche/quic/moqt/moqt_session.h
@@ -677,9 +677,9 @@
     void OnGroupAbandoned(uint64_t /*group_id*/) override {}
     void OnTrackPublisherGone() override {
       publisher_ = nullptr;
-      OnSubscribeRejected(
-          MoqtRequestErrorInfo(RequestErrorCode::kTrackDoesNotExist,
-                               std::nullopt, "Track publisher gone"));
+      OnSubscribeRejected(MoqtRequestErrorInfo(RequestErrorCode::kDoesNotExist,
+                                               std::nullopt,
+                                               "Track publisher gone"));
     }
 
    private:
@@ -871,8 +871,6 @@
   SessionNamespaceTree incoming_subscribe_namespace_;
   SessionNamespaceTree outgoing_subscribe_namespace_;
 
-  // The minimum request ID the peer can use that is monotonically increasing.
-  uint64_t next_incoming_request_id_ = 0;
   // The maximum request ID sent to the peer. Peer-generated IDs must be less
   // than this value.
   uint64_t local_max_request_id_ = 0;
diff --git a/quiche/quic/moqt/moqt_session_test.cc b/quiche/quic/moqt/moqt_session_test.cc
index e77fdcd..4f0feb7 100644
--- a/quiche/quic/moqt/moqt_session_test.cc
+++ b/quiche/quic/moqt/moqt_session_test.cc
@@ -649,10 +649,8 @@
 
   request.request_id = 3;
   request.parameters.subscription_filter.emplace(Location(12, 0));
-  EXPECT_CALL(mock_session_,
-              CloseSession(static_cast<uint64_t>(MoqtError::kProtocolViolation),
-                           "Duplicate subscribe for track"))
-      .Times(1);
+  EXPECT_CALL(mock_stream_,
+              Writev(ControlMessageOfType(MoqtMessageType::kRequestError), _));
   stream_input->OnSubscribeMessage(request);
 }
 
@@ -698,16 +696,15 @@
   MoqtSubscribe request = DefaultSubscribe();
   std::unique_ptr<MoqtControlParserVisitor> stream_input =
       MoqtSessionPeer::CreateControlStream(&session_, &mock_stream_);
-  // Request for track returns REQUEST_ERROR.
-  EXPECT_CALL(mock_stream_,
-              Writev(ControlMessageOfType(MoqtMessageType::kRequestError), _));
+  MockTrackPublisher* track = CreateTrackPublisher();
+  EXPECT_CALL(*track, AddObjectListener);
   stream_input->OnSubscribeMessage(request);
 
   // Second request is a protocol violation.
   request.full_track_name = FullTrackName({"dead", "beef"});
   EXPECT_CALL(mock_session_,
               CloseSession(static_cast<uint64_t>(MoqtError::kInvalidRequestId),
-                           "Request ID not monotonically increasing"));
+                           "Duplicate request ID"));
   stream_input->OnSubscribeMessage(request);
 }
 
@@ -893,8 +890,6 @@
   session_.GrantMoreRequests(1);
   // Peer subscribes to (0, 0)
   MoqtSubscribe request = DefaultSubscribe();
-  MoqtSessionPeer::set_next_incoming_request_id(
-      &session_, kDefaultInitialMaxRequestId + 1);
   request.request_id = kDefaultInitialMaxRequestId + 1;
   MockTrackPublisher* track = CreateTrackPublisher();
   ReceiveSubscribeSynchronousOk(track, request, stream_input.get());
@@ -1464,7 +1459,7 @@
       /*stream_count=*/1,
       /*error_reason=*/"",
   };
-  EXPECT_CALL(mock_stream_, ResetWithUserCode(kResetCodeCanceled));
+  EXPECT_CALL(mock_stream_, ResetWithUserCode(kResetCodeCancelled));
   webtransport::test::MockStream control_stream;
   std::unique_ptr<MoqtControlParserVisitor> stream_input =
       MoqtSessionPeer::CreateControlStream(&session_, &control_stream);
@@ -1532,7 +1527,7 @@
       /*stream_count=*/1,
       /*error_reason=*/"",
   };
-  EXPECT_CALL(mock_stream_, ResetWithUserCode(kResetCodeCanceled));
+  EXPECT_CALL(mock_stream_, ResetWithUserCode(kResetCodeCancelled));
   webtransport::test::MockStream control_stream;
   std::unique_ptr<MoqtControlParserVisitor> stream_input =
       MoqtSessionPeer::CreateControlStream(&session_, &control_stream);
@@ -2606,25 +2601,25 @@
                    MoqtFetchTask::GetNextObjectResult::kPending);
   stream_input->OnFetchMessage(fetch);
 
-  MoqtRequestError expected_error{fetch.request_id,
-                                  RequestErrorCode::kTrackDoesNotExist,
-                                  std::nullopt, "foo"};
+  MoqtRequestError expected_error{
+      fetch.request_id, RequestErrorCode::kDoesNotExist, std::nullopt, "foo"};
   EXPECT_CALL(mock_stream_,
               Writev(SerializedControlMessage(expected_error), _));
   fetch_task->CallFetchResponseCallback(expected_error);
 }
 
 TEST_F(MoqtSessionTest, InvalidFetch) {
-  // Update the state so that it expects ID > 0 next time.
-  MoqtSessionPeer::ValidateRequestId(&session_, 1);
   webtransport::test::MockStream control_stream;
   std::unique_ptr<MoqtControlParserVisitor> stream_input =
       MoqtSessionPeer::CreateControlStream(&session_, &control_stream);
+  MockTrackPublisher* track = CreateTrackPublisher();
   MoqtFetch fetch = DefaultFetch();
-  fetch.request_id = 1;  // Too low.
+  EXPECT_CALL(*track, StandaloneFetch)
+      .WillOnce(Return(std::make_unique<MockFetchTask>()));
+  stream_input->OnFetchMessage(fetch);
   EXPECT_CALL(mock_session_,
               CloseSession(static_cast<uint64_t>(MoqtError::kInvalidRequestId),
-                           "Request ID not monotonically increasing"))
+                           "Duplicate request ID"))
       .Times(1);
   stream_input->OnFetchMessage(fetch);
 }
@@ -4078,7 +4073,7 @@
   DeliverObject(object, /*fin=*/false, mock_session_, &mock_stream_,
                 data_stream, &remote_track_visitor_);
   // The data stream died and destroyed the visitor (IncomingDataStream).
-  data_stream->OnResetStreamReceived(kResetCodeCanceled);
+  data_stream->OnResetStreamReceived(kResetCodeCancelled);
   EXPECT_CALL(remote_track_visitor_, OnStreamReset(FullTrackName("foo", "bar"),
                                                    DataStreamIndex(0, 0)));
   data_stream.reset();
diff --git a/quiche/quic/moqt/moqt_track.cc b/quiche/quic/moqt/moqt_track.cc
index 25bf9b4..6b5b050 100644
--- a/quiche/quic/moqt/moqt_track.cc
+++ b/quiche/quic/moqt/moqt_track.cc
@@ -16,6 +16,7 @@
 #include "quiche/quic/core/quic_alarm.h"
 #include "quiche/quic/core/quic_clock.h"
 #include "quiche/quic/core/quic_time.h"
+#include "quiche/quic/moqt/moqt_error.h"
 #include "quiche/quic/moqt/moqt_fetch_task.h"
 #include "quiche/quic/moqt/moqt_key_value_pair.h"
 #include "quiche/quic/moqt/moqt_messages.h"
@@ -128,10 +129,11 @@
 }
 
 UpstreamFetch::~UpstreamFetch() {
-  if (task_.IsValid()) {
+  UpstreamFetchTask* task = task_.GetIfAvailable();
+  if (task != nullptr) {
     // Notify the task (which the application owns) that nothing more is coming.
     // If this has already been called, UpstreamFetchTask will ignore it.
-    task_.GetIfAvailable()->OnStreamAndFetchClosed(kResetCodeUnknown, "");
+    task->OnStreamAndFetchClosed(kResetCodeCancelled, "");
   }
 }
 
diff --git a/quiche/quic/moqt/test_tools/moqt_session_peer.h b/quiche/quic/moqt/test_tools/moqt_session_peer.h
index 403a346..6b0e117 100644
--- a/quiche/quic/moqt/test_tools/moqt_session_peer.h
+++ b/quiche/quic/moqt/test_tools/moqt_session_peer.h
@@ -153,10 +153,6 @@
     session->next_request_id_ = id;
   }
 
-  static void set_next_incoming_request_id(MoqtSession* session, uint64_t id) {
-    session->next_incoming_request_id_ = id;
-  }
-
   static void set_peer_max_request_id(MoqtSession* session, uint64_t id) {
     session->peer_max_request_id_ = id;
   }
diff --git a/quiche/quic/moqt/test_tools/moqt_test_message.h b/quiche/quic/moqt/test_tools/moqt_test_message.h
index ec708bf..ccf040e 100644
--- a/quiche/quic/moqt/test_tools/moqt_test_message.h
+++ b/quiche/quic/moqt/test_tools/moqt_test_message.h
@@ -785,7 +785,7 @@
   uint8_t raw_packet_[11] = {
       0x05, 0x00, 0x08,
       0x02,                    // request_id = 2
-      0x05,                    // error_code = 5
+      0x11,                    // error_code = 17
       0x67, 0x11,              // retry_interval = 10000 ms
       0x03, 0x62, 0x61, 0x72,  // reason_phrase = "bar"
   };
diff --git a/quiche/quic/moqt/tools/chat_client.cc b/quiche/quic/moqt/tools/chat_client.cc
index a82406c..c408333 100644
--- a/quiche/quic/moqt/tools/chat_client.cc
+++ b/quiche/quic/moqt/tools/chat_client.cc
@@ -76,7 +76,7 @@
     std::cout << "PUBLISH_NAMESPACE rejected, invalid namespace\n";
     if (callback != nullptr) {
       std::move(callback)(std::make_optional<MoqtRequestErrorInfo>(
-          RequestErrorCode::kTrackDoesNotExist, std::nullopt,
+          RequestErrorCode::kDoesNotExist, std::nullopt,
           "Not a subscribed namespace"));
     }
     return;