Minor improvements.

Author: samuel-williams-shopify

context/getting-started.md

@@ -130,3 +130,4 @@ call.deadline.exceeded?  # => false
 call.peer  # => Protocol::HTTP::Address
 ```
 
+

context/index.yaml

@@ -10,3 +10,4 @@ files:
   title: Getting Started
   description: This guide explains how to use `protocol-grpc` for building abstract
     gRPC interfaces.
+

guides/getting-started/readme.md

@@ -130,3 +130,4 @@ call.deadline.exceeded?  # => false
 call.peer  # => Protocol::HTTP::Address
 ```
 
+

lib/protocol/grpc/body/readable_body.rb

@@ -4,6 +4,7 @@
 # Copyright, 2025, by Samuel Williams.
 
 require "protocol/http"
+require "protocol/http/body/wrapper"
 require "zlib"
 
 module Protocol
@@ -12,56 +13,36 @@ module GRPC
 		module Body
 			# Represents a readable body for gRPC messages with length-prefixed framing.
 			# This is the standard readable body for gRPC - all gRPC responses use message framing.
-			class ReadableBody
+			# Wraps the underlying HTTP body and transforms raw chunks into decoded gRPC messages.
+			class ReadableBody < Protocol::HTTP::Body::Wrapper
+				def self.wrap(message, **options)
+					if body = message.body
+						message.body = self.new(body, **options)
+					end
+					
+					return message.body
+				end
+				
 				# Initialize a new readable body for gRPC messages.
 				# @parameter body [Protocol::HTTP::Body::Readable] The underlying HTTP body
 				# @parameter message_class [Class | Nil] Protobuf message class with .decode method.
 				#   If `nil`, returns raw binary data (useful for channel adapters)
 				# @parameter encoding [String | Nil] Compression encoding (from grpc-encoding header)
 				def initialize(body, message_class: nil, encoding: nil)
-					@body = body
+					super(body)
 					@message_class = message_class
 					@encoding = encoding
 					@buffer = String.new.force_encoding(Encoding::BINARY)
-					@closed = false
 				end
 
-				# @attribute [Protocol::HTTP::Body::Readable] The underlying HTTP body.
-				attr_reader :body
-				
 				# @attribute [String | Nil] The compression encoding.
 				attr_reader :encoding
 
-				# Close the input body.
-				# @parameter error [Exception | Nil] Optional error that caused the close
-				# @returns [Nil]
-				def close(error = nil)
-					@closed = true
-					
-					if @body
-						@body.close(error)
-						@body = nil
-					end
-					
-					nil
-				end
-				
-				# Check if the stream has been closed.
-				# @returns [Boolean] `true` if the stream is closed, `false` otherwise
-				def closed?
-					@closed or @body.nil?
-				end
-				
-				# Check if there are any input chunks remaining.
-				# @returns [Boolean] `true` if the body is empty, `false` otherwise
-				def empty?
-					@body.nil?
-				end
-				
 				# Read the next gRPC message.
+				# Overrides Wrapper#read to transform raw HTTP body chunks into decoded gRPC messages.
 				# @returns [Object | String | Nil] Decoded message, raw binary, or `Nil` if stream ended
 				def read
-					return nil if closed?
+					return nil if @body.nil? || @body.empty?
 
 					# Read 5-byte prefix: 1 byte compression flag + 4 bytes length
 					prefix = read_exactly(5)
@@ -87,24 +68,6 @@ def read
 					end
 				end
 
-				# Enumerate all messages until finished, then invoke {close}.
-				# @yields {|message| ...} The block to call with each message.
-				def each
-					return to_enum unless block_given?
-					
-					error = nil
-					begin
-						while (message = read)
-							yield message
-						end
-					rescue StandardError => e
-						error = e
-						raise
-					ensure
-						close(error)
-					end
-				end
-				
 			private
 
 				# Read exactly n bytes from the underlying body.
@@ -113,28 +76,18 @@ def each
 				def read_exactly(n)
 					# Fill buffer until we have enough data:
 					while @buffer.bytesize < n
-						return nil if closed?
+						return nil if @body.nil? || @body.empty?
 
 						# Read chunk from underlying body:
 						chunk = @body.read
 
 						if chunk.nil?
 							# End of stream:
-							if @body && !@closed
-								@body.close
-								@closed = true
-							end
 							return nil
 						end
 
 						# Append to buffer:
 						@buffer << chunk.force_encoding(Encoding::BINARY)
-						
-						# Check if body is empty and close if needed:
-						if @body.empty?
-							@body.close
-							@closed = true
-						end
 					end
 
 					# Extract the required data:

