openai 0.77.0 → 0.78.0

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:)

data/lib/openai/internal/util.rb

@@ -4,6 +4,11 @@ module OpenAI
   module Internal
     # @api private
     module Util
+      # Marks enumerators whose overridden rewind safely closes the iterator.
+      module FusedEnumerator
+      end
+      private_constant :FusedEnumerator
+
       # @api private
       #
       # @return [Float]
@@ -397,90 +402,6 @@ module OpenAI
         end
       end
 
-      # @api private
-      #
-      # An adapter that satisfies the IO interface required by `::IO.copy_stream`
-      class ReadIOAdapter
-        # @api private
-        #
-        # @return [Boolean, nil]
-        def close? = @closing
-
-        # @api private
-        def close
-          case @stream
-          in Enumerator
-            OpenAI::Internal::Util.close_fused!(@stream)
-          in 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
-            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)
-            else
-              src
-            end
-          @buf = String.new
-          @blk = blk
-        end
-      end
-
       class << self
         # @param blk [Proc]
         #
@@ -768,6 +689,7 @@ module OpenAI
             close&.call
             close = nil
           end
+          iter.extend(FusedEnumerator)
 
           iter.define_singleton_method(:rewind) do
             fused = true
@@ -780,7 +702,7 @@ module OpenAI
         #
         # @param enum [Enumerable<Object>, nil]
         def close_fused!(enum)
-          return unless enum.is_a?(Enumerator)
+          return unless enum.is_a?(FusedEnumerator)
 
           # rubocop:disable Lint/UnreachableLoop
           enum.rewind.each { break }

data/lib/openai/net_http_client.rb

