ruby-utcp 1.1.5 → 1.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8e5c4728819e312335ad446c2b453ceb45eafc6440d7926fd4116fac91852d4f
-  data.tar.gz: 5902911212d47fe254285b3218e7b47338bedef182ec1561b5b778de8c354d99
+  metadata.gz: 30241b18fd3629b65595bd41881c8c6c0b9836547b47a139e6a3a32c56111f42
+  data.tar.gz: e19fa7d10eb36ca41bcec9286ed75438df01f4a0d5d820a4f0ba76fad202cf17
 SHA512:
-  metadata.gz: 6631d90cb34d055462da1f31105380e5d61ba0b7bb73aaaf7494e5a7c5f826258e76b8cbb84bb7263ad73641866592e248fd94d47ef64d6b7ba4f7e0ed302a25
-  data.tar.gz: 56f38514be76d1e9dd0565084e7c1d6febfed61dc45f1a3ff27b9ff6849827b8bb184c255e2ef8b5e8d273015890af70ec006a8280eb4dc8cf4b3c8f5571f49b
+  metadata.gz: 634eeb0827c3eab6f57cf8b51c116ccd52981825e95b8a50f238a734f79631f174b9eaeccef60408f43fd08919dc5053d5a04b338550961d185638d5217fa2c9
+  data.tar.gz: 439c34aa64040a117248b21a05d59fc7088f46ad8e0b853f86aa4bce691c5bf976fb9fb5750136dad984a82359f768afe9c80f5ad46ddabc92984b23f298d6a8

data/CHANGELOG.md

@@ -1,6 +1,20 @@
 # Changelog
 
-## Unreleased
+## 1.1.6 (Unreleased)
+
+- Add configurable `max_response_bytes` (100 MiB by default) to every transport except file, CLI, and text. Bound discovery, protocol envelopes, streaming totals, UDP datagrams, and MCP pagination; retain TCP's stricter legacy size limit.
+- Add event/item limits and total deadlines for HTTP streams; bound buffered HTTP bodies during reads and cancel gRPC streams on early exit.
+- Parse SSE correctly across arbitrary CR/LF, BOM, and UTF-8 chunk boundaries, discard unfinished events at EOF, and preserve pretty-printed JSON sequences.
+- Resolve local OpenAPI parameter, body, response, and schema references, preserve recursive schemas, and resolve relative servers with operation/path precedence.
+- Retain only pending WebRTC responses, reject excess pending requests, discard late/unsolicited replies, and wake callers on close. Serialize native cleanup and release the GVL while destructors wait for callbacks, using UTCP-local bindings.
+- Add parser partition tests, byte-boundary transport checks, WebRTC concurrency regressions, and default native adapter lifecycle tests.
+
+## 1.1.5
+
+- Harden authentication across transports, including gRPC request metadata and streaming calls; reject unsupported auth configurations before transport I/O.
+- Protect OAuth token redirects and cache synchronization, isolate MCP sessions by credentials and endpoint, and test the authentication matrix at transport boundaries.
+
+## 1.1.4
 
 - Raise the Code Mode value budget to 30 MiB, account for string/symbol hash keys, and enforce shared byte, item, and step limits while collecting streams.
 - Close temporary discovery sessions when inspecting required variables, preserving active MCP, WebRTC, and WebSocket sessions. Isolate persistent WebSocket connections between clients and close transient discovery sockets on failure.

data/README.md