lib/protocol/grpc/call.rb

@@ -12,16 +12,21 @@ module GRPC
 		class Call
 			# Initialize a new RPC call context.
 			# @parameter request [Protocol::HTTP::Request] The HTTP request
+			# @parameter response [Protocol::HTTP::Response | Nil] The HTTP response (for setting metadata and trailers)
 			# @parameter deadline [Async::Deadline | Nil] Deadline for the call
-			def initialize(request, deadline: nil)
+			def initialize(request, response = nil, deadline: nil)
 				@request = request
+				@response = response
 				@deadline = deadline
 				@cancelled = false
 			end
 
 			# @attribute [Protocol::HTTP::Request] The underlying HTTP request.
 			attr_reader :request
 
+			# @attribute [Protocol::HTTP::Response | Nil] The HTTP response.
+			attr_reader :response
+			
 			# @attribute [Async::Deadline | Nil] The deadline for this call.
 			attr_reader :deadline
 

lib/protocol/grpc/header.rb

@@ -20,9 +20,9 @@ module Header
 			class Status
 				# Initialize the status header with the given value.
 				#
-				# @parameter value [String, Integer] The status code as a string or integer.
+				# @parameter value [String, Integer, Array] The status code as a string, integer, or array (takes first element).
 				def initialize(value)
-					@value = value.is_a?(String) ? value.to_i : value.to_i
+					@value = normalize_value(value)
 				end
 
 				# Get the status code as an integer.
@@ -40,12 +40,24 @@ def to_s
 				end
 
 				# Merge another status value (takes the new value, as status should only appear once)
-				# @parameter value [String, Integer] The new status code
+				# @parameter value [String, Integer, Array] The new status code
 				def <<(value)
-					@value = value.is_a?(String) ? value.to_i : value.to_i
+					@value = normalize_value(value)
 					self
 				end
 
+			private
+				
+				# Normalize a value to an integer status code.
+				# Handles arrays (from external clients), strings, and integers.
+				# @parameter value [String, Integer, Array] The raw value
+				# @returns [Integer] The normalized status code
+				def normalize_value(value)
+					# Handle Array case (may occur with external clients)
+					actual_value = value.is_a?(Array) ? value.flatten.compact.first : value
+					actual_value.to_i
+				end
+				
 				# Whether this header is acceptable in HTTP trailers.
 				# The `grpc-status` header can appear in trailers as per the gRPC specification.
 				# @returns [Boolean] `true`, as grpc-status can appear in trailers.

lib/protocol/grpc/interface.rb

@@ -15,6 +15,13 @@ class Interface
 				def initialize(request_class:, response_class:, streaming: :unary, method: nil)
 					super
 				end
+				
+				# Check if this RPC is a streaming RPC (server, client, or bidirectional).
+				# Server-side handlers for streaming RPCs are expected to block until all messages are sent.
+				# @returns [Boolean] `true` if streaming, `false` if unary
+				def streaming?
+					streaming != :unary
+				end
 			end
 
 			# Hook called when a subclass is created.

lib/protocol/grpc/metadata.rb

@@ -33,8 +33,22 @@ def self.extract_status(headers)
 					status.to_i
 				else
 					# Fallback for when header policy isn't used
-					status_value = status.is_a?(Array) ? status.first : status.to_s
-					status_value.to_i
+					# Handle Array case (may occur with external clients)
+					status_value = if status.is_a?(Array)
+						# Flatten and take first non-nil value, recursively handle nested arrays
+						flattened = status.flatten.compact.first
+						# If still an array, take first element
+						flattened.is_a?(Array) ? flattened.first : flattened
+					else
+						status
+					end
+					
+					# Convert to string then integer to handle various types
+					# Handle case where status_value might still be an array somehow
+					if status_value.is_a?(Array)
+						status_value = status_value.first
+					end
+					status_value.to_s.to_i
 				end
 			end
 

lib/protocol/grpc/version.rb

@@ -10,3 +10,4 @@ module GRPC
 		VERSION = "0.2.0"
 	end
 end
+

releases.md

@@ -1,8 +1,14 @@
 # Releases
 
+## Unreleased
+
+  - **Breaking**: `Protocol::GRPC::Call` now takes a `response` object parameter instead of separate `response_headers`.
+  - **Breaking**: Removed `Call#response_headers` method. Use `call.response.headers` directly.
+  - Added `RPC#streaming?` method to check if an RPC is streaming.
+
 ## v0.2.0
 
-  - `RCP#method` is always defined (snake case).
+  - `RPC#method` is always defined (snake case).
 
 ## v0.1.0