openai 0.95.0 → 0.96.0

data/lib/openai/helpers/responses_websocket/transports/async_websocket.rb

@@ -7,6 +7,147 @@ module OpenAI
       #
       # @api private
       class AsyncWebSocket < OpenAI::WebSocket::AsyncWebSocketTransport
+        # HTTP/1's buffered stream can inspect RSV1 without consuming bytes.
+        # Leave every part of frame parsing to the installed native protocol gem.
+        module PeekableFramer
+          # @api private
+          def next_frame_compressed?
+            first_byte = @stream.peek(1)&.getbyte(0) || 0
+            (first_byte & (::Protocol::WebSocket::Frame::RSV1 << 4)) != 0
+          end
+        end
+
+        private_constant :PeekableFramer
+
+        # Native frame parsing bounds each allocation before reading its body. Keep
+        # room for legal control frames, then enforce the exact data-only total.
+        class BoundedFramer
+          def initialize(framer, max_bytes:, max_frames:, max_plain_bytes: nil)
+            @framer = framer
+            @max_bytes = max_bytes
+            @max_frames = max_frames
+            @max_plain_bytes = max_plain_bytes
+            @message_bytes = 0
+            @message_frames = 0
+            @aborted = false
+            @compressed = false
+            @compression_negotiated = false
+          end
+
+          # @api private
+          attr_writer :compression_negotiated
+
+          def read_frame
+            limit = @max_bytes
+            if @max_plain_bytes
+              # Continuations of compressed messages never set RSV1 themselves.
+              # An unsolicited RSV1 cannot enlarge the limit when no compression
+              # was negotiated. The gem still validates reserved bits and opcodes.
+              compressed = @compression_negotiated &&
+                (@message_frames.zero? ? @framer.next_frame_compressed? : @compressed)
+              limit = [limit, @max_plain_bytes].min unless compressed
+            end
+
+            maximum_size = if @max_frames && @message_frames >= @max_frames
+              125
+            elsif limit
+              [limit - @message_bytes, 125].max
+            else
+              ::Protocol::WebSocket::MAXIMUM_ALLOWED_FRAME_SIZE
+            end
+
+            frame = @framer.read_frame(maximum_size)
+            unless frame.control?
+              if @message_frames.zero?
+                @compressed = @compression_negotiated && frame.flag?(::Protocol::WebSocket::Frame::RSV1)
+              end
+
+              @message_bytes += frame.length
+              @message_frames += 1
+              if (@max_bytes && @message_bytes > @max_bytes) ||
+                  (@max_frames && @message_frames > @max_frames) ||
+                  (!@compressed && @max_plain_bytes && @message_bytes > @max_plain_bytes)
+                raise ::Protocol::WebSocket::ProtocolError, "Responses WebSocket message exceeds configured limit."
+              end
+
+              if frame.finished?
+                @message_bytes = 0
+                @message_frames = 0
+              end
+            end
+
+            frame
+          rescue ::Protocol::WebSocket::ProtocolError
+            # Native protocol-error cleanup would flush to the rejected connection.
+            self.abort
+            raise
+          end
+
+          def write_frame(frame) = @framer.write_frame(frame)
+
+          def flush = @framer.flush
+
+          def close
+            @framer.close unless @aborted
+          end
+
+          def abort
+            return if @aborted
+
+            @aborted = true
+            @framer.abort
+          end
+        end
+
+        private_constant :BoundedFramer
+
+        # Keep the negotiated native reader, frame parsing and RSV checks. Bound
+        # inflation before collecting its full output; Zlib yields at most a
+        # native output chunk beyond the configured decoded-message limit.
+        module BoundedInflate
+          # @api private
+          def bound_decoded_messages(max_bytes, framer)
+            @responses_decoded_limit = max_bytes
+            @responses_bounded_framer = framer
+          end
+
+          private def inflate(buffer)
+            inflater = @responses_inflater ||= ::Zlib::Inflate.new(-window_bits)
+            start_out = inflater.total_out
+            decoded = +"".b
+            begin
+              inflater.inflate(buffer + ::Protocol::WebSocket::Extension::Compression::Inflate::TRAILER) do |chunk|
+                if inflater.total_out - start_out > @responses_decoded_limit
+                  raise ::Protocol::WebSocket::ProtocolError, "Responses WebSocket message exceeds configured limit."
+                end
+
+                decoded << chunk
+              end
+              # A PMCE SYNC_FLUSH does not yield the partial final chunk.
+              # Check the produced byte count before extracting that tail.
+              if inflater.total_out - start_out > @responses_decoded_limit
+                raise ::Protocol::WebSocket::ProtocolError, "Responses WebSocket message exceeds configured limit."
+              end
+
+              decoded << inflater.flush_next_out
+            rescue ::Protocol::WebSocket::ProtocolError
+              @responses_bounded_framer.abort
+              inflater.close
+              @responses_inflater = nil
+              raise
+            ensure
+              unless context_takeover || @responses_inflater.nil?
+                inflater.close
+                @responses_inflater = nil
+              end
+            end
+
+            decoded
+          end
+        end
+
+        private_constant :BoundedInflate
+
         def initialize
           error_factory = lambda do |url:, message: nil, http_status: nil, **_options|
             OpenAI::Errors::ResponsesConnectionError.new(
@@ -23,6 +164,48 @@ module OpenAI
             dependency_message: "Responses WebSockets require the async-websocket gem. Add it to your Gemfile."
           )
         end