@@ -125,6 +125,21 @@ Complete runnable/configuration examples are in [examples/README.md](examples/RE
 
 Run `make` to start every available matching local server, execute its clients, and cleanly stop the servers. Missing optional gRPC/WebRTC backends are reported and skipped. `make full-demo` is the strict 12/12 target; `make standard-demo` always runs only the pairs that do not need native backends.
 
+### Response limits
+
+All transports except `file`, `cli`, and `text` include `UTCP::ResponseLimits`. Set `max_response_bytes` on a call template to bound incoming responses; the default is **100 MiB (104,857,600 bytes)**. The value must be positive and is preserved when templates are serialized. Discovery responses are bounded as well as tool responses. Exceeding the limit aborts the read with a UTCP error; responses are never silently truncated.
+
+```ruby
+template = UTCP::HttpCallTemplate.new(
+  url: "https://api.example.com/results",
+  max_response_bytes: 2 * 1024 * 1024
+)
+```
+
+The budget counts response bytes before JSON/protobuf decoding, including protocol envelopes but excluding transport framing such as WebSocket frame headers and TCP length prefixes/delimiters. HTTP counts decompressed body bytes. SSE, Streamable HTTP, gRPC streams, GraphQL subscriptions (including control messages), and UDP calls share one budget across their response items. MCP limits each JSON-RPC exchange, including stdio notifications and line separators; discovery additionally bounds the serialized results collected across pages and servers. TCP also retains its existing `max_response_size` limit; the smaller limit applies. WebRTC limits both signaling bodies and data-channel messages. Custom adapters are checked when they return their data and must enforce read limits themselves to prevent buffering oversized data internally.
+
+HTTP, SSE, and Streamable HTTP templates also accept `total_timeout` in seconds. Buffered HTTP exchanges, including redirects, default to the request timeout as a total deadline. Collecting an SSE or Streamable HTTP response with `call_tool` also has a total deadline. Direct `call_tool_streaming` enumeration has a total deadline only when `total_timeout` is set; the existing read timeout still applies between network reads. SSE and Streamable HTTP additionally default to `max_event_bytes: 1_048_576` and `max_response_items: 10_000`. These bound individual events/records and the number of emitted values; binary output is split into bounded chunks. Breaking out of an HTTP stream, GraphQL subscription, or gRPC stream releases its connection or cancels its RPC.
+
 ### Authentication by transport
 
 | Transport | Supported `auth` | Authentication checks |
@@ -256,7 +271,7 @@ MCP sessions implement initialization, notifications, `tools/list`, `tools/call`
 
 Sessions and resource mappings are isolated per client. Closing one client does not close another client's sessions, even when manual and server names match. Tool and resource discovery follows all result pages. An MCP result with `isError: true` raises `UTCP::ToolCallError`; the original result is available in `error.response_body`.
 
-For stdio, `timeout` bounds the complete request write and response read, including partial lines and intervening notifications. Messages are limited to 16 MiB, and stderr is drained while retaining only its last 64 KiB. Call `client.close` when finished to release server processes.
+For stdio, `timeout` bounds the complete request write and response read, including partial lines and intervening notifications. Outgoing messages are limited to 16 MiB; incoming messages and notifications share the template's `max_response_bytes` budget. Stderr is drained while retaining only its last 64 KiB. Call `client.close` when finished to release server processes.
 
 ### WebRTC
 
@@ -264,6 +279,8 @@ WebRTC follows the reference signaling contract: `POST /connect` exchanges SDP a
 
 The built-in peer uses `webrtc-ruby` and `libdatachannel`. For another native stack, pass `peer_factory:` to `UTCP::WebRTCProtocol`; the adapter contract is demonstrated by the protocol tests.
 
+The built-in peer tracks only pending request IDs and discards unsolicited, duplicate, and late responses. `max_pending_requests` defaults to 1,024. Closing a peer wakes pending callers and serializes native destruction with connection setup and sends. UTCP uses local FFI bindings that release Ruby's GVL during native destruction, allowing outstanding callbacks to finish; it does not alter the installed gem's bindings.
+
 ### Text and file
 
 Text templates parse a manual supplied directly in `content`. File templates read JSON or safe YAML relative to the client's `root_dir`.
@@ -390,4 +407,4 @@ CI runs the tests and gem build on Ruby 2.6, 2.7, 3.0–3.4, and 4.0. A separate
 
 A dedicated Ruby 3.4 CI job sets `UTCP_NATIVE_TESTS=1` to install the original, unmodified backends from the Gemfile, builds libdatachannel 0.24.5 and the WebRTC extension, and runs `bundle exec rake native`. The test subprocess has a 45-second watchdog. The native dependencies remain optional for applications using the gem.
 
-The default native suite checks discovery, real calls, streaming, concurrent requests, timeouts, and client isolation. Additional backend shutdown probes are opt-in with `UTCP_WEBRTC_SHUTDOWN_REGRESSIONS=1`; they require callback shutdown guarantees that the stock `webrtc-ruby` 1.0.0 release does not provide and are not part of the CI job. No WebRTC patches are installed or applied.
+The default native suite checks discovery, real calls, response limits, streaming, concurrent requests, timeouts, and client isolation. It also checks the UTCP WebRTC adapter's destruction during an active callback, cancellation of pending calls, and reuse after late responses. Additional probes of the upstream backend itself are opt-in with `UTCP_WEBRTC_SHUTDOWN_REGRESSIONS=1`; they require callback shutdown guarantees that stock `webrtc-ruby` 1.0.0 bindings do not provide and are not part of the CI job. No patches are installed into the dependency.

data/lib/utcp/models.rb

@@ -4,6 +4,7 @@ require "securerandom"
 require_relative "version"
 require_relative "errors"
 require_relative "utils"
+require_relative "response_limits"
 
 module UTCP
   class JsonSchema
@@ -218,6 +219,7 @@ module UTCP
   end
 
   class HttpCallTemplate < CallTemplate
+    include HTTPResponseLimits
     METHODS = %w[GET POST PUT DELETE PATCH HEAD OPTIONS].freeze
     attr_accessor :http_method, :url, :content_type, :auth_tools, :headers, :body_field,
                   :header_fields, :timeout
@@ -236,6 +238,9 @@ module UTCP
       @body_field = body_field.nil? ? nil : body_field.to_s
       @header_fields = header_fields.nil? ? [] : Utils.array!(header_fields, "header_fields").map(&:to_s)
       @timeout = timeout.nil? ? nil : Float(timeout)
+      if @timeout && (!@timeout.finite? || !@timeout.positive?)
+        raise ValidationError.new("must be finite and greater than zero", path: "timeout")
+      end
     end
 
     def to_h
@@ -253,6 +258,7 @@ module UTCP
   end
 
   class SseCallTemplate < CallTemplate
+    include HTTPResponseLimits
     attr_accessor :url, :event_type, :reconnect, :retry_timeout, :headers, :body_field,
                   :header_fields, :timeout
 
@@ -288,6 +294,7 @@ module UTCP
   SSECallTemplate = SseCallTemplate
 
   class StreamableHttpCallTemplate < CallTemplate
+    include HTTPResponseLimits
     METHODS = %w[GET POST].freeze
     attr_accessor :url, :http_method, :content_type, :chunk_size, :timeout, :headers,
                   :body_field, :header_fields
@@ -327,6 +334,7 @@ module UTCP
   StreamableHTTPCallTemplate = StreamableHttpCallTemplate
 
   class WebSocketCallTemplate < CallTemplate
+    include ResponseLimits
     RESPONSE_FORMATS = %w[json text raw].freeze
     attr_accessor :url, :message, :protocol, :keep_alive, :response_format, :timeout,
                   :headers, :header_fields
@@ -365,6 +373,7 @@ module UTCP
   WebsocketCallTemplate = WebSocketCallTemplate
 
   class GrpcCallTemplate < CallTemplate
+    include ResponseLimits
     attr_accessor :host, :port, :service_name, :method_name, :target, :use_ssl,
                   :timeout, :metadata
 
@@ -406,6 +415,7 @@ module UTCP
   GRPCCallTemplate = GrpcCallTemplate
 
   class GraphQLCallTemplate < CallTemplate
+    include ResponseLimits
     OPERATION_TYPES = %w[query mutation subscription].freeze
     attr_accessor :url, :operation_type, :operation_name, :headers, :header_fields,
                   :query, :variable_types, :selection_set, :timeout
@@ -446,6 +456,7 @@ module UTCP
   GraphqlCallTemplate = GraphQLCallTemplate
 
   class TcpCallTemplate < CallTemplate
+    include ResponseLimits
     FORMATS = %w[json text].freeze
     FRAMING = %w[length_prefix delimiter fixed_length stream].freeze
     attr_accessor :host, :port, :request_data_format, :request_data_template,
@@ -512,6 +523,7 @@ module UTCP
   TCPCallTemplate = TcpCallTemplate
 
   class UdpCallTemplate < CallTemplate
+    include ResponseLimits
     FORMATS = %w[json text].freeze
     attr_accessor :host, :port, :number_of_response_datagrams, :request_data_format,
                   :request_data_template, :response_byte_format, :timeout
@@ -548,19 +560,23 @@ module UTCP
   UDPCallTemplate = UdpCallTemplate
 
   class WebRtcCallTemplate < CallTemplate
-    attr_accessor :signaling_server, :peer_id, :data_channel_name, :timeout, :ice_servers
+    include ResponseLimits
+    attr_accessor :signaling_server, :peer_id, :data_channel_name, :timeout, :ice_servers,
+                  :max_pending_requests
 
     def initialize(signaling_server:, peer_id:, data_channel_name:, call_template_type: "webrtc",
-                   timeout: 30, ice_servers: nil, **common)
+                   timeout: 30, ice_servers: nil, max_pending_requests: 1024, **common)
       super(call_template_type: call_template_type, auth: nil, **common)
       @signaling_server = Utils.required_string!(signaling_server, "signaling_server")
       @peer_id = Utils.required_string!(peer_id, "peer_id")
       @data_channel_name = Utils.required_string!(data_channel_name, "data_channel_name")
       @timeout = Float(timeout)
