openai 0.79.0 → 0.81.0

data/lib/openai/internal/stream.rb

@@ -29,15 +29,15 @@ module OpenAI
             in {data: String => data}
               case JSON.parse(data, symbolize_names: true)
               in {error: error}
-                message =
-                  case error
-                  in String
-                    error
-                  in {message: String => m}
-                    m
-                  else
-                    "An error occurred during streaming"
-                  end
+                message = case error
+                in String
+                  error
+                in {message: String => m}
+                  m
+                else
+                  "An error occurred during streaming"
+                end
+
                 err = OpenAI::Errors::APIStatusError.for(
                   url: @url,
                   status: status,
@@ -50,6 +50,9 @@ module OpenAI
                 raise err
               in decoded
                 unwrapped = OpenAI::Internal::Util.dig(decoded, @unwrap)
+                # Some providers emit transport heartbeats as JSON events. They are not
+                # part of the API's typed streaming event surface.
+                next if unwrapped in {type: "keepalive"}
                 y << OpenAI::Internal::Type::Converter.coerce(@model, unwrapped)
               end
             else

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "ipaddr"
+
 require_relative "../logging"
 
 module OpenAI
@@ -13,17 +15,26 @@ module OpenAI
 
         # from whatwg fetch spec
         MAX_REDIRECTS = 20
+        REDIRECT_ENTITY_HEADERS = %w[
+          content-encoding
+          content-language
+          content-length
+          content-location
+          content-type
+          transfer-encoding
+        ]
+          .freeze
+        private_constant :REDIRECT_ENTITY_HEADERS
 
         # rubocop:disable Style/MutableConstant
-        PLATFORM_HEADERS =
-          {
-            "x-stainless-arch" => OpenAI::Internal::Util.arch,
-            "x-stainless-lang" => "ruby",
-            "x-stainless-os" => OpenAI::Internal::Util.os,
-            "x-stainless-package-version" => OpenAI::VERSION,
-            "x-stainless-runtime" => ::RUBY_ENGINE,
-            "x-stainless-runtime-version" => ::RUBY_ENGINE_VERSION
-          }
+        PLATFORM_HEADERS = {
+          "x-stainless-arch" => OpenAI::Internal::Util.arch,
+          "x-stainless-lang" => "ruby",
+          "x-stainless-os" => OpenAI::Internal::Util.os,
+          "x-stainless-package-version" => OpenAI::VERSION,
+          "x-stainless-runtime" => ::RUBY_ENGINE,
+          "x-stainless-runtime-version" => ::RUBY_ENGINE_VERSION
+        }
         # rubocop:enable Style/MutableConstant
 
         class << self
@@ -126,27 +137,35 @@ module OpenAI
           # @return [Hash{Symbol=>Object}]
           def follow_redirect(request, status:, response_headers:)
             method, url, headers = request.fetch_values(:method, :url, :headers)
-            location =
-              Kernel.then do
-                URI.join(url, response_headers["location"])
-              rescue ArgumentError
-                message = "Server responded with status #{status} but no valid location header."
-                raise OpenAI::Errors::APIConnectionError.new(
+            location = Kernel.then do
+              URI.join(url, response_headers["location"])
+            rescue ArgumentError
+              message = "Server responded with status #{status} but no valid location header."
+              raise(
+                OpenAI::Errors::APIConnectionError.new(
                   url: url,
                   response: response_headers,
                   message: message
                 )
-              end
+              )
+            end
+
+            unless %w[http https].include?(location.scheme) && !location.host.to_s.empty?
+              message = "Server responded with status #{status} but no valid location header."
+              raise OpenAI::Errors::APIConnectionError.new(url: url, message: message)
+            end
 
             request = {**request, url: location}
 
             case [url.scheme, location.scheme]
             in ["https", "http"]
               message = "Tried to redirect to a insecure URL"
-              raise OpenAI::Errors::APIConnectionError.new(
-                url: url,
-                response: response_headers,
-                message: message
+              raise(
+                OpenAI::Errors::APIConnectionError.new(
+                  url: url,
+                  response: response_headers,
+                  message: message
+                )
               )
             else
               nil
@@ -155,30 +174,54 @@ module OpenAI
             # from whatwg fetch spec
             case [status, method]
             in [301 | 302, :post] | [303, _]
-              drop = %w[content-encoding content-language content-length content-location content-type]
               request = {
                 **request,
                 method: method == :head ? :head : :get,
-                headers: headers.except(*drop),
-                body: nil
+                headers: headers.reject { |name, _| REDIRECT_ENTITY_HEADERS.include?(name.to_s.downcase) },
+                body: nil,
+                redirect_body_forbidden: true
               }
             else
             end
 
             # from undici
-            if OpenAI::Internal::Util.uri_origin(url) != OpenAI::Internal::Util.uri_origin(location)
+            origin = OpenAI::Internal::Util.uri_origin(URI(url.to_s))
+            redirect_origin = OpenAI::Internal::Util.uri_origin(URI(location.to_s))
+            if url.host.start_with?("[") && !url.hostname.start_with?("v", "V")
+              origin = origin.sub(url.host, "[#{IPAddr.new(url.hostname)}]")
+            end
+
+            if location.host.start_with?("[") && !location.hostname.start_with?("v", "V")
+              redirect_origin = redirect_origin.sub(location.host, "[#{IPAddr.new(location.hostname)}]")
+            end
+
+            unless origin.casecmp?(redirect_origin)
+              unless request[:body].nil?
+                # An attacker who controls a trusted endpoint's redirect destination could receive the body.
+                message = "Cannot follow a cross-origin redirect with a request body."
+                raise(
+                  OpenAI::Errors::APIConnectionError.new(
+                    url: URI(redirect_origin),
+                    message: message
+                  )
+                )
+              end
+
               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
+              raise(
+                OpenAI::Errors::APIConnectionError.new(
+                  url: location,
+                  response: response_headers,
+                  message: message
+                )
               )
             end
 
@@ -263,6 +306,7 @@ module OpenAI
           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
@@ -270,6 +314,7 @@ module OpenAI
           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
@@ -307,6 +352,13 @@ module OpenAI
           request
         end
 
+        # Validate the effective request after all per-attempt preparation hooks.
+        #
+        # @api private
+        private def validate_prepared_request(request, **_context)
+          request
+        end
+
         # @api private
         #
         # @return [String]
@@ -363,6 +415,30 @@ module OpenAI
 
           query = OpenAI::Internal::Util.deep_merge(req[:query].to_h, opts[:extra_query].to_h)
 
+          url = OpenAI::Internal::Util.join_parsed_uri(
+            @base_url_components,
+            {**req, path: path, query: query}
+          )
+          request_origin = URI.parse(url.to_s).normalize
+          base_origin = URI.parse(OpenAI::Internal::Util.unparse_uri(@base_url_components).to_s).normalize
+          [request_origin, base_origin].each do |origin|
+            next unless origin.hostname&.include?(":")
+
+            begin
+              address = IPAddr.new(origin.hostname)
+            rescue IPAddr::InvalidAddressError
+              next
+            end
+
+            origin.hostname = address.to_s if address.ipv6?
+          end
+
+          unless !request_origin.host.to_s.empty? &&
+              !base_origin.host.to_s.empty? &&
+              OpenAI::Internal::Util.uri_origin(request_origin) == OpenAI::Internal::Util.uri_origin(base_origin)
+            raise OpenAI::Errors::Error, "Request path must resolve to the configured base URL origin"
+          end
+
           headers = OpenAI::Internal::Util.normalized_headers(
             @headers,
             auth_headers(
@@ -376,8 +452,8 @@ module OpenAI
           )
 
           if @idempotency_header &&
-             !headers.key?(@idempotency_header) &&
-             (!Net::HTTP::IDEMPOTENT_METHODS_.include?(method.to_s.upcase) || opts.key?(:idempotency_key))
+              !headers.key?(@idempotency_header) &&
+              (!Net::HTTP::IDEMPOTENT_METHODS_.include?(method.to_s.upcase) || opts.key?(:idempotency_key))
             headers[@idempotency_header] = opts.fetch(:idempotency_key) { generate_idempotency_key }
           end
 
@@ -393,23 +469,18 @@ module OpenAI
 
           headers.reject! { |_, v| v.to_s.empty? }
 
-          body =
-            case method
-            in :get | :head | :options | :trace
-              nil
-            else
-              OpenAI::Internal::Util.deep_merge(*[req[:body], opts[:extra_body]].compact)
-            end
+          body = case method
+          in :get | :head | :options | :trace
+            nil
+          else
+            OpenAI::Internal::Util.deep_merge(*[req[:body], opts[:extra_body]].compact)
+          end
 
           # Generated methods always pass `req[:body]` for operations that define a
           # request body, so only elide the content-type header when the operation
           # has no body at all, not when an optional body param was omitted.
           headers.delete("content-type") if body.nil? && !req.key?(:body)
 
-          url = OpenAI::Internal::Util.join_parsed_uri(
-            @base_url_components,
-            {**req, path: path, query: query}
-          )
           max_retries = opts.fetch(:max_retries, @max_retries)
           max_retries = 0 unless self.class.request_body_replayable?(body)
           {
@@ -447,11 +518,19 @@ module OpenAI
           server_delay = delays.find { _1&.finite? && !_1.negative? }
           return [server_delay, @max_retry_delay].min if server_delay
 
-          delay = (@initial_retry_delay * (2**retry_count)).clamp(0, @max_retry_delay)
+          delay = (@initial_retry_delay * (2 ** retry_count)).clamp(0, @max_retry_delay)
           jitter = 1 - (0.25 * rand)
           delay * jitter
         end
 
+        # Allow authentication strategies to enforce a shared request deadline
+        # before publishing or sleeping for an API retry.
+        #
+        # @api private
+        private def validate_retry_delay!(_request, **_context)
+          nil
+        end
+
         # @api private
         private def raise_status_error!(url:, status:, headers:, response:, stream:)
           decoded = Kernel.then do
@@ -460,13 +539,15 @@ module OpenAI
             self.class.reap_connection!(status, stream: stream)
           end
 
-          raise OpenAI::Errors::APIStatusError.for(
-            url: url,
-            status: status,
-            headers: headers,
-            body: decoded,
-            request: nil,
-            response: response
+          raise(
+            OpenAI::Errors::APIStatusError.for(
+              url: url,
+              status: status,
+              headers: headers,
+              body: decoded,
+              request: nil,
+              response: response
+            )
           )
         end
 
@@ -507,27 +588,71 @@ 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(
-            attempt_request,
-            redirect_count: redirect_count,
-            retry_count: retry_count
-          )
-          url, max_retries, timeout = prepared_request.fetch_values(:url, :max_retries, :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)
+          url, max_retries = request.fetch_values(:url, :max_retries)
+          authorized_url = url.class.new(*URI.split(url.to_s))
+          prepared_request = request
+          trusted_origin = request[:redirect_trusted_origin]
 
           begin
+            encoded_headers, encoded_body = OpenAI::Internal::Util.encode_content(
+              request.fetch(:headers),
+              request[:body]
+            )
+            attempt_request = request.except(:redirect_trusted_origin, :redirect_body_forbidden).merge(
+              url: authorized_url.class.new(*URI.split(authorized_url.to_s)),
+              headers: encoded_headers.transform_values(&:dup),
+              body: encoded_body
+            )
+            prepared_request = validate_prepared_request(
+              prepare_request(
+                attempt_request,
+                redirect_count: redirect_count,
+                retry_count: retry_count
+              ),
+              original_request: request
+            )
+
+            prepared_url = prepared_request.fetch(:url)
+            prepared_origin = OpenAI::Internal::Util.uri_origin(URI(prepared_url.to_s))
+            if prepared_url.host&.start_with?("[") && !prepared_url.hostname.start_with?("v", "V")
+              prepared_origin = prepared_origin.sub(prepared_url.host, "[#{IPAddr.new(prepared_url.hostname)}]")
+            end
+
+            trusted_origin ||= prepared_origin
+            authorized_origin = OpenAI::Internal::Util.uri_origin(URI(authorized_url.to_s))
+            if authorized_url.host.start_with?("[") && !authorized_url.hostname.start_with?("v", "V")
+              authorized_origin = authorized_origin.sub(authorized_url.host, "[#{IPAddr.new(authorized_url.hostname)}]")
+            end
+
+            cross_origin = redirect_count.positive? && !trusted_origin.casecmp?(authorized_origin)
+            escaped_origin = redirect_count.positive? && !authorized_origin.casecmp?(prepared_origin)
+            restore_authorized_url = cross_origin || escaped_origin
+            body_forbidden = request[:redirect_body_forbidden] || cross_origin
+            if restore_authorized_url || body_forbidden
+              safe_headers = prepared_request.fetch(:headers).reject do |name, _|
+                normalized_name = name.to_s.downcase
+                (restore_authorized_url &&
+                  (normalized_name == "host" || OpenAI::Internal::Logging.credential_header?(name))) ||
+                  (body_forbidden && REDIRECT_ENTITY_HEADERS.include?(normalized_name))
+              end
+
+              prepared_request = prepared_request.merge(
+                url: restore_authorized_url ? authorized_url : prepared_url,
+                method: body_forbidden ? request.fetch(:method) : prepared_request.fetch(:method),
+                headers: safe_headers,
+                body: body_forbidden ? nil : prepared_request[:body]
+              )
+            end
+
+            url, max_retries, timeout = prepared_request.fetch_values(:url, :max_retries, :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)
             http_response = @requester.execute(input)
             unless http_response.is_a?(OpenAI::HTTPClient::Response)
               raise TypeError, "`http_client#execute` must return an OpenAI::HTTPClient::Response"
@@ -544,15 +669,15 @@ module OpenAI
             log_context.attempt_failed(e)
           end
 
-          terminal_status =
-            case status
-            in 300..399
-              prepared_request[:follow_redirects] == false
-            in (400..)
-              retry_count >= max_retries || !self.class.should_retry?(status, headers: headers)
-            else
-              false
-            end
+          terminal_status = case status
+          in 300..399
+            prepared_request[:follow_redirects] == false
+          in (400..)
+            retry_count >= max_retries || !self.class.should_retry?(status, headers: headers)
+          else
+            false
+          end
+
           if terminal_status
             raise_status_error!(
               url: url,
@@ -574,12 +699,20 @@ module OpenAI
           in 300..399
             self.class.reap_connection!(status, stream: stream)
 
-            redirect_source = request.merge(url: prepared_request.fetch(:url))
+            redirect_body = request[:body]
+            redirect_body = prepared_request[:body] if redirect_body.nil? || prepared_request[:body].nil?
+            redirect_source = request.merge(
+              method: prepared_request.fetch(:method),
+              url: prepared_request.fetch(:url),
+              body: redirect_body
+            )
             redirected_request = self.class.follow_redirect(
               redirect_source,
               status: status,
               response_headers: headers
             )
+            redirected_request = redirected_request.merge(body: nil) if request[:body].nil?
+            redirected_request = redirected_request.merge(redirect_trusted_origin: trusted_origin)
             send_request(
               redirected_request,
               redirect_count: redirect_count + 1,
@@ -593,6 +726,7 @@ module OpenAI
             self.class.reap_connection!(status, stream: stream)
 
             delay = retry_delay(headers, retry_count: retry_count)
+            validate_retry_delay!(request, delay: delay)
             log_context.retry_scheduled(
               status,
               delay: delay,
@@ -718,6 +852,14 @@ module OpenAI
         # @return [Object]
         private def parse_response(req, url:, response:)
           model = req.fetch(:model) { OpenAI::Internal::Type::Unknown }
+          if model == OpenAI::HTTPClient::Response
+            return OpenAI::HTTPClient::Response.new(
+              status: response.status,
+              headers: response.headers,
+              body: response.body.to_a.join
+            )
+          end
+
           unwrap = req[:unwrap]
           response_metadata = response.metadata
 
@@ -748,8 +890,8 @@ module OpenAI
         #
         # @return [String]
         def inspect
-          "#<#{self.class.name}:0x#{object_id.to_s(16)} base_url=#{@base_url} " \
-            "max_retries=#{@max_retries} timeout=#{@timeout}>"
+          safe_base_url = OpenAI::Internal::Logging.safe_url(@base_url)
+          "#<#{self.class.name}:0x#{object_id.to_s(16)} base_url=#{safe_base_url} max_retries=#{@max_retries} timeout=#{@timeout}>"
         end
 
         define_sorbet_constant!(:RequestComponents) do
@@ -759,14 +901,16 @@ module OpenAI
               path: T.any(String, T::Array[String]),
               query: T.nilable(T::Hash[String, T.nilable(T.any(T::Array[String], String))]),
               headers: T.nilable(
-                T::Hash[String,
-                        T.nilable(
-                          T.any(
-                            String,
-                            Integer,
-                            T::Array[T.nilable(T.any(String, Integer))]
-                          )
-                        )]
+                T::Hash[
+                  String,
+                  T.nilable(
+                    T.any(
+                      String,
+                      Integer,
+                      T::Array[T.nilable(T.any(String, Integer))]
+                    )
+                  )
+                ]
               ),
               body: T.nilable(T.anything),
               unwrap: T.nilable(
@@ -778,13 +922,16 @@ module OpenAI
                 )
               ),
               page: T.nilable(T::Class[OpenAI::Internal::Type::BasePage[OpenAI::Internal::Type::BaseModel]]),
-              stream: T.nilable(T::Class[OpenAI::Internal::Type::BaseStream[T.anything, OpenAI::Internal::Type::BaseModel]]),
+              stream: T.nilable(
+                T::Class[OpenAI::Internal::Type::BaseStream[T.anything, OpenAI::Internal::Type::BaseModel]]
+              ),
               model: T.nilable(OpenAI::Internal::Type::Converter::Input),
               security: T.nilable({bearer_auth?: T::Boolean, admin_api_key_auth?: T::Boolean}),
               options: T.nilable(OpenAI::RequestOptions::OrHash)
             }
           end
         end
+
         define_sorbet_constant!(:RequestInput) do
           T.type_alias do
             {

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

@@ -38,7 +38,21 @@ module OpenAI
         # @param other [Object]
         #
         # @return [Boolean]
-        def ===(other) = other.is_a?(Array) && other.all?(item_type)
+        def ===(other)
+          return false unless other.is_a?(Array)
+
+          target = item_type
+          other.all? do |item|
+            case item
+            in ^target
+              true
+            in nil
+              nilable?
+            else
+              false
+            end
+          end
+        end
 
         # @api public
         #
@@ -46,15 +60,13 @@ module OpenAI
         #
         # @return [Boolean]
         def ==(other)
-          other.is_a?(OpenAI::Internal::Type::ArrayOf) &&
-            other.nilable? == nilable? &&
-            other.item_type == item_type
+          other.is_a?(OpenAI::Internal::Type::ArrayOf) && other.nilable? == nilable? && other.item_type == item_type
         end
 
         # @api public
         #
         # @return [Integer]
-        def hash = [self.class, item_type].hash
+        def hash = [self.class, item_type, nilable?].hash
 
         # @api private
         #
@@ -84,16 +96,22 @@ module OpenAI
 
           target = item_type
           exactness[:yes] += 1
-          value
-            .map do |item|
-              case [nilable?, item]
-              in [true, nil]
-                exactness[:yes] += 1
-                nil
-              else
-                OpenAI::Internal::Type::Converter.coerce(target, item, state: state)
-              end
+          previous_error = state.fetch(:error)
+          last_error = nil
+          converted = value.map do |item|
+            case [nilable?, item]
+            in [true, nil]
+              exactness[:yes] += 1
+              nil
+            else
+              coerced, item_error = OpenAI::Internal::Type::Converter.coerce_with_error(target, item, state: state)
+              last_error = item_error if item_error
+              coerced
             end
+          end
+
+          state[:error] = last_error || previous_error
+          converted
         end
 
         # @api private
@@ -162,7 +180,7 @@ module OpenAI
         def inspect(depth: 0)
           items = OpenAI::Internal::Type::Converter.inspect(item_type, depth: depth.succ)
 
-          "#{self.class}[#{[items, nilable? ? 'nil' : nil].compact.join(' | ')}]"
+          "#{self.class}[#{[items, nilable? ? "nil" : nil].compact.join(" | ")}]"
         end
       end
     end