openai 0.77.1 → 0.78.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 297d9623dbc4b6e0f7fa0237d4e35f4fe4f147eb3b862d9b5c5d4c2ea32a12c6
-  data.tar.gz: e9a284106c4f845bf5bf7fb15ef19479905edf8903375df61860f1eb8afe3b00
+  metadata.gz: cf3def8aaf6807cfdd1d5df8ed41e2eaf6513c703e9f8baa77db8c145637147a
+  data.tar.gz: 49a15beeb6bda9ba47e71cff822aa4eb0778c400b3a891ae15b2b7ade46f28ad
 SHA512:
-  metadata.gz: 78fe85ca363710e01d50a2421b04fad7e5633ce8447c41ff44d39168d54994c2f273192e02f2c2fc7ba669d1f365b19d66805e4b84df07a038e6c4176fe00110
-  data.tar.gz: 87405293563621fc6332fa479296f35015b1bc4463bf7e55f44a60e3611cf5d2c09f2ba67d2bdca96724c820369b6d27549ead881e346853adc35627a8450b73
+  metadata.gz: 7335e2cf29373c855d5f5866bb41ad0317ee0ba1df4ade67a9bfbddce0cd0befa3fb3910baa852bb2e95c8298b86a7c84de9a8cfe2c6324709ebf1ab47b4c17b
+  data.tar.gz: e596b1723939ef042457f1a9b7275cbb6f4d26fb6fe9f3a31bdbdc47d398f963da59b82217a4f626463a25596c6e0702193b95f4c3b2160c94a5340e7ef5971a