+      @max_pending_requests = Integer(max_pending_requests)
       @ice_servers = ice_servers.nil? ? [] : Utils.array!(ice_servers, "ice_servers").map do |server|
         Utils.stringify_keys(Utils.hash!(server, "ice_server"))
       end
-      raise ValidationError.new("must be greater than zero", path: "timeout") unless @timeout.positive?
+      raise ValidationError.new("must be finite and greater than zero", path: "timeout") unless @timeout.finite? && @timeout.positive?
+      raise ValidationError.new("must be greater than zero", path: "max_pending_requests") unless @max_pending_requests.positive?
     end
 
     def to_h
@@ -568,6 +584,7 @@ module UTCP
         "signaling_server" => signaling_server,
         "peer_id" => peer_id,
         "data_channel_name" => data_channel_name,
+        "max_pending_requests" => max_pending_requests,
         "timeout" => timeout,
         "ice_servers" => ice_servers.empty? ? nil : Utils.deep_copy(ice_servers)
       ))
@@ -576,6 +593,7 @@ module UTCP
   WebRTCCallTemplate = WebRtcCallTemplate
 
   class McpCallTemplate < CallTemplate
+    include ResponseLimits
     attr_accessor :config, :register_resources_as_tools, :protocol_version, :timeout
 
     def initialize(config:, call_template_type: "mcp", register_resources_as_tools: false,

data/lib/utcp/openapi_converter.rb

@@ -20,6 +20,7 @@ module UTCP
 
       tools = []
       paths.each do |path, path_item|
+        path_item = dereference(path_item)
         next unless path_item.is_a?(Hash)
 
         HTTP_METHODS.each do |method|
@@ -41,7 +42,12 @@ module UTCP
     private
 
     def convert_operation(path, method, path_item, operation)
-      parameters = Array(path_item["parameters"]) + Array(operation["parameters"])
+      parameters = (Array(path_item["parameters"]) + Array(operation["parameters"])).each_with_object({}) do |value, result|
+        parameter = dereference(value)
+        next unless parameter.is_a?(Hash)
+
+        result[[parameter["in"], parameter["name"]]] = parameter
+      end.values
       properties = {}
       required = []
       header_fields = []
@@ -55,20 +61,20 @@ module UTCP
         next if name.empty?
 
         if parameter["in"] == "body"
-          properties[body_field] = resolve_schema(parameter["schema"] || {})
+          properties[body_field] = parameter["schema"] || {}
           required << body_field if parameter["required"]
         else
-          properties[name] = resolve_schema(parameter["schema"] || parameter_schema(parameter))
+          properties[name] = parameter["schema"] || parameter_schema(parameter)
           required << name if parameter["required"] || parameter["in"] == "path"
           header_fields << name if parameter["in"] == "header"
         end
       end
 
-      request_body = operation["requestBody"]
+      request_body = dereference(operation["requestBody"])
       if request_body.is_a?(Hash)
         content_type, media = Array(request_body["content"]).first
         if media.is_a?(Hash)
-          properties[body_field] = resolve_schema(media["schema"] || {})
+          properties[body_field] = media["schema"] || {}
           required << body_field if request_body["required"]
         end
       else
@@ -84,12 +90,12 @@ module UTCP
       Tool.new(
         name: tool_name,
         description: description.to_s,
-        inputs: input_schema,
+        inputs: resolve_schema(input_schema),
         outputs: response_schema(operation),
         tags: Array(operation["tags"]),
         tool_call_template: HttpCallTemplate.new(
           name: tool_name,
-          url: join_url(resolve_base_url, path),
+          url: join_url(resolve_base_url(operation, path_item), path),
           http_method: method.upcase,
           content_type: content_type || Array(operation["consumes"]).first || "application/json",
           body_field: body_field,
@@ -105,18 +111,64 @@ module UTCP
       end
     end
 
-    def resolve_schema(schema, seen = [])
-      data = Utils.stringify_keys(schema || {})
-      reference = data["$ref"]
-      return data unless reference&.start_with?("#/")
-      return {} if seen.include?(reference)
+    def reference_value(reference)
+      unless reference.is_a?(String) && reference.start_with?("#/")
+        raise ValidationError, "Only local OpenAPI references are supported: #{reference.inspect}"
+      end
 
-      resolved = reference.sub(%r{\A#/}, "").split("/").reduce(@spec) do |node, component|
-        break nil unless node.is_a?(Hash)
+      reference.delete_prefix("#/").split("/").reduce(@spec) do |node, component|
+        key = component.gsub("~1", "/").gsub("~0", "~")
+        unless node.is_a?(Hash) && node.key?(key)
+          raise ValidationError, "Unresolved OpenAPI reference: #{reference}"
+        end
+        node[key]
+      end
+    end
+
+    def dereference(value, seen = [])
+      return value unless value.is_a?(Hash) && value.key?("$ref")
 
-        node[component.gsub("~1", "/").gsub("~0", "~")]
+      reference = value["$ref"]
+      raise ValidationError, "Circular OpenAPI object reference: #{reference}" if seen.include?(reference)
+
+      dereference(reference_value(reference), seen + [reference])
+    end
+
+    def resolve_schema(schema)
+      # Bundle references in the exported schema so recursive models remain usable
+      # after the original OpenAPI document is no longer available.
+      definitions = {}
+      references = {}
+      reserved_names = schema.is_a?(Hash) && schema["$defs"].is_a?(Hash) ? schema["$defs"].keys : []
+      transform = lambda do |value|
+        return value unless value.is_a?(Hash)
+
+        if value.key?("$ref")
+          reference = value["$ref"]
+          unless references.key?(reference)
+            name = "utcp_ref_#{references.length + 1}"
+            name = "_#{name}" while reserved_names.include?(name) || references.value?(name)
+            references[reference] = name
+            definitions[name] = transform.call(reference_value(reference))
+          end
+          return { "$ref" => "#/$defs/#{references.fetch(reference)}" }
+        end
+
+        value.each_with_object({}) do |(key, item), result|
+          result[key] = case key
+                        when "properties", "patternProperties", "definitions", "$defs", "dependentSchemas"
+                          item.is_a?(Hash) ? item.transform_values { |child| transform.call(child) } : item
+                        when "items", "additionalItems", "additionalProperties", "contains", "not", "if", "then", "else", "propertyNames"
+                          item.is_a?(Array) ? item.map { |child| transform.call(child) } : transform.call(item)
+                        when "allOf", "anyOf", "oneOf", "prefixItems"
+                          Array(item).map { |child| transform.call(child) }
+                        else Utils.deep_copy(item)
+                        end
+        end
       end
-      resolved ? resolve_schema(resolved, seen + [reference]) : data
+      result = transform.call(schema || {})
+      result["$defs"] = (result["$defs"] || {}).merge(definitions) unless definitions.empty?
+      result
     end
 
     def response_schema(operation)
@@ -124,6 +176,7 @@ module UTCP
       return {} unless responses.is_a?(Hash)
 
       _status, response = responses.find { |status, _value| status.to_s.match?(/\A2\d\d\z/) } || responses.first
+      response = dereference(response)
       return {} unless response.is_a?(Hash)
 
       if response["content"].is_a?(Hash)
@@ -139,11 +192,12 @@ module UTCP
       security.is_a?(Array) && !security.empty?
     end
 
-    def resolve_base_url
-      return @base_url if @base_url && !@base_url.empty?
+    def resolve_base_url(operation = {}, path_item = {})
+      return absolute_server_url(@base_url) if @base_url && !@base_url.empty?
 
-      server = Array(@spec["servers"]).first
-      return substitute_server_variables(server) if server.is_a?(Hash) && server["url"]
+      servers = [operation["servers"], path_item["servers"], @spec["servers"]].find { |value| value.is_a?(Array) && !value.empty? }
+      server = Array(servers).first
+      return absolute_server_url(substitute_server_variables(server)) if server.is_a?(Hash) && server["url"]
 
       if @spec["host"]
         scheme = Array(@spec["schemes"]).first || "https"
@@ -151,13 +205,23 @@ module UTCP
       end
 
       if @spec_url&.match?(/\Ahttps?:/)
-        uri = URI.parse(@spec_url)
-        return "#{uri.scheme}://#{uri.host}#{uri.port && ![80, 443].include?(uri.port) ? ":#{uri.port}" : ""}"
+        return absolute_server_url("/")
       end
 
       raise ValidationError, "OpenAPI document does not define a server URL; pass base_url"
     end
 
+    def absolute_server_url(url)
+      uri = URI.parse(url)
+      uri = URI.join(@spec_url, url) if !uri.absolute? && @spec_url
+      unless %w[http https].include?(uri.scheme) && uri.host
+        raise ValidationError, "OpenAPI server URL must resolve to HTTP(S); pass an absolute spec_url or base_url"
+      end
+      uri.to_s
+    rescue URI::InvalidURIError => error
+      raise ValidationError, "Invalid OpenAPI server URL: #{error.message}"
+    end
+
     def substitute_server_variables(server)
       variables = Utils.stringify_keys(server["variables"] || {})
       server["url"].gsub(/\{([^}]+)\}/) do
@@ -176,4 +240,3 @@ module UTCP
   end
   OpenApiConverter = OpenAPIConverter
 end
-

data/lib/utcp/protocols/graphql.rb

@@ -93,7 +93,7 @@ module UTCP
         body: payload,
         content_type: "application/json",
         timeout: template.timeout,
-        sensitive_headers: sensitive.uniq
+        sensitive_headers: sensitive.uniq, max_response_bytes: template.max_response_bytes
       )
       data = JSON.parse(response.body)
       raise_graphql_errors!(data, template.operation_name || template.name)
@@ -243,9 +243,12 @@ module UTCP
       ws_scheme = http_uri.scheme == "https" ? "wss" : "ws"
       ws_url = http_uri.to_s.sub(/\Ahttps?/, ws_scheme)
       connection = @websocket_factory.call(ws_url, headers, "graphql-transport-ws", template.timeout)
+      connection.max_response_bytes = template.max_response_bytes if connection.respond_to?(:max_response_bytes=)
+      budget = ResponseByteBudget.new(template.max_response_bytes, "GraphQL subscription")
       identifier = SecureRandom.uuid
       connection.send_text(JSON.generate("type" => "connection_init", "payload" => {}))
       ack = connection.read_message
+      budget.consume(ack[1]) if ack
       ack_data = ack && decode_json_or_text(ack[1].force_encoding(Encoding::UTF_8))
       unless ack_data.is_a?(Hash) && ack_data["type"] == "connection_ack"
         raise ToolCallError, "GraphQL subscription did not receive connection_ack"
@@ -255,7 +258,11 @@ module UTCP
         "type" => "subscribe",
         "payload" => graphql_payload(tool_name, args, template)
       ))
-      while (frame = connection.read_message)
+      loop do
+        connection.max_response_bytes = budget.remaining if connection.respond_to?(:max_response_bytes=)
+        frame = connection.read_message
+        break unless frame
+        budget.consume(frame[1])
         message = decode_json_or_text(frame[1].force_encoding(Encoding::UTF_8))
         next unless message.is_a?(Hash) && message["id"] == identifier
         break if message["type"] == "complete"

data/lib/utcp/protocols/grpc.rb

@@ -72,7 +72,8 @@ module UTCP
       require "grpc"
       address = "#{template.host}:#{template.port}"
       credentials = template.use_ssl ? GRPC::Core::ChannelCredentials.new : :this_channel_is_insecure
-      @stub = GRPC::ClientStub.new(address, credentials)
+      @stub = GRPC::ClientStub.new(address, credentials,
+                                   channel_args: { "grpc.max_receive_message_length" => template.max_response_bytes })
     rescue LoadError => error
       raise MissingDependencyError,
             "gRPC requires the optional 'grpc' gem (add gem \"grpc\" to your Gemfile): #{error.message}"
@@ -92,14 +93,18 @@ module UTCP
     def server_stream(route, payload, timeout:, metadata: {})
       return enum_for(__method__, route, payload, timeout: timeout, metadata: metadata) unless block_given?
 
-      @stub.server_streamer(
+      operation = @stub.server_streamer(
         route, payload,
         ->(value) { value.to_s.b }, ->(bytes) { bytes },
         deadline: Time.now + timeout,
-        metadata: metadata
-      ).each { |response| yield response }
+        metadata: metadata, return_op: true
+      )
+      operation.execute.each { |response| yield response }
+      complete = true
     rescue GRPC::Unauthenticated, GRPC::PermissionDenied => error
       raise AuthenticationError, "gRPC authentication failed: #{error.details}"
+    ensure
+      operation.cancel if operation && !complete
     end
   end
 
@@ -116,6 +121,7 @@ module UTCP
         timeout: template.timeout,
         metadata: grpc_metadata(template)
       )
