openai 0.84.0 → 0.86.0

data/lib/openai/internal/util.rb

@@ -185,7 +185,7 @@ module OpenAI
           in [Hash, Hash, _]
             lhs.merge(rhs) { deep_merge_lr(_2, _3, concat: concat) }
           in [Array, Array, true]
-            lhs.concat(rhs)
+            lhs + rhs
           else
             rhs
           end
@@ -449,6 +449,8 @@ module OpenAI
       JSON_CONTENT = %r{\Aapplication/(?:[a-z0-9.-]+\+)?json[ \t]*(?:;|\z)}i
       # @type [Regexp]
       JSONL_CONTENT = %r{\Aapplication/(?:x-[nl]djson|(?:x-)?jsonl)[ \t]*(?:;|\z)}i
+      # @type [Regexp]
+      MULTIPART_CONTENT = %r{\Amultipart/form-data[ \t]*(?:;|\z)}i
 
       class << self
         # @api private
@@ -555,7 +557,10 @@ module OpenAI
             filename = escape_multipart_header_param(val.filename)
             y << "; filename=\"#{filename}\""
           in Pathname | IO
-            filename = escape_multipart_header_param(::File.basename(val.to_path))
+            # Keep raw multipart IO consistent with FileInput.dump: pathless streams
+            # are still file parts and use the same stable fallback filename.
+            filename = val.to_path.nil? ? "upload" : ::File.basename(val.to_path)
+            filename = escape_multipart_header_param(filename)
             y << "; filename=\"#{filename}\""
           else
           end
@@ -631,14 +636,17 @@ module OpenAI
             [headers, JSON.generate(body)]
           in [OpenAI::Internal::Util::JSONL_CONTENT, Enumerable] unless OpenAI::Internal::Type::FileInput === body
             [headers, body.lazy.map { "#{JSON.generate(_1)}\n" }]
-          in [%r{^multipart/form-data}, Hash | OpenAI::Internal::Type::FileInput]
+          in [OpenAI::Internal::Util::MULTIPART_CONTENT, Hash | OpenAI::Internal::Type::FileInput]
             boundary, strio = encode_multipart_streaming(body)
             headers = {**headers, "content-type" => "#{content_type}; boundary=#{boundary}"}
             [headers, strio]
           in [_, Symbol | Numeric]
             [headers, body.to_s]
           in [_, StringIO]
-            [headers, body.string]
+            [headers, body.string.byteslice(body.pos..) || body.string.byteslice(0, 0)]
+          in [_, OpenAI::FilePart] if body.content.is_a?(StringIO)
+            content = body.content
+            [headers, content.string.byteslice(content.pos..) || content.string.byteslice(0, 0)]
           in [_, OpenAI::FilePart]
             [headers, body.content]
           else
@@ -647,6 +655,94 @@ module OpenAI
           # rubocop:enable Style/CaseEquality
         end
 
