openai 0.80.0 → 0.82.0

data/lib/openai/models/responses/tool.rb

@@ -77,9 +77,11 @@ module OpenAI
           #   The tool invocation context(s).
           #
           #   @return [Array<Symbol, OpenAI::Models::Responses::Tool::Mcp::AllowedCaller>, nil]
-          optional :allowed_callers,
-                   -> { OpenAI::Internal::Type::ArrayOf[enum: OpenAI::Responses::Tool::Mcp::AllowedCaller] },
-                   nil?: true
+          optional(
+            :allowed_callers,
+            -> { OpenAI::Internal::Type::ArrayOf[enum: OpenAI::Responses::Tool::Mcp::AllowedCaller] },
+            nil?: true
+          )
 
           # @!attribute allowed_tools
           #   List of allowed tool names or a filter object.
@@ -413,11 +415,13 @@ module OpenAI
           #   The tool invocation context(s).
           #
           #   @return [Array<Symbol, OpenAI::Models::Responses::Tool::CodeInterpreter::AllowedCaller>, nil]
-          optional :allowed_callers,
-                   -> {
-                     OpenAI::Internal::Type::ArrayOf[enum: OpenAI::Responses::Tool::CodeInterpreter::AllowedCaller]
-                   },
-                   nil?: true
+          optional(
+            :allowed_callers,
+            -> {
+              OpenAI::Internal::Type::ArrayOf[enum: OpenAI::Responses::Tool::CodeInterpreter::AllowedCaller]
+            },
+            nil?: true
+          )
 
           # @!method initialize(container:, allowed_callers: nil, type: :code_interpreter)
           #   Some parameter documentations has been truncated, see
@@ -462,18 +466,24 @@ module OpenAI
               #   The memory limit for the code interpreter container.
               #
               #   @return [Symbol, OpenAI::Models::Responses::Tool::CodeInterpreter::Container::CodeInterpreterToolAuto::MemoryLimit, nil]
-              optional :memory_limit,
-                       enum: -> {
-                         OpenAI::Responses::Tool::CodeInterpreter::Container::CodeInterpreterToolAuto::MemoryLimit
-                       },
-                       nil?: true
+              optional(
+                :memory_limit,
+                enum: -> {
+                  OpenAI::Responses::Tool::CodeInterpreter::Container::CodeInterpreterToolAuto::MemoryLimit
+                },
+                nil?: true
+              )
 
               # @!attribute network_policy
               #   Network access policy for the container.
               #
               #   @return [OpenAI::Models::Responses::ContainerNetworkPolicyDisabled, OpenAI::Models::Responses::ContainerNetworkPolicyAllowlist, nil]
-              optional :network_policy,
-                       union: -> { OpenAI::Responses::Tool::CodeInterpreter::Container::CodeInterpreterToolAuto::NetworkPolicy }
+              optional(
+                :network_policy,
+                union: -> {
+                  OpenAI::Responses::Tool::CodeInterpreter::Container::CodeInterpreterToolAuto::NetworkPolicy
+                }
+              )
 
               # @!method initialize(file_ids: nil, memory_limit: nil, network_policy: nil, type: :auto)
               #   Configuration for a code interpreter container. Optionally specify the IDs of
@@ -559,18 +569,13 @@ module OpenAI
           optional :action, enum: -> { OpenAI::Responses::Tool::ImageGeneration::Action }
 
           # @!attribute background
-          #   Allows to set transparency for the background of the generated image(s). This
-          #   parameter is only supported for GPT image models that support transparent
-          #   backgrounds. Must be one of `transparent`, `opaque`, or `auto` (default value).
-          #   When `auto` is used, the model will automatically determine the best background
-          #   for the image.
+          #   Allows to set transparency for the background of the generated image(s). Must be
+          #   one of `transparent`, `opaque`, or `auto` (default value). When `auto` is used,
+          #   the model will automatically determine the best background for the image.
           #
