openai 0.78.0 → 0.80.0

data/lib/openai/internal/read_io_adapter.rb

@@ -36,7 +36,6 @@ module OpenAI
           def to_a
             values = []
             loop { values << self.next }
-          rescue StopIteration
             values
           end
 
@@ -70,18 +69,36 @@ module OpenAI
         #
         # @param max_len [Integer, nil]
         #
-        # @return [String]
+        # @return [String, nil]
         private def read_enum(max_len)
           case max_len
           in nil
-            @stream.to_a.join
+            # `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 while @buf.length < max_len
-            @buf.slice!(..max_len)
+            @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
-          @buf.slice!(0..)
+          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
@@ -91,19 +108,26 @@ module OpenAI
         #
         # @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)
+          if max_len.is_a?(Integer) && max_len.negative?
+            raise ArgumentError, "negative length #{max_len} given"
+          end
+
+          read =
+            case @stream
             in nil
-              read
+              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
@@ -128,7 +152,7 @@ module OpenAI
             else
               src
             end
-          @buf = String.new
+          @buf = String.new.b
           @blk = blk
         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
@@ -165,8 +167,10 @@ 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])
@@ -199,7 +203,7 @@ module OpenAI
         # @return [URI::Generic]
         attr_reader :base_url
 
-        # @return [Float]
+        # @return [Float, nil]
         attr_reader :timeout
 
         # @return [Integer]
@@ -217,6 +221,15 @@ 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 [#execute]
         attr_reader :requester
@@ -224,13 +237,16 @@ module OpenAI
         # @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,
@@ -239,12 +255,26 @@ module OpenAI
           max_retry_delay: 0.0,
           headers: {},
           idempotency_header: nil,
-          http_client: nil
+          http_client: nil,
+          logger: nil,
+          log_level: nil,
+          on_retry: nil
         )
           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,
@@ -355,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
 
@@ -403,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
@@ -454,7 +484,7 @@ module OpenAI
         #
         #   @option request [Integer] :max_retries
         #
-        #   @option request [Float] :timeout
+        #   @option request [Float, nil] :timeout
         #
         # @param redirect_count [Integer]
         #
@@ -462,9 +492,15 @@ module OpenAI
         #
         # @param send_retry_header [Boolean]
         #
+        # @yieldreturn [OpenAI::Internal::Logging::Context]
+        #
         # @raise [OpenAI::Errors::APIError]
         # @return [OpenAI::HTTPClient::Response]
-        def send_request(request, redirect_count:, retry_count:, send_retry_header:)
+        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)
@@ -489,6 +525,7 @@ module OpenAI
             body: prepared_request[:body],
             timeout: timeout
           )
+          log_context.request_started(input, redirect_count: redirect_count)
 
           begin
             http_response = @requester.execute(input)
@@ -497,12 +534,14 @@ module OpenAI
             end
 
             status = http_response.status
-            stream = http_response.body
             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
 
           terminal_status =
@@ -545,7 +584,8 @@ 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
@@ -553,13 +593,21 @@ module OpenAI
             self.class.reap_connection!(status, stream: stream)
 
             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
@@ -606,13 +654,29 @@ 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"
@@ -621,7 +685,41 @@ module OpenAI
             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
 
           decoded = OpenAI::Internal::Util.decode_content(response.headers, stream: response.body)
           case req
@@ -629,17 +727,20 @@ module OpenAI
             st.new(
               model: model,
               url: url,
-              status: response.status,
-              headers: response.headers,
+              response_metadata: response_metadata,
               response: response,
               unwrap: unwrap,
               stream: decoded
             )
           in {page: Class => page}