+        # @api private
+        #
+        # Split a media type on its `;` delimiters, ignoring any that appear inside a
+        # quoted string so that a parameter value may contain one.
+        #
+        # @param content_type [String]
+        #
+        # @return [Array<String>]
+        private def split_media_type_segments(content_type)
+          segments = [String.new]
+          quoted = escaped = false
+
+          content_type.to_s.each_char do |char|
+            if escaped
+              segments.last << char
+              escaped = false
+            elsif quoted && char == "\\"
+              segments.last << char
+              escaped = true
+            elsif char == "\""
+              segments.last << char
+              quoted = !quoted
+            elsif char == ";" && !quoted
+              segments << String.new
+            else
+              segments.last << char
+            end
+          end
+
+          segments
+        end
+
+        # @api private
+        #
+        # Read a media type parameter value: either a token that ends at the first
+        # whitespace, or a quoted string in which `\` escapes the next character.
+        # A quoted string that is never closed, or has non-whitespace after its
+        # closing quote, has no value.
+        #
+        # @param value [String]
+        #
+        # @return [String, nil]
+        private def read_media_type_value(value)
+          return value[/\A[^;\s]+/] unless value.start_with?("\"")
+
+          unquoted = String.new
+          escaped = false
+
+          value[1..].to_s.each_char.with_index do |char, index|
+            if escaped
+              unquoted << char
+              escaped = false
+            elsif char == "\\"
+              escaped = true
+            elsif char == "\""
+              return unquoted if value[(index + 2)..].to_s.match?(/\A\s*\z/)
+
+              return nil
+            else
+              unquoted << char
+            end
+          end
+
+          nil
+        end
+
+        # @api private
+        #
+        # Find the value of the `charset` media type parameter. Parameter names are
+        # case-insensitive, so `Charset` and `CHARSET` name the same parameter, but the
+        # name has to match in full: a `charset` suffix of another parameter's name, or
+        # a `charset=` inside a quoted value, belongs to a different parameter.
+        #
+        # @param content_type [String]
+        #
+        # @return [String, nil]
+        private def media_type_charset(content_type)
+          split_media_type_segments(content_type).each do |segment|
+            name, separator, value = segment.partition("=")
+            next if separator.empty?
+            next unless name.strip.casecmp?("charset")
+
+            return read_media_type_value(value.lstrip)
+          end
+
+          nil
+        end
+
         # @api private
         #
         # https://www.iana.org/assignments/character-sets/character-sets.xhtml
@@ -654,9 +750,9 @@ module OpenAI
         # @param content_type [String]
         # @param text [String]
         def force_charset!(content_type, text:)
-          charset = /charset=([^;\s]+)/.match(content_type)&.captures&.first
+          charset = media_type_charset(content_type)
 
-          return unless charset
+          return if charset.nil? || charset.empty?
 
           begin
             encoding = Encoding.find(charset)
@@ -777,32 +873,37 @@ module OpenAI
       class << self
         # @api private
         #
-        # Assumes Strings have been forced into having `Encoding::BINARY`.
-        #
-        # This decoder is responsible for reassembling lines split across multiple
-        # fragments.
+        # This decoder is responsible for reassembling bytes split across multiple
+        # String fragments without depending on each fragment's encoding label
+        # while preserving the String encoding callers supplied.
         #
         # @param enum [Enumerable<String>]
         #
         # @return [Enumerable<String>]
         def decode_lines(enum)
           re = /(\r\n|\r|\n)/
-          buffer = String.new
+          buffer = String.new(encoding: Encoding::BINARY)
+          encoding = nil
           cr_seen = nil
 
           chain_fused(enum) do |y|
             enum.each do |row|
+              encoding = row.encoding if !row.empty? && (encoding.nil? || encoding == Encoding::US_ASCII)
               offset = buffer.bytesize
-              buffer << row
+              buffer << (row.encoding == Encoding::BINARY ? row : row.b)
               while (match = re.match(buffer, cr_seen&.to_i || offset))
                 case [match.captures.first, cr_seen]
                 in ["\r", nil]
                   cr_seen = match.end(1)
                   next
-                in ["\r" | "\r\n", Integer]
-                  y << buffer.slice!(..(cr_seen.pred))
+                in [terminator, Integer] if terminator != "\n" || match.begin(1) != cr_seen
+                  line = buffer.slice!(..(cr_seen.pred))
+                  line.force_encoding(encoding) unless encoding.nil?
+                  y << line
                 else
-                  y << buffer.slice!(..(match.end(1).pred))
+                  line = buffer.slice!(..(match.end(1).pred))
+                  line.force_encoding(encoding) unless encoding.nil?
+                  y << line
                 end
 
                 offset = 0
@@ -810,8 +911,16 @@ module OpenAI
               end
             end
 
-            y << buffer.slice!(..(cr_seen.pred)) unless cr_seen.nil?
-            y << buffer unless buffer.empty?
+            unless cr_seen.nil?
+              line = buffer.slice!(..(cr_seen.pred))
+              line.force_encoding(encoding) unless encoding.nil?
+              y << line
+            end
+
+            unless buffer.empty?
+              buffer.force_encoding(encoding) unless encoding.nil?
+              y << buffer
+            end
           end
         end
 
