openai 0.78.0 → 0.79.0

data/lib/openai/models/responses_model.rb

@@ -28,6 +28,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"
 
         # @!method self.values
         #   @return [Array<Symbol>]

data/lib/openai/models/skill_create_params.rb

@@ -10,6 +10,10 @@ module OpenAI
       # @!attribute files
       #   Skill files to upload (directory upload) or a single zip file.
       #
+      #   `String`, `StringIO`, and pathless `IO` inputs are sent with generic upload
+      #   metadata. Use `OpenAI::FilePart` when you need to override the filename or
+      #   content type.
+      #
       #   @return [Array<Pathname, StringIO, IO, String, OpenAI::FilePart>, Pathname, StringIO, IO, String, OpenAI::FilePart, nil]
       optional :files, union: -> { OpenAI::SkillCreateParams::Files }
 

data/lib/openai/models/skills/version_create_params.rb

@@ -22,6 +22,10 @@ module OpenAI
         # @!attribute files
         #   Skill files to upload (directory upload) or a single zip file.
         #
+        #   `String`, `StringIO`, and pathless `IO` inputs are sent with generic upload
+        #   metadata. Use `OpenAI::FilePart` when you need to override the filename or
+        #   content type.
+        #
         #   @return [Array<Pathname, StringIO, IO, String, OpenAI::FilePart>, Pathname, StringIO, IO, String, OpenAI::FilePart, nil]
         optional :files, union: -> { OpenAI::Skills::VersionCreateParams::Files }
 

data/lib/openai/models/uploads/part_create_params.rb

@@ -16,6 +16,10 @@ module OpenAI
         # @!attribute data
         #   The chunk of bytes for this Part.
         #
+        #   `String`, `StringIO`, and pathless `IO` inputs are sent with generic upload
+        #   metadata. Use `OpenAI::FilePart` when you need to override the filename or
+        #   content type.
+        #
         #   @return [Pathname, StringIO, IO, String, OpenAI::FilePart]
         required :data, OpenAI::Internal::Type::FileInput
 

data/lib/openai/models/vector_store_search_response.rb

@@ -13,7 +13,9 @@ module OpenAI
       #
       #   @return [Hash{Symbol=>String, Float, Boolean}, nil]
       required :attributes,
-               -> { OpenAI::Internal::Type::HashOf[union: OpenAI::Models::VectorStoreSearchResponse::Attribute] },
+               -> {
+                 OpenAI::Internal::Type::HashOf[union: OpenAI::Models::VectorStoreSearchResponse::Attribute]
+               },
                nil?: true
 
       # @!attribute content

data/lib/openai/models/video_create_character_params.rb

@@ -16,6 +16,10 @@ module OpenAI
       # @!attribute video
       #   Video file used to create a character.
       #
+      #   `String`, `StringIO`, and pathless `IO` inputs are sent with generic upload
+      #   metadata. Use `OpenAI::FilePart` when you need to override the filename or
+      #   content type.
+      #
       #   @return [Pathname, StringIO, IO, String, OpenAI::FilePart]
       required :video, OpenAI::Internal::Type::FileInput
 

data/lib/openai/models/video_create_params.rb

@@ -16,6 +16,10 @@ module OpenAI
       # @!attribute input_reference
       #   Optional reference asset upload or reference object that guides generation.
       #
+      #   `String`, `StringIO`, and pathless `IO` inputs are sent with generic upload
+      #   metadata. Use `OpenAI::FilePart` when you need to override the filename or
+      #   content type.
+      #
       #   @return [Pathname, StringIO, IO, String, OpenAI::FilePart, OpenAI::Models::ImageInputReferenceParam, nil]
       optional :input_reference, union: -> { OpenAI::VideoCreateParams::InputReference }
 

data/lib/openai/models/video_edit_params.rb

@@ -16,6 +16,10 @@ module OpenAI
       # @!attribute video
       #   Reference to the completed video to edit.
       #
