grpc 1.54.2 → 1.61.0

data/src/core/lib/surface/call.cc

@@ -27,7 +27,6 @@
 
 #include <algorithm>
 #include <atomic>
-#include <initializer_list>
 #include <memory>
 #include <new>
 #include <string>
@@ -36,7 +35,6 @@
 #include <vector>
 
 #include "absl/base/thread_annotations.h"
-#include "absl/meta/type_traits.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
@@ -47,6 +45,7 @@
 #include <grpc/compression.h>
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/grpc.h>
+#include <grpc/impl/call.h>
 #include <grpc/impl/propagation_bits.h>
 #include <grpc/slice.h>
 #include <grpc/slice_buffer.h>
@@ -55,11 +54,9 @@
 #include <grpc/support/atm.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
-#include <grpc/support/time.h>
 
 #include "src/core/lib/channel/call_finalization.h"
 #include "src/core/lib/channel/call_tracer.h"
-#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/channel/channelz.h"
 #include "src/core/lib/channel/context.h"
@@ -83,9 +80,9 @@
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/polling_entity.h"
 #include "src/core/lib/promise/activity.h"
+#include "src/core/lib/promise/all_ok.h"
 #include "src/core/lib/promise/arena_promise.h"
 #include "src/core/lib/promise/context.h"
-#include "src/core/lib/promise/detail/basic_seq.h"
 #include "src/core/lib/promise/latch.h"
 #include "src/core/lib/promise/map.h"
 #include "src/core/lib/promise/party.h"
@@ -93,6 +90,7 @@
 #include "src/core/lib/promise/poll.h"
 #include "src/core/lib/promise/race.h"
 #include "src/core/lib/promise/seq.h"
+#include "src/core/lib/promise/status_flag.h"
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/slice/slice_buffer.h"
 #include "src/core/lib/slice/slice_internal.h"
@@ -102,6 +100,7 @@
 #include "src/core/lib/surface/completion_queue.h"
 #include "src/core/lib/surface/server.h"
 #include "src/core/lib/surface/validate_metadata.h"
+#include "src/core/lib/surface/wait_for_cq_end_op.h"
 #include "src/core/lib/transport/batch_builder.h"
 #include "src/core/lib/transport/error_utils.h"
 #include "src/core/lib/transport/metadata_batch.h"