@@ -829,8 +938,14 @@ module OpenAI
           chain_fused(lines) do |y|
             blank = {event: nil, data: nil, id: nil, retry: nil}
             current = {}
+            first_line = true
 
             lines.each do |line|
+              if first_line
+                line = line.byteslice(3..) || "" if line.byteslice(0, 3)&.bytes == [0xEF, 0xBB, 0xBF]
+                first_line = false
+              end
+
               case line.sub(/\R$/, "")
               in ""
                 next if current.empty?
@@ -838,17 +953,21 @@ module OpenAI
                 current = {}
               in /^:/
                 next
-              in /^([^:]+):\s?(.*)$/
+              in /^([^:]+)(?::\s?(.*))?$/
                 field, value = Regexp.last_match.captures
+                # A line with no colon names a field whose value is the empty
+                # string, so a bare `data` line still contributes a blank line to
+                # the data buffer.
+                value = value.to_s
                 case field
                 in "event"
                   current.merge!(event: value)
                 in "data"
-                  (current[:data] ||= String.new) << (value << "\n")
+                  (current[:data] ||= String.new) << value << "\n"
                 in "id" unless value.include?("\0")
                   current.merge!(id: value)
                 in "retry" if /^\d+$/ =~ value
-                  current.merge!(retry: Integer(value))
+                  current.merge!(retry: Integer(value, 10))
                 else
                 end
               else

data/lib/openai/internal/vector_store_file_uploader.rb

@@ -132,7 +132,7 @@ module OpenAI
         complete = false
         case content
         in StringIO
-          temporary_file.write(content.string)
+          temporary_file.write(content.string.byteslice(content.pos..) || "")
         in String
           temporary_file.write(content)
         in IO

data/lib/openai/models/admin/organization/projects/service_accounts/api_key_create_params.rb

@@ -23,6 +23,12 @@ module OpenAI
               #   @return [String]
               required :service_account_id, String
 
+              # @!attribute expires_in_seconds
+              #   Number of seconds until the API key expires.
+              #
+              #   @return [Integer, nil]
+              optional :expires_in_seconds, Integer, nil?: true
+
               # @!attribute name
               #   API key name.
               #
@@ -35,11 +41,13 @@ module OpenAI
               #   @return [Array<String>, nil]
               optional :scopes, OpenAI::Internal::Type::ArrayOf[String]
 
-              # @!method initialize(project_id:, service_account_id:, name: nil, scopes: nil, request_options: {})
+              # @!method initialize(project_id:, service_account_id:, expires_in_seconds: nil, name: nil, scopes: nil, request_options: {})
               #   @param project_id [String] The ID of the project.
               #
               #   @param service_account_id [String] The ID of the service account.
               #
+              #   @param expires_in_seconds [Integer, nil] Number of seconds until the API key expires.
+              #
               #   @param name [String] API key name.
               #
               #   @param scopes [Array<String>] API key scopes.

data/lib/openai/models/admin/organization/projects/service_accounts/api_key_create_response.rb

@@ -38,7 +38,18 @@ module OpenAI
               #   @return [String]
               required :value, String
 
-              # @!method initialize(id:, created_at:, name:, value:, object: :"organization.project.service_account.api_key")
+              # @!attribute expires_at
+              #   The Unix timestamp (in seconds) when the API key expires, or null if it does not
+              #   expire.
+              #
+              #   @return [Integer, nil]
+              optional :expires_at, Integer, nil?: true
+
+              # @!method initialize(id:, created_at:, name:, value:, expires_at: nil, object: :"organization.project.service_account.api_key")
+              #   Some parameter documentations has been truncated, see
+              #   {OpenAI::Models::Admin::Organization::Projects::ServiceAccounts::APIKeyCreateResponse}
+              #   for more details.
+              #
               #   @param id [String] The identifier of the API key.
               #
               #   @param created_at [Integer] The Unix timestamp (in seconds) when the API key was created.
@@ -47,6 +58,8 @@ module OpenAI
               #
               #   @param value [String] The unredacted API key value.
               #
+              #   @param expires_at [Integer, nil] The Unix timestamp (in seconds) when the API key expires, or null if it does not
+              #
               #   @param object [Symbol, :"organization.project.service_account.api_key"] The object type, which is always `organization.project.service_account.api_key`
             end
           end