@@ -0,0 +1,281 @@
+# frozen_string_literal: true
+
+require_relative "internal/read_io_adapter"
+
+module OpenAI
+  # The SDK's pooled Net::HTTP implementation.
+  #
+  # Pass a block to configure each SDK-created connection before it is pooled
+  # and started.
+  class NetHTTPClient < HTTPClient
+    # from the golang stdlib
+    # https://github.com/golang/go/blob/c8eced8580028328fde7c03cbfcb720ce15b2358/src/net/http/transport.go#L49
+    KEEP_ALIVE_TIMEOUT = 30
+
+    DEFAULT_MAX_CONNECTIONS = [Etc.nprocessors, 99].max
+
+    NETWORK_ERRORS = [
+      EOFError,
+      IOError,
+      SocketError,
+      SystemCallError,
+      OpenSSL::SSL::SSLError,
+      Net::HTTPBadResponse,
+      Net::HTTPHeaderSyntaxError,
+      Net::ProtocolError,
+      (defined?(Zlib::Error) ? Zlib::Error : nil),
+      ConnectionPool::PoolShuttingDownError
+    ].compact.freeze
+    private_constant :NETWORK_ERRORS
+
+    class ConnectionConfigurationError < StandardError
+      attr_reader :original
+
+      def initialize(original)
+        @original = original
+        super()
+      end
+    end
+    private_constant :ConnectionConfigurationError
+
+    # @api private
+    #
+    # @param url [URI::Generic]
+    #
+    # @return [Net::HTTP]
+    private def connect(url:)
+      port =
+        case [url.port, url.scheme]
+        in [Integer, _]
+          url.port
+        in [nil, "http" | "ws"]
+          Net::HTTP.http_default_port
+        in [nil, "https" | "wss"]
+          Net::HTTP.https_default_port
+        end
+
+      Net::HTTP.new(url.host, port).tap do
+        _1.use_ssl = %w[https wss].include?(url.scheme)
+        _1.keep_alive_timeout = KEEP_ALIVE_TIMEOUT
+        _1.max_retries = 0
+
+        (_1.cert_store = @cert_store) if _1.use_ssl?
+      end
+    end
+
+    # @api private
+    #
+    # @param conn [Net::HTTP]
+    # @param deadline [Float]
+    private def calibrate_socket_timeout(conn, deadline)
+      timeout = remaining_timeout(deadline)
+      conn.open_timeout = conn.read_timeout = conn.write_timeout = conn.continue_timeout = timeout
+    end
+
+    # @api private
+    #
+    # @param deadline [Float]
+    # @return [Float]
+    # @raise [Timeout::Error]
+    private def remaining_timeout(deadline)
+      timeout = deadline - OpenAI::Internal::Util.monotonic_secs
+      raise Timeout::Error, "request timed out" unless timeout.positive?
+
+      timeout
+    end
+
+    # @api private
+    #
+    # @param request [OpenAI::HTTPClient::Request]
+    # @param blk [Proc]
+    #
+    # @yieldparam [String]
+    # @return [Array(Net::HTTPGenericRequest, Proc)]
+    private def build_request(request, &blk)
+      method = request.method
+      body = request.body
+      req = Net::HTTPGenericRequest.new(
+        method.to_s.upcase,
+        !body.nil?,
+        method != :head,
+        URI(request.url.to_s)
+      )
+
+      request.headers.each { req[_1] = _2 }
+
+      case body
+      in nil
+        req["content-length"] ||= 0 unless req["transfer-encoding"]
+      in String
+        req["content-length"] ||= body.bytesize.to_s unless req["transfer-encoding"]
+        req.body_stream = OpenAI::Internal::Util::ReadIOAdapter.new(body, &blk)
+      in StringIO
+        req["content-length"] ||= body.size.to_s unless req["transfer-encoding"]
+        req.body_stream = OpenAI::Internal::Util::ReadIOAdapter.new(body, &blk)
+      in Pathname | IO | Enumerator
+        req["transfer-encoding"] ||= "chunked" unless req["content-length"]
+        req.body_stream = OpenAI::Internal::Util::ReadIOAdapter.new(body, &blk)
+      end
+
+      [req, req.body_stream&.method(:close)]
+    end
+
+    # @api private
+    #
+    # @param url [URI::Generic]
+    # @param deadline [Float]
+    # @param blk [Proc]
+    #
+    # @raise [Timeout::Error]
+    # @yieldparam [Net::HTTP]
+    private def with_pool(url, deadline:, &blk)
+      origin = OpenAI::Internal::Util.uri_origin(url)
+      timeout = remaining_timeout(deadline)
+      pool =
+        @mutex.synchronize do
+          @pools[origin] ||= ConnectionPool.new(size: @size) do
+            configured_connection(url)
+          end
+        end
+
+      pool.with(timeout: timeout, &blk)
+    end
+
+    # @api private
+    #
+    # @param url [URI::Generic]
+    #
+    # @return [Net::HTTP]
+    private def configured_connection(url)
+      connection = nil
+      connection = connect(url: url)
+      begin
+        @connection_configurator&.call(connection)
+      rescue StandardError => e
+        raise ConnectionConfigurationError.new(e)
+      end
+
+      if connection.started?
+        raise ArgumentError, "connection configuration must leave the connection unstarted"
+      end
+
+      expected_ssl = %w[https wss].include?(url.scheme)
+      unless connection.use_ssl? == expected_ssl
+        raise ArgumentError, "connection configuration must preserve TLS for the requested URL"
+      end
+
+      connection.max_retries = 0
+      connection
+    rescue StandardError
+      begin
+        connection.finish if connection&.started?
+      rescue StandardError
+        nil
+      end
+      raise
+    end
+
+    # Closes current pooled connections. The client remains reusable and will
+    # create fresh pools on subsequent requests.
+    #
+    # In-flight requests are allowed to finish before their connection closes.
+    #
+    # @return [void]
+    def close
+      pools =
+        @mutex.synchronize do
+          current_pools = @pools
+          @pools = {}
+          current_pools
+        end
+      pools.each_value do |pool|
+        pool.shutdown { |connection| connection.finish if connection.started? }
+      end
+      nil
+    end
+
+    # Executes a request using a pooled Net::HTTP connection.
+    #
+    # @param request [OpenAI::HTTPClient::Request]
+    # @return [OpenAI::HTTPClient::Response]
+    def execute(request)
+      url = request.url
+      deadline = OpenAI::Internal::Util.monotonic_secs + request.timeout
+
+      req = nil
+      finished = false
+
+      # rubocop:disable Metrics/BlockLength
+      enum = Enumerator.new do |y|
+        next if finished
+
+        with_pool(url, deadline: deadline) do |conn|
+          eof = false
+          closing = nil
+          ::Thread.handle_interrupt(Object => :never) do
+            ::Thread.handle_interrupt(Object => :immediate) do
+              req, closing = build_request(request) do
+                calibrate_socket_timeout(conn, deadline)
+              end
+
+              calibrate_socket_timeout(conn, deadline)
+              conn.start unless conn.started?
+
+              calibrate_socket_timeout(conn, deadline)
+              ::Kernel.catch(:jump) do
+                conn.request(req) do |rsp|
+                  y << [req, rsp]
+                  ::Kernel.throw(:jump) if finished
+
+                  rsp.read_body do |bytes|
+                    y << bytes.force_encoding(Encoding::BINARY)
+                    ::Kernel.throw(:jump) if finished
+
+                    calibrate_socket_timeout(conn, deadline)
+                  end
+                  eof = true
+                end
+              end
+            end
+          ensure
+            begin
+              conn.finish if !eof && conn&.started?
+            ensure
+              closing&.call
+            end
+          end
+        end
+      rescue ConnectionConfigurationError => e
+        raise e.original, cause: e.original.cause
+      rescue Timeout::Error
+        raise OpenAI::Errors::APITimeoutError.new(url: url, request: req)
+      rescue *NETWORK_ERRORS
+        raise OpenAI::Errors::APIConnectionError.new(url: url, request: req)
+      end
+      # rubocop:enable Metrics/BlockLength
+
+      _, response = enum.next
+      body = OpenAI::Internal::Util.fused_enum(enum, external: true) do
+        finished = true
+        loop { enum.next }
+      end
+      OpenAI::HTTPClient::Response.new(
+        status: Integer(response.code),
+        headers: response.each_header.to_h,
+        body: body
+      )
+    end
+
+    # @param size [Integer]
+    # @param connection_configurator [#call, nil] A block that configures every
+    #   SDK-created Net::HTTP connection before it is pooled and started.
+    def initialize(size: self.class::DEFAULT_MAX_CONNECTIONS, &connection_configurator)
+      super()
+      @mutex = Mutex.new
+      @size = size
+      @cert_store = OpenSSL::X509::Store.new.tap(&:set_default_paths)
+      @connection_configurator = connection_configurator
+      @pools = {}
+    end
+  end
+end