+
+        private def negotiation_options(endpoint_options)
+          max_bytes = endpoint_options.delete(:max_message_bytes)
+          max_frames = endpoint_options.delete(:max_message_frames)
+          max_wire_bytes = endpoint_options.delete(:max_wire_message_bytes)
+          return {} if max_bytes.nil? && max_frames.nil? && max_wire_bytes.nil?
+
+          {max_message_bytes: max_bytes, max_message_frames: max_frames, max_wire_message_bytes: max_wire_bytes}.each do |
+              name,
+              value
+            |
+            unless value.nil? || (value.is_a?(Integer) && value.positive?)
+              raise ArgumentError, "#{name} must be a positive Integer or nil"
+            end
+          end
+
+          handler = lambda do |framer, protocol, extensions, **options|
+            framer.extend(AbortableFramer, PeekableFramer)
+            bounded = BoundedFramer.new(
+              framer,
+              max_bytes: max_wire_bytes || max_bytes,
+              max_frames: max_frames,
+              max_plain_bytes: max_wire_bytes ? max_bytes : nil
+            )
+            connection = ::Async::WebSocket::Connection.call(bounded, protocol, extensions, **options)
+            if max_wire_bytes &&
+                max_bytes &&
+                connection.reader.is_a?(::Protocol::WebSocket::Extension::Compression::Inflate)
+              connection.reader.extend(BoundedInflate)
+              connection.reader.bound_decoded_messages(max_bytes, bounded)
+              bounded.compression_negotiated = true
+            end
+
+            connection
+          end
+
+          options = {handler: handler}
+          # A decoded-byte limit cannot safely use the gem's whole-message inflate.
+          # No byte limit keeps the gem's default compression negotiation unchanged.
+          options[:extensions] = ::Protocol::WebSocket::Extensions::Client.new([]) if max_bytes && !max_wire_bytes
+          options
+        end
       end
     end
   end

data/lib/openai/helpers/responses_websocket.rb

@@ -11,3 +11,4 @@ require_relative "responses_websocket/transports/async_websocket"
 require_relative "responses_websocket/client_extension"
 require_relative "responses_websocket/resources/responses_extension"
 require_relative "responses_websocket/session"
+require_relative "responses_websocket/incremental"

data/lib/openai/helpers/streaming/response_stream.rb

@@ -207,40 +207,48 @@ module OpenAI
             return nil
           end
 
+          if event.is_a?(OpenAI::Models::Responses::ResponseCompletedEvent)
+            @completed_response = event.response
+          else
+            accumulate_output(event, current_snapshot.output)
+          end
+
+          current_snapshot
+        end
+
+        # @api private
+        def accumulate_output(event, items)
           case event
           when OpenAI::Models::Responses::ResponseOutputItemAddedEvent