data/lib/openai/models/admin/organization/usage_costs_params.rb

@@ -53,7 +53,7 @@ module OpenAI
 
           # @!attribute line_items
           #   Return only costs for these exact line item names. Each value must match the
-          #   complete `line_item` value, for example `gpt-5.6-sol, input_tokens`.
+          #   complete `line_item` value, for example `gpt-6-astra, input_tokens`.
           #
           #   @return [Array<String>, nil]
           optional :line_items, OpenAI::Internal::Type::ArrayOf[String]

data/lib/openai/models/audio/transcription_create_response.rb

@@ -12,17 +12,17 @@ module OpenAI
       module TranscriptionCreateResponse
         extend OpenAI::Internal::Type::Union
 
-        # Represents a transcription response returned by model, based on the provided input.
-        variant -> { OpenAI::Audio::Transcription }
+        # Represents a verbose json transcription response returned by model, based on the provided input.
+        variant -> { OpenAI::Audio::TranscriptionVerbose }
 
         # Represents a diarized transcription response returned by the model, including the combined transcript and speaker-segment annotations.
         variant -> { OpenAI::Audio::TranscriptionDiarized }
 
-        # Represents a verbose json transcription response returned by model, based on the provided input.
-        variant -> { OpenAI::Audio::TranscriptionVerbose }
+        # Represents a transcription response returned by model, based on the provided input.
+        variant -> { OpenAI::Audio::Transcription }
 
         # @!method self.variants
-        #   @return [Array(OpenAI::Models::Audio::Transcription, OpenAI::Models::Audio::TranscriptionDiarized, OpenAI::Models::Audio::TranscriptionVerbose)]
+        #   @return [Array(OpenAI::Models::Audio::TranscriptionVerbose, OpenAI::Models::Audio::TranscriptionDiarized, OpenAI::Models::Audio::Transcription)]
       end
     end
   end

data/lib/openai/models/batch.rb

@@ -116,7 +116,7 @@ module OpenAI
       optional :metadata, OpenAI::Internal::Type::HashOf[String], nil?: true
 
       # @!attribute model
-      #   Model ID used to process the batch, like `gpt-5.6-sol`. OpenAI offers a wide
+      #   Model ID used to process the batch, like `gpt-6-astra`. OpenAI offers a wide
       #   range of models with different capabilities, performance characteristics, and
       #   price points. Refer to the
       #   [model guide](https://platform.openai.com/docs/models) to browse and compare
@@ -183,7 +183,7 @@ module OpenAI
       #
       #   @param metadata [Hash{Symbol=>String}, nil] Set of 16 key-value pairs that can be attached to an object. This can be
       #
-      #   @param model [String] Model ID used to process the batch, like `gpt-5.6-sol`. OpenAI
+      #   @param model [String] Model ID used to process the batch, like `gpt-6-astra`. OpenAI
       #
       #   @param output_file_id [String] The ID of the file containing the outputs of successfully executed requests.
       #

data/lib/openai/models/beta/beta_custom_tool.rb

@@ -26,6 +26,13 @@ module OpenAI
           nil?: true
         )
 
+        # @!attribute async
+        #   Whether the tool response can be returned asynchronously versus immediately
+        #   returned on next response creation.
+        #
+        #   @return [Boolean, nil]
+        optional :async, OpenAI::Internal::Type::Boolean
+
         # @!attribute defer_loading
         #   Whether this tool should be deferred and discovered via tool search.
         #
@@ -44,7 +51,10 @@ module OpenAI
         #   @return [OpenAI::Models::Beta::BetaCustomTool::Format::Text, OpenAI::Models::Beta::BetaCustomTool::Format::Grammar, nil]
         optional :format_, union: -> { OpenAI::Beta::BetaCustomTool::Format }, api_name: :format
 