+      ResponseByteBudget.new(template.max_response_bytes, "gRPC").consume(response)
       fields = ProtobufWire.fields(response)
       tools = fields[2].map do |tool_bytes|
         tool_fields = ProtobufWire.fields(tool_bytes)
@@ -144,6 +150,7 @@ module UTCP
         timeout: template.timeout,
         metadata: grpc_metadata(template)
       )
+      ResponseByteBudget.new(template.max_response_bytes, "gRPC").consume(response)
       decode_tool_response(response)
     rescue Error
       raise
@@ -156,12 +163,16 @@ module UTCP
 
       assert_grpc_template!(template)
       method = template.method_name || "CallToolStream"
+      budget = ResponseByteBudget.new(template.max_response_bytes, "gRPC stream")
       rpc_client(template).server_stream(
         route(template, method),
         tool_call_request(tool_name, tool_args),
         timeout: template.timeout,
         metadata: grpc_metadata(template)
-      ).each { |response| yield decode_tool_response(response) }
+      ).each do |response|
+        budget.consume(response)
+        yield decode_tool_response(response)
+      end
     rescue Error
       raise
     rescue StandardError => error

data/lib/utcp/protocols/http.rb

@@ -136,7 +136,8 @@ module UTCP
         body: body,
         content_type: template.content_type,
         timeout: timeout,