-            current_snapshot.output.push(isolated_value(event.item))
+            items.push(isolated_value(event.item))
 
           when OpenAI::Models::Responses::ResponseContentPartAddedEvent
-            output = current_snapshot.output[event.output_index]
+            output = items[event.output_index]
             if output.is_a?(OpenAI::Models::Responses::ResponseOutputMessage)
               output.content.push(isolated_value(event.part))
-              current_snapshot.output[event.output_index] = output
+              items[event.output_index] = output
             end
 
           when OpenAI::Models::Responses::ResponseTextDeltaEvent
-            output = current_snapshot.output[event.output_index]
+            output = items[event.output_index]
             if output.is_a?(OpenAI::Models::Responses::ResponseOutputMessage)
               content = output.content[event.content_index]
               if content.is_a?(OpenAI::Models::Responses::ResponseOutputText)
                 content.text = append_delta(content.text, event.delta)
                 output.content[event.content_index] = content
-                current_snapshot.output[event.output_index] = output
+                items[event.output_index] = output
               end
             end
 
           when OpenAI::Models::Responses::ResponseFunctionCallArgumentsDeltaEvent
-            output = current_snapshot.output[event.output_index]
+            output = items[event.output_index]
             if output.is_a?(OpenAI::Models::Responses::ResponseFunctionToolCall)
               output.arguments = append_delta(output.arguments || "", event.delta)
-              current_snapshot.output[event.output_index] = output
+              items[event.output_index] = output
             end
-
-          when OpenAI::Models::Responses::ResponseCompletedEvent
-            @completed_response = event.response
           end
 
-          current_snapshot
+          nil
         end
 
         private

data/lib/openai/helpers/structured_output/chat_completion_parser.rb

@@ -9,7 +9,6 @@ module OpenAI
       module ChatCompletionParser
         # @api private
         def self.build_unwrap(model, tool_models)
-          # rubocop:disable Metrics/BlockLength
           -> (raw) do
             if model.is_a?(OpenAI::StructuredOutput::JsonSchemaConverter)
               raw[:choices]&.each do |choice|
@@ -47,7 +46,6 @@ module OpenAI
 
             raw
           end
-          # rubocop:enable Metrics/BlockLength
         end
 
         # @api private

data/lib/openai/helpers/structured_output/response_parser.rb

@@ -96,7 +96,6 @@ module OpenAI
 
           case parsed
           in {tools: Array => tools}
-            # rubocop:disable Metrics/BlockLength
             mapped = tools.map do |tool|
               case tool
               in OpenAI::StructuredOutput::JsonSchemaConverter
@@ -132,7 +131,7 @@ module OpenAI
                 tool
               end
             end
-            # rubocop:enable Metrics/BlockLength
+
             tools.replace(mapped)
           else
           end

data/lib/openai/helpers/structured_output/union_of.rb

@@ -21,7 +21,6 @@ module OpenAI
         #
         # @return [Hash{Symbol=>Object}]
         def to_json_schema_inner(state:)
-          # rubocop:disable Metrics/BlockLength
           OpenAI::Helpers::StructuredOutput::JsonSchemaConverter.cache_def!(state, type: self) do
             path = state.fetch(:path)
             mergeable_keys = {[:anyOf] => 0, [:type] => 0}
@@ -52,7 +51,6 @@ module OpenAI
               }
             end
           end
-          # rubocop:enable Metrics/BlockLength
         end
 
         private_class_method :new

data/lib/openai/helpers/websocket/async_websocket_transport.rb

@@ -192,7 +192,7 @@ module OpenAI
         # @api private
         def abort
           framer = @connection.framer
-          framer.extend(AbortableFramer)
+          framer.extend(AbortableFramer) unless framer.respond_to?(:abort)
           framer.abort
           @aborted = true
         rescue StandardError => e