+      #   `String`, `StringIO`, and pathless `IO` inputs are sent with generic upload
+      #   metadata. Use `OpenAI::FilePart` when you need to override the filename or
+      #   content type.
+      #
       #   @return [Pathname, StringIO, IO, String, OpenAI::FilePart, OpenAI::Models::VideoEditParams::Video::VideoReferenceInputParam]
       required :video, union: -> { OpenAI::VideoEditParams::Video }
 

data/lib/openai/models/video_extend_params.rb

@@ -23,6 +23,10 @@ module OpenAI
       # @!attribute video
       #   Reference to the completed video to extend.
       #
+      #   `String`, `StringIO`, and pathless `IO` inputs are sent with generic upload
+      #   metadata. Use `OpenAI::FilePart` when you need to override the filename or
+      #   content type.
+      #
       #   @return [Pathname, StringIO, IO, String, OpenAI::FilePart, OpenAI::Models::VideoExtendParams::Video::VideoReferenceInputParam]
       required :video, union: -> { OpenAI::VideoExtendParams::Video }
 

data/lib/openai/models.rb

@@ -1,7 +1,15 @@
 # frozen_string_literal: true
 
 module OpenAI
-  [OpenAI::Internal::Type::BaseModel, *OpenAI::Internal::Type::BaseModel.subclasses].each do |cls|
+  # 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
+
+  [base_model, *subclasses].each do |cls|
     cls.define_sorbet_constant!(:OrHash) { T.type_alias { T.any(cls, OpenAI::Internal::AnyHash) } }
   end
 

data/lib/openai/net_http_client.rb

@@ -5,6 +5,10 @@ require_relative "internal/read_io_adapter"
 module OpenAI
   # The SDK's pooled Net::HTTP implementation.
   #
+  # Network operations from a non-blocking fiber cooperate with its active Ruby
+  # Fiber scheduler, allowing concurrent requests and streams without occupying
+  # one thread per request.
+  #
   # Pass a block to configure each SDK-created connection before it is pooled
   # and started.
   class NetHTTPClient < HTTPClient
@@ -66,15 +70,15 @@ module OpenAI
     # @api private
     #
     # @param conn [Net::HTTP]
-    # @param deadline [Float]
+    # @param deadline [Float, nil]
     private def calibrate_socket_timeout(conn, deadline)
-      timeout = remaining_timeout(deadline)
+      timeout = deadline&.then { remaining_timeout(_1) }
       conn.open_timeout = conn.read_timeout = conn.write_timeout = conn.continue_timeout = timeout
     end
 
     # @api private
     #
-    # @param deadline [Float]
+    # @param deadline [Float, nil]
     # @return [Float]
     # @raise [Timeout::Error]
     private def remaining_timeout(deadline)
@@ -130,7 +134,6 @@ module OpenAI
     # @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
@@ -138,7 +141,18 @@ module OpenAI
           end
         end
 
-      pool.with(timeout: timeout, &blk)
+      return pool.with(timeout: remaining_timeout(deadline), &blk) if deadline
+
+      checked_out = false
+      begin
+        pool.with do |connection|
+          checked_out = true
+          blk.call(connection)
+        end
+      rescue ConnectionPool::TimeoutError
+        retry unless checked_out
+        raise
+      end
     end
 
     # @api private
@@ -200,7 +214,7 @@ module OpenAI
     # @return [OpenAI::HTTPClient::Response]
     def execute(request)
       url = request.url
-      deadline = OpenAI::Internal::Util.monotonic_secs + request.timeout
+      deadline = request.timeout&.then { OpenAI::Internal::Util.monotonic_secs + _1 }
 
       req = nil
       finished = false