-          #   `gpt-image-2` and `gpt-image-2-2026-04-21` do not support transparent
-          #   backgrounds. Requests with `background` set to `transparent` will return an
-          #   error for these models; use `opaque` or `auto` instead.
-          #
-          #   If `transparent`, the output format needs to support transparency, so it should
-          #   be set to either `png` (default value) or `webp`.
+          #   Transparent backgrounds are available for supported GPT Image models. For
+          #   `gpt-image-2` and `gpt-image-2-2026-04-21`, this support is in preview. When
+          #   using `transparent`, set the output format to `png` or `webp`.
           #
           #   @return [Symbol, OpenAI::Models::Responses::Tool::ImageGeneration::Background, nil]
           optional :background, enum: -> { OpenAI::Responses::Tool::ImageGeneration::Background }
@@ -582,11 +587,13 @@ module OpenAI
           #   `gpt-image-1-mini`. Supports `high` and `low`. Defaults to `low`.
           #
           #   @return [Symbol, OpenAI::Models::Responses::Tool::ImageGeneration::InputFidelity, nil]
-          optional :input_fidelity,
-                   enum: -> {
-                     OpenAI::Responses::Tool::ImageGeneration::InputFidelity
-                   },
-                   nil?: true
+          optional(
+            :input_fidelity,
+            enum: -> {
+              OpenAI::Responses::Tool::ImageGeneration::InputFidelity
+            },
+            nil?: true
+          )
 
           # @!attribute input_image_mask
           #   Optional mask for inpainting. Contains `image_url` (string, optional) and
@@ -596,7 +603,9 @@ module OpenAI
           optional :input_image_mask, -> { OpenAI::Responses::Tool::ImageGeneration::InputImageMask }
 
           # @!attribute model
-          #   The image generation model to use. Default: `gpt-image-1`.
+          #   The image generation model to use. One of `gpt-image-1`, `gpt-image-1-mini`,
+          #   `gpt-image-1.5`, `gpt-image-2`, `gpt-image-2-2026-04-21`, or
+          #   `chatgpt-image-latest`. Default: `gpt-image-1`.
           #
           #   @return [String, Symbol, OpenAI::Models::Responses::Tool::ImageGeneration::Model, nil]
           optional :model, union: -> { OpenAI::Responses::Tool::ImageGeneration::Model }
@@ -664,7 +673,7 @@ module OpenAI
           #
           #   @param input_image_mask [OpenAI::Models::Responses::Tool::ImageGeneration::InputImageMask] Optional mask for inpainting. Contains `image_url`
           #
-          #   @param model [String, Symbol, OpenAI::Models::Responses::Tool::ImageGeneration::Model] The image generation model to use. Default: `gpt-image-1`.
+          #   @param model [String, Symbol, OpenAI::Models::Responses::Tool::ImageGeneration::Model] The image generation model to use. One of `gpt-image-1`,
           #
           #   @param moderation [Symbol, OpenAI::Models::Responses::Tool::ImageGeneration::Moderation] Moderation level for the generated image. Default: `auto`.
           #
@@ -694,18 +703,13 @@ module OpenAI
             #   @return [Array<Symbol>]
           end
 
-          # Allows to set transparency for the background of the generated image(s). This
-          # parameter is only supported for GPT image models that support transparent
-          # backgrounds. Must be one of `transparent`, `opaque`, or `auto` (default value).
-          # When `auto` is used, the model will automatically determine the best background
-          # for the image.
-          #
-          # `gpt-image-2` and `gpt-image-2-2026-04-21` do not support transparent
-          # backgrounds. Requests with `background` set to `transparent` will return an
-          # error for these models; use `opaque` or `auto` instead.
+          # Allows to set transparency for the background of the generated image(s). Must be
+          # one of `transparent`, `opaque`, or `auto` (default value). When `auto` is used,
+          # the model will automatically determine the best background for the image.
           #
-          # If `transparent`, the output format needs to support transparency, so it should
-          # be set to either `png` (default value) or `webp`.
+          # Transparent backgrounds are available for supported GPT Image models. For
+          # `gpt-image-2` and `gpt-image-2-2026-04-21`, this support is in preview. When
+          # using `transparent`, set the output format to `png` or `webp`.
           #
           # @see OpenAI::Models::Responses::Tool::ImageGeneration#background
           module Background