@@ -153,6 +152,10 @@ class Call : public CppImplOf<Call, grpc_call> {
   // for that functionality be invented)
   virtual grpc_call_stack* call_stack() = 0;
 
+  // Return the EventEngine used for this call's async execution.
+  virtual grpc_event_engine::experimental::EventEngine* event_engine()
+      const = 0;
+
  protected:
   // The maximum number of concurrent batches possible.
   // Based upon the maximum number of individually queueable ops in the batch
@@ -195,7 +198,7 @@ class Call : public CppImplOf<Call, grpc_call> {
 
   ParentCall* GetOrCreateParentCall();
   ParentCall* parent_call();
-  Channel* channel() {
+  Channel* channel() const {
     GPR_DEBUG_ASSERT(channel_ != nullptr);
     return channel_.get();
   }
@@ -242,6 +245,8 @@ class Call : public CppImplOf<Call, grpc_call> {
   void HandleCompressionAlgorithmNotAccepted(
       grpc_compression_algorithm compression_algorithm) GPR_ATTRIBUTE_NOINLINE;
 
+  gpr_cycle_counter start_time() const { return start_time_; }
+
  private:
   RefCountedPtr<Channel> channel_;
   Arena* const arena_;
@@ -263,6 +268,7 @@ class Call : public CppImplOf<Call, grpc_call> {
   // of the recv_initial_metadata op.  The mutex should be mostly uncontended.
   mutable Mutex peer_mu_;
   Slice peer_string_;
+  gpr_cycle_counter start_time_ = gpr_get_cycle_counter();
 };
 
 Call::ParentCall* Call::GetOrCreateParentCall() {
@@ -442,6 +448,8 @@ void Call::PrepareOutgoingInitialMetadata(const grpc_op& op,
   }
   // Ignore any te metadata key value pairs specified.
   md.Remove(TeMetadata());
+  // Should never come from applications
+  md.Remove(GrpcLbClientStatsMetadata());
 }
 
 void Call::ProcessIncomingInitialMetadata(grpc_metadata_batch& md) {
@@ -529,6 +537,10 @@ class FilterStackCall final : public Call {
         GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(*this)));
   }
 
+  grpc_event_engine::experimental::EventEngine* event_engine() const override {
+    return channel()->event_engine();
+  }
+
   grpc_call_element* call_elem(size_t idx) {
     return grpc_call_stack_element(call_stack(), idx);
   }
@@ -706,7 +718,6 @@ class FilterStackCall final : public Call {
   CallCombiner call_combiner_;
   grpc_completion_queue* cq_;
   grpc_polling_entity pollent_;
-  gpr_cycle_counter start_time_ = gpr_get_cycle_counter();
 
   /// has grpc_call_unref been called
   bool destroy_called_ = false;
@@ -833,6 +844,9 @@ grpc_error_handle FilterStackCall::Create(grpc_call_create_args* args,
       call->send_initial_metadata_.Set(HttpAuthorityMetadata(),
                                        std::move(*args->authority));
     }
+    call->send_initial_metadata_.Set(
+        GrpcRegisteredMethod(), reinterpret_cast<void*>(static_cast<uintptr_t>(
+                                    args->registered_method)));
   } else {
     global_stats().IncrementServerCallsCreated();
     call->final_op_.server.cancelled = nullptr;
@@ -841,11 +855,11 @@ grpc_error_handle FilterStackCall::Create(grpc_call_create_args* args,
     // collecting from when the call is created at the transport. The idea is
     // that the transport would create the call tracer and pass it in as part of
     // the metadata.
-    auto* server_call_tracer_factory = ServerCallTracerFactory::Get(
-        args->server != nullptr ? args->server->channel_args() : ChannelArgs());
-    if (server_call_tracer_factory != nullptr) {
+    if (args->server != nullptr &&
+        args->server->server_call_tracer_factory() != nullptr) {
       auto* server_call_tracer =
-          server_call_tracer_factory->CreateNewServerCallTracer(arena);
+          args->server->server_call_tracer_factory()->CreateNewServerCallTracer(
+              arena, args->server->channel_args());
       if (server_call_tracer != nullptr) {
         // Note that we are setting both
         // GRPC_CONTEXT_CALL_TRACER_ANNOTATION_INTERFACE and
@@ -868,7 +882,7 @@ grpc_error_handle FilterStackCall::Create(grpc_call_create_args* args,
   grpc_call_element_args call_args = {
       call->call_stack(), args->server_transport_data,
       call->context_,     path,
-      call->start_time_,  call->send_deadline(),
+      call->start_time(), call->send_deadline(),
       call->arena(),      &call->call_combiner_};
   add_init_error(&error, grpc_call_stack_init(channel_stack, 1, DestroyCall,
                                               call, &call_args));
@@ -950,7 +964,7 @@ void FilterStackCall::DestroyCall(void* call, grpc_error_handle /*error*/) {
                         &(c->final_info_.error_string));
   c->status_error_.set(absl::OkStatus());
   c->final_info_.stats.latency =
-      gpr_cycle_counter_sub(gpr_get_cycle_counter(), c->start_time_);
+      gpr_cycle_counter_sub(gpr_get_cycle_counter(), c->start_time());
   grpc_call_stack_destroy(c->call_stack(), &c->final_info_,
                           GRPC_CLOSURE_INIT(&c->release_call_, ReleaseCall, c,
                                             grpc_schedule_on_exec_ctx));
@@ -1045,8 +1059,8 @@ void FilterStackCall::CancelWithError(grpc_error_handle error) {
 
 void FilterStackCall::SetFinalStatus(grpc_error_handle error) {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_call_error_trace)) {
-    gpr_log(GPR_DEBUG, "set_final_status %s", is_client() ? "CLI" : "SVR");
-    gpr_log(GPR_DEBUG, "%s", StatusToString(error).c_str());
+    gpr_log(GPR_DEBUG, "set_final_status %s %s", is_client() ? "CLI" : "SVR",
+            StatusToString(error).c_str());
   }
   if (is_client()) {
     std::string status_details;
@@ -1117,7 +1131,10 @@ bool FilterStackCall::PrepareApplicationMetadata(size_t count,
 namespace {
 class PublishToAppEncoder {
  public:
-  explicit PublishToAppEncoder(grpc_metadata_array* dest) : dest_(dest) {}
+  explicit PublishToAppEncoder(grpc_metadata_array* dest,
+                               const grpc_metadata_batch* encoding,
+                               bool is_client)
+      : dest_(dest), encoding_(encoding), is_client_(is_client) {}
 
   void Encode(const Slice& key, const Slice& value) {
     Append(key.c_slice(), value.c_slice());
@@ -1160,12 +1177,20 @@ class PublishToAppEncoder {
   }
 
   void Append(grpc_slice key, grpc_slice value) {
+    if (dest_->count == dest_->capacity) {
+      Crash(absl::StrCat(
+          "Too many metadata entries: capacity=", dest_->capacity, " on ",
+          is_client_ ? "client" : "server", " encoding ", encoding_->count(),
+          " elements: ", encoding_->DebugString().c_str()));
+    }
     auto* mdusr = &dest_->metadata[dest_->count++];
     mdusr->key = key;
     mdusr->value = value;
   }
 
   grpc_metadata_array* const dest_;
+  const grpc_metadata_batch* const encoding_;
+  const bool is_client_;
 };
 }  // namespace
 
@@ -1182,7 +1207,7 @@ void FilterStackCall::PublishAppMetadata(grpc_metadata_batch* b,
     dest->metadata = static_cast<grpc_metadata*>(
         gpr_realloc(dest->metadata, sizeof(grpc_metadata) * dest->capacity));
   }
-  PublishToAppEncoder encoder(dest);
+  PublishToAppEncoder encoder(dest, b, is_client());
   b->Encode(&encoder);
 }
 
@@ -1292,9 +1317,22 @@ FilterStackCall::BatchControl* FilterStackCall::ReuseOrAllocateBatchControl(
 void FilterStackCall::BatchControl::PostCompletion() {
   FilterStackCall* call = call_;
   grpc_error_handle error = batch_error_.get();
+
+  if (IsCallStatusOverrideOnCancellationEnabled()) {
+    // On the client side, if final call status is already known (i.e if this op
+    // includes recv_trailing_metadata) and if the call status is known to be
+    // OK, then disregard the batch error to ensure call->receiving_buffer_ is
+    // not cleared.
+    if (op_.recv_trailing_metadata && call->is_client() &&
+        call->status_error_.ok()) {
+      error = absl::OkStatus();
+    }
+  }
+
   if (grpc_call_trace.enabled()) {
-    gpr_log(GPR_DEBUG, "tag:%p batch_error=%s", completion_data_.notify_tag.tag,
-            error.ToString().c_str());
+    gpr_log(GPR_DEBUG, "tag:%p batch_error=%s op:%s",
+            completion_data_.notify_tag.tag, error.ToString().c_str(),
+            grpc_transport_stream_op_batch_string(&op_, false).c_str());
   }
 
   if (op_.send_initial_metadata) {
@@ -1312,16 +1350,17 @@ void FilterStackCall::BatchControl::PostCompletion() {
   if (op_.send_trailing_metadata) {
     call->send_trailing_metadata_.Clear();
   }
+
+  if (!error.ok() && op_.recv_message && *call->receiving_buffer_ != nullptr) {
+    grpc_byte_buffer_destroy(*call->receiving_buffer_);
+    *call->receiving_buffer_ = nullptr;
+  }
   if (op_.recv_trailing_metadata) {
     // propagate cancellation to any interested children
     gpr_atm_rel_store(&call->received_final_op_atm_, 1);
     call->PropagateCancellationToChildren();
     error = absl::OkStatus();
   }
-  if (!error.ok() && op_.recv_message && *call->receiving_buffer_ != nullptr) {
-    grpc_byte_buffer_destroy(*call->receiving_buffer_);
-    *call->receiving_buffer_ = nullptr;
-  }
   batch_error_.set(absl::OkStatus());
 
   if (completion_data_.notify_tag.is_closure) {
@@ -1925,6 +1964,9 @@ void FilterStackCall::ContextSet(grpc_context_index elem, void* value,
 
 namespace {
 bool ValidateMetadata(size_t count, grpc_metadata* metadata) {
+  if (count > INT_MAX) {
+    return false;
+  }
   for (size_t i = 0; i < count; i++) {
     grpc_metadata* md = &metadata[i];
     if (!GRPC_LOG_IF_ERROR("validate_metadata",
@@ -1948,24 +1990,58 @@ bool ValidateMetadata(size_t count, grpc_metadata* metadata) {
 // PromiseBasedCall
 // Will be folded into Call once the promise conversion is done
 
-class PromiseBasedCall : public Call,
-                         public Party,
-                         public grpc_event_engine::experimental::EventEngine::
-                             Closure /* for deadlines */ {
+class BasicPromiseBasedCall : public Call,
+                              public Party,
+                              public grpc_event_engine::experimental::
+                                  EventEngine::Closure /* for deadlines */ {
  public:
-  PromiseBasedCall(Arena* arena, uint32_t initial_external_refs,
-                   const grpc_call_create_args& args);
+  using Call::arena;
 
-  void ContextSet(grpc_context_index elem, void* value,
-                  void (*destroy)(void* value)) override;
-  void* ContextGet(grpc_context_index elem) const override;
-  void SetCompletionQueue(grpc_completion_queue* cq) override;
-  bool Completed() final { return finished_.IsSet(); }
+  BasicPromiseBasedCall(Arena* arena, uint32_t initial_external_refs,
+                        const grpc_call_create_args& args)
+      : Call(arena, args.server_transport_data == nullptr, args.send_deadline,
+             args.channel->Ref()),
+        Party(arena, initial_external_refs != 0 ? 1 : 0),
+        external_refs_(initial_external_refs),
+        cq_(args.cq) {
+    if (args.cq != nullptr) {
+      GRPC_CQ_INTERNAL_REF(args.cq, "bind");
+    }
+  }
+
+  ~BasicPromiseBasedCall() override {
+    if (cq_) GRPC_CQ_INTERNAL_UNREF(cq_, "bind");
+    for (int i = 0; i < GRPC_CONTEXT_COUNT; i++) {
+      if (context_[i].destroy) {
+        context_[i].destroy(context_[i].value);
+      }
+    }
+  }
+
+  // Implementation of EventEngine::Closure, called when deadline expires
+  void Run() final;
+
+  virtual void OrphanCall() = 0;
+
+  virtual ServerCallContext* server_call_context() { return nullptr; }
+  void SetCompletionQueue(grpc_completion_queue* cq) final {
+    cq_ = cq;
+    GRPC_CQ_INTERNAL_REF(cq, "bind");
+  }
 
   // Implementation of call refcounting: move this to DualRefCounted once we
   // don't need to maintain FilterStackCall compatibility
-  void ExternalRef() final { InternalRef("external"); }
-  void ExternalUnref() final { InternalUnref("external"); }
+  void ExternalRef() final {
+    if (external_refs_.fetch_add(1, std::memory_order_relaxed) == 0) {
+      InternalRef("external");
+    }
+  }
+  void ExternalUnref() final {
+    if (external_refs_.fetch_sub(1, std::memory_order_acq_rel) == 1) {
+      OrphanCall();
+      InternalUnref("external");
+    }
+  }
   void InternalRef(const char* reason) final {
     if (grpc_call_refcount_trace.enabled()) {
       gpr_log(GPR_DEBUG, "INTERNAL_REF:%p:%s", this, reason);
@@ -1989,40 +2065,169 @@ class PromiseBasedCall : public Call,
         [](Empty) {});
   }
 
-  // This should return nullptr for the promise stack (and alternative means
-  // for that functionality be invented)
-  grpc_call_stack* call_stack() override { return nullptr; }
+  void ContextSet(grpc_context_index elem, void* value,
+                  void (*destroy)(void*)) final {
+    if (context_[elem].destroy != nullptr) {
+      context_[elem].destroy(context_[elem].value);
+    }
+    context_[elem].value = value;
+    context_[elem].destroy = destroy;
+  }
+
+  void* ContextGet(grpc_context_index elem) const final {
+    return context_[elem].value;
+  }
 
   void UpdateDeadline(Timestamp deadline) ABSL_LOCKS_EXCLUDED(deadline_mu_);
   void ResetDeadline() ABSL_LOCKS_EXCLUDED(deadline_mu_);
+  Timestamp deadline() {
+    MutexLock lock(&deadline_mu_);
+    return deadline_;
+  }
 
-  // Implementation of EventEngine::Closure, called when deadline expires
-  void Run() override;
+  // Accept the stats from the context (call once we have proof the transport is
+  // done with them).
+  void AcceptTransportStatsFromContext() {
+    final_stats_ = *call_context_.call_stats();
+  }
 
-  virtual ServerCallContext* server_call_context() { return nullptr; }
+  // This should return nullptr for the promise stack (and alternative means
+  // for that functionality be invented)
+  grpc_call_stack* call_stack() final { return nullptr; }
 
-  using Call::arena;
+  virtual RefCountedPtr<CallSpineInterface> MakeCallSpine(CallArgs) {
+    Crash("Not implemented");
+  }
 
  protected:
   class ScopedContext
       : public ScopedActivity,
-        public BatchBuilder,
-        public promise_detail::Context<BatchBuilder>,
         public promise_detail::Context<Arena>,
         public promise_detail::Context<grpc_call_context_element>,
         public promise_detail::Context<CallContext>,
         public promise_detail::Context<CallFinalization> {
    public:
-    explicit ScopedContext(PromiseBasedCall* call)
+    explicit ScopedContext(BasicPromiseBasedCall* call)
         : ScopedActivity(call),
-          BatchBuilder(&call->batch_payload_),
-          promise_detail::Context<BatchBuilder>(this),
           promise_detail::Context<Arena>(call->arena()),
           promise_detail::Context<grpc_call_context_element>(call->context_),
           promise_detail::Context<CallContext>(&call->call_context_),
           promise_detail::Context<CallFinalization>(&call->finalization_) {}
   };
 
+  grpc_call_context_element* context() { return context_; }
+
+  grpc_completion_queue* cq() { return cq_; }
+
+  // At the end of the call run any finalization actions.
+  void SetFinalizationStatus(grpc_status_code status, Slice status_details) {
+    final_message_ = std::move(status_details);
+    final_status_ = status;
+  }
+
+  grpc_event_engine::experimental::EventEngine* event_engine() const override {
+    return channel()->event_engine();
+  }
+
+ private:
+  void PartyOver() final {
+    {
+      ScopedContext ctx(this);
+      std::string message;
+      grpc_call_final_info final_info;
+      final_info.stats = final_stats_;
+      final_info.final_status = final_status_;
+      // TODO(ctiller): change type here so we don't need to copy this string.
+      final_info.error_string = nullptr;
+      if (!final_message_.empty()) {
+        message = std::string(final_message_.begin(), final_message_.end());
+        final_info.error_string = message.c_str();
+      }
+      final_info.stats.latency =
+          gpr_cycle_counter_sub(gpr_get_cycle_counter(), start_time());
+      finalization_.Run(&final_info);
+      CancelRemainingParticipants();
+      arena()->DestroyManagedNewObjects();
+    }
+    DeleteThis();
+  }
+
+  // Double refcounted for now: party owns the internal refcount, we track the
+  // external refcount. Figure out a better scheme post-promise conversion.
+  std::atomic<size_t> external_refs_;
+  CallFinalization finalization_;
+  CallContext call_context_{this};
+  // Contexts for various subsystems (security, tracing, ...).
+  grpc_call_context_element context_[GRPC_CONTEXT_COUNT] = {};
+  grpc_call_stats final_stats_{};
+  // Current deadline.
+  Mutex deadline_mu_;
+  Timestamp deadline_ ABSL_GUARDED_BY(deadline_mu_) = Timestamp::InfFuture();
+  grpc_event_engine::experimental::EventEngine::TaskHandle ABSL_GUARDED_BY(
+      deadline_mu_) deadline_task_;
+  Slice final_message_;
+  grpc_status_code final_status_ = GRPC_STATUS_UNKNOWN;
+  grpc_completion_queue* cq_;
+};
+
+void BasicPromiseBasedCall::UpdateDeadline(Timestamp deadline) {
+  MutexLock lock(&deadline_mu_);
+  if (grpc_call_trace.enabled()) {
+    gpr_log(GPR_DEBUG, "%s[call] UpdateDeadline from=%s to=%s",
+            DebugTag().c_str(), deadline_.ToString().c_str(),
+            deadline.ToString().c_str());
+  }
+  if (deadline >= deadline_) return;
+  auto* const event_engine = channel()->event_engine();
+  if (deadline_ != Timestamp::InfFuture()) {
+    if (!event_engine->Cancel(deadline_task_)) return;
+  } else {
+    InternalRef("deadline");
+  }
+  deadline_ = deadline;
+  deadline_task_ = event_engine->RunAfter(deadline - Timestamp::Now(), this);
+}
+
+void BasicPromiseBasedCall::ResetDeadline() {
+  MutexLock lock(&deadline_mu_);
+  if (deadline_ == Timestamp::InfFuture()) return;
+  auto* const event_engine = channel()->event_engine();
+  if (!event_engine->Cancel(deadline_task_)) return;
+  deadline_ = Timestamp::InfFuture();
+  InternalUnref("deadline");
+}
+
+void BasicPromiseBasedCall::Run() {
+  ApplicationCallbackExecCtx callback_exec_ctx;
+  ExecCtx exec_ctx;
+  CancelWithError(absl::DeadlineExceededError("Deadline exceeded"));
+  InternalUnref("deadline");
+}
+
+class PromiseBasedCall : public BasicPromiseBasedCall {
+ public:
+  PromiseBasedCall(Arena* arena, uint32_t initial_external_refs,
+                   const grpc_call_create_args& args);
+
+  bool Completed() final { return finished_.IsSet(); }
+
+  bool failed_before_recv_message() const final {
+    return failed_before_recv_message_.load(std::memory_order_relaxed);
+  }
+
+  using Call::arena;
+
+ protected:
+  class ScopedContext : public BasicPromiseBasedCall::ScopedContext,
+                        public BatchBuilder,
+                        public promise_detail::Context<BatchBuilder> {
+   public:
+    explicit ScopedContext(PromiseBasedCall* call)
+        : BasicPromiseBasedCall::ScopedContext(call),
+          BatchBuilder(&call->batch_payload_),
+          promise_detail::Context<BatchBuilder>(this) {}
+  };
+
   class Completion {
    public:
     Completion() : index_(kNullIndex) {}
@@ -2049,15 +2254,6 @@ class PromiseBasedCall : public Call,
     uint8_t index_;
   };
 
-  ~PromiseBasedCall() override {
-    if (cq_) GRPC_CQ_INTERNAL_UNREF(cq_, "bind");
-    for (int i = 0; i < GRPC_CONTEXT_COUNT; i++) {
-      if (context_[i].destroy) {
-        context_[i].destroy(context_[i].value);
-      }
-    }
-  }
-
   // Enumerates why a Completion is still pending
   enum class PendingOp {
     // We're in the midst of starting a batch of operations
@@ -2124,29 +2320,6 @@ class PromiseBasedCall : public Call,
   // Mark the completion as infallible. Overrides FailCompletion to report
   // success always.
   void ForceCompletionSuccess(const Completion& completion);
-  // Accept the stats from the context (call once we have proof the transport is
-  // done with them).
-  // Right now this means that promise based calls do not record correct stats
-  // with census if they are cancelled.
-  // TODO(ctiller): this should be remedied before promise  based calls are
-  // dexperimentalized.
-  void AcceptTransportStatsFromContext() {
-    final_stats_ = *call_context_.call_stats();
-  }
-
-  grpc_completion_queue* cq() { return cq_; }
-
-  void CToMetadata(grpc_metadata* metadata, size_t count,
-                   grpc_metadata_batch* batch);
-
-  // At the end of the call run any finalization actions.
-  void RunFinalization(grpc_status_code status, const char* status_details) {
-    grpc_call_final_info final_info;
-    final_info.stats = final_stats_;
-    final_info.final_status = status;
-    final_info.error_string = status_details;
-    finalization_.Run(&final_info);
-  }
 
   std::string PresentAndCompletionText(const char* caption, bool has,
                                        const Completion& completion) const {
@@ -2172,7 +2345,7 @@ class PromiseBasedCall : public Call,
   void StartRecvMessage(const grpc_op& op, const Completion& completion,
                         FirstPromise first,
                         PipeReceiver<MessageHandle>* receiver,
-                        Party::BulkSpawner& spawner);
+                        bool cancel_on_error, Party::BulkSpawner& spawner);
   void StartSendMessage(const grpc_op& op, const Completion& completion,
                         PipeSender<MessageHandle>* sender,
                         Party::BulkSpawner& spawner);
@@ -2214,6 +2387,10 @@ class PromiseBasedCall : public Call,
     }
   }
 
+  void set_failed_before_recv_message() {
+    failed_before_recv_message_.store(true, std::memory_order_relaxed);
+  }
+
  private:
   union CompletionInfo {
     static constexpr uint32_t kOpFailed = 0x8000'0000u;
@@ -2293,37 +2470,17 @@ class PromiseBasedCall : public Call,
     grpc_cq_completion completion;
   };
 
-  void PartyOver() override {
-    {
-      ScopedContext ctx(this);
-      CancelRemainingParticipants();
-      arena()->DestroyManagedNewObjects();
-    }
-    DeleteThis();
-  }
-
-  CallContext call_context_{this};
-
-  // Contexts for various subsystems (security, tracing, ...).
-  grpc_call_context_element context_[GRPC_CONTEXT_COUNT] = {};
-  grpc_completion_queue* cq_;
   CompletionInfo completion_info_[6];
-  grpc_call_stats final_stats_{};
-  CallFinalization finalization_;
-  // Current deadline.
-  Mutex deadline_mu_;
-  Timestamp deadline_ ABSL_GUARDED_BY(deadline_mu_) = Timestamp::InfFuture();
-  grpc_event_engine::experimental::EventEngine::TaskHandle ABSL_GUARDED_BY(
-      deadline_mu_) deadline_task_;
   ExternallyObservableLatch<void> finished_;
   // Non-zero with an outstanding GRPC_OP_SEND_INITIAL_METADATA or
   // GRPC_OP_SEND_MESSAGE (one count each), and 0 once those payloads have been
   // pushed onto the outgoing pipe.
   std::atomic<uint8_t> sends_queued_{0};
+  std::atomic<bool> failed_before_recv_message_{false};
   // Waiter for when sends_queued_ becomes 0.
   IntraActivityWaiter waiting_for_queued_sends_;
   grpc_byte_buffer** recv_message_ = nullptr;
-  grpc_transport_stream_op_batch_payload batch_payload_{context_};
+  grpc_transport_stream_op_batch_payload batch_payload_{context()};
 };
 
 template <typename T>
@@ -2331,8 +2488,10 @@ grpc_error_handle MakePromiseBasedCall(grpc_call_create_args* args,
                                        grpc_call** out_call) {
   Channel* channel = args->channel.get();
 
-  auto alloc = Arena::CreateWithAlloc(channel->CallSizeEstimate(), sizeof(T),
-                                      channel->allocator());
+  const auto initial_size = channel->CallSizeEstimate();
+  global_stats().IncrementCallInitialSize(initial_size);
+  auto alloc =
+      Arena::CreateWithAlloc(initial_size, sizeof(T), channel->allocator());
   PromiseBasedCall* call = new (alloc.second) T(alloc.first, args);
   *out_call = call->c_ptr();
   GPR_DEBUG_ASSERT(Call::FromC(*out_call) == call);
@@ -2341,26 +2500,10 @@ grpc_error_handle MakePromiseBasedCall(grpc_call_create_args* args,
 
 PromiseBasedCall::PromiseBasedCall(Arena* arena, uint32_t initial_external_refs,
                                    const grpc_call_create_args& args)
-    : Call(arena, args.server_transport_data == nullptr, args.send_deadline,
-           args.channel->Ref()),
-      Party(arena, initial_external_refs),
-      cq_(args.cq) {
-  if (args.cq != nullptr) {
-    GPR_ASSERT(args.pollset_set_alternative == nullptr &&
-               "Only one of 'cq' and 'pollset_set_alternative' should be "
-               "non-nullptr.");
-    GRPC_CQ_INTERNAL_REF(args.cq, "bind");
-    call_context_.pollent_ =
-        grpc_polling_entity_create_from_pollset(grpc_cq_pollset(args.cq));
-  }
-  if (args.pollset_set_alternative != nullptr) {
-    call_context_.pollent_ = grpc_polling_entity_create_from_pollset_set(
-        args.pollset_set_alternative);
-  }
-}
+    : BasicPromiseBasedCall(arena, initial_external_refs, args) {}
 
-void PromiseBasedCall::CToMetadata(grpc_metadata* metadata, size_t count,
-                                   grpc_metadata_batch* b) {
+static void CToMetadata(grpc_metadata* metadata, size_t count,
+                        grpc_metadata_batch* b) {
   for (size_t i = 0; i < count; i++) {
     grpc_metadata* md = &metadata[i];
     auto key = StringViewFromSlice(md->key);
@@ -2377,19 +2520,6 @@ void PromiseBasedCall::CToMetadata(grpc_metadata* metadata, size_t count,
   }
 }
 
-void PromiseBasedCall::ContextSet(grpc_context_index elem, void* value,
-                                  void (*destroy)(void*)) {
-  if (context_[elem].destroy != nullptr) {
-    context_[elem].destroy(context_[elem].value);
-  }
-  context_[elem].value = value;
-  context_[elem].destroy = destroy;
-}
-
-void* PromiseBasedCall::ContextGet(grpc_context_index elem) const {
-  return context_[elem].value;
-}
-
 PromiseBasedCall::Completion PromiseBasedCall::StartCompletion(
     void* tag, bool is_closure, const grpc_op* ops) {
   Completion c(BatchSlotForOp(ops[0].op));
@@ -2459,51 +2589,14 @@ void PromiseBasedCall::FinishOpOnCompletion(Completion* completion,
     ExecCtx::Run(DEBUG_LOCATION, static_cast<grpc_closure*>(pending.tag),
                  error);
   } else {
+    InternalRef("cq_end_op");
     grpc_cq_end_op(
-        cq(), pending.tag, error, [](void*, grpc_cq_completion*) {}, nullptr,
-        &completion_info_[i].completion);
-  }
-}
-
-void PromiseBasedCall::SetCompletionQueue(grpc_completion_queue* cq) {
-  cq_ = cq;
-  GRPC_CQ_INTERNAL_REF(cq, "bind");
-  call_context_.pollent_ =
-      grpc_polling_entity_create_from_pollset(grpc_cq_pollset(cq));
-}
-
-void PromiseBasedCall::UpdateDeadline(Timestamp deadline) {
-  MutexLock lock(&deadline_mu_);
-  if (grpc_call_trace.enabled()) {
-    gpr_log(GPR_DEBUG, "%s[call] UpdateDeadline from=%s to=%s",
-            DebugTag().c_str(), deadline_.ToString().c_str(),
-            deadline.ToString().c_str());
-  }
-  if (deadline >= deadline_) return;
-  auto* const event_engine = channel()->event_engine();
-  if (deadline_ != Timestamp::InfFuture()) {
-    if (!event_engine->Cancel(deadline_task_)) return;
-  } else {
-    InternalRef("deadline");
+        cq(), pending.tag, error,
+        [](void* p, grpc_cq_completion*) {
+          static_cast<PromiseBasedCall*>(p)->InternalUnref("cq_end_op");
+        },
+        this, &completion_info_[i].completion);
   }
-  deadline_ = deadline;
-  deadline_task_ = event_engine->RunAfter(deadline - Timestamp::Now(), this);
-}
-
-void PromiseBasedCall::ResetDeadline() {
-  MutexLock lock(&deadline_mu_);
-  if (deadline_ == Timestamp::InfFuture()) return;
-  auto* const event_engine = channel()->event_engine();
-  if (!event_engine->Cancel(deadline_task_)) return;
-  deadline_ = Timestamp::InfFuture();
-  InternalUnref("deadline");
-}
-
-void PromiseBasedCall::Run() {
-  ApplicationCallbackExecCtx callback_exec_ctx;
-  ExecCtx exec_ctx;
-  CancelWithError(absl::DeadlineExceededError("Deadline exceeded"));
-  InternalUnref("deadline");
 }
 
 void PromiseBasedCall::StartSendMessage(const grpc_op& op,
@@ -2537,7 +2630,8 @@ template <typename FirstPromiseFactory>
 void PromiseBasedCall::StartRecvMessage(
     const grpc_op& op, const Completion& completion,
     FirstPromiseFactory first_promise_factory,
-    PipeReceiver<MessageHandle>* receiver, Party::BulkSpawner& spawner) {
+    PipeReceiver<MessageHandle>* receiver, bool cancel_on_error,
+    Party::BulkSpawner& spawner) {
   if (grpc_call_trace.enabled()) {
     gpr_log(GPR_INFO, "%s[call] Start RecvMessage: %s", DebugTag().c_str(),
             CompletionString(completion).c_str());
@@ -2548,7 +2642,7 @@ void PromiseBasedCall::StartRecvMessage(
       [first_promise_factory = std::move(first_promise_factory), receiver]() {
         return Seq(first_promise_factory(), receiver->Next());
       },
-      [this,
+      [this, cancel_on_error,
        completion = AddOpToCompletion(completion, PendingOp::kReceiveMessage)](
           NextResult<MessageHandle> result) mutable {
         if (result.has_value()) {
@@ -2577,7 +2671,9 @@ void PromiseBasedCall::StartRecvMessage(
                     "finishes: received end-of-stream with error",
                     DebugTag().c_str());
           }
+          set_failed_before_recv_message();
           FailCompletion(completion);
+          if (cancel_on_error) CancelWithError(absl::CancelledError());
           *recv_message_ = nullptr;
         } else {
           if (grpc_call_trace.enabled()) {
@@ -2609,15 +2705,25 @@ void CallContext::UpdateDeadline(Timestamp deadline) {
   call_->UpdateDeadline(deadline);
 }
 
+Timestamp CallContext::deadline() const { return call_->deadline(); }
+
 ServerCallContext* CallContext::server_call_context() {
   return call_->server_call_context();
 }
 
+RefCountedPtr<CallSpineInterface> CallContext::MakeCallSpine(
+    CallArgs call_args) {
+  return call_->MakeCallSpine(std::move(call_args));
+}
+
+grpc_call* CallContext::c_call() { return call_->c_ptr(); }
+
 ///////////////////////////////////////////////////////////////////////////////
 // PublishMetadataArray
 
 namespace {
-void PublishMetadataArray(grpc_metadata_batch* md, grpc_metadata_array* array) {
+void PublishMetadataArray(grpc_metadata_batch* md, grpc_metadata_array* array,
+                          bool is_client) {
   const auto md_count = md->count();
   if (md_count > array->capacity) {
     array->capacity =
@@ -2625,7 +2731,7 @@ void PublishMetadataArray(grpc_metadata_batch* md, grpc_metadata_array* array) {
     array->metadata = static_cast<grpc_metadata*>(
         gpr_realloc(array->metadata, sizeof(grpc_metadata) * array->capacity));
   }
-  PublishToAppEncoder encoder(array);
+  PublishToAppEncoder encoder(array, md, is_client);
   md->Encode(&encoder);
 }
 }  // namespace
@@ -2637,8 +2743,21 @@ void PublishMetadataArray(grpc_metadata_batch* md, grpc_metadata_array* array) {
 class ClientPromiseBasedCall final : public PromiseBasedCall {
  public:
   ClientPromiseBasedCall(Arena* arena, grpc_call_create_args* args)
-      : PromiseBasedCall(arena, 1, *args) {
+      : PromiseBasedCall(arena, 1, *args),
+        polling_entity_(
+            args->cq != nullptr
+                ? grpc_polling_entity_create_from_pollset(
+                      grpc_cq_pollset(args->cq))
+                : (args->pollset_set_alternative != nullptr
+                       ? grpc_polling_entity_create_from_pollset_set(
+                             args->pollset_set_alternative)
+                       : grpc_polling_entity{})) {
     global_stats().IncrementClientCallsCreated();
+    if (args->cq != nullptr) {
+      GPR_ASSERT(args->pollset_set_alternative == nullptr &&
+                 "Only one of 'cq' and 'pollset_set_alternative' should be "
+                 "non-nullptr.");
+    }
     ScopedContext context(this);
     send_initial_metadata_ =
         GetContext<Arena>()->MakePooled<ClientMetadata>(GetContext<Arena>());
@@ -2647,14 +2766,27 @@ class ClientPromiseBasedCall final : public PromiseBasedCall {
       send_initial_metadata_->Set(HttpAuthorityMetadata(),
                                   std::move(*args->authority));
     }
+    send_initial_metadata_->Set(GrpcRegisteredMethod(),
+                                reinterpret_cast<void*>(static_cast<uintptr_t>(
+                                    args->registered_method)));
     if (auto* channelz_channel = channel()->channelz_node()) {
       channelz_channel->RecordCallStarted();
     }
     if (args->send_deadline != Timestamp::InfFuture()) {
       UpdateDeadline(args->send_deadline);
     }
+    Call* parent = Call::FromC(args->parent);
+    if (parent != nullptr) {
+      auto parent_status = InitParent(parent, args->propagation_mask);
+      if (!parent_status.ok()) {
+        CancelWithError(std::move(parent_status));
+      }
+      PublishToParent(parent);
+    }
   }
 
+  void OrphanCall() override { MaybeUnpublishFromParent(); }
+
   ~ClientPromiseBasedCall() override {
     ScopedContext context(this);
     send_initial_metadata_.reset();
@@ -2667,13 +2799,18 @@ class ClientPromiseBasedCall final : public PromiseBasedCall {
   }
 
   void CancelWithError(absl::Status error) override {
+    if (cancel_with_error_called_.exchange(true, std::memory_order_relaxed)) {
+      return;
+    }
     if (!started_.exchange(true, std::memory_order_relaxed)) {
       // Initial metadata not sent yet, so we can just fail the call.
       Spawn(
           "cancel_before_initial_metadata",
           [error = std::move(error), this]() {
             server_to_client_messages_.sender.Close();
-            Finish(ServerMetadataFromStatus(error));
+            auto md = ServerMetadataFromStatus(error);
+            md->Set(GrpcCallWasCancelled(), true);
+            Finish(std::move(md));
             return Empty{};
           },
           [](Empty) {});
@@ -2682,7 +2819,9 @@ class ClientPromiseBasedCall final : public PromiseBasedCall {
           "cancel_with_error",
           [error = std::move(error), this]() {
             if (!cancel_error_.is_set()) {
-              cancel_error_.Set(ServerMetadataFromStatus(error));
+              auto md = ServerMetadataFromStatus(error);
+              md->Set(GrpcCallWasCancelled(), true);
+              cancel_error_.Set(std::move(md));
             }
             return Empty{};
           },
@@ -2691,7 +2830,6 @@ class ClientPromiseBasedCall final : public PromiseBasedCall {
   }
   absl::string_view GetServerAuthority() const override { abort(); }
   bool is_trailers_only() const override { return is_trailers_only_; }
-  bool failed_before_recv_message() const override { return false; }
 
   grpc_call_error StartBatch(const grpc_op* ops, size_t nops, void* notify_tag,
                              bool is_notify_tag_closure) override;
@@ -2700,6 +2838,81 @@ class ClientPromiseBasedCall final : public PromiseBasedCall {
     return absl::StrFormat("CLIENT_CALL[%p]: ", this);
   }
 
+  RefCountedPtr<CallSpineInterface> MakeCallSpine(CallArgs call_args) final {
+    class WrappingCallSpine final : public CallSpineInterface {
+     public:
+      WrappingCallSpine(ClientPromiseBasedCall* call,
+                        ClientMetadataHandle metadata)
+          : call_(call) {
+        call_->InternalRef("call-spine");
+        SpawnInfallible("send_client_initial_metadata",
+                        [this, metadata = std::move(metadata)]() mutable {
+                          return Map(client_initial_metadata_.sender.Push(
+                                         std::move(metadata)),
+                                     [](bool) { return Empty{}; });
+                        });
+        SpawnInfallible("monitor_cancellation", [this]() {
+          return Seq(cancel_error_.Wait(),
+                     [this](ServerMetadataHandle trailing_metadata) {
+                       Crash("here");
+                       return Map(server_trailing_metadata_.sender.Push(
+                                      std::move(trailing_metadata)),
+                                  [](bool) { return Empty{}; });
+                     });
+        });
+      }
+
+      ~WrappingCallSpine() override { call_->InternalUnref("call-spine"); }
+
+      Pipe<ClientMetadataHandle>& client_initial_metadata() override {
+        return client_initial_metadata_;
+      }
+
+      Pipe<MessageHandle>& client_to_server_messages() override {
+        return call_->client_to_server_messages_;
+      }
+
+      Pipe<ServerMetadataHandle>& server_initial_metadata() override {
+        return call_->server_initial_metadata_;
+      }
+
+      Pipe<MessageHandle>& server_to_client_messages() override {
+        return call_->server_to_client_messages_;
+      }
+
+      Pipe<ServerMetadataHandle>& server_trailing_metadata() override {
+        return server_trailing_metadata_;
+      }
+
+      Latch<ServerMetadataHandle>& cancel_latch() override {
+        return cancel_error_;
+      }
+
+      Party& party() override { return *call_; }
+
+      void IncrementRefCount() override { refs_.Ref(); }
+      void Unref() override {
+        if (refs_.Unref()) delete this;
+      }
+
+     private:
+      RefCount refs_;
+      ClientPromiseBasedCall* const call_;
+      std::atomic<bool> sent_trailing_metadata_{false};
+      Pipe<ClientMetadataHandle> client_initial_metadata_{call_->arena()};
+      Pipe<ServerMetadataHandle> server_trailing_metadata_{call_->arena()};
+      Latch<ServerMetadataHandle> cancel_error_;
+    };
+    GPR_ASSERT(call_args.server_initial_metadata ==
+               &server_initial_metadata_.sender);
+    GPR_ASSERT(call_args.client_to_server_messages ==
+               &client_to_server_messages_.receiver);
+    GPR_ASSERT(call_args.server_to_client_messages ==
+               &server_to_client_messages_.sender);
+    return MakeRefCounted<WrappingCallSpine>(
+        this, std::move(call_args.client_initial_metadata));
+  }
+
  private:
   // Finish the call with the given status/trailing metadata.
   void Finish(ServerMetadataHandle trailing_metadata);
@@ -2730,15 +2943,25 @@ class ClientPromiseBasedCall final : public PromiseBasedCall {
   Pipe<ServerMetadataHandle> server_initial_metadata_{arena()};
   Latch<ServerMetadataHandle> server_trailing_metadata_;
   Latch<ServerMetadataHandle> cancel_error_;
+  Latch<grpc_polling_entity> polling_entity_;
   Pipe<MessageHandle> client_to_server_messages_{arena()};
   Pipe<MessageHandle> server_to_client_messages_{arena()};
-  bool is_trailers_only_;
+  bool is_trailers_only_ = false;
+  bool scheduled_receive_status_ = false;
+  bool scheduled_send_close_ = false;
   // True once the promise for the call is started.
   // This corresponds to sending initial metadata, or cancelling before doing
   // so.
   // In the latter case real world code sometimes does not sent the initial
   // metadata, and so gating based upon that does not work out.
   std::atomic<bool> started_{false};
+  // True after the first CancelWithError call - prevents spamming cancels from
+  // overflowing the party.
+  std::atomic<bool> cancel_with_error_called_{false};
+  // TODO(ctiller): delete when we remove the filter based API (may require some
+  // cleanup in wrapped languages: they depend on this to hold slice refs)
+  ServerMetadataHandle recv_initial_metadata_;
+  ServerMetadataHandle recv_trailing_metadata_;
 };
 
 void ClientPromiseBasedCall::StartPromise(
@@ -2759,11 +2982,11 @@ void ClientPromiseBasedCall::StartPromise(
        token = std::move(token)]() mutable {
         return Race(
             cancel_error_.Wait(),
-            Map(channel()->channel_stack()->MakeClientCallPromise(
-                    CallArgs{std::move(client_initial_metadata),
-                             std::move(token), &server_initial_metadata_.sender,
-                             &client_to_server_messages_.receiver,
-                             &server_to_client_messages_.sender}),
+            Map(channel()->channel_stack()->MakeClientCallPromise(CallArgs{
+                    std::move(client_initial_metadata), std::move(token),
+                    &polling_entity_, &server_initial_metadata_.sender,
+                    &client_to_server_messages_.receiver,
+                    &server_to_client_messages_.sender}),
                 [this](ServerMetadataHandle trailing_metadata) {
                   // If we're cancelled the transport doesn't get to return
                   // stats.
@@ -2798,15 +3021,25 @@ grpc_call_error ClientPromiseBasedCall::ValidateBatch(const grpc_op* ops,
         break;
       case GRPC_OP_RECV_INITIAL_METADATA:
       case GRPC_OP_RECV_MESSAGE:
+        if (op.flags != 0) return GRPC_CALL_ERROR_INVALID_FLAGS;
+        break;
       case GRPC_OP_SEND_CLOSE_FROM_CLIENT:
+        if (scheduled_send_close_) return GRPC_CALL_ERROR_TOO_MANY_OPERATIONS;
+        if (op.flags != 0) return GRPC_CALL_ERROR_INVALID_FLAGS;
+        break;
       case GRPC_OP_RECV_STATUS_ON_CLIENT:
         if (op.flags != 0) return GRPC_CALL_ERROR_INVALID_FLAGS;
+        if (scheduled_receive_status_) {
+          return GRPC_CALL_ERROR_TOO_MANY_OPERATIONS;
+        }
         break;
       case GRPC_OP_RECV_CLOSE_ON_SERVER:
       case GRPC_OP_SEND_STATUS_FROM_SERVER:
         return GRPC_CALL_ERROR_NOT_ON_CLIENT;
     }
-    if (got_ops.is_set(op.op)) return GRPC_CALL_ERROR_TOO_MANY_OPERATIONS;
+    if (got_ops.is_set(op.op)) {
+      return GRPC_CALL_ERROR_TOO_MANY_OPERATIONS;
+    }
     got_ops.set(op.op);
   }
   return GRPC_CALL_OK;
@@ -2841,6 +3074,7 @@ void ClientPromiseBasedCall::CommitBatch(const grpc_op* ops, size_t nops,
             spawner);
       } break;
       case GRPC_OP_RECV_STATUS_ON_CLIENT: {
+        scheduled_receive_status_ = true;
         StartRecvStatusOnClient(completion, op.data.recv_status_on_client,
                                 spawner);
       } break;
@@ -2852,11 +3086,13 @@ void ClientPromiseBasedCall::CommitBatch(const grpc_op* ops, size_t nops,
         StartRecvMessage(
             op, completion,
             [this]() {
-              return server_initial_metadata_.receiver.AwaitClosed();
+              return Race(server_initial_metadata_.receiver.AwaitClosed(),
+                          server_to_client_messages_.receiver.AwaitClosed());
             },
-            &server_to_client_messages_.receiver, spawner);
+            &server_to_client_messages_.receiver, false, spawner);
         break;
       case GRPC_OP_SEND_CLOSE_FROM_CLIENT:
+        scheduled_send_close_ = true;
         spawner.Spawn(
             "send_close_from_client",
             [this]() {
@@ -2901,24 +3137,35 @@ void ClientPromiseBasedCall::StartRecvInitialMetadata(
     Party::BulkSpawner& spawner) {
   spawner.Spawn(
       "recv_initial_metadata",
-      Race(server_initial_metadata_.receiver.Next(),
-           Map(finished(),
-               [](Empty) { return NextResult<ServerMetadataHandle>(true); })),
+      [this]() {
+        return Race(server_initial_metadata_.receiver.Next(),
+                    Map(finished(), [](Empty) {
+                      return NextResult<ServerMetadataHandle>(true);
+                    }));
+      },
       [this, array,
        completion =
            AddOpToCompletion(completion, PendingOp::kReceiveInitialMetadata)](
           NextResult<ServerMetadataHandle> next_metadata) mutable {
         server_initial_metadata_.sender.Close();
         ServerMetadataHandle metadata;
+        if (grpc_call_trace.enabled()) {
+          gpr_log(GPR_INFO, "%s[call] RecvTrailingMetadata: %s",
+                  DebugTag().c_str(),
+                  next_metadata.has_value()
+                      ? next_metadata.value()->DebugString().c_str()
+                      : "null");
+        }
         if (next_metadata.has_value()) {
-          is_trailers_only_ = false;
           metadata = std::move(next_metadata.value());
+          is_trailers_only_ = metadata->get(GrpcTrailersOnly()).value_or(false);
         } else {
           is_trailers_only_ = true;
           metadata = arena()->MakePooled<ServerMetadata>(arena());
         }
         ProcessIncomingInitialMetadata(*metadata);
-        PublishMetadataArray(metadata.get(), array);
+        PublishMetadataArray(metadata.get(), array, true);
+        recv_initial_metadata_ = std::move(metadata);
         FinishOpOnCompletion(&completion, PendingOp::kReceiveInitialMetadata);
       });
 }
@@ -2930,7 +3177,12 @@ void ClientPromiseBasedCall::Finish(ServerMetadataHandle trailing_metadata) {
   }
   ResetDeadline();
   set_completed();
-  client_to_server_messages_.sender.Close();
+  client_to_server_messages_.sender.CloseWithError();
+  client_to_server_messages_.receiver.CloseWithError();
+  if (trailing_metadata->get(GrpcCallWasCancelled()).value_or(false)) {
+    server_to_client_messages_.receiver.CloseWithError();
+    server_initial_metadata_.receiver.CloseWithError();
+  }
   if (auto* channelz_channel = channel()->channelz_node()) {
     if (trailing_metadata->get(GrpcStatusMetadata())
             .value_or(GRPC_STATUS_UNKNOWN) == GRPC_STATUS_OK) {
@@ -2980,26 +3232,20 @@ void ClientPromiseBasedCall::StartRecvStatusOnClient(
             trailing_metadata->get(GrpcStatusMetadata())
                 .value_or(GRPC_STATUS_UNKNOWN);
         *op_args.status = status;
-        absl::string_view message_string;
+        Slice message_slice;
         if (Slice* message =
                 trailing_metadata->get_pointer(GrpcMessageMetadata())) {
-          message_string = message->as_string_view();
-          *op_args.status_details = message->Ref().TakeCSlice();
-        } else {
-          *op_args.status_details = grpc_empty_slice();
-        }
-        if (message_string.empty()) {
-          RunFinalization(status, nullptr);
-        } else {
-          std::string error_string(message_string);
-          RunFinalization(status, error_string.c_str());
+          message_slice = message->Ref();
         }
+        SetFinalizationStatus(status, message_slice.Ref());
+        *op_args.status_details = message_slice.TakeCSlice();
         if (op_args.error_string != nullptr && status != GRPC_STATUS_OK) {
           *op_args.error_string =
               gpr_strdup(MakeErrorString(trailing_metadata.get()).c_str());
         }
-        PublishMetadataArray(trailing_metadata.get(),
-                             op_args.trailing_metadata);
+        PublishMetadataArray(trailing_metadata.get(), op_args.trailing_metadata,
+                             true);
+        recv_trailing_metadata_ = std::move(trailing_metadata);
         FinishOpOnCompletion(&completion, PendingOp::kReceiveStatusOnClient);
       });
 }
@@ -3010,16 +3256,24 @@ void ClientPromiseBasedCall::StartRecvStatusOnClient(
 
 #ifdef GRPC_EXPERIMENT_IS_INCLUDED_PROMISE_BASED_SERVER_CALL
 
-class ServerPromiseBasedCall final : public PromiseBasedCall {
+class ServerPromiseBasedCall final : public PromiseBasedCall,
+                                     public ServerCallContext {
  public:
   ServerPromiseBasedCall(Arena* arena, grpc_call_create_args* args);
 
+  void OrphanCall() override {}
   void CancelWithError(grpc_error_handle) override;
   grpc_call_error StartBatch(const grpc_op* ops, size_t nops, void* notify_tag,
                              bool is_notify_tag_closure) override;
-  bool failed_before_recv_message() const override { return false; }
-  bool is_trailers_only() const override { abort(); }
-  absl::string_view GetServerAuthority() const override { return ""; }
+  bool is_trailers_only() const override {
+    Crash("is_trailers_only not implemented for server calls");
+  }
+  absl::string_view GetServerAuthority() const override {
+    const Slice* authority_metadata =
+        client_initial_metadata_->get_pointer(HttpAuthorityMetadata());
+    if (authority_metadata == nullptr) return "";
+    return authority_metadata->as_string_view();
+  }
 
   // Polling order for the server promise stack:
   //
@@ -3046,7 +3300,15 @@ class ServerPromiseBasedCall final : public PromiseBasedCall {
     return absl::StrFormat("SERVER_CALL[%p]: ", this);
   }
 
-  ServerCallContext* server_call_context() override { return &call_context_; }
+  ServerCallContext* server_call_context() override { return this; }
+
+  const void* server_stream_data() override { return server_transport_data_; }
+  void PublishInitialMetadata(
+      ClientMetadataHandle metadata,
+      grpc_metadata_array* publish_initial_metadata) override;
+  ArenaPromise<ServerMetadataHandle> MakeTopOfServerCallPromise(
+      CallArgs call_args, grpc_completion_queue* cq,
+      absl::FunctionRef<void(grpc_call* call)> publish) override;
 
  private:
   class RecvCloseOpCancelState {
@@ -3131,14 +3393,12 @@ class ServerPromiseBasedCall final : public PromiseBasedCall {
     std::atomic<uintptr_t> state_{kUnset};
   };
 
-  grpc_call_error ValidateBatch(const grpc_op* ops, size_t nops) const;
   void CommitBatch(const grpc_op* ops, size_t nops,
                    const Completion& completion);
   void Finish(ServerMetadataHandle result);
 
-  friend class ServerCallContext;
-  ServerCallContext call_context_;
   Server* const server_;
+  const void* const server_transport_data_;
   PipeSender<ServerMetadataHandle>* server_initial_metadata_ = nullptr;
   PipeSender<MessageHandle>* server_to_client_messages_ = nullptr;
   PipeReceiver<MessageHandle>* client_to_server_messages_ = nullptr;
@@ -3152,8 +3412,8 @@ class ServerPromiseBasedCall final : public PromiseBasedCall {
 ServerPromiseBasedCall::ServerPromiseBasedCall(Arena* arena,
                                                grpc_call_create_args* args)
     : PromiseBasedCall(arena, 0, *args),
-      call_context_(this, args->server_transport_data),
-      server_(args->server) {
+      server_(args->server),
+      server_transport_data_(args->server_transport_data) {
   global_stats().IncrementServerCallsCreated();
   channelz::ServerNode* channelz_node = server_->channelz_node();
   if (channelz_node != nullptr) {
@@ -3163,11 +3423,10 @@ ServerPromiseBasedCall::ServerPromiseBasedCall(Arena* arena,
   // collecting from when the call is created at the transport. The idea is that
   // the transport would create the call tracer and pass it in as part of the
   // metadata.
-  auto* server_call_tracer_factory =
-      ServerCallTracerFactory::Get(args->server->channel_args());
-  if (server_call_tracer_factory != nullptr) {
+  if (args->server->server_call_tracer_factory() != nullptr) {
     auto* server_call_tracer =
-        server_call_tracer_factory->CreateNewServerCallTracer(arena);
+        args->server->server_call_tracer_factory()->CreateNewServerCallTracer(
+            arena, args->server->channel_args());
     if (server_call_tracer != nullptr) {
       // Note that we are setting both
       // GRPC_CONTEXT_CALL_TRACER_ANNOTATION_INTERFACE and
@@ -3183,7 +3442,7 @@ ServerPromiseBasedCall::ServerPromiseBasedCall(Arena* arena,
   Spawn("server_promise",
         channel()->channel_stack()->MakeServerCallPromise(
             CallArgs{nullptr, ClientInitialMetadataOutstandingToken::Empty(),
-                     nullptr, nullptr, nullptr}),
+                     nullptr, nullptr, nullptr, nullptr}),
         [this](ServerMetadataHandle result) { Finish(std::move(result)); });
 }
 
@@ -3193,30 +3452,38 @@ void ServerPromiseBasedCall::Finish(ServerMetadataHandle result) {
             DebugTag().c_str(), recv_close_op_cancel_state_.ToString().c_str(),
             result->DebugString().c_str());
   }
+  const auto status =
+      result->get(GrpcStatusMetadata()).value_or(GRPC_STATUS_UNKNOWN);
+  channelz::ServerNode* channelz_node = server_->channelz_node();
+  if (channelz_node != nullptr) {
+    if (status == GRPC_STATUS_OK) {
+      channelz_node->RecordCallSucceeded();
+    } else {
+      channelz_node->RecordCallFailed();
+    }
+  }
+  bool was_cancelled = result->get(GrpcCallWasCancelled()).value_or(true);
   if (recv_close_op_cancel_state_.CompleteCallWithCancelledSetTo(
-          result->get(GrpcCallWasCancelled()).value_or(true))) {
+          was_cancelled)) {
     FinishOpOnCompletion(&recv_close_completion_,
                          PendingOp::kReceiveCloseOnServer);
   }
+  if (was_cancelled) set_failed_before_recv_message();
   if (server_initial_metadata_ != nullptr) {
     server_initial_metadata_->Close();
   }
-  channelz::ServerNode* channelz_node = server_->channelz_node();
-  if (channelz_node != nullptr) {
-    if (result->get(GrpcStatusMetadata()).value_or(GRPC_STATUS_UNKNOWN) ==
-        GRPC_STATUS_OK) {
-      channelz_node->RecordCallSucceeded();
-    } else {
-      channelz_node->RecordCallFailed();
-    }
+  Slice message_slice;
+  if (Slice* message = result->get_pointer(GrpcMessageMetadata())) {
+    message_slice = message->Ref();
   }
+  AcceptTransportStatsFromContext();
+  SetFinalizationStatus(status, std::move(message_slice));
   set_completed();
   ResetDeadline();
   PropagateCancellationToChildren();
 }
 
-grpc_call_error ServerPromiseBasedCall::ValidateBatch(const grpc_op* ops,
-                                                      size_t nops) const {
+grpc_call_error ValidateServerBatch(const grpc_op* ops, size_t nops) {
   BitSet<8> got_ops;
   for (size_t op_idx = 0; op_idx < nops; op_idx++) {
     const grpc_op& op = ops[op_idx];
@@ -3235,9 +3502,16 @@ grpc_call_error ServerPromiseBasedCall::ValidateBatch(const grpc_op* ops,
           return GRPC_CALL_ERROR_INVALID_FLAGS;
         }
         break;
+      case GRPC_OP_SEND_STATUS_FROM_SERVER:
+        if (op.flags != 0) return GRPC_CALL_ERROR_INVALID_FLAGS;
+        if (!ValidateMetadata(
+                op.data.send_status_from_server.trailing_metadata_count,
+                op.data.send_status_from_server.trailing_metadata)) {
+          return GRPC_CALL_ERROR_INVALID_METADATA;
+        }
+        break;
       case GRPC_OP_RECV_MESSAGE:
       case GRPC_OP_RECV_CLOSE_ON_SERVER:
-      case GRPC_OP_SEND_STATUS_FROM_SERVER:
         if (op.flags != 0) return GRPC_CALL_ERROR_INVALID_FLAGS;
         break;
       case GRPC_OP_RECV_INITIAL_METADATA:
@@ -3276,7 +3550,10 @@ void ServerPromiseBasedCall::CommitBatch(const grpc_op* ops, size_t nops,
             [this,
              completion = AddOpToCompletion(
                  completion, PendingOp::kSendInitialMetadata)](bool r) mutable {
-              if (!r) FailCompletion(completion);
+              if (!r) {
+                set_failed_before_recv_message();
+                FailCompletion(completion);
+              }
               FinishOpOnCompletion(&completion,
                                    PendingOp::kSendInitialMetadata);
             });
@@ -3286,12 +3563,13 @@ void ServerPromiseBasedCall::CommitBatch(const grpc_op* ops, size_t nops,
         break;
       case GRPC_OP_RECV_MESSAGE:
         if (cancelled_.load(std::memory_order_relaxed)) {
+          set_failed_before_recv_message();
           FailCompletion(completion);
           break;
         }
         StartRecvMessage(
             op, completion, []() { return []() { return Empty{}; }; },
-            client_to_server_messages_, spawner);
+            client_to_server_messages_, true, spawner);
         break;
       case GRPC_OP_SEND_STATUS_FROM_SERVER: {
         auto metadata = arena()->MakePooled<ServerMetadata>(arena());
@@ -3301,7 +3579,12 @@ void ServerPromiseBasedCall::CommitBatch(const grpc_op* ops, size_t nops,
         metadata->Set(GrpcStatusMetadata(),
                       op.data.send_status_from_server.status);
         if (auto* details = op.data.send_status_from_server.status_details) {
-          metadata->Set(GrpcMessageMetadata(), Slice(CSliceRef(*details)));
+          // TODO(ctiller): this should not be a copy, but we have callers that
+          // allocate and pass in a slice created with
+          // grpc_slice_from_static_string and then delete the string after
+          // passing it in, which shouldn't be a supported API.
+          metadata->Set(GrpcMessageMetadata(),
+                        Slice(grpc_slice_copy(*details)));
         }
         spawner.Spawn(
             "call_send_status_from_server",
@@ -3321,7 +3604,10 @@ void ServerPromiseBasedCall::CommitBatch(const grpc_op* ops, size_t nops,
             [this, completion = AddOpToCompletion(
                        completion, PendingOp::kSendStatusFromServer)](
                 bool ok) mutable {
-              if (!ok) FailCompletion(completion);
+              if (!ok) {
+                set_failed_before_recv_message();
+                FailCompletion(completion);
+              }
               FinishOpOnCompletion(&completion,
                                    PendingOp::kSendStatusFromServer);
             });
@@ -3357,7 +3643,7 @@ grpc_call_error ServerPromiseBasedCall::StartBatch(const grpc_op* ops,
     EndOpImmediately(cq(), notify_tag, is_notify_tag_closure);
     return GRPC_CALL_OK;
   }
-  const grpc_call_error validation_result = ValidateBatch(ops, nops);
+  const grpc_call_error validation_result = ValidateServerBatch(ops, nops);
   if (validation_result != GRPC_CALL_OK) {
     return validation_result;
   }
@@ -3391,32 +3677,400 @@ void ServerPromiseBasedCall::CancelWithError(absl::Status error) {
 #endif
 
 #ifdef GRPC_EXPERIMENT_IS_INCLUDED_PROMISE_BASED_SERVER_CALL
+void ServerPromiseBasedCall::PublishInitialMetadata(
+    ClientMetadataHandle metadata,
+    grpc_metadata_array* publish_initial_metadata) {
+  if (grpc_call_trace.enabled()) {
+    gpr_log(GPR_INFO, "%s[call] PublishInitialMetadata: %s", DebugTag().c_str(),
+            metadata->DebugString().c_str());
+  }
+  PublishMetadataArray(metadata.get(), publish_initial_metadata, false);
+  client_initial_metadata_ = std::move(metadata);
+}
+
 ArenaPromise<ServerMetadataHandle>
-ServerCallContext::MakeTopOfServerCallPromise(
+ServerPromiseBasedCall::MakeTopOfServerCallPromise(
     CallArgs call_args, grpc_completion_queue* cq,
-    grpc_metadata_array* publish_initial_metadata,
     absl::FunctionRef<void(grpc_call* call)> publish) {
-  call_->SetCompletionQueue(cq);
-  call_->server_to_client_messages_ = call_args.server_to_client_messages;
-  call_->client_to_server_messages_ = call_args.client_to_server_messages;
-  call_->server_initial_metadata_ = call_args.server_initial_metadata;
-  call_->client_initial_metadata_ =
-      std::move(call_args.client_initial_metadata);
-  call_->ProcessIncomingInitialMetadata(*call_->client_initial_metadata_);
-  PublishMetadataArray(call_->client_initial_metadata_.get(),
-                       publish_initial_metadata);
-  call_->ExternalRef();
-  publish(call_->c_ptr());
-  return Seq(call_->server_to_client_messages_->AwaitClosed(),
-             call_->send_trailing_metadata_.Wait());
+  SetCompletionQueue(cq);
+  call_args.polling_entity->Set(
+      grpc_polling_entity_create_from_pollset(grpc_cq_pollset(cq)));
+  server_to_client_messages_ = call_args.server_to_client_messages;
+  client_to_server_messages_ = call_args.client_to_server_messages;
+  server_initial_metadata_ = call_args.server_initial_metadata;
+  set_send_deadline(deadline());
+  ProcessIncomingInitialMetadata(*client_initial_metadata_);
+  ExternalRef();
+  publish(c_ptr());
+  return Seq(server_to_client_messages_->AwaitClosed(),
+             send_trailing_metadata_.Wait());
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// CallSpine based Server Call
+
+class ServerCallSpine final : public CallSpineInterface,
+                              public ServerCallContext,
+                              public BasicPromiseBasedCall {
+ public:
+  ServerCallSpine(Server* server, Channel* channel, Arena* arena);
+
+  // CallSpineInterface
+  Pipe<ClientMetadataHandle>& client_initial_metadata() override {
+    return client_initial_metadata_;
+  }
+  Pipe<ServerMetadataHandle>& server_initial_metadata() override {
+    return server_initial_metadata_;
+  }
+  Pipe<MessageHandle>& client_to_server_messages() override {
+    return client_to_server_messages_;
+  }
+  Pipe<MessageHandle>& server_to_client_messages() override {
+    return server_to_client_messages_;
+  }
+  Pipe<ServerMetadataHandle>& server_trailing_metadata() override {
+    return server_trailing_metadata_;
+  }
+  Latch<ServerMetadataHandle>& cancel_latch() override { return cancel_latch_; }
+  Party& party() override { return *this; }
+  void IncrementRefCount() override { InternalRef("CallSpine"); }
+  void Unref() override { InternalUnref("CallSpine"); }
+
+  // PromiseBasedCall
+  void OrphanCall() override {}
+  void CancelWithError(grpc_error_handle error) override {
+    SpawnInfallible("CancelWithError", [this, error = std::move(error)] {
+      std::ignore = Cancel(ServerMetadataFromStatus(error));
+      return Empty{};
+    });
+  }
+  bool is_trailers_only() const override {
+    Crash("is_trailers_only not implemented for server calls");
+  }
+  absl::string_view GetServerAuthority() const override {
+    Crash("unimplemented");
+  }
+  grpc_call_error StartBatch(const grpc_op* ops, size_t nops, void* notify_tag,
+                             bool is_notify_tag_closure) override;
+
+  bool Completed() final { Crash("unimplemented"); }
+  bool failed_before_recv_message() const final { Crash("unimplemented"); }
+
+  ServerCallContext* server_call_context() override { return this; }
+  const void* server_stream_data() override { Crash("unimplemented"); }
+  void PublishInitialMetadata(
+      ClientMetadataHandle metadata,
+      grpc_metadata_array* publish_initial_metadata) override;
+  ArenaPromise<ServerMetadataHandle> MakeTopOfServerCallPromise(
+      CallArgs, grpc_completion_queue*,
+      absl::FunctionRef<void(grpc_call* call)>) override {
+    Crash("unimplemented");
+  }
+
+  bool RunParty() override {
+    ScopedContext ctx(this);
+    return Party::RunParty();
+  }
+
+ private:
+  void CommitBatch(const grpc_op* ops, size_t nops, void* notify_tag,
+                   bool is_notify_tag_closure);
+  StatusFlag FinishRecvMessage(NextResult<MessageHandle> result);
+
+  std::string DebugTag() const override {
+    return absl::StrFormat("SERVER_CALL_SPINE[%p]: ", this);
+  }
+
+  // Initial metadata from client to server
+  Pipe<ClientMetadataHandle> client_initial_metadata_;
+  // Initial metadata from server to client
+  Pipe<ServerMetadataHandle> server_initial_metadata_;
+  // Messages travelling from the application to the transport.
+  Pipe<MessageHandle> client_to_server_messages_;
+  // Messages travelling from the transport to the application.
+  Pipe<MessageHandle> server_to_client_messages_;
+  // Trailing metadata from server to client
+  Pipe<ServerMetadataHandle> server_trailing_metadata_;
+  // Latch that can be set to terminate the call
+  Latch<ServerMetadataHandle> cancel_latch_;
+  grpc_byte_buffer** recv_message_ = nullptr;
+  ClientMetadataHandle client_initial_metadata_stored_;
+};
+
+ServerCallSpine::ServerCallSpine(Server* server, Channel* channel, Arena* arena)
+    : BasicPromiseBasedCall(
+          arena, 1, [channel, server]() -> grpc_call_create_args {
+            grpc_call_create_args args;
+            args.channel = channel->Ref();
+            args.server = server;
+            args.parent = nullptr;
+            args.propagation_mask = 0;
+            args.cq = nullptr;
+            args.pollset_set_alternative = nullptr;
+            args.server_transport_data = &args;  // Arbitrary non-null pointer
+            args.send_deadline = Timestamp::InfFuture();
+            return args;
+          }()) {
+  global_stats().IncrementServerCallsCreated();
+  channel->channel_stack()->InitServerCallSpine(this);
+}
+
+void ServerCallSpine::PublishInitialMetadata(
+    ClientMetadataHandle metadata,
+    grpc_metadata_array* publish_initial_metadata) {
+  if (grpc_call_trace.enabled()) {
+    gpr_log(GPR_INFO, "%s[call] PublishInitialMetadata: %s", DebugTag().c_str(),
+            metadata->DebugString().c_str());
+  }
+  PublishMetadataArray(metadata.get(), publish_initial_metadata, false);
+  client_initial_metadata_stored_ = std::move(metadata);
+}
+
+grpc_call_error ServerCallSpine::StartBatch(const grpc_op* ops, size_t nops,
+                                            void* notify_tag,
+                                            bool is_notify_tag_closure) {
+  if (nops == 0) {
+    EndOpImmediately(cq(), notify_tag, is_notify_tag_closure);
+    return GRPC_CALL_OK;
+  }
+  const grpc_call_error validation_result = ValidateServerBatch(ops, nops);
+  if (validation_result != GRPC_CALL_OK) {
+    return validation_result;
+  }
+  CommitBatch(ops, nops, notify_tag, is_notify_tag_closure);
+  return GRPC_CALL_OK;
+}
+
+namespace {
+template <typename SetupFn>
+class MaybeOpImpl {
+ public:
+  using SetupResult = decltype(std::declval<SetupFn>()(grpc_op()));
+  using PromiseFactory = promise_detail::OncePromiseFactory<void, SetupResult>;
+  using Promise = typename PromiseFactory::Promise;
+  struct Dismissed {};
+  using State = absl::variant<Dismissed, PromiseFactory, Promise>;
+
+  MaybeOpImpl() : state_(Dismissed{}) {}
+  explicit MaybeOpImpl(SetupResult result)
+      : state_(PromiseFactory(std::move(result))) {}
+
+  MaybeOpImpl(const MaybeOpImpl&) = delete;
+  MaybeOpImpl& operator=(const MaybeOpImpl&) = delete;
+  MaybeOpImpl(MaybeOpImpl&& other) noexcept : state_(MoveState(other.state_)) {}
+  MaybeOpImpl& operator=(MaybeOpImpl&& other) noexcept {
+    if (absl::holds_alternative<Dismissed>(state_)) {
+      state_.template emplace<Dismissed>();
+      return *this;
+    }
+    // Can't move after first poll => Promise is not an option
+    state_.template emplace<PromiseFactory>(
+        std::move(absl::get<PromiseFactory>(other.state_)));
+    return *this;
+  }
+
+  Poll<StatusFlag> operator()() {
+    if (absl::holds_alternative<Dismissed>(state_)) return Success{};
+    if (absl::holds_alternative<PromiseFactory>(state_)) {
+      auto& factory = absl::get<PromiseFactory>(state_);
+      auto promise = factory.Make();
+      state_.template emplace<Promise>(std::move(promise));
+    }
+    auto& promise = absl::get<Promise>(state_);
+    return poll_cast<StatusFlag>(promise());
+  }
+
+ private:
+  State state_;
+
+  static State MoveState(State& state) {
+    if (absl::holds_alternative<Dismissed>(state)) return Dismissed{};
+    // Can't move after first poll => Promise is not an option
+    return std::move(absl::get<PromiseFactory>(state));
+  }
+};
+
+// MaybeOp captures a fairly complicated dance we need to do for the batch API.
+// We first check if an op is included or not, and if it is, we run the setup
+// function in the context of the API call (NOT in the call party).
+// This setup function returns a promise factory which we'll then run *in* the
+// party to do initial setup, and have it return the promise that we'll
+// ultimately poll on til completion.
+// Once we express our surface API in terms of core internal types this whole
+// dance will go away.
+template <typename SetupFn>
+auto MaybeOp(const grpc_op* ops, uint8_t idx, SetupFn setup) {
+  if (idx == 255) {
+    return MaybeOpImpl<SetupFn>();
+  } else {
+    return MaybeOpImpl<SetupFn>(setup(ops[idx]));
+  }
+}
+}  // namespace
+
+StatusFlag ServerCallSpine::FinishRecvMessage(
+    NextResult<MessageHandle> result) {
+  if (result.has_value()) {
+    MessageHandle& message = *result;
+    NoteLastMessageFlags(message->flags());
+    if ((message->flags() & GRPC_WRITE_INTERNAL_COMPRESS) &&
+        (incoming_compression_algorithm() != GRPC_COMPRESS_NONE)) {
+      *recv_message_ = grpc_raw_compressed_byte_buffer_create(
+          nullptr, 0, incoming_compression_algorithm());
+    } else {
+      *recv_message_ = grpc_raw_byte_buffer_create(nullptr, 0);
+    }
+    grpc_slice_buffer_move_into(message->payload()->c_slice_buffer(),
+                                &(*recv_message_)->data.raw.slice_buffer);
+    if (grpc_call_trace.enabled()) {
+      gpr_log(GPR_INFO,
+              "%s[call] RecvMessage: outstanding_recv "
+              "finishes: received %" PRIdPTR " byte message",
+              DebugTag().c_str(),
+              (*recv_message_)->data.raw.slice_buffer.length);
+    }
+    return Success{};
+  }
+  if (result.cancelled()) {
+    if (grpc_call_trace.enabled()) {
+      gpr_log(GPR_INFO,
+              "%s[call] RecvMessage: outstanding_recv "
+              "finishes: received end-of-stream with error",
+              DebugTag().c_str());
+    }
+    *recv_message_ = nullptr;
+    return Failure{};
+  }
+  if (grpc_call_trace.enabled()) {
+    gpr_log(GPR_INFO,
+            "%s[call] RecvMessage: outstanding_recv "
+            "finishes: received end-of-stream",
+            DebugTag().c_str());
+  }
+  *recv_message_ = nullptr;
+  return Success{};
+}
+
+void ServerCallSpine::CommitBatch(const grpc_op* ops, size_t nops,
+                                  void* notify_tag,
+                                  bool is_notify_tag_closure) {
+  std::array<uint8_t, 8> got_ops{255, 255, 255, 255, 255, 255, 255, 255};
+  for (size_t op_idx = 0; op_idx < nops; op_idx++) {
+    const grpc_op& op = ops[op_idx];
+    got_ops[op.op] = op_idx;
+  }
+  if (!is_notify_tag_closure) grpc_cq_begin_op(cq(), notify_tag);
+  auto send_initial_metadata = MaybeOp(
+      ops, got_ops[GRPC_OP_SEND_INITIAL_METADATA], [this](const grpc_op& op) {
+        auto metadata = arena()->MakePooled<ServerMetadata>(arena());
+        PrepareOutgoingInitialMetadata(op, *metadata);
+        CToMetadata(op.data.send_initial_metadata.metadata,
+                    op.data.send_initial_metadata.count, metadata.get());
+        if (grpc_call_trace.enabled()) {
+          gpr_log(GPR_INFO, "%s[call] Send initial metadata",
+                  DebugTag().c_str());
+        }
+        return [this, metadata = std::move(metadata)]() mutable {
+          return Map(server_initial_metadata_.sender.Push(std::move(metadata)),
+                     [this](bool r) {
+                       server_initial_metadata_.sender.Close();
+                       return StatusFlag(r);
+                     });
+        };
+      });
+  auto send_message =
+      MaybeOp(ops, got_ops[GRPC_OP_SEND_MESSAGE], [this](const grpc_op& op) {
+        SliceBuffer send;
+        grpc_slice_buffer_swap(
+            &op.data.send_message.send_message->data.raw.slice_buffer,
+            send.c_slice_buffer());
+        auto msg = arena()->MakePooled<Message>(std::move(send), op.flags);
+        return [this, msg = std::move(msg)]() mutable {
+          return Map(server_to_client_messages_.sender.Push(std::move(msg)),
+                     [](bool r) { return StatusFlag(r); });
+        };
+      });
+  auto send_trailing_metadata = MaybeOp(
+      ops, got_ops[GRPC_OP_SEND_STATUS_FROM_SERVER], [this](const grpc_op& op) {
+        auto metadata = arena()->MakePooled<ServerMetadata>(arena());
+        CToMetadata(op.data.send_status_from_server.trailing_metadata,
+                    op.data.send_status_from_server.trailing_metadata_count,
+                    metadata.get());
+        metadata->Set(GrpcStatusMetadata(),
+                      op.data.send_status_from_server.status);
+        if (auto* details = op.data.send_status_from_server.status_details) {
+          // TODO(ctiller): this should not be a copy, but we have
+          // callers that allocate and pass in a slice created with
+          // grpc_slice_from_static_string and then delete the string
+          // after passing it in, which shouldn't be a supported API.
+          metadata->Set(GrpcMessageMetadata(),
+                        Slice(grpc_slice_copy(*details)));
+        }
+        return [this, metadata = std::move(metadata)]() mutable {
+          server_to_client_messages_.sender.Close();
+          return Map(server_trailing_metadata_.sender.Push(std::move(metadata)),
+                     [](bool r) { return StatusFlag(r); });
+        };
+      });
+  auto recv_message =
+      MaybeOp(ops, got_ops[GRPC_OP_RECV_MESSAGE], [this](const grpc_op& op) {
+        GPR_ASSERT(recv_message_ == nullptr);
+        recv_message_ = op.data.recv_message.recv_message;
+        return [this]() mutable {
+          return Map(client_to_server_messages_.receiver.Next(),
+                     [this](NextResult<MessageHandle> msg) {
+                       return FinishRecvMessage(std::move(msg));
+                     });
+        };
+      });
+  auto primary_ops = AllOk<StatusFlag>(
+      std::move(send_initial_metadata), std::move(send_message),
+      std::move(send_trailing_metadata), std::move(recv_message));
+  if (got_ops[GRPC_OP_RECV_CLOSE_ON_SERVER] != 255) {
+    auto recv_trailing_metadata = MaybeOp(
+        ops, got_ops[GRPC_OP_RECV_CLOSE_ON_SERVER], [this](const grpc_op& op) {
+          return [this, cancelled = op.data.recv_close_on_server.cancelled]() {
+            return Map(server_trailing_metadata_.receiver.AwaitClosed(),
+                       [cancelled](bool result) -> Success {
+                         *cancelled = result ? 1 : 0;
+                         Crash("return metadata here");
+                         return Success{};
+                       });
+          };
+        });
+    SpawnInfallible(
+        "final-batch",
+        [primary_ops = std::move(primary_ops),
+         recv_trailing_metadata = std::move(recv_trailing_metadata),
+         is_notify_tag_closure, notify_tag, this]() mutable {
+          return Seq(std::move(primary_ops), std::move(recv_trailing_metadata),
+                     [is_notify_tag_closure, notify_tag, this](StatusFlag) {
+                       return WaitForCqEndOp(is_notify_tag_closure, notify_tag,
+                                             absl::OkStatus(), cq());
+                     });
+        });
+  } else {
+    SpawnInfallible(
+        "batch", [primary_ops = std::move(primary_ops), is_notify_tag_closure,
+                  notify_tag, this]() mutable {
+          return Seq(std::move(primary_ops), [is_notify_tag_closure, notify_tag,
+                                              this](StatusFlag r) {
+            return WaitForCqEndOp(is_notify_tag_closure, notify_tag,
+                                  StatusCast<grpc_error_handle>(r), cq());
+          });
+        });
+  }
+}
+
+RefCountedPtr<CallSpineInterface> MakeServerCall(Server* server,
+                                                 Channel* channel,
+                                                 Arena* arena) {
+  return RefCountedPtr<ServerCallSpine>(
+      arena->New<ServerCallSpine>(server, channel, arena));
 }
 #else
-ArenaPromise<ServerMetadataHandle>
-ServerCallContext::MakeTopOfServerCallPromise(
-    CallArgs, grpc_completion_queue*, grpc_metadata_array*,
-    absl::FunctionRef<void(grpc_call*)>) {
-  (void)call_;
-  Crash("Promise-based server call is not enabled");
+RefCountedPtr<CallSpineInterface> MakeServerCall(Server*, Channel*, Arena*) {
+  Crash("not implemented");
 }
 #endif
 
@@ -3476,6 +4130,9 @@ grpc_call* grpc_call_from_top_element(grpc_call_element* surface_element) {
 grpc_call_error grpc_call_cancel(grpc_call* call, void* reserved) {
   GRPC_API_TRACE("grpc_call_cancel(call=%p, reserved=%p)", 2, (call, reserved));
   GPR_ASSERT(reserved == nullptr);
+  if (call == nullptr) {
+    return GRPC_CALL_ERROR;
+  }
   grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
   grpc_core::ExecCtx exec_ctx;
   grpc_core::Call::FromC(call)->CancelWithError(absl::CancelledError());
@@ -3491,6 +4148,9 @@ grpc_call_error grpc_call_cancel_with_status(grpc_call* c,
       "c=%p, status=%d, description=%s, reserved=%p)",
       4, (c, (int)status, description, reserved));
   GPR_ASSERT(reserved == nullptr);
+  if (c == nullptr) {
+    return GRPC_CALL_ERROR;
+  }
   grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
   grpc_core::ExecCtx exec_ctx;
   grpc_core::Call::FromC(c)->CancelWithStatus(status, description);
@@ -3531,7 +4191,7 @@ grpc_call_error grpc_call_start_batch(grpc_call* call, const grpc_op* ops,
       "reserved=%p)",
       5, (call, ops, (unsigned long)nops, tag, reserved));
 
-  if (reserved != nullptr) {
+  if (reserved != nullptr || call == nullptr) {
     return GRPC_CALL_ERROR;
   } else {
     grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
@@ -3616,3 +4276,8 @@ const char* grpc_call_error_to_string(grpc_call_error error) {
   }
   GPR_UNREACHABLE_CODE(return "GRPC_CALL_ERROR_UNKNOW");
 }
+
+void grpc_call_run_in_event_engine(const grpc_call* call,
+                                   absl::AnyInvocable<void()> cb) {
+  grpc_core::Call::FromC(call)->event_engine()->Run(std::move(cb));
+}