openai 0.77.0 → 0.78.0

data/rbi/openai/net_http_client.rbi

@@ -0,0 +1,64 @@
+# typed: strong
+
+module OpenAI
+  class NetHTTPClient < OpenAI::HTTPClient
+    KEEP_ALIVE_TIMEOUT = 30
+
+    DEFAULT_MAX_CONNECTIONS = T.let(T.unsafe(nil), Integer)
+
+    sig { params(url: URI::Generic).returns(Net::HTTP) }
+    private def connect(url:)
+    end
+
+    sig { params(conn: Net::HTTP, deadline: Float).void }
+    private def calibrate_socket_timeout(conn, deadline)
+    end
+
+    sig do
+      params(
+        request: OpenAI::HTTPClient::Request,
+        blk: T.proc.params(arg0: String).void
+      ).returns([Net::HTTPGenericRequest, T.proc.void])
+    end
+    private def build_request(request, &blk)
+    end
+
+    sig do
+      params(
+        url: URI::Generic,
+        deadline: Float,
+        blk: T.proc.params(arg0: Net::HTTP).void
+      ).void
+    end
+    private def with_pool(url, deadline:, &blk)
+    end
+
+    sig { params(url: URI::Generic).returns(Net::HTTP) }
+    private def configured_connection(url)
+    end
+
+    sig { void }
+    def close
+    end
+
+    sig do
+      params(request: OpenAI::HTTPClient::Request).returns(
+        OpenAI::HTTPClient::Response
+      )
+    end
+    def execute(request)
+    end
+
+    sig do
+      params(
+        size: Integer,
+        connection_configurator: T.nilable(T.proc.params(http: Net::HTTP).void)
+      ).returns(T.attached_class)
+    end
+    def self.new(
+      size: OpenAI::NetHTTPClient::DEFAULT_MAX_CONNECTIONS,
+      &connection_configurator
+    )
+    end
+  end
+end

data/sig/openai/client.rbs

@@ -94,7 +94,8 @@ module OpenAI
       ?max_retries: Integer,
       ?timeout: Float,
       ?initial_retry_delay: Float,
-      ?max_retry_delay: Float
+      ?max_retry_delay: Float,
+      ?http_client: OpenAI::_HTTPClient?
     ) -> void
   end
 end

data/sig/openai/http_client.rbs

@@ -0,0 +1,41 @@
+module OpenAI
+  interface _HTTPClient
+    def execute: (
+      OpenAI::HTTPClient::Request request
+    ) -> OpenAI::HTTPClient::Response
+  end
+
+  class HTTPClient
+    class Request
+      attr_reader method: Symbol
+      attr_reader url: URI::Generic
+      attr_reader headers: ::Hash[String, String]
+      attr_reader body: top
+      attr_reader timeout: Float
+
+      def initialize: (
+        method: Symbol,
+        url: URI::Generic,
+        headers: ::Hash[String, String],
+        body: top,
+        timeout: Float
+      ) -> void
+    end
+
+    class Response
+      attr_reader status: Integer
+      attr_reader headers: ::Hash[String, String]
+      attr_reader body: Enumerable[String]
+
+      def initialize: (
+        status: Integer,
+        headers: ::Hash[String, String],
+        body: String | Enumerable[String]
+      ) -> void
+    end
+
+    def execute: (
+      OpenAI::HTTPClient::Request request
+    ) -> OpenAI::HTTPClient::Response
+  end
+end

data/sig/openai/internal/read_io_adapter.rbs

@@ -0,0 +1,21 @@
+module OpenAI
+  module Internal
+    module Util
+      class ReadIOAdapter
+        def close?: -> bool?
+
+        def close: -> void
+
+        private def read_enum: (Integer? max_len) -> String
+
+        def read: (?Integer? max_len, ?String? out_string) -> String?
+
+        def initialize: (
+          String | Pathname | StringIO | Enumerable[String] src
+        ) {
+          (String arg0) -> void
+        } -> void
+      end
+    end
+  end
+end