data/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## [0.78.0](https://github.com/openai/openai-ruby/compare/v0.77.1...v0.78.0) (2026-08-07)
+
+
+### Features
+
+* support custom HTTP transports ([174aca9](https://github.com/openai/openai-ruby/commit/174aca90eba958f34c903e05f749051f8d8686f9))
+* support custom HTTP transports ([#342](https://github.com/openai/openai-ruby/issues/342)) ([174aca9](https://github.com/openai/openai-ruby/commit/174aca90eba958f34c903e05f749051f8d8686f9))
+
+
+### Bug Fixes
+
+* harden custom HTTP transports ([#345](https://github.com/openai/openai-ruby/issues/345)) ([2b12ac8](https://github.com/openai/openai-ruby/commit/2b12ac85771b32bdc5947b613fef0e605e061d9a))
+
+
+### Chores
+
+* **deps-dev:** bump json from 2.21.1 to 2.21.2 ([#344](https://github.com/openai/openai-ruby/issues/344)) ([5043e3b](https://github.com/openai/openai-ruby/commit/5043e3b3415ccabca872db74c5673640502a513a))
+
 ## [0.77.1](https://github.com/openai/openai-ruby/compare/v0.77.0...v0.77.1) (2026-08-04)
 
 

data/README.md

@@ -15,7 +15,7 @@ To use this gem, install via Bundler by adding the following to your application
 <!-- x-release-please-start-version -->
 
 ```ruby
-gem "openai", "~> 0.77.1"
+gem "openai", "~> 0.78.0"
 ```
 
 <!-- x-release-please-end -->
@@ -107,6 +107,104 @@ puts(edited.data.first)
 
 Note that you can also pass a raw `IO` descriptor, but this disables retries, as the library can't be sure if the descriptor is a file or pipe (which cannot be rewound).
 
+### Custom HTTP clients
+
+`OpenAI::Client` accepts an `http_client` for advanced transport requirements.
+Provide an object that implements `execute(request)` and returns an
+`OpenAI::HTTPClient::Response`; subclassing `OpenAI::HTTPClient` is the easiest
+way to make that contract explicit. The request exposes the SDK-prepared HTTP
+method, URL, headers, encoded body, and timeout. Response bodies are enumerable
+byte-string chunks (or a single buffered string), so large and streaming
+responses do not need to be buffered.
+
+The OpenAI client owns API authentication, redirects, and API-level retries.
+The custom HTTP client owns connection pooling and lifecycle, must enforce
+`request.timeout`, and should raise `OpenAI::Errors::APIConnectionError` or
+`OpenAI::Errors::APITimeoutError` for retryable transport failures. Other
+exceptions propagate without an SDK retry. The SDK does not close an injected
+HTTP client.
+
+The default `OpenAI::NetHTTPClient` implements this contract with pooled
+`Net::HTTP` connections. It accepts an optional block for native connection
+configuration, as shown below. Call `close` to retire its current pools; the
+HTTP client remains reusable and creates fresh connections on its next request.
+
+### Mutual TLS with a custom HTTP client
+
+To opt in and activate mTLS for an organization or project, follow the
+[OpenAI Mutual TLS Beta Program
+guide](https://help.openai.com/en/articles/10876024-openai-mutual-tls-beta-program).
+If you use an intermediate chain, confirm that certificate-chain support is
+enabled for your organization.
+
+For API-key requests that also require mutual TLS (mTLS), set the mTLS endpoint
+explicitly and pass a configured `OpenAI::NetHTTPClient` as `http_client`.
+`OpenAI::Client` accepts an HTTP client object so advanced transport behavior
+does not require a separate SDK option for every use case. The default
+`OpenAI::NetHTTPClient` accepts a block that configures each native
+`Net::HTTP` connection before it is pooled and started.
+
+Ruby's native TLS properties configure the client identity. The certificate
+file must contain the leaf certificate first, followed by any intermediate
+certificates needed when certificate-chain support is enabled for your
+organization:
+
+```ruby
+require "openai"
+
+mtls_endpoint = URI("https://mtls.api.openai.com/v1")
+certificates = OpenSSL::X509::Certificate.load(
+  File.binread(ENV.fetch("OPENAI_CLIENT_CERTIFICATE_CHAIN"))
+)
+raise "Expected a client certificate" if certificates.empty?
+
+leaf_certificate, *intermediates = certificates
+private_key = OpenSSL::PKey.read(
+  File.binread(ENV.fetch("OPENAI_CLIENT_KEY")),
+  ENV["OPENAI_CLIENT_KEY_PASSPHRASE"]
+)
+raise "Certificate and key do not match" unless leaf_certificate.check_private_key(private_key)
+
+now = Time.now
+raise "Certificate is not yet valid" if now < leaf_certificate.not_before
+raise "Certificate has expired" if now > leaf_certificate.not_after
+
+mtls_destination = [mtls_endpoint.host, mtls_endpoint.port]
+http_client = OpenAI::NetHTTPClient.new do |http|
+  unless http.use_ssl? && mtls_destination == [http.address, http.port]
+    raise "Refusing to present the client certificate to an unexpected origin"
+  end
+
+  http.cert = leaf_certificate
+  http.extra_chain_cert = intermediates
+  http.key = private_key
+end
+
+client = OpenAI::Client.new(
+  api_key: ENV.fetch("OPENAI_API_KEY"),
+  base_url: mtls_endpoint.to_s,
+  http_client: http_client
+)
+```
+
+The SDK cannot infer whether custom HTTP configuration uses mTLS, so it does not
+automatically change `base_url`. An explicit `base_url`, including an EU or
+custom endpoint, is always preserved. Scope client certificates to the expected
+origin, as above, so they cannot be presented elsewhere. Use the
+`OpenAI::NetHTTPClient` block for TLS and other connection-level configuration.
+Server trust remains separate from the client identity and can be customized
+with `Net::HTTP` properties such as `cert_store` or `ca_file`.
+
+Each `OpenAI::NetHTTPClient` owns its connection pool, so separate HTTP client
+instances do not share connections or credentials.
+
+After a process forks, create new OpenAI and HTTP clients in the child. Keep the
+certificate configuration captured by an HTTP client immutable. For certificate
+rotation, build and atomically swap in new `OpenAI::NetHTTPClient` and
+`OpenAI::Client` instances, then call `close` on the retired HTTP client after
+in-flight work finishes. See the complete [custom HTTP client mTLS
+example](examples/mtls_custom_http_client.rb).
+
 ## Amazon Bedrock
 
 Use the standard client with the Bedrock provider to call OpenAI models through Amazon Bedrock's OpenAI-compatible API. Add `aws-sdk-core` to your application for AWS credential discovery and SigV4 signing:
@@ -568,9 +666,9 @@ response = client.request(
 
 ### Concurrency & connection pooling
 
-The `OpenAI::Client` instances are threadsafe, but are only fork-safe when there are no in-flight HTTP requests.
+`OpenAI::Client` instances using the default `OpenAI::NetHTTPClient` are threadsafe, but are only fork-safe when there are no in-flight HTTP requests. Injected HTTP clients are responsible for documenting and enforcing their own concurrency guarantees.
 
-Each instance of `OpenAI::Client` has its own HTTP connection pool with a default size of 99. As such, we recommend instantiating the client once per application in most settings.
+By default, each `OpenAI::Client` creates its own HTTP connection pool with a size of at least 99 connections. As such, we recommend instantiating the client once per application in most settings. An injected HTTP client may instead share its pool across multiple SDK clients; the caller owns that HTTP client's lifecycle.
 
 When all available connections from the pool are checked out, requests wait for a new connection to become available, with queue time counting towards the request timeout.
 

data/lib/openai/client.rb

@@ -163,14 +163,6 @@ module OpenAI
     #   Mutually exclusive with `workload_identity`.
     #
 
-    # @api private
-    private def request_replayable?(request)
-      body = request[:body]
-      return true if body.nil? || body.is_a?(String)
-      return false if body.respond_to?(:read)
-      true
-    end
-
     # @api private
     private def prepare_request(request, redirect_count:, retry_count:)
       preparer = @provider_runtime&.prepare_request
@@ -244,6 +236,9 @@ module OpenAI
     # @param initial_retry_delay [Float]
     #
     # @param max_retry_delay [Float]
+    #
+    # @param http_client [#execute, nil] The HTTP client used to
+    #   execute SDK requests. Defaults to {OpenAI::NetHTTPClient}.
     def initialize(
       api_key: OpenAI::Internal::OMIT,
       admin_api_key: OpenAI::Internal::OMIT,
@@ -256,7 +251,8 @@ module OpenAI
       max_retries: self.class::DEFAULT_MAX_RETRIES,
       timeout: self.class::DEFAULT_TIMEOUT_IN_SECONDS,
       initial_retry_delay: self.class::DEFAULT_INITIAL_RETRY_DELAY,
-      max_retry_delay: self.class::DEFAULT_MAX_RETRY_DELAY
+      max_retry_delay: self.class::DEFAULT_MAX_RETRY_DELAY,
+      http_client: nil
     )
       provider_runtime = nil
       unless provider.nil?
@@ -344,7 +340,8 @@ module OpenAI
         max_retries: max_retries,
         initial_retry_delay: initial_retry_delay,
         max_retry_delay: max_retry_delay,
-        headers: headers
+        headers: headers,
+        http_client: http_client
       )
 
       @completions = OpenAI::Resources::Completions.new(client: self)

data/lib/openai/http_client.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module OpenAI
+  # The transport boundary used by {OpenAI::Client}.
+  #
+  # Implement {#execute} to replace the SDK's HTTP transport. Subclassing this
+  # class is optional; any object that implements the same method is accepted.
+  # Most applications should use {OpenAI::NetHTTPClient}.
+  class HTTPClient
+    # An HTTP request prepared by the SDK.
+    class Request
+      # @return [Symbol]
+      attr_reader :method
+
+      # @return [URI::Generic]
+      attr_reader :url
+
+      # @return [Hash{String=>String}]
+      attr_reader :headers
+
+      # @return [Object, nil]
+      attr_reader :body
+
+      # @return [Float]
+      attr_reader :timeout
+
+      # @param method [Symbol]
+      # @param url [URI::Generic]
+      # @param headers [Hash{String=>String}]
+      # @param body [Object, nil]
+      # @param timeout [Float]
+      def initialize(method:, url:, headers:, body:, timeout:)
+        @method = method
+        @url = url
+        @headers = headers.dup.freeze
+        @body = body
+        @timeout = timeout
+        freeze
+      end
+    end
+
+    # An HTTP response returned to the SDK.
+    class Response
+      # @return [Integer]
+      attr_reader :status
+
+      # @return [Hash{String=>String}]
+      attr_reader :headers
+
+      # The body is normalized to a one-shot enumerable. If the supplied body
+      # responds to `close`, the SDK calls it when the body is consumed or
+      # discarded.
+      #
+      # @return [Enumerable<String>]
+      attr_reader :body
+
+      # @param status [Integer]
+      # @param headers [Hash{String=>String}]
+      # @param body [String, Enumerable<String>]
+      def initialize(status:, headers:, body:)
+        unless body.is_a?(String) || body.respond_to?(:each)
+          raise ArgumentError, "`body` must be a String or respond to `each`"
+        end
+
+        @status = Integer(status)
+        @headers =
+          headers.to_h do |name, value|
+            [name.to_s.downcase, value.to_s]
+          end.freeze
+        source = body.is_a?(String) ? [body].freeze : body
+        @body = OpenAI::Internal::Util.fused_enum(source) do
+          if source.respond_to?(:close)
+            source.close
+          else
+            OpenAI::Internal::Util.close_fused!(source)
+          end
+        end
+        freeze
+      end
+    end
+
+    # Executes one SDK-prepared HTTP request.
+    #
+    # Implementations must return an {OpenAI::HTTPClient::Response}. Connection
+    # pooling and transport-specific retries belong to the implementation; the
+    # SDK remains responsible for API-level retries and redirects. Transport
+    # failures should be raised as {OpenAI::Errors::APIConnectionError} or
+    # {OpenAI::Errors::APITimeoutError} so the SDK can apply its retry policy;
+    # other exceptions propagate without an SDK retry.
+    #
+    # @param request [OpenAI::HTTPClient::Request]
+    # @return [OpenAI::HTTPClient::Response]
+    def execute(request)
+      raise NotImplementedError, "#{self.class} must implement #execute for #{request.class}"
+    end
+  end
+end

data/lib/openai/internal/read_io_adapter.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module OpenAI
+  module Internal
+    module Util
+      # @api private
+      #
+      # An adapter that satisfies the IO interface required by `::IO.copy_stream`
+      class ReadIOAdapter
+        class InterruptibleEnumerator
+          # Cancellation must bypass application rescues so a suspended source cannot
+          # swallow it and keep the request teardown blocked.
+          class Interrupt < Exception # rubocop:disable Lint/InheritException
+          end
+          private_constant :Interrupt
+
+          def initialize(source)
+            @started = false
+            @fiber = Fiber.new do
+              source.each { Fiber.yield(_1) }
+            rescue Interrupt
+              nil
+            end
+          end
+
+          def next
+            raise StopIteration unless @fiber&.alive?
+
+            @started = true
+            value = @fiber.resume
+            raise StopIteration unless @fiber.alive?
+
+            value
+          end
+
+          def to_a
+            values = []
+            loop { values << self.next }
+          rescue StopIteration
+            values
+          end
+
+          def close
+            @fiber&.raise(Interrupt) if @started && @fiber&.alive?
+          rescue Interrupt
+            nil
+          ensure
+            @fiber = nil
+          end
+        end
+        private_constant :InterruptibleEnumerator
+
+        # @api private
+        #
+        # @return [Boolean, nil]
+        def close? = @closing
+
+        # @api private
+        def close
+          case @stream
+          in Enumerator
+            OpenAI::Internal::Util.close_fused!(@stream)
+          in InterruptibleEnumerator | IO if close?
+            @stream.close
+          else
+          end
+        end
+
+        # @api private
+        #
+        # @param max_len [Integer, nil]
+        #
+        # @return [String]
+        private def read_enum(max_len)
+          case max_len
+          in nil
+            @stream.to_a.join
+          in Integer
+            @buf << @stream.next while @buf.length < max_len
+            @buf.slice!(..max_len)
+          end
+        rescue StopIteration
+          @stream = nil
+          @buf.slice!(0..)
+        end
+
+        # @api private
+        #
+        # @param max_len [Integer, nil]
+        # @param out_string [String, nil]
+        #
+        # @return [String, nil]
+        def read(max_len = nil, out_string = nil)
+          case @stream
+          in nil
+            nil
+          in IO | StringIO
+            @stream.read(max_len, out_string)
+          in Enumerator | InterruptibleEnumerator
+            read = read_enum(max_len)
+            case out_string
+            in String
+              out_string.replace(read)
+            in nil
+              read
+            end
+          end
+            .tap(&@blk)
+        end
+
+        # @api private
+        #
+        # @param src [String, Pathname, StringIO, Enumerable<String>]
+        # @param blk [Proc]
+        #
+        # @yieldparam [String]
+        def initialize(src, &blk)
+          @stream =
+            case src
+            in String
+              StringIO.new(src)
+            in Pathname
+              @closing = true
+              src.open(binmode: true)
+            in Enumerator
+              @closing = true
+              InterruptibleEnumerator.new(src)
+            else
+              src
+            end
+          @buf = String.new
+          @blk = blk
+        end
+      end
+    end
+  end
+end

data/lib/openai/internal/transport/base_client.rb

@@ -79,6 +79,28 @@ module OpenAI
             end
           end
 
+          # @api private
+          #
+          # @param body [Object]
+          #
+          # @return [Boolean]
+          def request_body_replayable?(body)
+            case body
+            in nil | String | StringIO | Pathname
+              true
+            in OpenAI::FilePart
+              request_body_replayable?(body.content)
+            in Hash
+              body.each_value.all? { request_body_replayable?(_1) }
+            in Array
+              body.all? { request_body_replayable?(_1) }
+            in IO | Enumerable
+              false
+            else
+              !body.respond_to?(:read)
+            end
+          end
+
           # @api private
           #
           # @param request [Hash{Symbol=>Object}] .
@@ -147,6 +169,15 @@ module OpenAI
               request = {**request, headers: request.fetch(:headers).except(*drop)}
             end
 
+            unless request_body_replayable?(request[:body])
+              message = "Cannot follow a body-preserving redirect with a non-replayable request body."
+              raise OpenAI::Errors::APIConnectionError.new(
+                url: location,
+                response: response_headers,
+                message: message
+              )
+            end
+
             request
           end
 
@@ -187,7 +218,7 @@ module OpenAI
         attr_reader :idempotency_header
 
         # @api private
-        # @return [OpenAI::Internal::Transport::PooledNetRequester]
+        # @return [#execute]
         attr_reader :requester
 
         # @api private
@@ -199,6 +230,7 @@ module OpenAI
         # @param max_retry_delay [Float]
         # @param headers [Hash{String=>String, Integer, Array<String, Integer, nil>, nil}]
         # @param idempotency_header [String, nil]
+        # @param http_client [#execute, nil]
         def initialize(
           base_url:,
           timeout: 0.0,
@@ -206,9 +238,14 @@ module OpenAI
           initial_retry_delay: 0.0,
           max_retry_delay: 0.0,
           headers: {},
-          idempotency_header: nil
+          idempotency_header: nil,
+          http_client: nil
         )
-          @requester = OpenAI::Internal::Transport::PooledNetRequester.new
+          unless http_client.nil? || http_client.respond_to?(:execute)
+            raise ArgumentError, "`http_client` must respond to `execute`"
+          end
+
+          @requester = http_client || OpenAI::NetHTTPClient.new
           @headers = OpenAI::Internal::Util.normalized_headers(
             self.class::PLATFORM_HEADERS,
             {
@@ -342,17 +379,23 @@ module OpenAI
             @base_url_components,
             {**req, path: path, query: query}
           )
-          headers, encoded = OpenAI::Internal::Util.encode_content(headers, body)
+          max_retries = opts.fetch(:max_retries, @max_retries)
+          max_retries = 0 unless self.class.request_body_replayable?(body)
           {
             method: method,
             url: url,
             headers: headers,
-            body: encoded,
-            max_retries: opts.fetch(:max_retries, @max_retries),
+            body: body,
+            max_retries: max_retries,
             timeout: timeout
           }
         end
 
+        # @api private
+        private def request_replayable?(request)
+          self.class.request_body_replayable?(request[:body])
+        end
+
         # @api private
         #
         # @param headers [Hash{String=>String}]
@@ -420,7 +463,7 @@ module OpenAI
         # @param send_retry_header [Boolean]
         #
         # @raise [OpenAI::Errors::APIError]
-        # @return [Array(Integer, Net::HTTPResponse, Enumerable<String>)]
+        # @return [OpenAI::HTTPClient::Response]
         def send_request(request, redirect_count:, retry_count:, send_retry_header:)
           if send_retry_header
             request = request.merge(
@@ -428,23 +471,39 @@ module OpenAI
             )
           end
 
+          encoded_headers, encoded_body = OpenAI::Internal::Util.encode_content(
+            request.fetch(:headers),
+            request[:body]
+          )
+          attempt_request = request.merge(headers: encoded_headers, body: encoded_body)
           prepared_request = prepare_request(
-            request,
+            attempt_request,
             redirect_count: redirect_count,
             retry_count: retry_count
           )
           url, max_retries, timeout = prepared_request.fetch_values(:url, :max_retries, :timeout)
-          input = {
-            **prepared_request.except(:timeout, :follow_redirects, :provider_auth),
-            deadline: OpenAI::Internal::Util.monotonic_secs + timeout
-          }
+          input = OpenAI::HTTPClient::Request.new(
+            method: prepared_request.fetch(:method),
+            url: url,
+            headers: prepared_request.fetch(:headers),
+            body: prepared_request[:body],
+            timeout: timeout
+          )
 
           begin
-            status, response, stream = @requester.execute(input)
+            http_response = @requester.execute(input)
+            unless http_response.is_a?(OpenAI::HTTPClient::Response)
+              raise TypeError, "`http_client#execute` must return an OpenAI::HTTPClient::Response"
+            end
+
+            status = http_response.status
+            stream = http_response.body
+            headers = http_response.headers
           rescue OpenAI::Errors::APIConnectionError => e
             status = e
+            stream = nil
+            headers = {}
           end
-          headers = OpenAI::Internal::Util.normalized_headers(response&.each_header&.to_h)
 
           terminal_status =
             case status
@@ -460,24 +519,25 @@ module OpenAI
               url: url,
               status: status,
               headers: headers,
-              response: response,
+              response: http_response,
               stream: stream
             )
           end
 
           case status
           in ..299
-            [status, response, stream]
+            http_response
           in 300..399 if redirect_count >= self.class::MAX_REDIRECTS
             self.class.reap_connection!(status, stream: stream)
 
             message = "Failed to complete the request within #{self.class::MAX_REDIRECTS} redirects."
-            raise OpenAI::Errors::APIConnectionError.new(url: url, response: response, message: message)
+            raise OpenAI::Errors::APIConnectionError.new(url: url, response: http_response, message: message)
           in 300..399
             self.class.reap_connection!(status, stream: stream)
 
+            redirect_source = request.merge(url: prepared_request.fetch(:url))
             redirected_request = self.class.follow_redirect(
-              prepared_request,
+              redirect_source,
               status: status,
               response_headers: headers
             )
@@ -492,7 +552,7 @@ module OpenAI
           in (400..) | OpenAI::Errors::APIConnectionError
             self.class.reap_connection!(status, stream: stream)
 
-            delay = retry_delay(response || {}, retry_count: retry_count)
+            delay = retry_delay(headers, retry_count: retry_count)
             sleep(delay)
 
             send_request(
@@ -556,28 +616,27 @@ module OpenAI
 
           # Don't send the current retry count in the headers if the caller modified the header defaults.
           send_retry_header = request.fetch(:headers)["x-stainless-retry-count"] == "0"
-          status, response, stream = send_request(
+          response = send_request(
             request,
             redirect_count: 0,
             retry_count: 0,
             send_retry_header: send_retry_header
           )
 
-          headers = OpenAI::Internal::Util.normalized_headers(response.each_header.to_h)
-          decoded = OpenAI::Internal::Util.decode_content(headers, stream: stream)
+          decoded = OpenAI::Internal::Util.decode_content(response.headers, stream: response.body)
           case req
           in {stream: Class => st}
             st.new(
               model: model,
               url: url,
-              status: status,
-              headers: headers,
+              status: response.status,
+              headers: response.headers,
               response: response,
               unwrap: unwrap,
               stream: decoded
             )
           in {page: Class => page}
-            page.new(client: self, req: req, headers: headers, page_data: decoded)
+            page.new(client: self, req: req, headers: response.headers, page_data: decoded)
           else
             unwrapped = OpenAI::Internal::Util.dig(decoded, unwrap)
             OpenAI::Internal::Type::Converter.coerce(model, unwrapped)

data/lib/openai/internal/type/base_stream.rb

@@ -55,7 +55,7 @@ module OpenAI
         # @param url [URI::Generic]
         # @param status [Integer]
         # @param headers [Hash{String=>String}]
-        # @param response [Net::HTTPResponse]
+        # @param response [OpenAI::HTTPClient::Response]
         # @param unwrap [Symbol, Integer, Array<Symbol, Integer>, Proc]
         # @param stream [Enumerable<Object>]
         def initialize(model:, url:, status:, headers:, response:, unwrap:, stream:)