-            page.new(client: self, req: req, headers: response.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
 
@@ -647,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
@@ -693,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

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

@@ -226,6 +226,32 @@ module OpenAI
         # @return [Integer]
         def hash = [self.class, @data].hash
 
+        # The ID of the API request, returned via the `x-request-id` response
+        # header. This is only populated on top-level response objects returned
+        # by the client.
+        #
+        # @api public
+        #
+        # @return [String, nil]
+        def _request_id = @last_response&.request_id
+
+        # Metadata from the HTTP response that produced this model. This is
+        # only populated on top-level response objects returned by the client.
+        #
+        # @api public
+        #
+        # @return [OpenAI::ResponseMetadata, nil]
+        attr_reader :last_response
+
+        # @api private
+        #
+        # @param response [OpenAI::ResponseMetadata]
+        # @return [self]
+        def _set_last_response(response)
+          @last_response = response
+          self
+        end
+
         class << self
           # @api private
           #
@@ -247,7 +273,7 @@ module OpenAI
           def coerce(value, state:)
             exactness = state.fetch(:exactness)
 
-            if value.is_a?(self.class)
+            if value.is_a?(self)
               exactness[:yes] += 1
               return value
             end
@@ -470,12 +496,24 @@ module OpenAI
         # @return [String]
         def to_yaml(*a) = OpenAI::Internal::Type::Converter.dump(self.class, self).to_yaml(*a)
 
+        # Keep transport metadata outside Psych's object serialization path.
+        #
+        # @api private
+        #
+        # @param coder [Psych::Coder]
+        # @return [void]
+        def encode_with(coder)
+          coder["data"] = @data
+          coder["coerced"] = @coerced
+        end
+
         # Create a new instance of a model.
         #
         # @param data [Hash{Symbol=>Object}, self]
         def initialize(data = {})
           @data = {}
           @coerced = {}
+          @last_response = nil
           OpenAI::Internal::Util.coerce_hash!(data).each do
             if self.class.known_fields.key?(_1)
               public_send(:"#{_1}=", _2)

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

@@ -11,6 +11,22 @@ module OpenAI
       module BasePage
         # rubocop:disable Lint/UnusedMethodArgument
 
+        # The ID of the API request, returned via the `x-request-id` response
+        # header. This is only populated on top-level response objects returned
+        # by the client.
+        #
+        # @api public
+        #
+        # @return [String, nil]
+        def _request_id = last_response.request_id
+
+        # Metadata from the HTTP response that produced this page.
+        #
+        # @api public
+        #
+        # @return [OpenAI::ResponseMetadata]
+        attr_reader :last_response
+
         # @api public
         #
         # @return [Boolean]
@@ -39,12 +55,13 @@ 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 [Object]
-        def initialize(client:, req:, headers:, page_data:)
+        def initialize(client:, req:, response_metadata:, page_data:)
           @client = client
           @req = req
           @model = req.fetch(:model)
+          @last_response = response_metadata
           super()
         end
 

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

@@ -14,16 +14,50 @@ module OpenAI
         include Enumerable
 
         # @return [Integer]
-        attr_reader :status
+        def status = last_response.status
 
         # @return [Hash{String=>String}]
-        attr_reader :headers
+        def headers = last_response.headers
+
+        # Metadata from the HTTP response that opened this stream.
+        #
+        # @api public
+        #
+        # @return [OpenAI::ResponseMetadata]
+        attr_reader :last_response
 
         # @api public
         #
         # @return [void]
         def close = OpenAI::Internal::Util.close_fused!(@iterator)
 
+        # Attach request lifecycle logging without changing the stream's identity.
+        #
+        # @api private
+        #
+        # @param context [OpenAI::Internal::Logging::Context]
+        # @param response [OpenAI::HTTPClient::Response]
+        # @return [self]
+        def observe(context:, response:)
+          source = @iterator
+          @iterator = OpenAI::Internal::Util.chain_fused(source) do |yielder|
+            loop do
+              event =
+                begin
+                  source.next
+                rescue StopIteration
+                  context.completed(response)
+                  break
+                rescue StandardError => e
+                  context.request_failed(e)
+                  raise
+                end
+              yielder << event
+            end
+          end
+          self
+        end
+
         # @api private
         #
         # @return [Enumerable<generic<Elem>>]
@@ -53,16 +87,14 @@ module OpenAI
         #
         # @param model [Class, OpenAI::Internal::Type::Converter]
         # @param url [URI::Generic]
-        # @param status [Integer]
-        # @param headers [Hash{String=>String}]
+        # @param response_metadata [OpenAI::ResponseMetadata]
         # @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:)
+        def initialize(model:, url:, response_metadata:, response:, unwrap:, stream:)
           @model = model
           @url = url
-          @status = status
-          @headers = headers
+          @last_response = response_metadata
           @response = response
           @unwrap = unwrap
           @stream = stream

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

@@ -61,9 +61,9 @@ module OpenAI
         #
         # @return [Boolean]
         def ==(other)
-          # rubocop:disable Layout/LineLength
-          other.is_a?(OpenAI::Internal::Type::HashOf) && other.nilable? == nilable? && other.item_type == item_type
-          # rubocop:enable Layout/LineLength
+          other.is_a?(OpenAI::Internal::Type::HashOf) &&
+            other.nilable? == nilable? &&
+            other.item_type == item_type
         end
 
         # @api public