@@ -762,7 +766,9 @@ module OpenAI
             #   @param image_url [String] Base64-encoded mask image.
           end
 
-          # The image generation model to use. Default: `gpt-image-1`.
+          # The image generation model to use. One of `gpt-image-1`, `gpt-image-1-mini`,
+          # `gpt-image-1.5`, `gpt-image-2`, `gpt-image-2-2026-04-21`, or
+          # `chatgpt-image-latest`. Default: `gpt-image-1`.
           #
           # @see OpenAI::Models::Responses::Tool::ImageGeneration#model
           module Model

data/lib/openai/models/responses/tool_choice_allowed.rb

@@ -29,8 +29,10 @@ module OpenAI
         #   ```
         #
         #   @return [Array<Hash{Symbol=>Object}>]
-        required :tools,
-                 OpenAI::Internal::Type::ArrayOf[OpenAI::Internal::Type::HashOf[OpenAI::Internal::Type::Unknown]]
+        required(
+          :tools,
+          OpenAI::Internal::Type::ArrayOf[OpenAI::Internal::Type::HashOf[OpenAI::Internal::Type::Unknown]]
+        )
 
         # @!attribute type
         #   Allowed tool configuration type. Always `allowed_tools`.

data/lib/openai/models/responses/web_search_preview_tool.rb

@@ -14,8 +14,10 @@ module OpenAI
         # @!attribute search_content_types
         #
         #   @return [Array<Symbol, OpenAI::Models::Responses::WebSearchPreviewTool::SearchContentType>, nil]
-        optional :search_content_types,
-                 -> { OpenAI::Internal::Type::ArrayOf[enum: OpenAI::Responses::WebSearchPreviewTool::SearchContentType] }
+        optional(
+          :search_content_types,
+          -> { OpenAI::Internal::Type::ArrayOf[enum: OpenAI::Responses::WebSearchPreviewTool::SearchContentType] }
+        )
 
         # @!attribute search_context_size
         #   High level guidance for the amount of context window space to use for the

data/lib/openai/models/vector_store_search_response.rb

@@ -12,18 +12,20 @@ module OpenAI
       #   characters, booleans, or numbers.
       #
       #   @return [Hash{Symbol=>String, Float, Boolean}, nil]
-      required :attributes,
-               -> {
-                 OpenAI::Internal::Type::HashOf[union: OpenAI::Models::VectorStoreSearchResponse::Attribute]
-               },
-               nil?: true
+      required(
+        :attributes,
+        -> { OpenAI::Internal::Type::HashOf[union: OpenAI::Models::VectorStoreSearchResponse::Attribute] },
+        nil?: true
+      )
 
       # @!attribute content
       #   Content chunks from the file.
       #
       #   @return [Array<OpenAI::Models::VectorStoreSearchResponse::Content>]
-      required :content,
-               -> { OpenAI::Internal::Type::ArrayOf[OpenAI::Models::VectorStoreSearchResponse::Content] }
+      required(
+        :content,
+        -> { OpenAI::Internal::Type::ArrayOf[OpenAI::Models::VectorStoreSearchResponse::Content] }
+      )
 
       # @!attribute file_id
       #   The ID of the vector store file.

data/lib/openai/models/vector_stores/file_batch_create_params.rb

@@ -21,11 +21,13 @@ module OpenAI
         #   characters, booleans, or numbers.
         #
         #   @return [Hash{Symbol=>String, Float, Boolean}, nil]
-        optional :attributes,
-                 -> {
-                   OpenAI::Internal::Type::HashOf[union: OpenAI::VectorStores::FileBatchCreateParams::Attribute]
-                 },
-                 nil?: true
+        optional(
+          :attributes,
+          -> {
+            OpenAI::Internal::Type::HashOf[union: OpenAI::VectorStores::FileBatchCreateParams::Attribute]
+          },
+          nil?: true
+        )
 
         # @!attribute chunking_strategy
         #   The chunking strategy used to chunk the file(s). If not set, will use the `auto`
@@ -104,11 +106,13 @@ module OpenAI
           #   characters, booleans, or numbers.
           #
           #   @return [Hash{Symbol=>String, Float, Boolean}, nil]