data/lib/openai/providers/azure.rb

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+
+module OpenAI
+  module Providers
+    # @api private
+    module Azure
+      API_KEY_AUTH_MARKER = :openai_azure_api_key
+      BEARER_AUTH_MARKER = :openai_azure_bearer
+      AUTH_HEADERS = %w[api-key authorization].freeze
+      MISSING_ENDPOINT_MESSAGE =
+        "Azure OpenAI requires an endpoint. Pass `endpoint` to `azure(...)`, or set " \
+        "`AZURE_OPENAI_ENDPOINT`."
+      MISSING_CREDENTIALS_MESSAGE =
+        "Could not find credentials for Azure OpenAI. Pass `api_key` or `token_provider` " \
+        "to `azure(...)`, or set `AZURE_OPENAI_API_KEY`."
+
+      class Definition
+        attr_reader :name
+
+        def initialize(base_url:, credential_provider:, authentication:)
+          @name = "azure"
+          @base_url = base_url.freeze
+          @credential_provider = credential_provider
+          @authentication = authentication
+        end
+
+        def configure
+          auth = Auth.new(
+            base_url: @base_url,
+            credential_provider: @credential_provider,
+            authentication: @authentication
+          )
+          OpenAI::Internal::Provider::Runtime.new(
+            name: name,
+            base_url: @base_url,
+            prepare_request: auth.method(:prepare_request),
+            authentication_headers: AUTH_HEADERS
+          )
+        end
+      end
+
+      class Auth
+        def initialize(base_url:, credential_provider:, authentication:)
+          @base_url = URI(base_url)
+          @credential_provider = credential_provider
+          @authentication = authentication
+        end
+
+        def prepare_request(request)
+          Azure.validate_origin!(request.fetch(:url), @base_url)
+          marker = @authentication == :api_key ? API_KEY_AUTH_MARKER : BEARER_AUTH_MARKER
+          headers = Azure.provider_headers(request, marker: marker)
+          credential = resolve_credential
+          auth_header =
+            if @authentication == :api_key
+              {"api-key" => credential}
+            else
+              {"authorization" => "Bearer #{credential}"}
+            end
+
+          request.merge(headers: headers.merge(auth_header), provider_auth: marker)
+        end
+
+        private def resolve_credential
+          credential = @credential_provider.call
+          unless credential.is_a?(String) && !credential.strip.empty?
+            name = @authentication == :api_key ? "API key" : "token provider"
+            raise OpenAI::Errors::Error,
+                  "The Azure OpenAI #{name} must return a non-empty string."
+          end
+          credential
+        rescue OpenAI::Errors::Error
+          raise
+        rescue StandardError => e
+          message =
+            if @authentication == :api_key
+              "Failed to resolve an API key for Azure OpenAI."
+            else
+              "Failed to resolve a bearer token for Azure OpenAI."
+            end
+          raise OpenAI::Errors::Error.new(message), cause: e
+        end
+      end
+
+      class << self
+        def normalize_endpoint(endpoint)
+          uri = URI(endpoint)
+          unless uri.is_a?(URI::HTTP) && uri.host
+            raise ArgumentError, "The Azure OpenAI `endpoint` must be an absolute HTTP or HTTPS URL."
+          end
+          unless uri.query.nil?
+            raise ArgumentError, "The Azure OpenAI `endpoint` must not include a query string."
+          end
+          unless uri.fragment.nil?
+            raise ArgumentError, "The Azure OpenAI `endpoint` must not include a fragment."
+          end
+          unless uri.userinfo.nil?
+            raise ArgumentError, "The Azure OpenAI `endpoint` must not include user information."
+          end
+
+          path = uri.path.sub(%r{/+\z}, "")
+          uri.path =
+            case path
+            when %r{/openai/v1\z}
+              path
+            when %r{/openai\z}
+              "#{path}/v1"
+            else
+              "#{path}/openai/v1"
+            end
+          uri.to_s
+        rescue URI::InvalidURIError => e
+          message = "The Azure OpenAI `endpoint` must be an absolute HTTP or HTTPS URL."
+          raise ArgumentError.new(message), cause: e
+        end
+
+        def normalize_optional_string(value)
+          return nil unless value.is_a?(String)
+          normalized = value.strip
+          normalized unless normalized.empty?
+        end
+
+        def provider_headers(request, marker:)
+          headers = request.fetch(:headers).dup
+          if request[:provider_auth] == marker
+            AUTH_HEADERS.each { headers.delete(_1) }
+          elsif AUTH_HEADERS.any? { headers.key?(_1) }
+            raise OpenAI::Errors::Error,
+                  "Azure OpenAI provider authentication cannot be combined with a custom " \
+                  "`Authorization` or `api-key` header."
+          end
+          headers
+        end
+
+        def validate_origin!(url, base_url)
+          return if OpenAI::Internal::Util.uri_origin(url) == OpenAI::Internal::Util.uri_origin(base_url)
+          raise OpenAI::Errors::Error,
+                "Refusing to authenticate a request for an origin other than the configured " \
+                "Azure OpenAI endpoint."
+        end
+      end
+    end
+
+    class << self
+      # Configure the standard OpenAI client for the Azure OpenAI v1 API.
+      #
+      # @param endpoint [String, nil] Azure OpenAI resource endpoint. Defaults to
+      #   `AZURE_OPENAI_ENDPOINT`. `/openai/v1` is appended when absent.
+      #
+      # @param api_key [String, nil] Azure OpenAI API key. Defaults to
+      #   `AZURE_OPENAI_API_KEY` when no token provider is configured. Passing
+      #   `nil` explicitly skips the environment fallback.
+      #
+      # @param token_provider [#call, nil] Callable returning a Microsoft Entra
+      #   bearer token before each request attempt.
+      #
+      # @return [OpenAI::Provider]
+      def azure(
+        endpoint: OpenAI::Internal::OMIT,
+        api_key: OpenAI::Internal::OMIT,
+        token_provider: nil
+      )
+        configured_endpoint =
+          if endpoint.equal?(OpenAI::Internal::OMIT)
+            Azure.normalize_optional_string(ENV["AZURE_OPENAI_ENDPOINT"])
+          else
+            normalized = Azure.normalize_optional_string(endpoint)
+            if !endpoint.nil? && normalized.nil?
+              raise ArgumentError, "The Azure OpenAI `endpoint` must not be empty."
+            end
+            normalized
+          end
+        raise ArgumentError, Azure::MISSING_ENDPOINT_MESSAGE if configured_endpoint.nil?
+        base_url = Azure.normalize_endpoint(configured_endpoint)
+
+        explicit_api_key = !api_key.equal?(OpenAI::Internal::OMIT) && !api_key.nil?
+        normalized_api_key = Azure.normalize_optional_string(api_key)
+        if explicit_api_key && normalized_api_key.nil?
+          raise ArgumentError, "The Azure OpenAI API key must not be empty."
+        end
+        unless token_provider.nil? || token_provider.respond_to?(:call)
+          raise ArgumentError, "The Azure OpenAI `token_provider` must respond to `call`."
+        end
+        if explicit_api_key && !token_provider.nil?
+          raise ArgumentError,
+                "The Azure OpenAI `api_key` and `token_provider` options are mutually exclusive."
+        end
+
+        environment_api_key =
+          if api_key.equal?(OpenAI::Internal::OMIT) && token_provider.nil?
+            Azure.normalize_optional_string(ENV["AZURE_OPENAI_API_KEY"])
+          end
+        resolved_api_key = normalized_api_key || environment_api_key
+        if resolved_api_key.nil? && token_provider.nil?
+          raise ArgumentError, Azure::MISSING_CREDENTIALS_MESSAGE
+        end
+
+        if token_provider
+          credential_provider = token_provider
+          authentication = :bearer
+        else
+          resolved_api_key.freeze
+          credential_provider = -> { resolved_api_key }
+          authentication = :api_key
+        end
+
+        definition = Azure::Definition.new(
+          base_url: base_url,
+          credential_provider: credential_provider,
+          authentication: authentication
+        )
+        OpenAI::Internal::Provider.create(definition)
+      end
+    end
+  end
+end