@@ -208,6 +208,7 @@ module OpenAI
 
       def open(url:, headers:, timeout:, **endpoint_options)
         load_dependencies(url)
+        connect_options = negotiation_options(endpoint_options)
 
         # Proxy credentials belong only on the CONNECT request assembled from
         # proxy configuration. Never forward a caller-supplied value to the
@@ -274,7 +275,8 @@ module OpenAI
               endpoint,
               request_target: request_target,
               headers: headers,
-              timeout: timeout
+              timeout: timeout,
+              connect_options: connect_options
             )
             socket = build_socket(connection, url: url)
             begin
@@ -303,10 +305,12 @@ module OpenAI
         raise error, cause: error.cause
       end
 
-      private def negotiate(client, endpoint, request_target:, headers:, timeout:)
+      private def negotiation_options(_endpoint_options) = {}
+
+      private def negotiate(client, endpoint, request_target:, headers:, timeout:, connect_options:)
         safe_headers = trace_safe_headers(headers)
         operation = lambda do
-          client.connect(authority(endpoint.url), request_target, headers: safe_headers)
+          client.connect(authority(endpoint.url), request_target, headers: safe_headers, **connect_options)
         end
 
         return operation.call if timeout.nil?
@@ -376,9 +380,10 @@ module OpenAI
         host = url.hostname
         host = "[#{host}]" if host.include?(":")
         default_port = %w[https wss].include?(url.scheme) ? 443 : 80
-        return host if !include_default_port && url.port == default_port
+        port = url.port || default_port
+        return host if !include_default_port && port == default_port
 
-        "#{host}:#{url.port}"
+        "#{host}:#{port}"
       end
 
       private def proxy_uri(url)

data/lib/openai/helpers/websocket/connection_manager.rb

@@ -27,6 +27,7 @@ module OpenAI
         request:,
         block_error_message:,
         abort_after_block:,
+        transport_error_factory: nil,
         transport_error_message: "transport must respond to open",
         reserved_options_error_message: nil
       )
@@ -36,6 +37,7 @@ module OpenAI
         @request = request
         @block_error_message = block_error_message
         @abort_after_block = abort_after_block
+        @transport_error_factory = transport_error_factory
         @transport_error_message = transport_error_message
         @reserved_options_error_message = reserved_options_error_message
         @transport_options = validated_transport_options(transport_options)
@@ -49,6 +51,7 @@ module OpenAI
         raise ArgumentError, @transport_error_message unless transport.respond_to?(:open)
 
         @request.call do |request, mark_handshake_completed|