-          optional :attributes,
-                   -> {
-                     OpenAI::Internal::Type::HashOf[union: OpenAI::VectorStores::FileBatchCreateParams::File::Attribute]
-                   },
-                   nil?: true
+          optional(
+            :attributes,
+            -> {
+              OpenAI::Internal::Type::HashOf[union: OpenAI::VectorStores::FileBatchCreateParams::File::Attribute]
+            },
+            nil?: true
+          )
 
           # @!attribute chunking_strategy
           #   The chunking strategy used to chunk the file(s). If not set, will use the `auto`

data/lib/openai/models/vector_stores/file_create_params.rb

@@ -31,11 +31,13 @@ module OpenAI
         #   characters, booleans, or numbers.
         #
         #   @return [Hash{Symbol=>String, Float, Boolean}, nil]
-        optional :attributes,
-                 -> {
-                   OpenAI::Internal::Type::HashOf[union: OpenAI::VectorStores::FileCreateParams::Attribute]
-                 },
-                 nil?: true
+        optional(
+          :attributes,
+          -> {
+            OpenAI::Internal::Type::HashOf[union: OpenAI::VectorStores::FileCreateParams::Attribute]
+          },
+          nil?: true
+        )
 
         # @!attribute chunking_strategy
         #   The chunking strategy used to chunk the file(s). If not set, will use the `auto`

data/lib/openai/models/vector_stores/file_update_params.rb

@@ -26,11 +26,13 @@ module OpenAI
         #   characters, booleans, or numbers.
         #
         #   @return [Hash{Symbol=>String, Float, Boolean}, nil]
-        required :attributes,
-                 -> {
-                   OpenAI::Internal::Type::HashOf[union: OpenAI::VectorStores::FileUpdateParams::Attribute]
-                 },
-                 nil?: true
+        required(
+          :attributes,
+          -> {
+            OpenAI::Internal::Type::HashOf[union: OpenAI::VectorStores::FileUpdateParams::Attribute]
+          },
+          nil?: true
+        )
 
         # @!method initialize(vector_store_id:, file_id:, attributes:, request_options: {})
         #   Some parameter documentations has been truncated, see

data/lib/openai/models/vector_stores/vector_store_file.rb

@@ -62,11 +62,13 @@ module OpenAI
         #   characters, booleans, or numbers.
         #
         #   @return [Hash{Symbol=>String, Float, Boolean}, nil]
-        optional :attributes,
-                 -> {
-                   OpenAI::Internal::Type::HashOf[union: OpenAI::VectorStores::VectorStoreFile::Attribute]
-                 },
-                 nil?: true
+        optional(
+          :attributes,
+          -> {
+            OpenAI::Internal::Type::HashOf[union: OpenAI::VectorStores::VectorStoreFile::Attribute]
+          },
+          nil?: true
+        )
 
         # @!attribute chunking_strategy
         #   The strategy used to chunk the file.

data/lib/openai/models/webhooks/live_call_incoming_webhook_event.rb

@@ -65,8 +65,10 @@ module OpenAI
           #   Headers from the SIP Invite.
           #
           #   @return [Array<OpenAI::Models::Webhooks::LiveCallIncomingWebhookEvent::Data::SipHeader>]
-          required :sip_headers,
-                   -> { OpenAI::Internal::Type::ArrayOf[OpenAI::Webhooks::LiveCallIncomingWebhookEvent::Data::SipHeader] }
+          required(
+            :sip_headers,
+            -> { OpenAI::Internal::Type::ArrayOf[OpenAI::Webhooks::LiveCallIncomingWebhookEvent::Data::SipHeader] }
+          )
 
           # @!method initialize(session_id:, sip_headers:)
           #   Some parameter documentations has been truncated, see

data/lib/openai/models/webhooks/realtime_call_incoming_webhook_event.rb

@@ -65,8 +65,10 @@ module OpenAI
           #   Headers from the SIP Invite.
           #
           #   @return [Array<OpenAI::Models::Webhooks::RealtimeCallIncomingWebhookEvent::Data::SipHeader>]