data/lib/openai/providers/bedrock.rb

@@ -6,6 +6,7 @@ module OpenAI
     module Bedrock
       SERVICE = "bedrock-mantle"
       CANONICAL_HOST = /\Abedrock-mantle\.([a-z0-9-]+)\.api\.aws\z/i
+      AUTH_HEADERS = %w[authorization].freeze
       SIGNING_HEADERS = %w[authorization x-amz-content-sha256 x-amz-date x-amz-security-token].freeze
       BEARER_AUTH_MARKER = :openai_bedrock_bearer
       SIGV4_AUTH_MARKER = :openai_bedrock_sigv4
@@ -91,7 +92,8 @@ module OpenAI
           OpenAI::Internal::Provider::Runtime.new(
             name: name,
             base_url: base_url,
-            prepare_request: auth.method(:prepare_request)
+            prepare_request: auth.method(:prepare_request),
+            authentication_headers: AUTH_HEADERS
           )
         end
       end

data/lib/openai/resources/admin/organization/projects/groups/roles.rb

@@ -97,11 +97,11 @@ module OpenAI
               # @see OpenAI::Models::Admin::Organization::Projects::Groups::RoleListParams
               def list(group_id, params)
                 parsed, options = OpenAI::Admin::Organization::Projects::Groups::RoleListParams.dump_request(params)