+          block_error = nil
           transport
             .open(
               url: request.fetch(:url),
@@ -61,9 +64,15 @@ module OpenAI
               begin
                 yield(connection)
               ensure
+                block_error = $ERROR_INFO
                 cleanup(connection)
               end
             end
+
+        rescue StandardError => error
+          raise if @transport_error_factory.nil?
+          raise block_error, cause: block_error.cause if block_error
+          raise @transport_error_factory.call(url: request.fetch(:url), error: error), cause: nil
         end
       end
 

data/lib/openai/internal/read_io_adapter.rb

@@ -78,9 +78,7 @@ module OpenAI
           case max_len
           in nil
             # `loop` rescues StopIteration, but this method handles it below.
-            # rubocop:disable Style/InfiniteLoop
             @buf << @stream.next.b while true
-            # rubocop:enable Style/InfiniteLoop
           in Integer
             @buf << @stream.next.b while @buf.bytesize < max_len
             read_buffer(max_len)

data/lib/openai/internal/stream.rb

@@ -17,7 +17,6 @@ module OpenAI
       #
       # @return [Enumerable<generic<Elem>>]
       private def iterator
-        # rubocop:disable Metrics/BlockLength
         @iterator ||= OpenAI::Internal::Util.chain_fused(@stream) do |y|
           consume = false
           decoder = OpenAI::Helpers::Streaming::ResponseEventDecoder.new(model: @model)
@@ -62,7 +61,6 @@ module OpenAI
             end
           end
         end
-        # rubocop:enable Metrics/BlockLength
       end
     end
   end

data/lib/openai/internal/type/base_model.rb

@@ -97,8 +97,6 @@ module OpenAI
               end
             end
 
-            # rubocop:disable Style/CaseEquality
-            # rubocop:disable Metrics/BlockLength
             define_method(name_sym) do
               target = type_fn.call
 
@@ -142,8 +140,6 @@ module OpenAI
                 end
               end
             end
-            # rubocop:enable Metrics/BlockLength
-            # rubocop:enable Style/CaseEquality
           end
 
           # @api private
@@ -301,11 +297,14 @@ module OpenAI
             data = instance.to_h
             viability = instance.instance_variable_get(:@coerced)
 
-            # rubocop:disable Metrics/BlockLength
             fields.each do |name, field|
               mode, required, target = field.fetch_values(:mode, :required, :type)
               api_name, nilable, const = field.fetch_values(:api_name, :nilable, :const)
               src_name = state.fetch(:translate_names) ? api_name : name
+              if state[:request_only] && mode == :coerce
+                keys.delete(src_name)
+                next
+              end
 
               unless val.key?(src_name)
                 if required && mode != :dump && const == OpenAI::Internal::OMIT
@@ -337,7 +336,6 @@ module OpenAI
               viability.store(name, state.fetch(:error) || true)
               data.store(name, converted)
             end
-            # rubocop:enable Metrics/BlockLength
 
             keys.each { data.store(_1, val.fetch(_1)) }
             instance

data/lib/openai/internal/type/converter.rb

@@ -132,10 +132,13 @@ module OpenAI
           #
           # @param translate_names [Boolean]
           #
+          # @param request_only [Boolean] Exclude fields omitted by the request serializer.
+          #
           # @return [Hash{Symbol=>Object}]
-          def new_coerce_state(translate_names: true)
+          def new_coerce_state(translate_names: true, request_only: false)
             {
               translate_names: translate_names,
+              request_only: request_only,
               strictness: true,
               exactness: {yes: 0, no: 0, maybe: 0},
               error: nil,
@@ -188,7 +191,6 @@ module OpenAI
           #
           # @return [Object]
           def coerce(target, value, state: OpenAI::Internal::Type::Converter.new_coerce_state)
-            # rubocop:disable Metrics/BlockNesting
             exactness = state.fetch(:exactness)
 
             case target
@@ -278,7 +280,6 @@ module OpenAI
 
             exactness[:no] += 1
             value
-            # rubocop:enable Metrics/BlockNesting
           end
 
           # @api private
@@ -345,6 +346,7 @@ module OpenAI
           T.type_alias do
             {
               translate_names: T::Boolean,
+              request_only: T::Boolean,
               strictness: T::Boolean,
               exactness: {yes: Integer, no: Integer, maybe: Integer},
               error: T.nilable(StandardError),

data/lib/openai/internal/type/enum.rb

@@ -62,9 +62,7 @@ module OpenAI
         #
         # @return [Boolean]
         def ==(other)
-          # rubocop:disable Style/CaseEquality
           OpenAI::Internal::Type::Enum === other && other.values.to_set == values.to_set
-          # rubocop:enable Style/CaseEquality
         end
 
         # @api public

data/lib/openai/internal/type/union.rb

@@ -124,9 +124,6 @@ module OpenAI
           end
         end
 
-        # rubocop:disable Style/HashEachMethods
-        # rubocop:disable Style/CaseEquality
-
         # @api public
         #
         # @param other [Object]
@@ -256,9 +253,6 @@ module OpenAI
           end
         end
 
-        # rubocop:enable Style/CaseEquality
-        # rubocop:enable Style/HashEachMethods
-
         # @api private
         #
         # @param depth [Integer]

data/lib/openai/internal/type/unknown.rb

@@ -55,16 +55,44 @@ module OpenAI
             value
           end
 
-          # @!method dump(value, state:)
-          #   @api private
+          # @api private
           #
-          #   @param value [Object]
+          # Traverse arbitrary JSON containers without consuming the Ruby stack.
+          # Delegate model, file, and scalar conversion to the existing converter.
           #
-          #   @param state [Hash{Symbol=>Object}] .
+          # @param value [Object]
           #
-          #     @option state [Boolean] :can_retry
+          # @param state [Hash{Symbol=>Object}] .
           #
-          #   @return [Object]
+          #   @option state [Boolean] :can_retry
+          #
+          # @return [Object]
+          def dump(value, state:)
+            return super unless value.is_a?(Hash) || value.is_a?(Array)
+
+            result = value.is_a?(Hash) ? {} : []
+            copies = {}.compare_by_identity
+            copies[value] = result
+            pending = [[value, result]]
+            until pending.empty?
+              source, destination = pending.pop
+              entries = source.is_a?(Hash) ? source.each_pair : source.each_with_index.lazy.map { |item, i| [i, item] }
+              entries.each do |key, item|
+                if item.is_a?(Hash) || item.is_a?(Array)
+                  unless copies.key?(item)
+                    copies[item] = item.is_a?(Hash) ? {} : []
+                    pending << [item, copies.fetch(item)]
+                  end
+
+                  destination[key] = copies.fetch(item)
+                else
+                  destination[key] = super(item, state: state)
+                end
+              end
+            end
+
+            result
+          end
 
           # @api private
           #

data/lib/openai/internal/util.rb

@@ -629,7 +629,6 @@ module OpenAI
         #
         # @return [Object]
         def encode_content(headers, body)
-          # rubocop:disable Style/CaseEquality
           content_type = headers["content-type"]
           case [content_type, body]
           in [OpenAI::Internal::Util::JSON_CONTENT, Hash | Array | -> { primitive?(_1) }]
@@ -652,7 +651,6 @@ module OpenAI
           else
             [headers, body]
           end
-          # rubocop:enable Style/CaseEquality
         end
 
         # @api private
@@ -934,7 +932,6 @@ module OpenAI
         #
         # @return [Enumerable<Hash{Symbol=>Object}>]
         def decode_sse(lines)
-          # rubocop:disable Metrics/BlockLength
           chain_fused(lines) do |y|
             blank = {event: nil, data: nil, id: nil, retry: nil}
             current = {}
@@ -973,7 +970,6 @@ module OpenAI
               else
               end
             end
-            # rubocop:enable Metrics/BlockLength
 
             y << {**blank, **current} unless current.empty?
           end

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

@@ -142,6 +142,12 @@ module OpenAI
 
           variant const: -> { OpenAI::Models::Audio::SpeechCreateParams::Voice::CEDAR }
 
+          variant const: -> { OpenAI::Models::Audio::SpeechCreateParams::Voice::FABLE }
+
+          variant const: -> { OpenAI::Models::Audio::SpeechCreateParams::Voice::ONYX }
+
+          variant const: -> { OpenAI::Models::Audio::SpeechCreateParams::Voice::NOVA }
+
           # Custom voice reference.
           variant -> { OpenAI::Audio::SpeechCreateParams::Voice::ID }
 
@@ -184,6 +190,9 @@ module OpenAI
           VERSE = :verse
           MARIN = :marin
           CEDAR = :cedar
+          FABLE = :fable
+          ONYX = :onyx
+          NOVA = :nova
 
           # @!endgroup
         end

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

@@ -21,8 +21,11 @@ module OpenAI
         # Represents a transcription response returned by model, based on the provided input.
         variant -> { OpenAI::Audio::Transcription }
 
+        # Text, SRT, and VTT responses retain the SDK's readable IO return value.
+        variant StringIO
+
         # @!method self.variants
-        #   @return [Array(OpenAI::Models::Audio::TranscriptionVerbose, OpenAI::Models::Audio::TranscriptionDiarized, OpenAI::Models::Audio::Transcription)]
+        #   @return [Array(OpenAI::Models::Audio::TranscriptionVerbose, OpenAI::Models::Audio::TranscriptionDiarized, OpenAI::Models::Audio::Transcription, StringIO)]
       end
     end
   end