data/sig/openai/internal/transport/base_client.rbs

@@ -48,6 +48,8 @@ module OpenAI
           headers: ::Hash[String, String]
         ) -> bool
 
+        def self.request_body_replayable?: (top body) -> bool
+
         def self.follow_redirect: (
           OpenAI::Internal::Transport::BaseClient::request_input request,
           status: Integer,
@@ -74,7 +76,7 @@ module OpenAI
         attr_reader idempotency_header: String?
 
         # @api private
-        attr_reader requester: OpenAI::Internal::Transport::PooledNetRequester
+        attr_reader requester: OpenAI::_HTTPClient
 
         def initialize: (
           base_url: String,
@@ -85,7 +87,8 @@ module OpenAI
           ?headers: ::Hash[String, (String
           | Integer
           | ::Array[(String | Integer)?])?],
-          ?idempotency_header: String?
+          ?idempotency_header: String?,
+          ?http_client: OpenAI::_HTTPClient?
         ) -> void
 
         private def auth_headers: -> ::Hash[String, String]
@@ -105,6 +108,10 @@ module OpenAI
           OpenAI::request_options opts
         ) -> OpenAI::Internal::Transport::BaseClient::request_input
 
+        private def request_replayable?: (
+          OpenAI::Internal::Transport::BaseClient::request_input request
+        ) -> bool
+
         private def retry_delay: (
           ::Hash[String, String] headers,
           retry_count: Integer
@@ -123,7 +130,7 @@ module OpenAI
           redirect_count: Integer,
           retry_count: Integer,
           send_retry_header: bool
-        ) -> [Integer, top, Enumerable[String]]
+        ) -> OpenAI::HTTPClient::Response
 
         def request: (
           Symbol method,

data/sig/openai/internal/type/base_stream.rbs

@@ -23,7 +23,7 @@ module OpenAI
           url: URI::Generic,
           status: Integer,
           headers: ::Hash[String, String],
-          response: top,
+          response: OpenAI::HTTPClient::Response,
           unwrap: Symbol
           | Integer
           | ::Array[Symbol | Integer]

data/sig/openai/internal/util.rbs

@@ -87,22 +87,6 @@ module OpenAI
         | ::Array[(String | Integer)?])?] headers
       ) -> ::Hash[String, String]
 
-      class ReadIOAdapter
-        def close?: -> bool?
-
-        def close: -> void
-
-        private def read_enum: (Integer? max_len) -> String
-
-        def read: (?Integer? max_len, ?String? out_string) -> String?
-
-        def initialize: (
-          String | Pathname | StringIO | Enumerable[String] src
-        ) {
-          (String arg0) -> void
-        } -> void
-      end
-
       def self?.writable_enum: {
         (Enumerator::Yielder y) -> void
       } -> Enumerable[String]

data/sig/openai/net_http_client.rbs

@@ -0,0 +1,34 @@
+module OpenAI
+  class NetHTTPClient < OpenAI::HTTPClient
+    KEEP_ALIVE_TIMEOUT: 30
+
+    DEFAULT_MAX_CONNECTIONS: Integer
+
+    private def connect: (url: URI::Generic) -> top
+
+    private def calibrate_socket_timeout: (top conn, Float deadline) -> void
+
+    private def build_request: (
+      OpenAI::HTTPClient::Request request
+    ) {
+      (String arg0) -> void
+    } -> [top, (^-> void)]
+
+    private def with_pool: (
+      URI::Generic url,
+      deadline: Float
+    ) {
+      (top arg0) -> void
+    } -> void
+
+    private def configured_connection: (URI::Generic url) -> top
+
+    def close: -> void
+
+    def execute: (
+      OpenAI::HTTPClient::Request request
+    ) -> OpenAI::HTTPClient::Response
+
+    def initialize: (?size: Integer) ?{ (Net::HTTP) -> void } -> void
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: openai
 version: !ruby/object:Gem::Version
-  version: 0.77.0
+  version: 0.78.0
 platform: ruby
 authors:
 - OpenAI
