openai 0.77.1 → 0.79.0

data/lib/openai/internal/page.rb

@@ -54,9 +54,9 @@ module OpenAI
       #
       # @param client [OpenAI::Internal::Transport::BaseClient]
       # @param req [Hash{Symbol=>Object}]
-      # @param headers [Hash{String=>String}]
+      # @param response_metadata [OpenAI::ResponseMetadata]
       # @param page_data [Array<Object>]
-      def initialize(client:, req:, headers:, page_data:)
+      def initialize(client:, req:, response_metadata:, page_data:)
         super
 
         case page_data

data/lib/openai/internal/provider.rb

@@ -7,7 +7,13 @@ module OpenAI
     # Provider factories return opaque OpenAI::Provider instances whose public
     # representation does not expose their definition.
     module Provider
-      Runtime = Struct.new(:name, :base_url, :prepare_request, keyword_init: true)
+      Runtime = Struct.new(
+        :name,
+        :base_url,
+        :prepare_request,
+        :authentication_headers,
+        keyword_init: true
+      )
 
       class << self
         # @api private

data/lib/openai/internal/read_io_adapter.rb

@@ -0,0 +1,161 @@
+# 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 }
+            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, nil]
+        private def read_enum(max_len)
+          case max_len
+          in nil
+            # `loop` rescues StopIteration, but this method handles it below.
+            # rubocop:disable Style/InfiniteLoop
+            @buf << @stream.next.b while true
+            # rubocop:enable Style/InfiniteLoop
+          in Integer
+            @buf << @stream.next.b while @buf.bytesize < max_len
+            read_buffer(max_len)
+          end
+        rescue StopIteration
+          return @buf.slice!(0..) if max_len.nil?
+
+          @stream = nil
+          return nil if @buf.bytesize.zero?
+
+          read_buffer(max_len)
+        end
+
+        # @api private
+        #
+        # @param max_len [Integer]
+        #
+        # @return [String]
+        private def read_buffer(max_len)
+          read = @buf.byteslice(0, max_len)
+          @buf = @buf.byteslice(max_len..) || String.new.b
+          read
+        end
+
+        # @api private
+        #
+        # @param max_len [Integer, nil]
+        # @param out_string [String, nil]
+        #
+        # @return [String, nil]
+        def read(max_len = nil, out_string = nil)
+          if max_len.is_a?(Integer) && max_len.negative?
+            raise ArgumentError, "negative length #{max_len} given"
+          end
+
+          read =
+            case @stream
+            in nil
+              max_len.nil? || max_len.zero? ? +"" : nil
+            in IO | StringIO
+              return @stream.read(max_len, out_string).tap(&@blk)
+            in Enumerator | InterruptibleEnumerator
+              read_enum(max_len)
+            end
+
+          case out_string
+          in String
+            out_string.replace(read || +"")
+            read.nil? ? nil : out_string
+          in nil
+            read
+          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.b
+          @blk = blk
+        end
+      end
+    end
+  end
+end

data/lib/openai/internal/stream.rb

@@ -40,8 +40,8 @@ module OpenAI
                   end
                 err = OpenAI::Errors::APIStatusError.for(
                   url: @url,
-                  status: @status,
-                  headers: @headers,
+                  status: status,
+                  headers: headers,
                   body: data,
                   request: nil,
                   response: @response,

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../logging"
+
 module OpenAI
   module Internal
     module Transport
@@ -79,6 +81,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}] .
@@ -143,8 +167,19 @@ module OpenAI
 
             # from undici
             if OpenAI::Internal::Util.uri_origin(url) != OpenAI::Internal::Util.uri_origin(location)
-              drop = %w[authorization cookie host proxy-authorization]
-              request = {**request, headers: request.fetch(:headers).except(*drop)}
+              headers = request.fetch(:headers).reject do |name, _|
+                name == "host" || OpenAI::Internal::Logging.credential_header?(name)
+              end
+              request = {**request, headers: headers}
+            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
@@ -168,7 +203,7 @@ module OpenAI
         # @return [URI::Generic]
         attr_reader :base_url
 
-        # @return [Float]
+        # @return [Float, nil]
         attr_reader :timeout
 
         # @return [Integer]
@@ -186,19 +221,32 @@ module OpenAI
         # @return [String, nil]
         attr_reader :idempotency_header
 
+        # @return [#debug, #info, #warn, #error, nil]
+        attr_reader :logger
+
+        # @return [Symbol]
+        attr_reader :log_level
+
+        # @return [Proc, nil]
+        attr_reader :on_retry
+
         # @api private
-        # @return [OpenAI::Internal::Transport::PooledNetRequester]
+        # @return [#execute]
         attr_reader :requester
 
         # @api private
         #
         # @param base_url [String]
-        # @param timeout [Float]
+        # @param timeout [Float, nil]
         # @param max_retries [Integer]
         # @param initial_retry_delay [Float]
         # @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]
