diff --git a/Examples/echo/Sources/Generated/echo.grpc.swift b/Examples/echo/Sources/Generated/echo.grpc.swift
index a782d7d4a..88b929b9a 100644
--- a/Examples/echo/Sources/Generated/echo.grpc.swift
+++ b/Examples/echo/Sources/Generated/echo.grpc.swift
@@ -87,27 +87,27 @@ extension GRPCCore.ServiceDescriptor {
 internal protocol Echo_Echo_StreamingServiceProtocol: GRPCCore.RegistrableRPCService {
     /// Immediately returns an echo of a request.
     func get(
-        request: GRPCCore.ServerRequest.Stream<Echo_EchoRequest>,
+        request: GRPCCore.StreamingServerRequest<Echo_EchoRequest>,
         context: GRPCCore.ServerContext
-    ) async throws -> GRPCCore.ServerResponse.Stream<Echo_EchoResponse>
+    ) async throws -> GRPCCore.StreamingServerResponse<Echo_EchoResponse>
     
     /// Splits a request into words and returns each word in a stream of messages.
     func expand(
-        request: GRPCCore.ServerRequest.Stream<Echo_EchoRequest>,
+        request: GRPCCore.StreamingServerRequest<Echo_EchoRequest>,
         context: GRPCCore.ServerContext
-    ) async throws -> GRPCCore.ServerResponse.Stream<Echo_EchoResponse>
+    ) async throws -> GRPCCore.StreamingServerResponse<Echo_EchoResponse>
     
     /// Collects a stream of messages and returns them concatenated when the caller closes.
     func collect(
-        request: GRPCCore.ServerRequest.Stream<Echo_EchoRequest>,
+        request: GRPCCore.StreamingServerRequest<Echo_EchoRequest>,
         context: GRPCCore.ServerContext
-    ) async throws -> GRPCCore.ServerResponse.Stream<Echo_EchoResponse>
+    ) async throws -> GRPCCore.StreamingServerResponse<Echo_EchoResponse>
     
     /// Streams back messages as they are received in an input stream.
     func update(
-        request: GRPCCore.ServerRequest.Stream<Echo_EchoRequest>,
+        request: GRPCCore.StreamingServerRequest<Echo_EchoRequest>,
         context: GRPCCore.ServerContext
-    ) async throws -> GRPCCore.ServerResponse.Stream<Echo_EchoResponse>
+    ) async throws -> GRPCCore.StreamingServerResponse<Echo_EchoResponse>
 }
 
 /// Conformance to `GRPCCore.RegistrableRPCService`.
@@ -166,63 +166,63 @@ extension Echo_Echo.StreamingServiceProtocol {
 internal protocol Echo_Echo_ServiceProtocol: Echo_Echo.StreamingServiceProtocol {
     /// Immediately returns an echo of a request.
     func get(
-        request: GRPCCore.ServerRequest.Single<Echo_EchoRequest>,
+        request: GRPCCore.ServerRequest<Echo_EchoRequest>,
         context: GRPCCore.ServerContext
-    ) async throws -> GRPCCore.ServerResponse.Single<Echo_EchoResponse>
+    ) async throws -> GRPCCore.ServerResponse<Echo_EchoResponse>
     
     /// Splits a request into words and returns each word in a stream of messages.
     func expand(
-        request: GRPCCore.ServerRequest.Single<Echo_EchoRequest>,
+        request: GRPCCore.ServerRequest<Echo_EchoRequest>,
         context: GRPCCore.ServerContext
-    ) async throws -> GRPCCore.ServerResponse.Stream<Echo_EchoResponse>
+    ) async throws -> GRPCCore.StreamingServerResponse<Echo_EchoResponse>
     
     /// Collects a stream of messages and returns them concatenated when the caller closes.
     func collect(
-        request: GRPCCore.ServerRequest.Stream<Echo_EchoRequest>,
+        request: GRPCCore.StreamingServerRequest<Echo_EchoRequest>,
         context: GRPCCore.ServerContext
-    ) async throws -> GRPCCore.ServerResponse.Single<Echo_EchoResponse>
+    ) async throws -> GRPCCore.ServerResponse<Echo_EchoResponse>
     
     /// Streams back messages as they are received in an input stream.
     func update(
-        request: GRPCCore.ServerRequest.Stream<Echo_EchoRequest>,
+        request: GRPCCore.StreamingServerRequest<Echo_EchoRequest>,
         context: GRPCCore.ServerContext
-    ) async throws -> GRPCCore.ServerResponse.Stream<Echo_EchoResponse>
+    ) async throws -> GRPCCore.StreamingServerResponse<Echo_EchoResponse>
 }
 
 /// Partial conformance to `Echo_Echo_StreamingServiceProtocol`.
 @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
 extension Echo_Echo.ServiceProtocol {
     internal func get(
-        request: GRPCCore.ServerRequest.Stream<Echo_EchoRequest>,
+        request: GRPCCore.StreamingServerRequest<Echo_EchoRequest>,
         context: GRPCCore.ServerContext
-    ) async throws -> GRPCCore.ServerResponse.Stream<Echo_EchoResponse> {
+    ) async throws -> GRPCCore.StreamingServerResponse<Echo_EchoResponse> {
         let response = try await self.get(
-            request: GRPCCore.ServerRequest.Single(stream: request),
+            request: GRPCCore.ServerRequest(stream: request),
             context: context
         )
-        return GRPCCore.ServerResponse.Stream(single: response)
+        return GRPCCore.StreamingServerResponse(single: response)
     }
     
     internal func expand(
-        request: GRPCCore.ServerRequest.Stream<Echo_EchoRequest>,
+        request: GRPCCore.StreamingServerRequest<Echo_EchoRequest>,
         context: GRPCCore.ServerContext
-    ) async throws -> GRPCCore.ServerResponse.Stream<Echo_EchoResponse> {
+    ) async throws -> GRPCCore.StreamingServerResponse<Echo_EchoResponse> {
         let response = try await self.expand(
-            request: GRPCCore.ServerRequest.Single(stream: request),
+            request: GRPCCore.ServerRequest(stream: request),
             context: context
         )
         return response
     }
     
     internal func collect(
-        request: GRPCCore.ServerRequest.Stream<Echo_EchoRequest>,
+        request: GRPCCore.StreamingServerRequest<Echo_EchoRequest>,
         context: GRPCCore.ServerContext
-    ) async throws -> GRPCCore.ServerResponse.Stream<Echo_EchoResponse> {
+    ) async throws -> GRPCCore.StreamingServerResponse<Echo_EchoResponse> {
         let response = try await self.collect(
             request: request,
             context: context
         )
-        return GRPCCore.ServerResponse.Stream(single: response)
+        return GRPCCore.StreamingServerResponse(single: response)
     }
 }
 