@@ -43,14 +43,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 2.2.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 2.2.3
 email: support@openai.com
 executables: []
 extensions: []
@@ -87,15 +87,16 @@ files:
 - lib/openai/helpers/structured_output/json_schema_converter.rb
 - lib/openai/helpers/structured_output/parsed_json.rb
 - lib/openai/helpers/structured_output/union_of.rb
+- lib/openai/http_client.rb
 - lib/openai/internal.rb
 - lib/openai/internal/conversation_cursor_page.rb
 - lib/openai/internal/cursor_page.rb
 - lib/openai/internal/next_cursor_page.rb
 - lib/openai/internal/page.rb
 - lib/openai/internal/provider.rb
+- lib/openai/internal/read_io_adapter.rb
 - lib/openai/internal/stream.rb
 - lib/openai/internal/transport/base_client.rb
-- lib/openai/internal/transport/pooled_net_requester.rb
 - lib/openai/internal/type/array_of.rb
 - lib/openai/internal/type/base_model.rb
 - lib/openai/internal/type/base_page.rb
@@ -1196,6 +1197,7 @@ files:
 - lib/openai/models/webhooks/response_incomplete_webhook_event.rb
 - lib/openai/models/webhooks/unwrap_webhook_event.rb
 - lib/openai/models/webhooks/webhook_unwrap_params.rb
+- lib/openai/net_http_client.rb
 - lib/openai/provider.rb
 - lib/openai/providers/bedrock.rb
 - lib/openai/request_options.rb
@@ -1310,15 +1312,16 @@ files:
 - rbi/openai/helpers/structured_output/enum_of.rbi
 - rbi/openai/helpers/structured_output/json_schema_converter.rbi
 - rbi/openai/helpers/structured_output/union_of.rbi
+- rbi/openai/http_client.rbi
 - rbi/openai/internal.rbi
 - rbi/openai/internal/conversation_cursor_page.rbi
 - rbi/openai/internal/cursor_page.rbi
 - rbi/openai/internal/next_cursor_page.rbi
 - rbi/openai/internal/page.rbi
 - rbi/openai/internal/provider.rbi
+- rbi/openai/internal/read_io_adapter.rbi
 - rbi/openai/internal/stream.rbi
 - rbi/openai/internal/transport/base_client.rbi
-- rbi/openai/internal/transport/pooled_net_requester.rbi
 - rbi/openai/internal/type/array_of.rbi
 - rbi/openai/internal/type/base_model.rbi
 - rbi/openai/internal/type/base_page.rbi
@@ -2418,6 +2421,7 @@ files:
 - rbi/openai/models/webhooks/response_incomplete_webhook_event.rbi
 - rbi/openai/models/webhooks/unwrap_webhook_event.rbi
 - rbi/openai/models/webhooks/webhook_unwrap_params.rbi
+- rbi/openai/net_http_client.rbi
 - rbi/openai/provider.rbi
 - rbi/openai/providers.rbi
 - rbi/openai/request_options.rbi
@@ -2521,15 +2525,16 @@ files:
 - sig/openai/client.rbs
 - sig/openai/errors.rbs
 - sig/openai/file_part.rbs
+- sig/openai/http_client.rbs
 - sig/openai/internal.rbs
 - sig/openai/internal/conversation_cursor_page.rbs
 - sig/openai/internal/cursor_page.rbs
 - sig/openai/internal/next_cursor_page.rbs
 - sig/openai/internal/page.rbs
 - sig/openai/internal/provider.rbs
+- sig/openai/internal/read_io_adapter.rbs
 - sig/openai/internal/stream.rbs
 - sig/openai/internal/transport/base_client.rbs
-- sig/openai/internal/transport/pooled_net_requester.rbs
 - sig/openai/internal/type/array_of.rbs
 - sig/openai/internal/type/base_model.rbs
 - sig/openai/internal/type/base_page.rbs