-                query = OpenAI::Internal::Util.encode_query_params(parsed)
                 project_id =
                   parsed.delete(:project_id) do
                     raise ArgumentError.new("missing required path argument #{_1}")
                   end
+                query = OpenAI::Internal::Util.encode_query_params(parsed)
                 @client.request(
                   method: :get,
                   path: ["projects/%1$s/groups/%2$s/roles", project_id, group_id],

data/lib/openai/resources/admin/organization/projects/groups.rb

@@ -53,11 +53,11 @@ module OpenAI
             # @see OpenAI::Models::Admin::Organization::Projects::GroupRetrieveParams
             def retrieve(group_id, params)
               parsed, options = OpenAI::Admin::Organization::Projects::GroupRetrieveParams.dump_request(params)
-              query = OpenAI::Internal::Util.encode_query_params(parsed)
               project_id =
                 parsed.delete(:project_id) do
                   raise ArgumentError.new("missing required path argument #{_1}")
                 end
+              query = OpenAI::Internal::Util.encode_query_params(parsed)
               @client.request(
                 method: :get,
                 path: ["organization/projects/%1$s/groups/%2$s", project_id, group_id],

data/lib/openai/resources/admin/organization/projects/users/roles.rb

@@ -97,11 +97,11 @@ module OpenAI
               # @see OpenAI::Models::Admin::Organization::Projects::Users::RoleListParams
               def list(user_id, params)
                 parsed, options = OpenAI::Admin::Organization::Projects::Users::RoleListParams.dump_request(params)
-                query = OpenAI::Internal::Util.encode_query_params(parsed)
                 project_id =
                   parsed.delete(:project_id) do
                     raise ArgumentError.new("missing required path argument #{_1}")
                   end
+                query = OpenAI::Internal::Util.encode_query_params(parsed)
                 @client.request(
                   method: :get,
                   path: ["projects/%1$s/users/%2$s/roles", project_id, user_id],

data/lib/openai/resources/admin/organization/projects.rb

@@ -182,7 +182,8 @@ module OpenAI
           def initialize(client:)
             @client = client
             @users = OpenAI::Resources::Admin::Organization::Projects::Users.new(client: client)
-            @service_accounts = OpenAI::Resources::Admin::Organization::Projects::ServiceAccounts.new(client: client)
+            @service_accounts =
+              OpenAI::Resources::Admin::Organization::Projects::ServiceAccounts.new(client: client)
             @api_keys = OpenAI::Resources::Admin::Organization::Projects::APIKeys.new(client: client)
             @rate_limits = OpenAI::Resources::Admin::Organization::Projects::RateLimits.new(client: client)
             @model_permissions =
@@ -191,7 +192,8 @@ module OpenAI
               OpenAI::Resources::Admin::Organization::Projects::HostedToolPermissions.new(client: client)
             @groups = OpenAI::Resources::Admin::Organization::Projects::Groups.new(client: client)
             @roles = OpenAI::Resources::Admin::Organization::Projects::Roles.new(client: client)
-            @data_retention = OpenAI::Resources::Admin::Organization::Projects::DataRetention.new(client: client)
+            @data_retention =
+              OpenAI::Resources::Admin::Organization::Projects::DataRetention.new(client: client)
             @spend_limit = OpenAI::Resources::Admin::Organization::Projects::SpendLimit.new(client: client)
             @spend_alerts = OpenAI::Resources::Admin::Organization::Projects::SpendAlerts.new(client: client)
             @certificates = OpenAI::Resources::Admin::Organization::Projects::Certificates.new(client: client)

data/lib/openai/resources/audio/transcriptions.rb

@@ -16,6 +16,10 @@ module OpenAI
         # Returns a transcription object in `json`, `diarized_json`, or `verbose_json`
         # format, or a stream of transcript events.
         #
+        # `String`, `StringIO`, and pathless `IO` inputs are sent with generic upload
+        # metadata. Use `OpenAI::FilePart` when you need to override the filename or
+        # content type.
+        #
         # @overload create(file:, model:, chunking_strategy: nil, include: nil, keywords: nil, known_speaker_names: nil, known_speaker_references: nil, language: nil, languages: nil, prompt: nil, response_format: nil, temperature: nil, timestamp_granularities: nil, request_options: {})
         #
         # @param file [Pathname, StringIO, IO, String, OpenAI::FilePart] The audio file object (not file name) to transcribe, in one of these formats: fl
@@ -77,6 +81,10 @@ module OpenAI
         # Returns a transcription object in `json`, `diarized_json`, or `verbose_json`
         # format, or a stream of transcript events.
         #
+        # `String`, `StringIO`, and pathless `IO` inputs are sent with generic upload
+        # metadata. Use `OpenAI::FilePart` when you need to override the filename or
+        # content type.
+        #
         # @overload create_streaming(file:, model:, chunking_strategy: nil, include: nil, keywords: nil, known_speaker_names: nil, known_speaker_references: nil, language: nil, languages: nil, prompt: nil, response_format: nil, temperature: nil, timestamp_granularities: nil, request_options: {})
         #
         # @param file [Pathname, StringIO, IO, String, OpenAI::FilePart] The audio file object (not file name) to transcribe, in one of these formats: fl

data/lib/openai/resources/audio/translations.rb

@@ -10,6 +10,10 @@ module OpenAI
         #
         # Translates audio into English.
         #
+        # `String`, `StringIO`, and pathless `IO` inputs are sent with generic upload
+        # metadata. Use `OpenAI::FilePart` when you need to override the filename or
+        # content type.
+        #
         # @overload create(file:, model:, prompt: nil, response_format: nil, temperature: nil, request_options: {})
         #
         # @param file [Pathname, StringIO, IO, String, OpenAI::FilePart] The audio file object (not file name) translate, in one of these formats: flac,

data/lib/openai/resources/beta/responses.rb

@@ -301,12 +301,12 @@ module OpenAI
         def retrieve_streaming(response_id, params = {})
           query_params = [:include, :include_obfuscation, :starting_after, :stream]
           parsed, options = OpenAI::Beta::ResponseRetrieveParams.dump_request(params)
-          query = OpenAI::Internal::Util.encode_query_params(parsed.slice(*query_params))
           unless parsed.fetch(:stream, true)
             message = "Please use `#retrieve` for the non-streaming use case."
             raise ArgumentError.new(message)
           end
           parsed.store(:stream, true)
+          query = OpenAI::Internal::Util.encode_query_params(parsed.slice(*query_params))
           @client.request(
             method: :get,
             path: ["responses/%1$s?beta=true", response_id],

data/lib/openai/resources/beta/threads/runs/steps.rb

@@ -33,7 +33,6 @@ module OpenAI
             # @see OpenAI::Models::Beta::Threads::Runs::StepRetrieveParams
             def retrieve(step_id, params)
               parsed, options = OpenAI::Beta::Threads::Runs::StepRetrieveParams.dump_request(params)
-              query = OpenAI::Internal::Util.encode_query_params(parsed)
               thread_id =
                 parsed.delete(:thread_id) do
                   raise ArgumentError.new("missing required path argument #{_1}")
@@ -42,6 +41,7 @@ module OpenAI
                 parsed.delete(:run_id) do
                   raise ArgumentError.new("missing required path argument #{_1}")
                 end
+              query = OpenAI::Internal::Util.encode_query_params(parsed)
               @client.request(
                 method: :get,
                 path: ["threads/%1$s/runs/%2$s/steps/%3$s", thread_id, run_id, step_id],
@@ -82,11 +82,11 @@ module OpenAI
             # @see OpenAI::Models::Beta::Threads::Runs::StepListParams
             def list(run_id, params)
               parsed, options = OpenAI::Beta::Threads::Runs::StepListParams.dump_request(params)
-              query = OpenAI::Internal::Util.encode_query_params(parsed)
               thread_id =
                 parsed.delete(:thread_id) do
                   raise ArgumentError.new("missing required path argument #{_1}")
                 end
+              query = OpenAI::Internal::Util.encode_query_params(parsed)
               @client.request(
                 method: :get,
                 path: ["threads/%1$s/runs/%2$s/steps", thread_id, run_id],

data/lib/openai/resources/containers/files.rb

@@ -15,6 +15,10 @@ module OpenAI
         # You can send either a multipart/form-data request with the raw file content, or
         # a JSON request with a file ID.
         #
+        # `String`, `StringIO`, and pathless `IO` inputs are sent with generic upload
+        # metadata. Use `OpenAI::FilePart` when you need to override the filename or
+        # content type.
+        #
         # @overload create(container_id, file: nil, file_id: nil, request_options: {})
         #
         # @param container_id [String]

data/lib/openai/resources/content_provenance_checks.rb

@@ -13,6 +13,10 @@ module OpenAI
       # signals were available. Content could also still be AI-generated by another
       # company's model, which the tool currently does not detect.
       #
+      # `String`, `StringIO`, and pathless `IO` inputs are sent with generic upload
+      # metadata. Use `OpenAI::FilePart` when you need to override the filename or
+      # content type.
+      #
       # @overload create(file:, request_options: {})
       #
       # @param file [Pathname, StringIO, IO, String, OpenAI::FilePart] The image or audio file to check for supported OpenAI provenance signals.

data/lib/openai/resources/conversations/items.rb

@@ -58,11 +58,11 @@ module OpenAI
         # @see OpenAI::Models::Conversations::ItemRetrieveParams
         def retrieve(item_id, params)
           parsed, options = OpenAI::Conversations::ItemRetrieveParams.dump_request(params)
-          query = OpenAI::Internal::Util.encode_query_params(parsed)
           conversation_id =
             parsed.delete(:conversation_id) do
               raise ArgumentError.new("missing required path argument #{_1}")
             end
+          query = OpenAI::Internal::Util.encode_query_params(parsed)
           @client.request(
             method: :get,
             path: ["conversations/%1$s/items/%2$s", conversation_id, item_id],

data/lib/openai/resources/evals/runs/output_items.rb

@@ -66,11 +66,11 @@ module OpenAI
           # @see OpenAI::Models::Evals::Runs::OutputItemListParams
           def list(run_id, params)
             parsed, options = OpenAI::Evals::Runs::OutputItemListParams.dump_request(params)
-            query = OpenAI::Internal::Util.encode_query_params(parsed)
             eval_id =
               parsed.delete(:eval_id) do
                 raise ArgumentError.new("missing required path argument #{_1}")
               end
+            query = OpenAI::Internal::Util.encode_query_params(parsed)
             @client.request(
               method: :get,
               path: ["evals/%1$s/runs/%2$s/output_items", eval_id, run_id],

data/lib/openai/resources/files.rb

@@ -36,6 +36,10 @@ module OpenAI
       # Please [contact us](https://help.openai.com/) if you need to increase these
       # storage limits.
       #
+      # `String`, `StringIO`, and pathless `IO` inputs are sent with generic upload
+      # metadata. Use `OpenAI::FilePart` when you need to override the filename or
+      # content type.
+      #
       # @overload create(file:, purpose:, expires_after: nil, request_options: {})
       #
       # @param file [Pathname, StringIO, IO, String, OpenAI::FilePart] The File object (not file name) to be uploaded.