-          required :sip_headers,
-                   -> { OpenAI::Internal::Type::ArrayOf[OpenAI::Webhooks::RealtimeCallIncomingWebhookEvent::Data::SipHeader] }
+          required(
+            :sip_headers,
+            -> { OpenAI::Internal::Type::ArrayOf[OpenAI::Webhooks::RealtimeCallIncomingWebhookEvent::Data::SipHeader] }
+          )
 
           # @!method initialize(call_id:, sip_headers:)
           #   Some parameter documentations has been truncated, see

data/lib/openai/models.rb

@@ -4,10 +4,9 @@ module OpenAI
   # ActiveSupport 6 implements Class#subclasses using ==, which invokes BaseModel's
   # structural equality before all model aliases are loaded.
   base_model = OpenAI::Internal::Type::BaseModel
-  subclasses =
-    ObjectSpace.each_object(base_model.singleton_class).select do |candidate|
-      !candidate.singleton_class? && candidate.superclass.equal?(base_model)
-    end
+  subclasses = ObjectSpace.each_object(base_model.singleton_class).select do |candidate|
+    !candidate.singleton_class? && candidate.superclass.equal?(base_model)
+  end
 
   [base_model, *subclasses].each do |cls|
     cls.define_sorbet_constant!(:OrHash) { T.type_alias { T.any(cls, OpenAI::Internal::AnyHash) } }
@@ -37,15 +36,16 @@ module OpenAI
     end
   end
 
-  OpenAI::Internal::Util.walk_namespaces(OpenAI::Models)
-                        .lazy
-                        .grep(OpenAI::Internal::Type::Union)
-                        .each do |mod|
-    const = :Variants
-    next if mod.sorbet_constant_defined?(const)
+  OpenAI::Internal::Util
+    .walk_namespaces(OpenAI::Models)
+    .lazy
+    .grep(OpenAI::Internal::Type::Union)
+    .each do |mod|
+      const = :Variants
+      next if mod.sorbet_constant_defined?(const)
 
-    mod.define_sorbet_constant!(const) { T.type_alias { mod.to_sorbet_type } }
-  end
+      mod.define_sorbet_constant!(const) { T.type_alias { mod.to_sorbet_type } }
+    end
 
   Admin = OpenAI::Models::Admin
 

data/lib/openai/net_http_client.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "internal/read_io_adapter"
+require "timeout"
 
 module OpenAI
   # The SDK's pooled Net::HTTP implementation.
@@ -40,23 +41,26 @@ module OpenAI
         super()
       end
     end
+
     private_constant :ConnectionConfigurationError
 
+    PooledConnection = Struct.new(:connection)
+    private_constant :PooledConnection
+
     # @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
+      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)
@@ -127,28 +131,47 @@ module OpenAI
     # @api private
     #
     # @param url [URI::Generic]
-    # @param deadline [Float]
+    # @param deadline [Float, nil]
     # @param blk [Proc]
     #
     # @raise [Timeout::Error]
     # @yieldparam [Net::HTTP]
     private def with_pool(url, deadline:, &blk)
       origin = OpenAI::Internal::Util.uri_origin(url)
-      pool =
-        @mutex.synchronize do
-          @pools[origin] ||= ConnectionPool.new(size: @size) do
-            configured_connection(url)
+      pool = @mutex.synchronize do
+        @pools[origin] ||= ConnectionPool.new(size: @size) do
+          PooledConnection.new
+        end
+      end
+
+      checkout = lambda do |pooled_connection|
+        if pooled_connection.connection.nil?
+          connection = nil
+          begin
+            connection = connect(url: url)
+            configure_connection(connection, url, deadline: deadline)
+            pooled_connection.connection = connection
+          ensure
+            if pooled_connection.connection.nil?
+              close_connection(connection) unless connection.nil?
+              # Return the empty slot to the pool so a later checkout retries setup.
+              # This also keeps compatibility with connection_pool 2.x.
+            end
           end
         end
 