+        # @param logger [#debug, #info, #warn, #error, nil]
+        # @param log_level [Symbol, String, nil]
+        # @param on_retry [Proc, nil]
         def initialize(
           base_url:,
           timeout: 0.0,
@@ -206,9 +254,28 @@ module OpenAI
           initial_retry_delay: 0.0,
           max_retry_delay: 0.0,
           headers: {},
-          idempotency_header: nil
+          idempotency_header: nil,
+          http_client: nil,
+          logger: nil,
+          log_level: nil,
+          on_retry: 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
+          unless on_retry.nil? || on_retry.respond_to?(:call)
+            raise ArgumentError, "`on_retry` must respond to `call`"
+          end
+
+          if log_level.nil?
+            log_level = ENV.fetch("OPENAI_LOG", logger.nil? ? :off : :info)
+          end
+          @log_level = OpenAI::Internal::Logging.normalize_level(log_level)
+          OpenAI::Internal::Logging.validate_logger!(logger)
+          @logger = logger
+          @logger ||= OpenAI::Internal::Logging.default_logger unless @log_level == :off
+          @on_retry = on_retry
+          @requester = http_client || OpenAI::NetHTTPClient.new
           @headers = OpenAI::Internal::Util.normalized_headers(
             self.class::PLATFORM_HEADERS,
             {
@@ -318,8 +385,9 @@ module OpenAI
             headers["x-stainless-retry-count"] = "0"
           end
 
-          timeout = opts.fetch(:timeout, @timeout).to_f.clamp(0..)
-          unless headers.key?("x-stainless-timeout") || timeout.zero?
+          timeout = opts.fetch(:timeout, @timeout)
+          timeout = timeout.to_f.clamp(0..) unless timeout.nil?
+          unless headers.key?("x-stainless-timeout") || timeout.nil? || timeout.zero?
             headers["x-stainless-timeout"] = timeout.to_s
           end
 
@@ -342,17 +410,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}]
@@ -360,23 +434,22 @@ module OpenAI
         #
         # @return [Float]
         private def retry_delay(headers, retry_count:)
-          # Non-standard extension
-          span = Float(headers["retry-after-ms"], exception: false)&.then { _1 / 1000 }
-          return span if span
-
           retry_header = headers["retry-after"]
-          return span if (span = Float(retry_header, exception: false))
-
-          span = retry_header&.then do
-            Time.httpdate(_1) - Time.now
-          rescue ArgumentError
-            nil
-          end
-          return span if span
+          delays = [
+            Float(headers["retry-after-ms"], exception: false)&.then { _1 / 1000 },
+            Float(retry_header, exception: false),
+            retry_header&.then do
+              Time.httpdate(_1) - Time.now
+            rescue ArgumentError
+              nil
+            end
+          ]
+          server_delay = delays.find { _1&.finite? && !_1.negative? }
+          return [server_delay, @max_retry_delay].min if server_delay
 
-          scale = retry_count**2
+          delay = (@initial_retry_delay * (2**retry_count)).clamp(0, @max_retry_delay)
           jitter = 1 - (0.25 * rand)
-          (@initial_retry_delay * scale * jitter).clamp(0, @max_retry_delay)
+          delay * jitter
         end
 
         # @api private
@@ -411,7 +484,7 @@ module OpenAI
         #
         #   @option request [Integer] :max_retries
         #
-        #   @option request [Float] :timeout
+        #   @option request [Float, nil] :timeout
         #
         # @param redirect_count [Integer]
         #
@@ -419,32 +492,57 @@ module OpenAI
         #
         # @param send_retry_header [Boolean]
         #
+        # @yieldreturn [OpenAI::Internal::Logging::Context]
+        #
         # @raise [OpenAI::Errors::APIError]
-        # @return [Array(Integer, Net::HTTPResponse, Enumerable<String>)]
-        def send_request(request, redirect_count:, retry_count:, send_retry_header:)
+        # @return [OpenAI::HTTPClient::Response]
+        def send_request(request, redirect_count:, retry_count:, send_retry_header:, &context_provider)
+          # Generated clients override this hook. A block keeps observability
+          # state out of their stable keyword signature and is forwarded by
+          # their existing `super` calls.
+          log_context = context_provider.call
           if send_retry_header
             request = request.merge(
               headers: request.fetch(:headers).merge("x-stainless-retry-count" => retry_count.to_s)
             )
           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
+          )
+          log_context.request_started(input, redirect_count: redirect_count)
 
           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
+            headers = http_response.headers
+            http_response = log_context.response_received(http_response)
+            stream = http_response.body
           rescue OpenAI::Errors::APIConnectionError => e
             status = e
+            stream = nil
+            headers = {}
+            log_context.attempt_failed(e)
           end
-          headers = OpenAI::Internal::Util.normalized_headers(response&.each_header&.to_h)
 
           terminal_status =
             case status
@@ -460,24 +558,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
             )
@@ -485,21 +584,30 @@ module OpenAI
               redirected_request,
               redirect_count: redirect_count + 1,
               retry_count: retry_count,
-              send_retry_header: send_retry_header
+              send_retry_header: send_retry_header,
+              &context_provider
             )
           in OpenAI::Errors::APIConnectionError if retry_count >= max_retries
             raise status
           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)