-        sensitive_headers: sensitive_headers.uniq
+        sensitive_headers: sensitive_headers.uniq, max_response_bytes: template.max_response_bytes,
+        deadline: response_deadline(template.total_timeout || timeout)
       )
     end
 
@@ -245,7 +246,9 @@ module UTCP
     end
 
     def perform_request(method, uri, headers:, cookies:, body:, content_type:, timeout:,
-                        sensitive_headers:, redirects: 0, allow_cross_origin_redirects: true)
+                        sensitive_headers:, redirects: 0, allow_cross_origin_redirects: true,
+                        max_response_bytes: ResponseLimits::DEFAULT_MAX_RESPONSE_BYTES, deadline: nil)
+      deadline ||= response_deadline(timeout)
       URLSecurity.validate!(uri.to_s, context: "HTTP request")
       raise ToolCallError, "Too many HTTP redirects" if redirects > @max_redirects
 
@@ -270,7 +273,15 @@ module UTCP
         request.body = content_type.to_s.include?("json") && !body.is_a?(String) ? JSON.generate(body) : body.to_s
       end
 
-      response = send_request(uri, request, timeout)
+      response = with_response_timeout(deadline - Process.clock_gettime(Process::CLOCK_MONOTONIC)) do
+        send_request(uri, request, timeout) do |incoming|
+          incoming.body = LimitedHTTPResponse.new(incoming, max_response_bytes).body
+        end
+      end
+      # Custom adapters may return a buffered response without yielding it.
+      if response.body.to_s.bytesize > max_response_bytes
+        raise ToolCallError, "HTTP response exceeds max_response_bytes (#{max_response_bytes})"
+      end
       if REDIRECTS.include?(response.code.to_i) && response["location"]
         target = URI.join(uri.to_s, response["location"])
         URLSecurity.validate!(target.to_s, context: "HTTP redirect")