@@ -230,47 +230,47 @@ extension Echo_Echo.ServiceProtocol {
 internal protocol Echo_Echo_ClientProtocol: Sendable {
     /// Immediately returns an echo of a request.
     func get<R>(
-        request: GRPCCore.ClientRequest.Single<Echo_EchoRequest>,
+        request: GRPCCore.ClientRequest<Echo_EchoRequest>,
         serializer: some GRPCCore.MessageSerializer<Echo_EchoRequest>,
         deserializer: some GRPCCore.MessageDeserializer<Echo_EchoResponse>,
         options: GRPCCore.CallOptions,
-        _ body: @Sendable @escaping (GRPCCore.ClientResponse.Single<Echo_EchoResponse>) async throws -> R
+        _ body: @Sendable @escaping (GRPCCore.ClientResponse<Echo_EchoResponse>) async throws -> R
     ) async throws -> R where R: Sendable
     
     /// Splits a request into words and returns each word in a stream of messages.
     func expand<R>(
-        request: GRPCCore.ClientRequest.Single<Echo_EchoRequest>,
+        request: GRPCCore.ClientRequest<Echo_EchoRequest>,
         serializer: some GRPCCore.MessageSerializer<Echo_EchoRequest>,
         deserializer: some GRPCCore.MessageDeserializer<Echo_EchoResponse>,
         options: GRPCCore.CallOptions,
-        _ body: @Sendable @escaping (GRPCCore.ClientResponse.Stream<Echo_EchoResponse>) async throws -> R
+        _ body: @Sendable @escaping (GRPCCore.StreamingClientResponse<Echo_EchoResponse>) async throws -> R
     ) async throws -> R where R: Sendable
     
     /// Collects a stream of messages and returns them concatenated when the caller closes.
     func collect<R>(
-        request: GRPCCore.ClientRequest.Stream<Echo_EchoRequest>,
+        request: GRPCCore.StreamingClientRequest<Echo_EchoRequest>,
         serializer: some GRPCCore.MessageSerializer<Echo_EchoRequest>,
         deserializer: some GRPCCore.MessageDeserializer<Echo_EchoResponse>,
         options: GRPCCore.CallOptions,
-        _ body: @Sendable @escaping (GRPCCore.ClientResponse.Single<Echo_EchoResponse>) async throws -> R
+        _ body: @Sendable @escaping (GRPCCore.ClientResponse<Echo_EchoResponse>) async throws -> R
     ) async throws -> R where R: Sendable
     
     /// Streams back messages as they are received in an input stream.
     func update<R>(
-        request: GRPCCore.ClientRequest.Stream<Echo_EchoRequest>,
+        request: GRPCCore.StreamingClientRequest<Echo_EchoRequest>,
         serializer: some GRPCCore.MessageSerializer<Echo_EchoRequest>,
         deserializer: some GRPCCore.MessageDeserializer<Echo_EchoResponse>,
         options: GRPCCore.CallOptions,
-        _ body: @Sendable @escaping (GRPCCore.ClientResponse.Stream<Echo_EchoResponse>) async throws -> R
+        _ body: @Sendable @escaping (GRPCCore.StreamingClientResponse<Echo_EchoResponse>) async throws -> R
     ) async throws -> R where R: Sendable
 }
 
 @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
 extension Echo_Echo.ClientProtocol {
     internal func get<R>(
-        request: GRPCCore.ClientRequest.Single<Echo_EchoRequest>,
+        request: GRPCCore.ClientRequest<Echo_EchoRequest>,
         options: GRPCCore.CallOptions = .defaults,
-        _ body: @Sendable @escaping (GRPCCore.ClientResponse.Single<Echo_EchoResponse>) async throws -> R = {
+        _ body: @Sendable @escaping (GRPCCore.ClientResponse<Echo_EchoResponse>) async throws -> R = {
             try $0.message
         }
     ) async throws -> R where R: Sendable {
@@ -284,9 +284,9 @@ extension Echo_Echo.ClientProtocol {
     }
     
     internal func expand<R>(
-        request: GRPCCore.ClientRequest.Single<Echo_EchoRequest>,
+        request: GRPCCore.ClientRequest<Echo_EchoRequest>,
         options: GRPCCore.CallOptions = .defaults,
-        _ body: @Sendable @escaping (GRPCCore.ClientResponse.Stream<Echo_EchoResponse>) async throws -> R
+        _ body: @Sendable @escaping (GRPCCore.StreamingClientResponse<Echo_EchoResponse>) async throws -> R
     ) async throws -> R where R: Sendable {
         try await self.expand(
             request: request,
@@ -298,9 +298,9 @@ extension Echo_Echo.ClientProtocol {
     }
     
     internal func collect<R>(
-        request: GRPCCore.ClientRequest.Stream<Echo_EchoRequest>,
+        request: GRPCCore.StreamingClientRequest<Echo_EchoRequest>,
         options: GRPCCore.CallOptions = .defaults,
-        _ body: @Sendable @escaping (GRPCCore.ClientResponse.Single<Echo_EchoResponse>) async throws -> R = {
+        _ body: @Sendable @escaping (GRPCCore.ClientResponse<Echo_EchoResponse>) async throws -> R = {
             try $0.message
         }
     ) async throws -> R where R: Sendable {
@@ -314,9 +314,9 @@ extension Echo_Echo.ClientProtocol {
     }
     
     internal func update<R>(
-        request: GRPCCore.ClientRequest.Stream<Echo_EchoRequest>,
+        request: GRPCCore.StreamingClientRequest<Echo_EchoRequest>,
         options: GRPCCore.CallOptions = .defaults,
-        _ body: @Sendable @escaping (GRPCCore.ClientResponse.Stream<Echo_EchoResponse>) async throws -> R
+        _ body: @Sendable @escaping (GRPCCore.StreamingClientResponse<Echo_EchoResponse>) async throws -> R
     ) async throws -> R where R: Sendable {
         try await self.update(
             request: request,
@@ -335,11 +335,11 @@ extension Echo_Echo.ClientProtocol {
         _ message: Echo_EchoRequest,
         metadata: GRPCCore.Metadata = [:],
         options: GRPCCore.CallOptions = .defaults,
-        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse.Single<Echo_EchoResponse>) async throws -> Result = {
+        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Echo_EchoResponse>) async throws -> Result = {
             try $0.message
         }
     ) async throws -> Result where Result: Sendable {
-        let request = GRPCCore.ClientRequest.Single<Echo_EchoRequest>(
+        let request = GRPCCore.ClientRequest<Echo_EchoRequest>(
             message: message,
             metadata: metadata
         )
@@ -355,9 +355,9 @@ extension Echo_Echo.ClientProtocol {
         _ message: Echo_EchoRequest,
         metadata: GRPCCore.Metadata = [:],
         options: GRPCCore.CallOptions = .defaults,
-        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse.Stream<Echo_EchoResponse>) async throws -> Result
+        onResponse handleResponse: @Sendable @escaping (GRPCCore.StreamingClientResponse<Echo_EchoResponse>) async throws -> Result
     ) async throws -> Result where Result: Sendable {
-        let request = GRPCCore.ClientRequest.Single<Echo_EchoRequest>(
+        let request = GRPCCore.ClientRequest<Echo_EchoRequest>(
             message: message,
             metadata: metadata
         )
@@ -373,11 +373,11 @@ extension Echo_Echo.ClientProtocol {
         metadata: GRPCCore.Metadata = [:],
         options: GRPCCore.CallOptions = .defaults,
         requestProducer: @Sendable @escaping (GRPCCore.RPCWriter<Echo_EchoRequest>) async throws -> Void,
-        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse.Single<Echo_EchoResponse>) async throws -> Result = {
+        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Echo_EchoResponse>) async throws -> Result = {
             try $0.message
         }
     ) async throws -> Result where Result: Sendable {
-        let request = GRPCCore.ClientRequest.Stream<Echo_EchoRequest>(
+        let request = GRPCCore.StreamingClientRequest<Echo_EchoRequest>(
             metadata: metadata,
             producer: requestProducer
         )
@@ -393,9 +393,9 @@ extension Echo_Echo.ClientProtocol {
         metadata: GRPCCore.Metadata = [:],
         options: GRPCCore.CallOptions = .defaults,
         requestProducer: @Sendable @escaping (GRPCCore.RPCWriter<Echo_EchoRequest>) async throws -> Void,
-        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse.Stream<Echo_EchoResponse>) async throws -> Result
+        onResponse handleResponse: @Sendable @escaping (GRPCCore.StreamingClientResponse<Echo_EchoResponse>) async throws -> Result
     ) async throws -> Result where Result: Sendable {
-        let request = GRPCCore.ClientRequest.Stream<Echo_EchoRequest>(
+        let request = GRPCCore.StreamingClientRequest<Echo_EchoRequest>(
             metadata: metadata,
             producer: requestProducer
         )
@@ -417,11 +417,11 @@ internal struct Echo_Echo_Client: Echo_Echo.ClientProtocol {
     
     /// Immediately returns an echo of a request.
     internal func get<R>(
-        request: GRPCCore.ClientRequest.Single<Echo_EchoRequest>,
+        request: GRPCCore.ClientRequest<Echo_EchoRequest>,
         serializer: some GRPCCore.MessageSerializer<Echo_EchoRequest>,
         deserializer: some GRPCCore.MessageDeserializer<Echo_EchoResponse>,
         options: GRPCCore.CallOptions = .defaults,
-        _ body: @Sendable @escaping (GRPCCore.ClientResponse.Single<Echo_EchoResponse>) async throws -> R = {
+        _ body: @Sendable @escaping (GRPCCore.ClientResponse<Echo_EchoResponse>) async throws -> R = {
             try $0.message
         }
     ) async throws -> R where R: Sendable {
@@ -437,11 +437,11 @@ internal struct Echo_Echo_Client: Echo_Echo.ClientProtocol {
     
     /// Splits a request into words and returns each word in a stream of messages.
     internal func expand<R>(
-        request: GRPCCore.ClientRequest.Single<Echo_EchoRequest>,
+        request: GRPCCore.ClientRequest<Echo_EchoRequest>,
         serializer: some GRPCCore.MessageSerializer<Echo_EchoRequest>,
         deserializer: some GRPCCore.MessageDeserializer<Echo_EchoResponse>,
         options: GRPCCore.CallOptions = .defaults,
-        _ body: @Sendable @escaping (GRPCCore.ClientResponse.Stream<Echo_EchoResponse>) async throws -> R
+        _ body: @Sendable @escaping (GRPCCore.StreamingClientResponse<Echo_EchoResponse>) async throws -> R
     ) async throws -> R where R: Sendable {
         try await self.client.serverStreaming(
             request: request,
@@ -455,11 +455,11 @@ internal struct Echo_Echo_Client: Echo_Echo.ClientProtocol {
     
     /// Collects a stream of messages and returns them concatenated when the caller closes.
     internal func collect<R>(
-        request: GRPCCore.ClientRequest.Stream<Echo_EchoRequest>,
+        request: GRPCCore.StreamingClientRequest<Echo_EchoRequest>,
         serializer: some GRPCCore.MessageSerializer<Echo_EchoRequest>,
         deserializer: some GRPCCore.MessageDeserializer<Echo_EchoResponse>,
         options: GRPCCore.CallOptions = .defaults,
-        _ body: @Sendable @escaping (GRPCCore.ClientResponse.Single<Echo_EchoResponse>) async throws -> R = {
+        _ body: @Sendable @escaping (GRPCCore.ClientResponse<Echo_EchoResponse>) async throws -> R = {
             try $0.message
         }
     ) async throws -> R where R: Sendable {
@@ -475,11 +475,11 @@ internal struct Echo_Echo_Client: Echo_Echo.ClientProtocol {
     
     /// Streams back messages as they are received in an input stream.
     internal func update<R>(
-        request: GRPCCore.ClientRequest.Stream<Echo_EchoRequest>,
+        request: GRPCCore.StreamingClientRequest<Echo_EchoRequest>,
         serializer: some GRPCCore.MessageSerializer<Echo_EchoRequest>,
         deserializer: some GRPCCore.MessageDeserializer<Echo_EchoResponse>,
         options: GRPCCore.CallOptions = .defaults,
-        _ body: @Sendable @escaping (GRPCCore.ClientResponse.Stream<Echo_EchoResponse>) async throws -> R
+        _ body: @Sendable @escaping (GRPCCore.StreamingClientResponse<Echo_EchoResponse>) async throws -> R
     ) async throws -> R where R: Sendable {
         try await self.client.bidirectionalStreaming(
             request: request,
diff --git a/Examples/echo/Sources/Subcommands/Serve.swift b/Examples/echo/Sources/Subcommands/Serve.swift
index b5e126788..396ecef55 100644
--- a/Examples/echo/Sources/Subcommands/Serve.swift
+++ b/Examples/echo/Sources/Subcommands/Serve.swift
@@ -45,26 +45,26 @@ struct Serve: AsyncParsableCommand {
 @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
 struct EchoService: Echo_Echo_ServiceProtocol {
   func get(
-    request: ServerRequest.Single<Echo_EchoRequest>,
+    request: ServerRequest<Echo_EchoRequest>,
     context: ServerContext
-  ) async throws -> ServerResponse.Single<Echo_EchoResponse> {
-    return ServerResponse.Single(message: .with { $0.text = request.message.text })
+  ) async throws -> ServerResponse<Echo_EchoResponse> {
+    return ServerResponse(message: .with { $0.text = request.message.text })
   }
 
   func collect(
-    request: ServerRequest.Stream<Echo_EchoRequest>,
+    request: StreamingServerRequest<Echo_EchoRequest>,
     context: ServerContext
-  ) async throws -> ServerResponse.Single<Echo_EchoResponse> {
+  ) async throws -> ServerResponse<Echo_EchoResponse> {
     let messages = try await request.messages.reduce(into: []) { $0.append($1.text) }
     let joined = messages.joined(separator: " ")
-    return ServerResponse.Single(message: .with { $0.text = joined })
+    return ServerResponse(message: .with { $0.text = joined })
   }
 
   func expand(
-    request: ServerRequest.Single<Echo_EchoRequest>,
+    request: ServerRequest<Echo_EchoRequest>,
     context: ServerContext
-  ) async throws -> ServerResponse.Stream<Echo_EchoResponse> {
-    return ServerResponse.Stream { writer in
+  ) async throws -> StreamingServerResponse<Echo_EchoResponse> {
+    return StreamingServerResponse { writer in
       let parts = request.message.text.split(separator: " ")
       let messages = parts.map { part in Echo_EchoResponse.with { $0.text = String(part) } }
       try await writer.write(contentsOf: messages)
@@ -73,10 +73,10 @@ struct EchoService: Echo_Echo_ServiceProtocol {
   }
 
   func update(
-    request: ServerRequest.Stream<Echo_EchoRequest>,
+    request: StreamingServerRequest<Echo_EchoRequest>,
     context: ServerContext
-  ) async throws -> ServerResponse.Stream<Echo_EchoResponse> {
-    return ServerResponse.Stream { writer in
+  ) async throws -> StreamingServerResponse<Echo_EchoResponse> {
+    return StreamingServerResponse { writer in
       for try await message in request.messages {
         try await writer.write(.with { $0.text = message.text })
       }
diff --git a/Examples/hello-world/Sources/Generated/helloworld.grpc.swift b/Examples/hello-world/Sources/Generated/helloworld.grpc.swift
index 7ae35011b..bc729483a 100644
--- a/Examples/hello-world/Sources/Generated/helloworld.grpc.swift
+++ b/Examples/hello-world/Sources/Generated/helloworld.grpc.swift
@@ -61,9 +61,9 @@ extension GRPCCore.ServiceDescriptor {
 internal protocol Helloworld_Greeter_StreamingServiceProtocol: GRPCCore.RegistrableRPCService {
     /// Sends a greeting
     func sayHello(
-        request: GRPCCore.ServerRequest.Stream<Helloworld_HelloRequest>,
+        request: GRPCCore.StreamingServerRequest<Helloworld_HelloRequest>,
         context: GRPCCore.ServerContext
-    ) async throws -> GRPCCore.ServerResponse.Stream<Helloworld_HelloReply>
+    ) async throws -> GRPCCore.StreamingServerResponse<Helloworld_HelloReply>
 }
 
 /// Conformance to `GRPCCore.RegistrableRPCService`.
@@ -90,23 +90,23 @@ extension Helloworld_Greeter.StreamingServiceProtocol {
 internal protocol Helloworld_Greeter_ServiceProtocol: Helloworld_Greeter.StreamingServiceProtocol {
     /// Sends a greeting
     func sayHello(
-        request: GRPCCore.ServerRequest.Single<Helloworld_HelloRequest>,
+        request: GRPCCore.ServerRequest<Helloworld_HelloRequest>,
         context: GRPCCore.ServerContext
-    ) async throws -> GRPCCore.ServerResponse.Single<Helloworld_HelloReply>
+    ) async throws -> GRPCCore.ServerResponse<Helloworld_HelloReply>
 }
 
 /// Partial conformance to `Helloworld_Greeter_StreamingServiceProtocol`.
 @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
 extension Helloworld_Greeter.ServiceProtocol {
     internal func sayHello(
-        request: GRPCCore.ServerRequest.Stream<Helloworld_HelloRequest>,
+        request: GRPCCore.StreamingServerRequest<Helloworld_HelloRequest>,
         context: GRPCCore.ServerContext
-    ) async throws -> GRPCCore.ServerResponse.Stream<Helloworld_HelloReply> {
+    ) async throws -> GRPCCore.StreamingServerResponse<Helloworld_HelloReply> {
         let response = try await self.sayHello(
-            request: GRPCCore.ServerRequest.Single(stream: request),
+            request: GRPCCore.ServerRequest(stream: request),
             context: context
         )
-        return GRPCCore.ServerResponse.Stream(single: response)
+        return GRPCCore.StreamingServerResponse(single: response)
     }
 }
 
@@ -115,20 +115,20 @@ extension Helloworld_Greeter.ServiceProtocol {
 internal protocol Helloworld_Greeter_ClientProtocol: Sendable {
     /// Sends a greeting
     func sayHello<R>(
-        request: GRPCCore.ClientRequest.Single<Helloworld_HelloRequest>,
+        request: GRPCCore.ClientRequest<Helloworld_HelloRequest>,
         serializer: some GRPCCore.MessageSerializer<Helloworld_HelloRequest>,
         deserializer: some GRPCCore.MessageDeserializer<Helloworld_HelloReply>,
         options: GRPCCore.CallOptions,
-        _ body: @Sendable @escaping (GRPCCore.ClientResponse.Single<Helloworld_HelloReply>) async throws -> R
+        _ body: @Sendable @escaping (GRPCCore.ClientResponse<Helloworld_HelloReply>) async throws -> R
     ) async throws -> R where R: Sendable
 }
 
 @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
 extension Helloworld_Greeter.ClientProtocol {
     internal func sayHello<R>(
-        request: GRPCCore.ClientRequest.Single<Helloworld_HelloRequest>,
+        request: GRPCCore.ClientRequest<Helloworld_HelloRequest>,
         options: GRPCCore.CallOptions = .defaults,
-        _ body: @Sendable @escaping (GRPCCore.ClientResponse.Single<Helloworld_HelloReply>) async throws -> R = {
+        _ body: @Sendable @escaping (GRPCCore.ClientResponse<Helloworld_HelloReply>) async throws -> R = {
             try $0.message
         }
     ) async throws -> R where R: Sendable {
@@ -149,11 +149,11 @@ extension Helloworld_Greeter.ClientProtocol {
         _ message: Helloworld_HelloRequest,
         metadata: GRPCCore.Metadata = [:],
         options: GRPCCore.CallOptions = .defaults,
-        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse.Single<Helloworld_HelloReply>) async throws -> Result = {
+        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Helloworld_HelloReply>) async throws -> Result = {
             try $0.message
         }
     ) async throws -> Result where Result: Sendable {
-        let request = GRPCCore.ClientRequest.Single<Helloworld_HelloRequest>(
+        let request = GRPCCore.ClientRequest<Helloworld_HelloRequest>(
             message: message,
             metadata: metadata
         )
@@ -176,11 +176,11 @@ internal struct Helloworld_Greeter_Client: Helloworld_Greeter.ClientProtocol {
     
     /// Sends a greeting
     internal func sayHello<R>(
-        request: GRPCCore.ClientRequest.Single<Helloworld_HelloRequest>,
+        request: GRPCCore.ClientRequest<Helloworld_HelloRequest>,
         serializer: some GRPCCore.MessageSerializer<Helloworld_HelloRequest>,
         deserializer: some GRPCCore.MessageDeserializer<Helloworld_HelloReply>,
         options: GRPCCore.CallOptions = .defaults,
-        _ body: @Sendable @escaping (GRPCCore.ClientResponse.Single<Helloworld_HelloReply>) async throws -> R = {
+        _ body: @Sendable @escaping (GRPCCore.ClientResponse<Helloworld_HelloReply>) async throws -> R = {
             try $0.message
         }
     ) async throws -> R where R: Sendable {
diff --git a/Examples/hello-world/Sources/Subcommands/Serve.swift b/Examples/hello-world/Sources/Subcommands/Serve.swift
index 6ae06d013..ef5dc2935 100644
--- a/Examples/hello-world/Sources/Subcommands/Serve.swift
+++ b/Examples/hello-world/Sources/Subcommands/Serve.swift
@@ -44,12 +44,12 @@ struct Serve: AsyncParsableCommand {
 
 struct Greeter: Helloworld_Greeter_ServiceProtocol {
   func sayHello(
-    request: ServerRequest.Single<Helloworld_HelloRequest>,
+    request: ServerRequest<Helloworld_HelloRequest>,
     context: ServerContext
-  ) async throws -> ServerResponse.Single<Helloworld_HelloReply> {
+  ) async throws -> ServerResponse<Helloworld_HelloReply> {
     var reply = Helloworld_HelloReply()
     let recipient = request.message.name.isEmpty ? "stranger" : request.message.name
     reply.message = "Hello, \(recipient)"
-    return ServerResponse.Single(message: reply)
+    return ServerResponse(message: reply)
   }
 }
diff --git a/Examples/route-guide/Sources/Generated/route_guide.grpc.swift b/Examples/route-guide/Sources/Generated/route_guide.grpc.swift
index 3e9f77ffc..2468fd7d7 100644
--- a/Examples/route-guide/Sources/Generated/route_guide.grpc.swift
+++ b/Examples/route-guide/Sources/Generated/route_guide.grpc.swift
@@ -93,9 +93,9 @@ internal protocol Routeguide_RouteGuide_StreamingServiceProtocol: GRPCCore.Regis
     /// A feature with an empty name is returned if there's no feature at the given
     /// position.
     func getFeature(
-        request: GRPCCore.ServerRequest.Stream<Routeguide_Point>,
+        request: GRPCCore.StreamingServerRequest<Routeguide_Point>,
         context: GRPCCore.ServerContext
-    ) async throws -> GRPCCore.ServerResponse.Stream<Routeguide_Feature>
+    ) async throws -> GRPCCore.StreamingServerResponse<Routeguide_Feature>
     
     /// A server-to-client streaming RPC.
     ///
@@ -104,27 +104,27 @@ internal protocol Routeguide_RouteGuide_StreamingServiceProtocol: GRPCCore.Regis
     /// repeated field), as the rectangle may cover a large area and contain a
     /// huge number of features.
     func listFeatures(
-        request: GRPCCore.ServerRequest.Stream<Routeguide_Rectangle>,
+        request: GRPCCore.StreamingServerRequest<Routeguide_Rectangle>,
         context: GRPCCore.ServerContext
-    ) async throws -> GRPCCore.ServerResponse.Stream<Routeguide_Feature>
+    ) async throws -> GRPCCore.StreamingServerResponse<Routeguide_Feature>
     
     /// A client-to-server streaming RPC.
     ///
     /// Accepts a stream of Points on a route being traversed, returning a
     /// RouteSummary when traversal is completed.
     func recordRoute(
-        request: GRPCCore.ServerRequest.Stream<Routeguide_Point>,
+        request: GRPCCore.StreamingServerRequest<Routeguide_Point>,
         context: GRPCCore.ServerContext
-    ) async throws -> GRPCCore.ServerResponse.Stream<Routeguide_RouteSummary>
+    ) async throws -> GRPCCore.StreamingServerResponse<Routeguide_RouteSummary>
     
     /// A Bidirectional streaming RPC.
     ///
     /// Accepts a stream of RouteNotes sent while a route is being traversed,
     /// while receiving other RouteNotes (e.g. from other users).
     func routeChat(
-        request: GRPCCore.ServerRequest.Stream<Routeguide_RouteNote>,
+        request: GRPCCore.StreamingServerRequest<Routeguide_RouteNote>,
         context: GRPCCore.ServerContext
-    ) async throws -> GRPCCore.ServerResponse.Stream<Routeguide_RouteNote>
+    ) async throws -> GRPCCore.StreamingServerResponse<Routeguide_RouteNote>
 }
 
 /// Conformance to `GRPCCore.RegistrableRPCService`.
@@ -189,9 +189,9 @@ internal protocol Routeguide_RouteGuide_ServiceProtocol: Routeguide_RouteGuide.S
     /// A feature with an empty name is returned if there's no feature at the given
     /// position.
     func getFeature(
-        request: GRPCCore.ServerRequest.Single<Routeguide_Point>,
+        request: GRPCCore.ServerRequest<Routeguide_Point>,
         context: GRPCCore.ServerContext
-    ) async throws -> GRPCCore.ServerResponse.Single<Routeguide_Feature>
+    ) async throws -> GRPCCore.ServerResponse<Routeguide_Feature>
     
     /// A server-to-client streaming RPC.
     ///
@@ -200,63 +200,63 @@ internal protocol Routeguide_RouteGuide_ServiceProtocol: Routeguide_RouteGuide.S
     /// repeated field), as the rectangle may cover a large area and contain a
     /// huge number of features.
     func listFeatures(
-        request: GRPCCore.ServerRequest.Single<Routeguide_Rectangle>,
+        request: GRPCCore.ServerRequest<Routeguide_Rectangle>,
         context: GRPCCore.ServerContext
-    ) async throws -> GRPCCore.ServerResponse.Stream<Routeguide_Feature>
+    ) async throws -> GRPCCore.StreamingServerResponse<Routeguide_Feature>
     
     /// A client-to-server streaming RPC.
     ///
     /// Accepts a stream of Points on a route being traversed, returning a
     /// RouteSummary when traversal is completed.
     func recordRoute(
-        request: GRPCCore.ServerRequest.Stream<Routeguide_Point>,
+        request: GRPCCore.StreamingServerRequest<Routeguide_Point>,
         context: GRPCCore.ServerContext
-    ) async throws -> GRPCCore.ServerResponse.Single<Routeguide_RouteSummary>
+    ) async throws -> GRPCCore.ServerResponse<Routeguide_RouteSummary>
     
     /// A Bidirectional streaming RPC.
     ///
     /// Accepts a stream of RouteNotes sent while a route is being traversed,
     /// while receiving other RouteNotes (e.g. from other users).
     func routeChat(
-        request: GRPCCore.ServerRequest.Stream<Routeguide_RouteNote>,
+        request: GRPCCore.StreamingServerRequest<Routeguide_RouteNote>,
         context: GRPCCore.ServerContext
-    ) async throws -> GRPCCore.ServerResponse.Stream<Routeguide_RouteNote>
+    ) async throws -> GRPCCore.StreamingServerResponse<Routeguide_RouteNote>
 }
 
 /// Partial conformance to `Routeguide_RouteGuide_StreamingServiceProtocol`.
 @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
 extension Routeguide_RouteGuide.ServiceProtocol {
     internal func getFeature(
-        request: GRPCCore.ServerRequest.Stream<Routeguide_Point>,
+        request: GRPCCore.StreamingServerRequest<Routeguide_Point>,
         context: GRPCCore.ServerContext
-    ) async throws -> GRPCCore.ServerResponse.Stream<Routeguide_Feature> {
+    ) async throws -> GRPCCore.StreamingServerResponse<Routeguide_Feature> {
         let response = try await self.getFeature(
-            request: GRPCCore.ServerRequest.Single(stream: request),
+            request: GRPCCore.ServerRequest(stream: request),
             context: context
         )
-        return GRPCCore.ServerResponse.Stream(single: response)
+        return GRPCCore.StreamingServerResponse(single: response)
     }
     
     internal func listFeatures(
-        request: GRPCCore.ServerRequest.Stream<Routeguide_Rectangle>,
+        request: GRPCCore.StreamingServerRequest<Routeguide_Rectangle>,
         context: GRPCCore.ServerContext
-    ) async throws -> GRPCCore.ServerResponse.Stream<Routeguide_Feature> {
+    ) async throws -> GRPCCore.StreamingServerResponse<Routeguide_Feature> {
         let response = try await self.listFeatures(
-            request: GRPCCore.ServerRequest.Single(stream: request),
+            request: GRPCCore.ServerRequest(stream: request),
             context: context
         )
         return response
     }
     
     internal func recordRoute(
-        request: GRPCCore.ServerRequest.Stream<Routeguide_Point>,
+        request: GRPCCore.StreamingServerRequest<Routeguide_Point>,
         context: GRPCCore.ServerContext
-    ) async throws -> GRPCCore.ServerResponse.Stream<Routeguide_RouteSummary> {
+    ) async throws -> GRPCCore.StreamingServerResponse<Routeguide_RouteSummary> {
         let response = try await self.recordRoute(
             request: request,
             context: context
         )
-        return GRPCCore.ServerResponse.Stream(single: response)
+        return GRPCCore.StreamingServerResponse(single: response)
     }
 }
 
@@ -270,11 +270,11 @@ internal protocol Routeguide_RouteGuide_ClientProtocol: Sendable {
     /// A feature with an empty name is returned if there's no feature at the given
     /// position.
     func getFeature<R>(
-        request: GRPCCore.ClientRequest.Single<Routeguide_Point>,
+        request: GRPCCore.ClientRequest<Routeguide_Point>,
         serializer: some GRPCCore.MessageSerializer<Routeguide_Point>,
         deserializer: some GRPCCore.MessageDeserializer<Routeguide_Feature>,
         options: GRPCCore.CallOptions,
-        _ body: @Sendable @escaping (GRPCCore.ClientResponse.Single<Routeguide_Feature>) async throws -> R
+        _ body: @Sendable @escaping (GRPCCore.ClientResponse<Routeguide_Feature>) async throws -> R
     ) async throws -> R where R: Sendable
     
     /// A server-to-client streaming RPC.
@@ -284,11 +284,11 @@ internal protocol Routeguide_RouteGuide_ClientProtocol: Sendable {
     /// repeated field), as the rectangle may cover a large area and contain a
     /// huge number of features.
     func listFeatures<R>(
-        request: GRPCCore.ClientRequest.Single<Routeguide_Rectangle>,
+        request: GRPCCore.ClientRequest<Routeguide_Rectangle>,
         serializer: some GRPCCore.MessageSerializer<Routeguide_Rectangle>,
         deserializer: some GRPCCore.MessageDeserializer<Routeguide_Feature>,
         options: GRPCCore.CallOptions,
-        _ body: @Sendable @escaping (GRPCCore.ClientResponse.Stream<Routeguide_Feature>) async throws -> R
+        _ body: @Sendable @escaping (GRPCCore.StreamingClientResponse<Routeguide_Feature>) async throws -> R
     ) async throws -> R where R: Sendable
     
     /// A client-to-server streaming RPC.
@@ -296,11 +296,11 @@ internal protocol Routeguide_RouteGuide_ClientProtocol: Sendable {
     /// Accepts a stream of Points on a route being traversed, returning a
     /// RouteSummary when traversal is completed.
     func recordRoute<R>(
-        request: GRPCCore.ClientRequest.Stream<Routeguide_Point>,
+        request: GRPCCore.StreamingClientRequest<Routeguide_Point>,
         serializer: some GRPCCore.MessageSerializer<Routeguide_Point>,
         deserializer: some GRPCCore.MessageDeserializer<Routeguide_RouteSummary>,
         options: GRPCCore.CallOptions,
-        _ body: @Sendable @escaping (GRPCCore.ClientResponse.Single<Routeguide_RouteSummary>) async throws -> R
+        _ body: @Sendable @escaping (GRPCCore.ClientResponse<Routeguide_RouteSummary>) async throws -> R
     ) async throws -> R where R: Sendable
     
     /// A Bidirectional streaming RPC.
@@ -308,20 +308,20 @@ internal protocol Routeguide_RouteGuide_ClientProtocol: Sendable {
     /// Accepts a stream of RouteNotes sent while a route is being traversed,
     /// while receiving other RouteNotes (e.g. from other users).
     func routeChat<R>(
-        request: GRPCCore.ClientRequest.Stream<Routeguide_RouteNote>,
+        request: GRPCCore.StreamingClientRequest<Routeguide_RouteNote>,
         serializer: some GRPCCore.MessageSerializer<Routeguide_RouteNote>,
         deserializer: some GRPCCore.MessageDeserializer<Routeguide_RouteNote>,
         options: GRPCCore.CallOptions,
-        _ body: @Sendable @escaping (GRPCCore.ClientResponse.Stream<Routeguide_RouteNote>) async throws -> R
+        _ body: @Sendable @escaping (GRPCCore.StreamingClientResponse<Routeguide_RouteNote>) async throws -> R
     ) async throws -> R where R: Sendable
 }
 
 @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
 extension Routeguide_RouteGuide.ClientProtocol {
     internal func getFeature<R>(
-        request: GRPCCore.ClientRequest.Single<Routeguide_Point>,
+        request: GRPCCore.ClientRequest<Routeguide_Point>,
         options: GRPCCore.CallOptions = .defaults,
-        _ body: @Sendable @escaping (GRPCCore.ClientResponse.Single<Routeguide_Feature>) async throws -> R = {
+        _ body: @Sendable @escaping (GRPCCore.ClientResponse<Routeguide_Feature>) async throws -> R = {
             try $0.message
         }
     ) async throws -> R where R: Sendable {
@@ -335,9 +335,9 @@ extension Routeguide_RouteGuide.ClientProtocol {
     }
     
     internal func listFeatures<R>(
-        request: GRPCCore.ClientRequest.Single<Routeguide_Rectangle>,
+        request: GRPCCore.ClientRequest<Routeguide_Rectangle>,
         options: GRPCCore.CallOptions = .defaults,
-        _ body: @Sendable @escaping (GRPCCore.ClientResponse.Stream<Routeguide_Feature>) async throws -> R
+        _ body: @Sendable @escaping (GRPCCore.StreamingClientResponse<Routeguide_Feature>) async throws -> R
     ) async throws -> R where R: Sendable {
         try await self.listFeatures(
             request: request,
@@ -349,9 +349,9 @@ extension Routeguide_RouteGuide.ClientProtocol {
     }
     
     internal func recordRoute<R>(
-        request: GRPCCore.ClientRequest.Stream<Routeguide_Point>,
+        request: GRPCCore.StreamingClientRequest<Routeguide_Point>,
         options: GRPCCore.CallOptions = .defaults,
-        _ body: @Sendable @escaping (GRPCCore.ClientResponse.Single<Routeguide_RouteSummary>) async throws -> R = {
+        _ body: @Sendable @escaping (GRPCCore.ClientResponse<Routeguide_RouteSummary>) async throws -> R = {
             try $0.message
         }
     ) async throws -> R where R: Sendable {
@@ -365,9 +365,9 @@ extension Routeguide_RouteGuide.ClientProtocol {
     }
     
     internal func routeChat<R>(
-        request: GRPCCore.ClientRequest.Stream<Routeguide_RouteNote>,
+        request: GRPCCore.StreamingClientRequest<Routeguide_RouteNote>,
         options: GRPCCore.CallOptions = .defaults,
-        _ body: @Sendable @escaping (GRPCCore.ClientResponse.Stream<Routeguide_RouteNote>) async throws -> R
+        _ body: @Sendable @escaping (GRPCCore.StreamingClientResponse<Routeguide_RouteNote>) async throws -> R
     ) async throws -> R where R: Sendable {
         try await self.routeChat(
             request: request,
@@ -391,11 +391,11 @@ extension Routeguide_RouteGuide.ClientProtocol {
         _ message: Routeguide_Point,
         metadata: GRPCCore.Metadata = [:],
         options: GRPCCore.CallOptions = .defaults,
-        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse.Single<Routeguide_Feature>) async throws -> Result = {
+        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Routeguide_Feature>) async throws -> Result = {
             try $0.message
         }
     ) async throws -> Result where Result: Sendable {
-        let request = GRPCCore.ClientRequest.Single<Routeguide_Point>(
+        let request = GRPCCore.ClientRequest<Routeguide_Point>(
             message: message,
             metadata: metadata
         )
@@ -416,9 +416,9 @@ extension Routeguide_RouteGuide.ClientProtocol {
         _ message: Routeguide_Rectangle,
         metadata: GRPCCore.Metadata = [:],
         options: GRPCCore.CallOptions = .defaults,
-        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse.Stream<Routeguide_Feature>) async throws -> Result
+        onResponse handleResponse: @Sendable @escaping (GRPCCore.StreamingClientResponse<Routeguide_Feature>) async throws -> Result
     ) async throws -> Result where Result: Sendable {
-        let request = GRPCCore.ClientRequest.Single<Routeguide_Rectangle>(
+        let request = GRPCCore.ClientRequest<Routeguide_Rectangle>(
             message: message,
             metadata: metadata
         )
@@ -437,11 +437,11 @@ extension Routeguide_RouteGuide.ClientProtocol {
         metadata: GRPCCore.Metadata = [:],
         options: GRPCCore.CallOptions = .defaults,
         requestProducer: @Sendable @escaping (GRPCCore.RPCWriter<Routeguide_Point>) async throws -> Void,
-        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse.Single<Routeguide_RouteSummary>) async throws -> Result = {
+        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<Routeguide_RouteSummary>) async throws -> Result = {
             try $0.message
         }
     ) async throws -> Result where Result: Sendable {
-        let request = GRPCCore.ClientRequest.Stream<Routeguide_Point>(
+        let request = GRPCCore.StreamingClientRequest<Routeguide_Point>(
             metadata: metadata,
             producer: requestProducer
         )
@@ -460,9 +460,9 @@ extension Routeguide_RouteGuide.ClientProtocol {
         metadata: GRPCCore.Metadata = [:],
         options: GRPCCore.CallOptions = .defaults,
         requestProducer: @Sendable @escaping (GRPCCore.RPCWriter<Routeguide_RouteNote>) async throws -> Void,
-        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse.Stream<Routeguide_RouteNote>) async throws -> Result
+        onResponse handleResponse: @Sendable @escaping (GRPCCore.StreamingClientResponse<Routeguide_RouteNote>) async throws -> Result
     ) async throws -> Result where Result: Sendable {
-        let request = GRPCCore.ClientRequest.Stream<Routeguide_RouteNote>(
+        let request = GRPCCore.StreamingClientRequest<Routeguide_RouteNote>(
             metadata: metadata,
             producer: requestProducer
         )
@@ -490,11 +490,11 @@ internal struct Routeguide_RouteGuide_Client: Routeguide_RouteGuide.ClientProtoc
     /// A feature with an empty name is returned if there's no feature at the given
     /// position.
     internal func getFeature<R>(
-        request: GRPCCore.ClientRequest.Single<Routeguide_Point>,
+        request: GRPCCore.ClientRequest<Routeguide_Point>,
         serializer: some GRPCCore.MessageSerializer<Routeguide_Point>,
         deserializer: some GRPCCore.MessageDeserializer<Routeguide_Feature>,
         options: GRPCCore.CallOptions = .defaults,
-        _ body: @Sendable @escaping (GRPCCore.ClientResponse.Single<Routeguide_Feature>) async throws -> R = {
+        _ body: @Sendable @escaping (GRPCCore.ClientResponse<Routeguide_Feature>) async throws -> R = {
             try $0.message
         }
     ) async throws -> R where R: Sendable {
@@ -515,11 +515,11 @@ internal struct Routeguide_RouteGuide_Client: Routeguide_RouteGuide.ClientProtoc
     /// repeated field), as the rectangle may cover a large area and contain a
     /// huge number of features.
     internal func listFeatures<R>(
-        request: GRPCCore.ClientRequest.Single<Routeguide_Rectangle>,
+        request: GRPCCore.ClientRequest<Routeguide_Rectangle>,
         serializer: some GRPCCore.MessageSerializer<Routeguide_Rectangle>,
         deserializer: some GRPCCore.MessageDeserializer<Routeguide_Feature>,
         options: GRPCCore.CallOptions = .defaults,
-        _ body: @Sendable @escaping (GRPCCore.ClientResponse.Stream<Routeguide_Feature>) async throws -> R
+        _ body: @Sendable @escaping (GRPCCore.StreamingClientResponse<Routeguide_Feature>) async throws -> R
     ) async throws -> R where R: Sendable {
         try await self.client.serverStreaming(
             request: request,
@@ -536,11 +536,11 @@ internal struct Routeguide_RouteGuide_Client: Routeguide_RouteGuide.ClientProtoc
     /// Accepts a stream of Points on a route being traversed, returning a
     /// RouteSummary when traversal is completed.
     internal func recordRoute<R>(
-        request: GRPCCore.ClientRequest.Stream<Routeguide_Point>,
+        request: GRPCCore.StreamingClientRequest<Routeguide_Point>,
         serializer: some GRPCCore.MessageSerializer<Routeguide_Point>,
         deserializer: some GRPCCore.MessageDeserializer<Routeguide_RouteSummary>,
         options: GRPCCore.CallOptions = .defaults,
-        _ body: @Sendable @escaping (GRPCCore.ClientResponse.Single<Routeguide_RouteSummary>) async throws -> R = {
+        _ body: @Sendable @escaping (GRPCCore.ClientResponse<Routeguide_RouteSummary>) async throws -> R = {
             try $0.message
         }
     ) async throws -> R where R: Sendable {
@@ -559,11 +559,11 @@ internal struct Routeguide_RouteGuide_Client: Routeguide_RouteGuide.ClientProtoc
     /// Accepts a stream of RouteNotes sent while a route is being traversed,
     /// while receiving other RouteNotes (e.g. from other users).
     internal func routeChat<R>(
-        request: GRPCCore.ClientRequest.Stream<Routeguide_RouteNote>,
+        request: GRPCCore.StreamingClientRequest<Routeguide_RouteNote>,
         serializer: some GRPCCore.MessageSerializer<Routeguide_RouteNote>,
         deserializer: some GRPCCore.MessageDeserializer<Routeguide_RouteNote>,
         options: GRPCCore.CallOptions = .defaults,
-        _ body: @Sendable @escaping (GRPCCore.ClientResponse.Stream<Routeguide_RouteNote>) async throws -> R
+        _ body: @Sendable @escaping (GRPCCore.StreamingClientResponse<Routeguide_RouteNote>) async throws -> R
     ) async throws -> R where R: Sendable {
         try await self.client.bidirectionalStreaming(
             request: request,
diff --git a/Examples/route-guide/Sources/Subcommands/Serve.swift b/Examples/route-guide/Sources/Subcommands/Serve.swift
index 5bfdc200e..c799b4fb7 100644
--- a/Examples/route-guide/Sources/Subcommands/Serve.swift
+++ b/Examples/route-guide/Sources/Subcommands/Serve.swift
@@ -100,16 +100,16 @@ struct RouteGuideService {
 
 extension RouteGuideService: Routeguide_RouteGuide.ServiceProtocol {
   func getFeature(
-    request: ServerRequest.Single<Routeguide_Point>,
+    request: ServerRequest<Routeguide_Point>,
     context: ServerContext
-  ) async throws -> ServerResponse.Single<Routeguide_Feature> {
+  ) async throws -> ServerResponse<Routeguide_Feature> {
     let feature = self.findFeature(
       latitude: request.message.latitude,
       longitude: request.message.longitude
     )
 
     if let feature {
-      return ServerResponse.Single(message: feature)
+      return ServerResponse(message: feature)
     } else {
       // No feature: return a feature with an empty name.
       let unknownFeature = Routeguide_Feature.with {
@@ -119,15 +119,15 @@ extension RouteGuideService: Routeguide_RouteGuide.ServiceProtocol {
           $0.longitude = request.message.longitude
         }
       }
-      return ServerResponse.Single(message: unknownFeature)
+      return ServerResponse(message: unknownFeature)
     }
   }
 
   func listFeatures(
-    request: ServerRequest.Single<Routeguide_Rectangle>,
+    request: ServerRequest<Routeguide_Rectangle>,
     context: ServerContext
-  ) async throws -> ServerResponse.Stream<Routeguide_Feature> {
-    return ServerResponse.Stream { writer in
+  ) async throws -> StreamingServerResponse<Routeguide_Feature> {
+    return StreamingServerResponse { writer in
       let featuresWithinBounds = self.features.filter { feature in
         !feature.name.isEmpty && feature.isContained(by: request.message)
       }
@@ -138,9 +138,9 @@ extension RouteGuideService: Routeguide_RouteGuide.ServiceProtocol {
   }
 
   func recordRoute(
-    request: ServerRequest.Stream<Routeguide_Point>,
+    request: StreamingServerRequest<Routeguide_Point>,
     context: ServerContext
-  ) async throws -> ServerResponse.Single<Routeguide_RouteSummary> {
+  ) async throws -> ServerResponse<Routeguide_RouteSummary> {
     let startTime = ContinuousClock.now
     var pointsVisited = 0
     var featuresVisited = 0
@@ -169,14 +169,14 @@ extension RouteGuideService: Routeguide_RouteGuide.ServiceProtocol {
       $0.distance = Int32(distanceTravelled)
     }
 
-    return ServerResponse.Single(message: summary)
+    return ServerResponse(message: summary)
   }
 
   func routeChat(
-    request: ServerRequest.Stream<Routeguide_RouteNote>,
+    request: StreamingServerRequest<Routeguide_RouteNote>,
     context: ServerContext
-  ) async throws -> ServerResponse.Stream<Routeguide_RouteNote> {
-    return ServerResponse.Stream { writer in
+  ) async throws -> StreamingServerResponse<Routeguide_RouteNote> {
+    return StreamingServerResponse { writer in
       for try await note in request.messages {
         let notes = self.receivedNotes.recordNote(note)
         try await writer.write(contentsOf: notes)