+            log_context.retry_scheduled(
+              status,
+              delay: delay,
+              response: http_response&.metadata,
+              retry_count: retry_count,
+              max_retries: max_retries
+            )
             sleep(delay)
 
             send_request(
               request,
               redirect_count: redirect_count,
               retry_count: retry_count + 1,
-              send_retry_header: send_retry_header
+              send_retry_header: send_retry_header,
+              &context_provider
             )
           end
         end
@@ -546,41 +654,93 @@ module OpenAI
         # @raise [OpenAI::Errors::APIError]
         # @return [Object]
         def request(req)
+          url, response, log_context = perform_request(req)
+          finish_request(log_context, response) do
+            parse_response(req, url: url, response: response)
+          end
+        end
+
+        # @api private
+        #
+        # @param req [Hash{Symbol=>Object}]
+        # @return [Array(URI::Generic, OpenAI::HTTPClient::Response, OpenAI::Internal::Logging::Context)]
+        private def perform_request(req)
           self.class.validate!(req)
-          model = req.fetch(:model) { OpenAI::Internal::Type::Unknown }
           opts = req[:options].to_h
-          unwrap = req[:unwrap]
           OpenAI::RequestOptions.validate!(opts)
           request = build_request(req.except(:options), opts)
           url = request.fetch(:url)
+          log_context = OpenAI::Internal::Logging::Context.new(
+            logger: @logger,
+            log_level: @log_level,
+            on_retry: @on_retry,
+            method: request.fetch(:method),
+            url: url
+          )
 
           # 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
-          )
+          ) { log_context }
+          [url, response, log_context]
+        rescue StandardError => e
+          log_context&.request_failed(e)
+          raise
+        end
+
+        # @api private
+        #
+        # @param log_context [OpenAI::Internal::Logging::Context]
+        # @param response [OpenAI::HTTPClient::Response]
+        # @return [Object]
+        private def finish_request(log_context, response)
+          result = yield
+          if result.is_a?(OpenAI::Internal::Type::BaseStream)
+            return log_context.observe_stream(result, response: response)
+          end
+
+          log_context.completed(response)
+          result
+        rescue StandardError => e
+          log_context.request_failed(e)
+          raise
+        end
+
+        # @api private
+        #
+        # @param req [Hash{Symbol=>Object}]
+        # @param url [URI::Generic]
+        # @param response [OpenAI::HTTPClient::Response]
+        # @return [Object]
+        private def parse_response(req, url:, response:)
+          model = req.fetch(:model) { OpenAI::Internal::Type::Unknown }
+          unwrap = req[:unwrap]
+          response_metadata = response.metadata
 
-          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,
+              response_metadata: response_metadata,
               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, response_metadata: response_metadata, page_data: decoded)
           else
             unwrapped = OpenAI::Internal::Util.dig(decoded, unwrap)
-            OpenAI::Internal::Type::Converter.coerce(model, unwrapped)
+            OpenAI::Internal::Type::Converter.coerce(model, unwrapped).tap do |result|
+              if result.is_a?(OpenAI::Internal::Type::BaseModel)
+                result._set_last_response(response_metadata)
+              end
+            end
           end
         end
 
@@ -588,9 +748,8 @@ module OpenAI
         #
         # @return [String]
         def inspect
-          # rubocop:disable Layout/LineLength
-          "#<#{self.class.name}:0x#{object_id.to_s(16)} base_url=#{@base_url} max_retries=#{@max_retries} timeout=#{@timeout}>"
-          # rubocop:enable Layout/LineLength
+          "#<#{self.class.name}:0x#{object_id.to_s(16)} base_url=#{@base_url} " \
+            "max_retries=#{@max_retries} timeout=#{@timeout}>"
         end
 
         define_sorbet_constant!(:RequestComponents) do
@@ -634,7 +793,7 @@ module OpenAI
               headers: T::Hash[String, String],
               body: T.anything,
               max_retries: Integer,
-              timeout: Float
+              timeout: T.nilable(Float)
             }
           end
         end

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

@@ -46,9 +46,9 @@ module OpenAI
         #
         # @return [Boolean]
         def ==(other)
-          # rubocop:disable Layout/LineLength
-          other.is_a?(OpenAI::Internal::Type::ArrayOf) && other.nilable? == nilable? && other.item_type == item_type
-          # rubocop:enable Layout/LineLength
+          other.is_a?(OpenAI::Internal::Type::ArrayOf) &&
+            other.nilable? == nilable? &&
+            other.item_type == item_type
         end
 
         # @api public
@@ -120,7 +120,9 @@ module OpenAI
         #
         # @return [Object]
         def to_sorbet_type
-          T::Array[OpenAI::Internal::Util::SorbetRuntimeSupport.to_sorbet_type(item_type)]
+          type = OpenAI::Internal::Util::SorbetRuntimeSupport.to_sorbet_type(item_type)
+          type = T.nilable(type) if nilable?
+          T::Array[type]
         end
 
         # @api private