@@ -292,7 +303,8 @@ module UTCP
           next_method, target, headers: next_headers, cookies: next_cookies,
           body: next_body, content_type: content_type, timeout: timeout,
           sensitive_headers: sensitive_headers, redirects: redirects + 1,
-          allow_cross_origin_redirects: allow_cross_origin_redirects
+          allow_cross_origin_redirects: allow_cross_origin_redirects,
+          max_response_bytes: max_response_bytes, deadline: deadline
         )
       end
 
@@ -320,7 +332,27 @@ module UTCP
       http.verify_mode = OpenSSL::SSL::VERIFY_PEER if http.use_ssl?
       http.open_timeout = [Float(timeout), @open_timeout].min
       http.read_timeout = Float(timeout)
-      http.start { |connection| connection.request(request) }
+      http.write_timeout = Float(timeout) if http.respond_to?(:write_timeout=)
+      http.start do |connection|
+        connection.request(request) do |response|
+          if block_given?
+            yield response
+          else
+            response.body = LimitedHTTPResponse.new(response, ResponseLimits::DEFAULT_MAX_RESPONSE_BYTES).body
+          end
+        end
+      end
+    end
+
+    def response_deadline(seconds)
+      Process.clock_gettime(Process::CLOCK_MONOTONIC) + Float(seconds)
+    end
+
+    def with_response_timeout(seconds)
+      return yield if seconds.nil?
+      raise TimeoutError, "HTTP total response timeout exceeded" unless seconds.positive?
+
+      Timeout.timeout(seconds, TimeoutError, "HTTP total response timeout exceeded") { yield }
     end
 
     def parse_document(body, content_type, url)