@@ -3629,6 +3634,7 @@ files:
 - sig/openai/models/webhooks/response_incomplete_webhook_event.rbs
 - sig/openai/models/webhooks/unwrap_webhook_event.rbs
 - sig/openai/models/webhooks/webhook_unwrap_params.rbs
+- sig/openai/net_http_client.rbs
 - sig/openai/provider.rbs
 - sig/openai/providers.rbs
 - sig/openai/request_options.rbs

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

@@ -1,210 +0,0 @@
-# frozen_string_literal: true
-
-module OpenAI
-  module Internal
-    module Transport
-      # @api private
-      class PooledNetRequester
-        extend OpenAI::Internal::Util::SorbetRuntimeSupport
-
-        # 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
-
-        class << self
-          # @api private
-          #
-          # @param cert_store [OpenSSL::X509::Store]
-          # @param url [URI::Generic]
-          #
-          # @return [Net::HTTP]
-          def connect(cert_store:, 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.max_retries = 0
-
-              (_1.cert_store = cert_store) if _1.use_ssl?
-            end
-          end
-
-          # @api private
-          #
-          # @param conn [Net::HTTP]
-          # @param deadline [Float]
-          def calibrate_socket_timeout(conn, deadline)
-            timeout = deadline - OpenAI::Internal::Util.monotonic_secs
-            conn.open_timeout = conn.read_timeout = conn.write_timeout = conn.continue_timeout = timeout
-          end
-
-          # @api private
-          #
-          # @param request [Hash{Symbol=>Object}] .
-          #
-          #   @option request [Symbol] :method
-          #
-          #   @option request [URI::Generic] :url
-          #
-          #   @option request [Hash{String=>String}] :headers
-          #
-          # @param blk [Proc]
-          #
-          # @yieldparam [String]
-          # @return [Array(Net::HTTPGenericRequest, Proc)]
-          def build_request(request, &blk)
-            method, url, headers, body = request.fetch_values(:method, :url, :headers, :body)
-            req = Net::HTTPGenericRequest.new(
-              method.to_s.upcase,
-              !body.nil?,
-              method != :head,
-              URI(url.to_s) # ensure we construct a URI class of the right scheme
-            )
-
-            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
-        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 = deadline - OpenAI::Internal::Util.monotonic_secs
-          pool =
-            @mutex.synchronize do
-              @pools[origin] ||= ConnectionPool.new(size: @size) do
-                self.class.connect(cert_store: @cert_store, url: url)
-              end
-            end
-
-          pool.with(timeout: timeout, &blk)
-        end
-
-        # @api private
-        #
-        # @param request [Hash{Symbol=>Object}] .
-        #
-        #   @option request [Symbol] :method
-        #
-        #   @option request [URI::Generic] :url
-        #
-        #   @option request [Hash{String=>String}] :headers
-        #
-        #   @option request [Object] :body
-        #
-        #   @option request [Float] :deadline
-        #
-        # @return [Array(Integer, Net::HTTPResponse, Enumerable<String>)]
-        def execute(request)
-          url, deadline = request.fetch_values(:url, :deadline)
-
-          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 = self.class.build_request(request) do
-                    self.class.calibrate_socket_timeout(conn, deadline)
-                  end
-
-                  self.class.calibrate_socket_timeout(conn, deadline)
-                  unless conn.started?
-                    conn.keep_alive_timeout = self.class::KEEP_ALIVE_TIMEOUT
-                    conn.start
-                  end
-
-                  self.class.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
-
-                        self.class.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 Timeout::Error
-            raise OpenAI::Errors::APITimeoutError.new(url: url, request: req)
-          rescue StandardError
-            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
-          [Integer(response.code), response, body]
-        end
-
-        # @api private
-        #
-        # @param size [Integer]
-        def initialize(size: self.class::DEFAULT_MAX_CONNECTIONS)
-          @mutex = Mutex.new
-          @size = size
-          @cert_store = OpenSSL::X509::Store.new.tap(&:set_default_paths)
-          @pools = {}
-        end
-
-        define_sorbet_constant!(:Request) do
-          T.type_alias { {method: Symbol, url: URI::Generic, headers: T::Hash[String, String], body: T.anything, deadline: Float} }
-        end
-      end
-    end
-  end
-end

data/rbi/openai/internal/transport/pooled_net_requester.rbi

@@ -1,82 +0,0 @@
-# typed: strong
-
-module OpenAI
-  module Internal
-    module Transport
-      # @api private
-      class PooledNetRequester
-        extend OpenAI::Internal::Util::SorbetRuntimeSupport
-
-        Request =
-          T.type_alias do
-            {
-              method: Symbol,
-              url: URI::Generic,
-              headers: T::Hash[String, String],
-              body: T.anything,
-              deadline: Float
-            }
-          end
-
-        # from the golang stdlib
-        # https://github.com/golang/go/blob/c8eced8580028328fde7c03cbfcb720ce15b2358/src/net/http/transport.go#L49
-        KEEP_ALIVE_TIMEOUT = 30
-
-        DEFAULT_MAX_CONNECTIONS = T.let(T.unsafe(nil), Integer)
-
-        class << self
-          # @api private
-          sig do
-            params(cert_store: OpenSSL::X509::Store, url: URI::Generic).returns(
-              Net::HTTP
-            )
-          end
-          def connect(cert_store:, url:)
-          end
-
-          # @api private
-          sig { params(conn: Net::HTTP, deadline: Float).void }
-          def calibrate_socket_timeout(conn, deadline)
-          end
-
-          # @api private
-          sig do
-            params(
-              request: OpenAI::Internal::Transport::PooledNetRequester::Request,
-              blk: T.proc.params(arg0: String).void
-            ).returns([Net::HTTPGenericRequest, T.proc.void])
-          end
-          def build_request(request, &blk)
-          end
-        end
-
-        # @api private
-        sig do
-          params(
-            url: URI::Generic,
-            deadline: Float,
-            blk: T.proc.params(arg0: Net::HTTP).void
-          ).void
-        end
-        private def with_pool(url, deadline:, &blk)
-        end
-
-        # @api private
-        sig do
-          params(
-            request: OpenAI::Internal::Transport::PooledNetRequester::Request
-          ).returns([Integer, Net::HTTPResponse, T::Enumerable[String]])
-        end
-        def execute(request)
-        end
-
-        # @api private
-        sig { params(size: Integer).returns(T.attached_class) }
-        def self.new(
-          size: OpenAI::Internal::Transport::PooledNetRequester::DEFAULT_MAX_CONNECTIONS
-        )
-        end
-      end
-    end
-  end
-end

data/sig/openai/internal/transport/pooled_net_requester.rbs

@@ -1,48 +0,0 @@
-module OpenAI
-  module Internal
-    module Transport
-      class PooledNetRequester
-        extend OpenAI::Internal::Util::SorbetRuntimeSupport
-
-        type request =
-          {
-            method: Symbol,
-            url: URI::Generic,
-            headers: ::Hash[String, String],
-            body: top,
-            deadline: Float
-          }
-
-        KEEP_ALIVE_TIMEOUT: 30
-
-        DEFAULT_MAX_CONNECTIONS: Integer
-
-        def self.connect: (
-          cert_store: OpenSSL::X509::Store,
-          url: URI::Generic
-        ) -> top
-
-        def self.calibrate_socket_timeout: (top conn, Float deadline) -> void
-
-        def self.build_request: (
-          OpenAI::Internal::Transport::PooledNetRequester::request request
-        ) {
-          (String arg0) -> void
-        } -> [top, (^-> void)]
-
-        private def with_pool: (
-          URI::Generic url,
-          deadline: Float
-        ) {
-          (top arg0) -> void
-        } -> void
-
-        def execute: (
-          OpenAI::Internal::Transport::PooledNetRequester::request request
-        ) -> [Integer, top, Enumerable[String]]
-
-        def initialize: (?size: Integer) -> void
-      end
-    end
-  end
-end