openai 0.77.1 → 0.79.0

data/sig/openai/models/responses_model.rbs

@@ -23,6 +23,9 @@ module OpenAI
         | :"gpt-5-pro"
         | :"gpt-5-pro-2025-10-06"
         | :"gpt-5.1-codex-max"
+        | :"gpt-daybreak-blue-latest"
+        | :"gpt-daybreak-red-latest"
+        | :"gpt-5.6-cyber"
 
       module ResponsesOnlyModel
         extend OpenAI::Internal::Type::Enum
@@ -41,6 +44,9 @@ module OpenAI
         GPT_5_PRO: :"gpt-5-pro"
         GPT_5_PRO_2025_10_06: :"gpt-5-pro-2025-10-06"
         GPT_5_1_CODEX_MAX: :"gpt-5.1-codex-max"
+        GPT_DAYBREAK_BLUE_LATEST: :"gpt-daybreak-blue-latest"
+        GPT_DAYBREAK_RED_LATEST: :"gpt-daybreak-red-latest"
+        GPT_5_6_CYBER: :"gpt-5.6-cyber"
 
         def self?.values: -> ::Array[OpenAI::Models::ResponsesModel::responses_only_model]
       end

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

data/sig/openai/providers.rbs

@@ -1,5 +1,11 @@
 module OpenAI
   module Providers
+    def self.azure: (
+      ?endpoint: String?,
+      ?api_key: String?,
+      ?token_provider: (^-> String)?
+    ) -> OpenAI::Provider
+
     def self.bedrock: (
       ?region: String?,
       ?base_url: String?,

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: openai
 version: !ruby/object:Gem::Version
-  version: 0.77.1
+  version: 0.79.0
 platform: ruby
 authors:
 - OpenAI
@@ -39,6 +39,20 @@ dependencies:
         version: '0'
 - !ruby/object:Gem::Dependency
   name: connection_pool
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.2.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.2.3
+- !ruby/object:Gem::Dependency
+  name: logger
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -57,12 +71,17 @@ extensions: []
 extra_rdoc_files:
 - README.md
 - VERSIONING.md
+- azure.md
+- bedrock.md
 files:
 - ".ignore"
 - CHANGELOG.md
 - README.md
 - SECURITY.md
 - VERSIONING.md
+- azure.md
+- bedrock.md
+- examples/mtls_custom_http_client.rb
 - lib/openai.rb
 - lib/openai/auth/subject_token_provider.rb
 - lib/openai/auth/subject_token_providers/azure_managed_identity_token_provider.rb
@@ -87,15 +106,17 @@ 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/logging.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,7 +1217,9 @@ 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/azure.rb
 - lib/openai/providers/bedrock.rb
 - lib/openai/request_options.rb
 - lib/openai/resources/admin.rb
@@ -1310,15 +1333,17 @@ 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/logging.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 +2443,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 +2547,17 @@ 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/logging.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 +3657,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