data/lib/openai/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module OpenAI
-  VERSION = "0.77.0"
+  VERSION = "0.78.0"
 end

data/lib/openai.rb

@@ -53,11 +53,12 @@ require_relative "openai/internal"
 require_relative "openai/request_options"
 require_relative "openai/file_part"
 require_relative "openai/errors"
+require_relative "openai/http_client"
+require_relative "openai/net_http_client"
 require_relative "openai/provider"
 require_relative "openai/internal/provider"
 require_relative "openai/providers/bedrock"
 require_relative "openai/internal/transport/base_client"
-require_relative "openai/internal/transport/pooled_net_requester"
 require_relative "openai/client"
 require_relative "openai/internal/stream"
 require_relative "openai/internal/conversation_cursor_page"

data/rbi/openai/client.rbi

@@ -162,7 +162,8 @@ module OpenAI
         max_retries: Integer,
         timeout: Float,
         initial_retry_delay: Float,
-        max_retry_delay: Float
+        max_retry_delay: Float,
+        http_client: T.untyped
       ).returns(T.attached_class)
     end
     def self.new(
@@ -185,7 +186,8 @@ module OpenAI
       max_retries: OpenAI::Client::DEFAULT_MAX_RETRIES,
       timeout: OpenAI::Client::DEFAULT_TIMEOUT_IN_SECONDS,
       initial_retry_delay: OpenAI::Client::DEFAULT_INITIAL_RETRY_DELAY,
-      max_retry_delay: OpenAI::Client::DEFAULT_MAX_RETRY_DELAY
+      max_retry_delay: OpenAI::Client::DEFAULT_MAX_RETRY_DELAY,
+      http_client: nil
     )
     end
   end

data/rbi/openai/http_client.rbi

@@ -0,0 +1,63 @@
+# typed: strong
+
+module OpenAI
+  class HTTPClient
+    class Request
+      sig { returns(Symbol) }
+      attr_reader :method
+
+      sig { returns(URI::Generic) }
+      attr_reader :url
+
+      sig { returns(T::Hash[String, String]) }
+      attr_reader :headers
+
+      sig { returns(T.anything) }
+      attr_reader :body
+
+      sig { returns(Float) }
+      attr_reader :timeout
+
+      sig do
+        params(
+          method: Symbol,
+          url: URI::Generic,
+          headers: T::Hash[String, String],
+          body: T.anything,
+          timeout: Float
+        ).returns(T.attached_class)
+      end
+      def self.new(method:, url:, headers:, body:, timeout:)
+      end
+    end
+
+    class Response
+      sig { returns(Integer) }
+      attr_reader :status
+
+      sig { returns(T::Hash[String, String]) }
+      attr_reader :headers
+
+      sig { returns(T::Enumerable[String]) }
+      attr_reader :body
+
+      sig do
+        params(
+          status: Integer,
+          headers: T::Hash[String, String],
+          body: T.any(String, T::Enumerable[String])
+        ).returns(T.attached_class)
+      end
+      def self.new(status:, headers:, body:)
+      end
+    end
+
+    sig do
+      params(request: OpenAI::HTTPClient::Request).returns(
+        OpenAI::HTTPClient::Response
+      )
+    end
+    def execute(request)
+    end
+  end
+end

data/rbi/openai/internal/read_io_adapter.rbi