-        # @!method initialize(name:, allowed_callers: nil, defer_loading: nil, description: nil, format_: nil, type: :custom)
+        # @!method initialize(name:, allowed_callers: nil, async: nil, defer_loading: nil, description: nil, format_: nil, type: :custom)
+        #   Some parameter documentations has been truncated, see
+        #   {OpenAI::Models::Beta::BetaCustomTool} for more details.
+        #
         #   A custom tool that processes input using a specified format. Learn more about
         #   [custom tools](https://platform.openai.com/docs/guides/function-calling#custom-tools)
         #
@@ -52,6 +62,8 @@ module OpenAI
         #
         #   @param allowed_callers [Array<Symbol, OpenAI::Models::Beta::BetaCustomTool::AllowedCaller>, nil] The tool invocation context(s).
         #
+        #   @param async [Boolean] Whether the tool response can be returned asynchronously versus immediately retu
+        #
         #   @param defer_loading [Boolean] Whether this tool should be deferred and discovered via tool search.
         #
         #   @param description [String] Optional description of the custom tool, used to provide more context.

data/lib/openai/models/beta/beta_function_tool.rb

@@ -38,6 +38,11 @@ module OpenAI
           nil?: true
         )
 
+        # @!attribute async
+        #
+        #   @return [Boolean, nil]
+        optional :async, OpenAI::Internal::Type::Boolean
+
         # @!attribute defer_loading
         #   Whether this function is deferred and loaded via tool search.
         #
@@ -58,7 +63,7 @@ module OpenAI
         #   @return [Hash{Symbol=>Object}, nil]
         optional :output_schema, OpenAI::Internal::Type::HashOf[OpenAI::Internal::Type::Unknown], nil?: true
 
-        # @!method initialize(name:, parameters:, strict:, allowed_callers: nil, defer_loading: nil, description: nil, output_schema: nil, type: :function)
+        # @!method initialize(name:, parameters:, strict:, allowed_callers: nil, async: nil, defer_loading: nil, description: nil, output_schema: nil, type: :function)
         #   Some parameter documentations has been truncated, see
         #   {OpenAI::Models::Beta::BetaFunctionTool} for more details.
         #
@@ -74,6 +79,8 @@ module OpenAI
         #
         #   @param allowed_callers [Array<Symbol, OpenAI::Models::Beta::BetaFunctionTool::AllowedCaller>, nil] The tool invocation context(s).
         #
+        #   @param async [Boolean]
+        #
         #   @param defer_loading [Boolean] Whether this function is deferred and loaded via tool search.
         #
         #   @param description [String, nil] A description of the function. Used by the model to determine whether or not to

data/lib/openai/models/beta/beta_namespace_tool.rb

@@ -73,6 +73,13 @@ module OpenAI
               nil?: true
             )
 
+            # @!attribute async
+            #   Whether the tool response can be returned asynchronously versus immediately
+            #   returned on next response creation.
+            #
+            #   @return [Boolean, nil]
+            optional :async, OpenAI::Internal::Type::Boolean
+
             # @!attribute defer_loading
             #   Whether this function should be deferred and discovered via tool search.
             #
@@ -108,7 +115,7 @@ module OpenAI
             #   @return [Boolean, nil]
             optional :strict, OpenAI::Internal::Type::Boolean, nil?: true
 
-            # @!method initialize(name:, allowed_callers: nil, defer_loading: nil, description: nil, output_schema: nil, parameters: nil, strict: nil, type: :function)
+            # @!method initialize(name:, allowed_callers: nil, async: nil, defer_loading: nil, description: nil, output_schema: nil, parameters: nil, strict: nil, type: :function)
             #   Some parameter documentations has been truncated, see
             #   {OpenAI::Models::Beta::BetaNamespaceTool::Tool::Function} for more details.
             #
@@ -116,6 +123,8 @@ module OpenAI
             #
             #   @param allowed_callers [Array<Symbol, OpenAI::Models::Beta::BetaNamespaceTool::Tool::Function::AllowedCaller>, nil] The tool invocation context(s).
             #
+            #   @param async [Boolean] Whether the tool response can be returned asynchronously versus immediately retu
+            #
             #   @param defer_loading [Boolean] Whether this function should be deferred and discovered via tool search.
             #
             #   @param description [String, nil]