-      return pool.with(timeout: remaining_timeout(deadline), &blk) if deadline
+        blk.call(pooled_connection.connection, pooled_connection)
+      end
+
+      return pool.with(timeout: remaining_timeout(deadline), &checkout) if deadline
 
       checked_out = false
       begin
-        pool.with do |connection|
+        pool.with do |pooled_connection|
           checked_out = true
-          blk.call(connection)
+          checkout.call(pooled_connection)
         end
+
       rescue ConnectionPool::TimeoutError
         retry unless checked_out
         raise
@@ -157,12 +180,12 @@ module OpenAI
 
     # @api private
     #
+    # @param connection [Net::HTTP]
     # @param url [URI::Generic]
-    #
-    # @return [Net::HTTP]
-    private def configured_connection(url)
-      connection = nil
-      connection = connect(url: url)
+    # @param deadline [Float, nil]
+    # @return [void]
+    private def configure_connection(connection, url, deadline:)
+      remaining_timeout(deadline) unless deadline.nil?
       begin
         @connection_configurator&.call(connection)
       rescue StandardError => e
@@ -179,14 +202,15 @@ module OpenAI
       end
 
       connection.max_retries = 0
-      connection
+      remaining_timeout(deadline) unless deadline.nil?
+      nil
+    end
+
+    # @api private
+    private def close_connection(connection)
+      connection.finish if connection.started?
     rescue StandardError
-      begin
-        connection.finish if connection&.started?
-      rescue StandardError
-        nil
-      end
-      raise
+      nil
     end
 
     # Closes current pooled connections. The client remains reusable and will
@@ -196,23 +220,25 @@ module OpenAI
     #
     # @return [void]
     def close
-      pools =
-        @mutex.synchronize do
-          current_pools = @pools
-          @pools = {}
-          current_pools
-        end
+      pools = @mutex.synchronize do
+        current_pools = @pools
+        @pools = {}
+        current_pools
+      end
+
       pools.each_value do |pool|
-        pool.shutdown { |connection| connection.finish if connection.started? }
+        pool.shutdown { |pooled_connection| close_connection(pooled_connection.connection) }
       end
+
       nil
     end
 
     # Executes a request using a pooled Net::HTTP connection.
     #
     # @param request [OpenAI::HTTPClient::Request]
+    # @yieldparam connection [Net::HTTP] configured connection, before any network I/O
     # @return [OpenAI::HTTPClient::Response]
-    def execute(request)
+    def execute(request, &connection_validator)
       url = request.url
       deadline = request.timeout&.then { OpenAI::Internal::Util.monotonic_secs + _1 }
 
@@ -223,7 +249,29 @@ module OpenAI
       enum = Enumerator.new do |y|
         next if finished
 
-        with_pool(url, deadline: deadline) do |conn|
+        with_pool(url, deadline: deadline) do |conn, pooled_connection|
+          previously_started = conn.started?
+          validation_complete = false
+          begin
+            connection_validator&.call(conn)
+
+            if !previously_started && conn.started?
+              raise ArgumentError, "connection validation must leave the connection unstarted"
+            end
+
+            expected_ssl = %w[https wss].include?(url.scheme)
+            unless conn.use_ssl? == expected_ssl
+              raise ArgumentError, "connection validation must preserve TLS for the requested URL"
+            end
+
+            validation_complete = true
+          ensure
+            unless validation_complete
+              close_connection(conn)
+              pooled_connection.connection = nil
+            end
+          end
+
           eof = false
           closing = nil
           ::Thread.handle_interrupt(Object => :never) do
@@ -247,10 +295,12 @@ module OpenAI
 
                     calibrate_socket_timeout(conn, deadline)
                   end
+
                   eof = true
                 end
               end
             end
+
           ensure
             begin
               conn.finish if !eof && conn&.started?
@@ -259,6 +309,7 @@ module OpenAI
             end
           end
         end
+
       rescue ConnectionConfigurationError => e
         raise e.original, cause: e.original.cause
       rescue Timeout::Error
@@ -273,6 +324,7 @@ module OpenAI
         finished = true
         loop { enum.next }
       end
+
       OpenAI::HTTPClient::Response.new(
         status: Integer(response.code),
         headers: response.each_header.to_h,