@@ -0,0 +1,47 @@
+# typed: strong
+
+module OpenAI
+  module Internal
+    module Util
+      # @api private
+      #
+      # An adapter that satisfies the IO interface required by `::IO.copy_stream`
+      class ReadIOAdapter
+        # @api private
+        sig { returns(T.nilable(T::Boolean)) }
+        def close?
+        end
+
+        # @api private
+        sig { void }
+        def close
+        end
+
+        # @api private
+        sig { params(max_len: T.nilable(Integer)).returns(String) }
+        private def read_enum(max_len)
+        end
+
+        # @api private
+        sig do
+          params(
+            max_len: T.nilable(Integer),
+            out_string: T.nilable(String)
+          ).returns(T.nilable(String))
+        end
+        def read(max_len = nil, out_string = nil)
+        end
+
+        # @api private
+        sig do
+          params(
+            src: T.any(String, Pathname, StringIO, T::Enumerable[String]),
+            blk: T.proc.params(arg0: String).void
+          ).returns(T.attached_class)
+        end
+        def self.new(src, &blk)
+        end
+      end
+    end
+  end
+end

data/rbi/openai/internal/transport/base_client.rbi

@@ -103,6 +103,11 @@ module OpenAI
           def should_retry?(status, headers:)
           end
 
+          # @api private
+          sig { params(body: T.untyped).returns(T::Boolean) }
+          def request_body_replayable?(body)
+          end
+
           # @api private
           sig do
             params(
@@ -147,7 +152,7 @@ module OpenAI
         attr_reader :idempotency_header
 
         # @api private
-        sig { returns(OpenAI::Internal::Transport::PooledNetRequester) }
+        sig { returns(T.untyped) }
         attr_reader :requester
 
         # @api private
@@ -169,7 +174,8 @@ module OpenAI
                   )
                 )
               ],
-            idempotency_header: T.nilable(String)
+            idempotency_header: T.nilable(String),
+            http_client: T.untyped
           ).returns(T.attached_class)
         end
         def self.new(
@@ -179,7 +185,8 @@ module OpenAI
           initial_retry_delay: 0.0,
           max_retry_delay: 0.0,
           headers: {},
-          idempotency_header: nil
+          idempotency_header: nil,
+          http_client: nil
         )
         end
 
@@ -223,6 +230,15 @@ module OpenAI
         private def build_request(req, opts)
         end
 
+        # @api private
+        sig do
+          params(
+            request: OpenAI::Internal::Transport::BaseClient::RequestInput
+          ).returns(T::Boolean)
+        end
+        private def request_replayable?(request)
+        end
+
         # @api private
         sig do
           params(
@@ -239,7 +255,7 @@ module OpenAI
             url: URI::Generic,
             status: Integer,
             headers: T::Hash[String, String],
-            response: Net::HTTPResponse,
+            response: OpenAI::HTTPClient::Response,
             stream: T::Enumerable[String]
           ).returns(T.noreturn)
         end
@@ -259,7 +275,7 @@ module OpenAI
             redirect_count: Integer,
             retry_count: Integer,
             send_retry_header: T::Boolean
-          ).returns([Integer, Net::HTTPResponse, T::Enumerable[String]])
+          ).returns(OpenAI::HTTPClient::Response)
         end
         def send_request(
           request,

data/rbi/openai/internal/type/base_stream.rbi

@@ -43,7 +43,7 @@ module OpenAI
             url: URI::Generic,
             status: Integer,
             headers: T::Hash[String, String],
-            response: Net::HTTPResponse,
+            response: OpenAI::HTTPClient::Response,
             unwrap:
               T.any(
                 Symbol,

data/rbi/openai/internal/util.rbi

@@ -253,46 +253,6 @@ module OpenAI
         end
       end
 
-      # @api private
-      #
-      # An adapter that satisfies the IO interface required by `::IO.copy_stream`
-      class ReadIOAdapter
-        # @api private
-        sig { returns(T.nilable(T::Boolean)) }
-        def close?
-        end
-
-        # @api private
-        sig { void }
-        def close
-        end
-
-        # @api private
-        sig { params(max_len: T.nilable(Integer)).returns(String) }
-        private def read_enum(max_len)
-        end
-
-        # @api private
-        sig do
-          params(
-            max_len: T.nilable(Integer),
-            out_string: T.nilable(String)
-          ).returns(T.nilable(String))
-        end
-        def read(max_len = nil, out_string = nil)
-        end
-
-        # @api private
-        sig do
-          params(
-            src: T.any(String, Pathname, StringIO, T::Enumerable[String]),
-            blk: T.proc.params(arg0: String).void
-          ).returns(T.attached_class)
-        end
-        def self.new(src, &blk)
-        end
-      end
-
       class << self
         sig do
           params(blk: T.proc.params(y: Enumerator::Yielder).void).returns(