data/lib/utcp/protocols/http_stream_support.rb

@@ -9,7 +9,8 @@ module UTCP
       perform_request(
         parts[:method], parts[:uri], headers: parts[:headers], cookies: parts[:cookies],
         body: parts[:body], content_type: parts[:content_type], timeout: parts[:timeout],
-        sensitive_headers: parts[:sensitive_headers]
+        sensitive_headers: parts[:sensitive_headers], max_response_bytes: template.max_response_bytes,
+        deadline: response_deadline(template.total_timeout || parts[:timeout])
       )
     end
 
@@ -31,9 +32,12 @@ module UTCP
           JSON.generate(parts[:body]) : parts[:body].to_s
       end
 
-      send_stream_request(parts[:uri], request, parts[:timeout]) do |response|
-        validate_stream_response!(response)
-        yield response
+      with_response_timeout(template.total_timeout) do
+        send_stream_request(parts[:uri], request, parts[:timeout]) do |response|
+          limited = LimitedHTTPResponse.new(response, template.max_response_bytes)
+          validate_stream_response!(limited)
+          yield limited
+        end
       end
     rescue Net::OpenTimeout, Net::ReadTimeout => error
       raise TimeoutError, "Streaming HTTP request timed out: #{error.message}"
@@ -43,6 +47,10 @@ module UTCP
       raise ToolCallError, "Streaming HTTP request failed: #{error.message}"
     end
 
+    def with_collection_timeout(template, &block)
+      with_response_timeout(template.total_timeout || protocol_timeout_seconds(template, false), &block)
+    end
+
     def http_parts(template, arguments, discovery:, accept: nil)
       headers = Utils.stringify_keys(template.headers || {})
       headers["Accept"] = accept if accept
@@ -100,6 +108,7 @@ module UTCP
       http.verify_mode = OpenSSL::SSL::VERIFY_PEER if http.use_ssl?
       http.open_timeout = [Float(timeout), 10].min
       http.read_timeout = Float(timeout)
+      http.write_timeout = Float(timeout) if http.respond_to?(:write_timeout=)
       http.start do |connection|
         connection.request(request) { |response| yield response }
       end