openai 0.106.0 → 0.107.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c24e00e4168b6f3661b2eb29d8de97727d4bcd6a80e40f68512ab21c3c025b46
-  data.tar.gz: 16f33bff54375b5f3fb5174af63026f95e79ab2ca1cdfe6dd07cedfacac31568
+  metadata.gz: e70580b3709d068f537d9eed65ea7e9da96f89e0e2260b36ebf23a9c3590ecf1
+  data.tar.gz: 83910cf81a9410c93588e877cca7f88e3d70cbe07e8eed3cd0789b08e3299a0c
 SHA512:
-  metadata.gz: 0fe9484b436e02d3b50981251596b57195cef1a604207b7b496049a2214b44eb3953447568b3dcfb3e1e0827279785587e66dfc1d2427c1fa858b7bcb87c54c1
-  data.tar.gz: 2cabbb26e7382803fbc4aa5ddcc47e3be1bad88c2d05510fb0a44f537653761a0c888157d407764ebeaab8de174cf5f8a44338ae868b16c016914b31cdd1978c
+  metadata.gz: 0e854d18548c800c72da1eb04b022befc61b36ccd3e1d24fa732db7b66a0d5c3fdca08a73dd0be579f97ad2c24fbf94f318c42e800eea5b9a8118b35b18b6cbe
+  data.tar.gz: 8dd6d3894a1137351eea2bcdad51308b46cdf025de798e913bc1f64c198beb31a264140dcd1c2d901249a21f0bea4c22a6ea61ed274a54f9f031fef73a457cf3

data/CHANGELOG.md

@@ -1,5 +1,56 @@
 # Changelog
 
+## [0.107.0](https://github.com/openai/openai-ruby/compare/v0.106.0...v0.107.0) (2026-10-20)
+
+
+### Features
+
+* **api:** add 30-minute cache-write usage counts ([#915](https://github.com/openai/openai-ruby/issues/915)) ([ea2dd66](https://github.com/openai/openai-ruby/commit/ea2dd66ed0c16e544490332fc2ea8ec4f5abd1bb))
+* **api:** add compaction trigger IDs ([#934](https://github.com/openai/openai-ruby/issues/934)) ([224e04a](https://github.com/openai/openai-ruby/commit/224e04ac2f610c793d772efafe7244d6c88039fc))
+
+
+### Bug Fixes
+
+* **api:** correct authentication security key types ([#938](https://github.com/openai/openai-ruby/issues/938)) ([4a5cc74](https://github.com/openai/openai-ruby/commit/4a5cc744b38dc39042d98ae2ff5a32fdd0247bc9))
+* decode base64 embedding vectors ([#942](https://github.com/openai/openai-ruby/issues/942)) ([d684df4](https://github.com/openai/openai-ruby/commit/d684df4dc2a633e34836a346bbbe1e7cbb3d2707))
+* drain audio diagnostics while waiting on input ([#920](https://github.com/openai/openai-ruby/issues/920)) ([8a0b876](https://github.com/openai/openai-ruby/commit/8a0b87606e55f26e86e289577cdfd2533c329ad6))
+* drain ready audio diagnostics without delay ([#918](https://github.com/openai/openai-ruby/issues/918)) ([3e87ce3](https://github.com/openai/openai-ruby/commit/3e87ce380fafe08bb4348b9b867d4006bb939e49))
+* keep Realtime diagnostic rendering payload-free ([#924](https://github.com/openai/openai-ruby/issues/924)) ([3a29026](https://github.com/openai/openai-ruby/commit/3a29026ab177704dbe30d688fddd085e737dfc6d))
+* preserve deep JSON in WebSocket event codecs ([#928](https://github.com/openai/openai-ruby/issues/928)) ([57462c9](https://github.com/openai/openai-ruby/commit/57462c938e3b7602c456b0816e8873bd67fad241))
+* preserve typed Realtime event identity ([#931](https://github.com/openai/openai-ruby/issues/931)) ([9bb5618](https://github.com/openai/openai-ruby/commit/9bb56187c7eb0d72f992c76fed68369d34972d81))
+* **realtime:** abort connections after failed or canceled WebSocket writes so buffered application data cannot be flushed later. On a poisoned connection, `close(code:, reason:)` aborts without a close handshake; the supplied code and reason are not sent. ([#914](https://github.com/openai/openai-ruby/issues/914)) ([d219f3d](https://github.com/openai/openai-ruby/commit/d219f3d0461dd96911429f1b89369eadd382f234))
+* report terminal Realtime failures before transport cleanup ([#923](https://github.com/openai/openai-ruby/issues/923)) ([0d21d75](https://github.com/openai/openai-ruby/commit/0d21d751cd89621c6a32c0048c45ef6e5b7c1af4))
+* retain Translation completion across callback exits ([#921](https://github.com/openai/openai-ruby/issues/921)) ([e6fb44e](https://github.com/openai/openai-ruby/commit/e6fb44e57d233e657d982eee4cf27c6a5d7977c7))
+* share strict WebSocket model validation ([#929](https://github.com/openai/openai-ruby/issues/929)) ([51c6f0b](https://github.com/openai/openai-ruby/commit/51c6f0b73081f0f02f981d2beb4a8b129b2ec1ba))
+* validate nested WebSocket wire field names ([#922](https://github.com/openai/openai-ruby/issues/922)) ([ae551ef](https://github.com/openai/openai-ruby/commit/ae551ef48d52d2c2f415f63c39e0c643fcfb1d75))
+* validate typed WebSocket event constants before conversion ([#925](https://github.com/openai/openai-ruby/issues/925)) ([3ae0cd3](https://github.com/openai/openai-ruby/commit/3ae0cd3070b4fcf046f8823f4cca1b7b8829effe))
+
+
+### Chores
+
+* **api:** clarify project API key update requirements ([#936](https://github.com/openai/openai-ruby/issues/936)) ([34606cc](https://github.com/openai/openai-ruby/commit/34606cc46087dae5a643256e9cae93966a106182))
+* **api:** Keep SDK maintenance checks aligned ([#917](https://github.com/openai/openai-ruby/issues/917)) ([ebe5bf4](https://github.com/openai/openai-ruby/commit/ebe5bf4dd74d87acf86e30f5c7a78350ce3f8e8d))
+* **api:** preserve audio transcription response compatibility ([#911](https://github.com/openai/openai-ruby/issues/911)) ([c93fb88](https://github.com/openai/openai-ruby/commit/c93fb88b350c80d724912351cf02d7ff51e3073a))
+* **api:** preserve JSON Schema adapter types ([#930](https://github.com/openai/openai-ruby/issues/930)) ([f1430b8](https://github.com/openai/openai-ruby/commit/f1430b8038c7f01123fbf9f2703f6eb5b7fa8c14))
+* **api:** preserve legacy Threads stream behavior ([#910](https://github.com/openai/openai-ruby/issues/910)) ([436887f](https://github.com/openai/openai-ruby/commit/436887fbe6bc3d0874cb75dca501ba1da0a9d9b4))
+* **api:** preserve optional Decisions usage filters ([#909](https://github.com/openai/openai-ruby/issues/909)) ([34f61df](https://github.com/openai/openai-ruby/commit/34f61dfc23bd1ade311e09a036ef6696af37c138))
+* **api:** preserve optional image edit safety identifiers ([#913](https://github.com/openai/openai-ruby/issues/913)) ([6bbfad1](https://github.com/openai/openai-ruby/commit/6bbfad1a6305b5efc71dbb41dce8560d2865bda2))
+* **api:** preserve standard library loading ([#935](https://github.com/openai/openai-ruby/issues/935)) ([a742640](https://github.com/openai/openai-ruby/commit/a7426400cf499f0d88c9e88e694d86369f8d9cb5))
+* **deps-dev:** bump the development-dependencies group with 3 updates ([#912](https://github.com/openai/openai-ruby/issues/912)) ([1227860](https://github.com/openai/openai-ruby/commit/1227860daec638117ce1f14dcd570cffc92c9647))
+* **deps:** bump ruby/setup-ruby from 1.329.0 to 1.331.0 ([#937](https://github.com/openai/openai-ruby/issues/937)) ([8b3ab95](https://github.com/openai/openai-ruby/commit/8b3ab95e7332a7c5325b4718d4e01246c5a54054))
+* prepare generic WebSocket binding signatures ([#941](https://github.com/openai/openai-ruby/issues/941)) ([9206c8c](https://github.com/openai/openai-ruby/commit/9206c8ceb99cc18df859d06c251fa5336c59ecdf))
+
+
+### Documentation
+
+* clarify Realtime guide scope and Translation support ([#905](https://github.com/openai/openai-ruby/issues/905)) ([efb4004](https://github.com/openai/openai-ruby/commit/efb4004aa49a8a4374833f4b07fbd373fdebb685))
+
+
+### Refactors
+
+* share Live codecs and use generated sideband commands ([#933](https://github.com/openai/openai-ruby/issues/933)) ([02861d0](https://github.com/openai/openai-ruby/commit/02861d0780eb18f493f881cfa9ed7cdf9a68abe3))
+* share Translation and binding event codecs ([#932](https://github.com/openai/openai-ruby/issues/932)) ([7dc0088](https://github.com/openai/openai-ruby/commit/7dc00884ba30a54a965fc41e8b19e1840e9faec9))
+
 ## [0.106.0](https://github.com/openai/openai-ruby/compare/v0.105.0...v0.106.0) (2026-10-17)
 
 

data/README.md

@@ -15,7 +15,7 @@ To use this gem, install via Bundler by adding the following to your application
 <!-- x-release-please-start-version -->
 
 ```ruby
-gem "openai", "~> 0.106.0"
+gem "openai", "~> 0.107.0"
 ```
 
 <!-- x-release-please-end -->

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

@@ -26,6 +26,8 @@ module OpenAI
     # A future server event retains its raw data, but routine diagnostics do not
     # render potentially sensitive audio, transcript, or session fields.
     class UnknownServerEvent
+      include OpenAI::WebSocket::Protocol
+
       attr_reader :type, :data
 
       def initialize(data:)
@@ -38,160 +40,33 @@ module OpenAI
       def inspect = "#<#{self.class} type=#{@type.inspect}>"
       alias to_s inspect
 
-      private def freeze_json(value)
-        pending = [value]
-        visited = {}.compare_by_identity
-        until pending.empty?
-          item = pending.pop
-          next if visited.key?(item)
-          visited[item] = true
-          case item
-          when Hash
-            item.each { |key, val| pending.push(key, val) }
-          when Array
-            pending.concat(item)
-          end
-
-          item.freeze
-        end
-
-        value
-      end
     end
 
     # A transport-open primary connection. Startup is owned by the caller:
     # send session.start and observe session.started before further commands.
-    class Connection < OpenAI::WebSocket::Connection
-      include OpenAI::WebSocket::Protocol
-      include OpenAI::WebSocket::GuardedConnection
-
+    class Connection < OpenAI::WebSocket::TypedConnection
       # @api private
       def initialize(socket:, url:)
-        super
+        super(socket: socket, url: url, client_event: client_event_type, server_event: server_event_type)
         @poisoned = false
         @closed = false
-        @server_event_names = discriminator_values(server_event_type)
-        @client_event_names = discriminator_values(client_event_type)
-      end
-
-      def send_event(event)
-        send_raw(encode_client_event(event))
       end
 
-      private def encode_client_event(event)
-        validate_event_tree!(event)
-        payload = OpenAI::Internal::Type::Converter.dump(client_event_type, event)
-        type = payload[:type] || payload["type"] if payload.is_a?(Hash)
-        raise ArgumentError unless (type.is_a?(String) || type.is_a?(Symbol)) && @client_event_names.key?(type.to_s)
-
-        coerced = coerce_event(client_event_type, payload, outbound: true)
-        serialized = OpenAI::Internal::Type::Converter.dump(client_event_type, coerced)
-        validate_event_tree!(serialized, json_only: true)
-        JSON.generate(serialized, max_nesting: false)
-      rescue StandardError, SystemStackError
-        raise ArgumentError, "Invalid Live client event.", cause: nil
-      end
+      private :parse_event
 
-      private def parse_event(data)
-        parsed = JSON.parse(data, symbolize_names: true, max_nesting: false)
-        type = event_type(parsed, message: "Live server event must be an object with a string type")
-        unless @server_event_names.key?(type.to_s)
-          return OpenAI::Live::UnknownServerEvent.new(data: parsed)
-        end
+      private def coerce_client_event(payload) = coerce_event(@client_event, payload, outbound: true)
 
-        event = coerce_event(server_event_type, parsed)
+      private def coerce(type, payload)
+        event = coerce_event(type, payload)
         validate_event_tree!(event)
         event
-      rescue StandardError, SystemStackError
-        raise OpenAI::Errors::LiveProtocolError.new, cause: nil
       end
 
-      private def coerce_event(union, payload, outbound: false)
-        state = OpenAI::Internal::Type::Converter.new_coerce_state(request_only: outbound)
-        event = OpenAI::Internal::Type::Converter.coerce(union, payload, state: state)
-        raise ArgumentError if state[:error] || !state.fetch(:exactness).fetch(:no).zero?
-        pending = [event]
-        until pending.empty?
-          value = pending.pop
-          case value
-          when OpenAI::Internal::Type::BaseModel
-            value.class.fields.each do |name, field|
-              if field.fetch(:required) &&
-                  field.fetch(:mode) != (outbound ? :coerce : :dump) &&
-                  (!outbound || field.fetch(:const) == OpenAI::Internal::OMIT) &&
-                  !value.to_h.key?(name)
-                raise ArgumentError
-              end
-            end
-
-            pending.concat(value.to_h.values)
-          when Hash
-            pending.concat(value.values)
-          when Array
-            pending.concat(value)
-          end
-        end
-
-        event
-      end
+      private def client_event_error_message = "Invalid Live client event."
 
-      private def validate_event_tree!(event, json_only: false)
-        ancestors = {}.compare_by_identity
-        pending = [[event, false]]
-        until pending.empty?
-          value, exiting = pending.pop
-          if exiting
-            ancestors.delete(value)
-            next
-          end
+      private def unknown_server_event(payload) = OpenAI::Live::UnknownServerEvent.new(data: payload)
 
-          children = case value
-          when OpenAI::Internal::Type::BaseModel
-            raise ArgumentError if json_only
-            data = value.to_h
-            keys = {}
-            data.each do |key, val|
-              name = key.is_a?(String) ? key.to_sym : key
-              field = value.class.known_fields[name]
-              serialized_name = field ? field.fetch(:api_name).to_s : name.to_s
-              raise ArgumentError if keys.key?(serialized_name)
-              keys[serialized_name] = true
-              next unless field
-              const = field.fetch(:const)
-              next if const == OpenAI::Internal::OMIT
-              if const.is_a?(Symbol)
-                raise ArgumentError unless (val.is_a?(String) || val.is_a?(Symbol)) && val.to_s == const.to_s
-              elsif val != const
-                raise ArgumentError
-              end
-            end
-
-            [data]
-          when Hash
-            keys = {}
-            value.each_key do |key|
-              raise ArgumentError unless key.is_a?(String) || key.is_a?(Symbol)
-              name = key.to_s
-              raise ArgumentError if keys.key?(name)
-              keys[name] = true
-            end
-
-            value.values
-          when Array
-            value
-          when NilClass, TrueClass, FalseClass, String, Integer, Float, Symbol
-            next
-          else
-            raise ArgumentError if json_only
-            next
-          end
-
-          raise ArgumentError if ancestors.key?(value)
-          ancestors[value] = true
-          pending << [value, true]
-          children.each { |child| pending << [child, false] }
-        end
-      end
+      private def protocol_error = OpenAI::Errors::LiveProtocolError.new
 
       private def transport_error = OpenAI::Errors::LiveConnectionError.new(url: @url)
       private def failed_read_message = "Cannot read from a failed Live WebSocket."
@@ -206,11 +81,7 @@ module OpenAI
 
     # Attached to an existing session; no new session.start handshake is sent.
     class SidebandConnection < Connection
-      # @api private
-      def initialize(socket:, url:)
-        super
-        @client_event_names = @client_event_names.except("session.start", "session.input_audio.append")
-      end
+      private def client_event_type = OpenAI::Live::SidebandClientEvent
     end
 
     # Caller-driven startup using overrides for an eligible stored session.

data/lib/openai/helpers/local_audio/process.rb

@@ -70,6 +70,7 @@ module OpenAI
         if @error_reader && !@error_reader.closed?
           chunk = @error_reader.read_nonblock(65_536, exception: false)
           @errors = true if chunk.is_a?(String) && !chunk.empty?
+          @error_reader.close if chunk.nil?
         end
 
         !!@errors
@@ -86,7 +87,9 @@ module OpenAI
             raise PlaybackError, "Audio player exited before the input ended." if @status
           end
 
-          io.wait_readable(0.05)
+          readers = [io]
+          readers << @error_reader if @error_reader && !@error_reader.closed?
+          IO.select(readers, nil, nil, 0.05)
         end
       end
 
@@ -96,7 +99,8 @@ module OpenAI
           check_deadline
           result = io.write_nonblock(bytes.byteslice(offset, 65_536), exception: false)
           if result == :wait_writable
-            io.wait_writable(0.05)
+            readers = @error_reader && !@error_reader.closed? ? [@error_reader] : []
+            IO.select(readers, [io], nil, 0.05)
           else
             offset += result
           end
@@ -110,7 +114,13 @@ module OpenAI
         until @status
           check_deadline
           reap
-          sleep(0.01) unless @status
+          unless @status
+            if @error_reader && !@error_reader.closed?
+              @error_reader.wait_readable(0.01)
+            else
+              sleep(0.01)
+            end
+          end
         end
 
         @status

data/lib/openai/helpers/models/embedding.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative "../../models/embedding"
+
+module OpenAI
+  module Models
+    class Embedding
+      alias_method :embedding_without_base64, :embedding
+      private :embedding_without_base64
+
+      def embedding
+        value = self[:embedding]
+        return embedding_without_base64 unless value.is_a?(String)
+
+        # The generated setter replaces this per-field state on assignment.
+        cached = @coerced[:embedding]
+        return cached if cached.is_a?(Array)
+
+        # Base64 embedding values contain little-endian float32 samples.
+        decoded = begin
+          value.unpack1("m0")
+        rescue ArgumentError
+          nil
+        end
+
+        return embedding_without_base64 unless decoded && (decoded.bytesize % 4).zero?
+
+        @coerced[:embedding] = decoded.unpack("e*")
+      end
+
+      # Equal embeddings still have equal raw data, so the inherited hash remains valid.
+      def ==(other)
+        return false unless super
+        return true unless self[:embedding].is_a?(String)
+
+        embedding == other.embedding
+      rescue OpenAI::Errors::ConversionError
+        true
+      end
+    end
+  end
+end

data/lib/openai/helpers/realtime/connection.rb

@@ -33,7 +33,7 @@ module OpenAI
       # Parse raw JSON as a typed server event. Valid events that are newer than this
       # SDK remain observable as {UnknownServerEvent} values.
       def parse_event(data)
-        parsed = JSON.parse(data, symbolize_names: true)
+        parsed = parse_json(data)
         type = event_type(parsed)
         unless @server_event_names.key?(type.to_s)
           return OpenAI::Realtime::UnknownServerEvent.new(data: parsed)
@@ -46,14 +46,16 @@ module OpenAI
           state: state
         )
         if (cause = coercion_error(state))
-          raise OpenAI::Errors::RealtimeProtocolError.new(data: data, cause: cause)
+          raise OpenAI::Errors::RealtimeProtocolError.new(data: data, cause: cause), cause: nil
         end
 
-        event
+        validate_wire_field_names!(event, parsed)
       rescue OpenAI::Errors::RealtimeProtocolError
         raise
+      rescue SystemStackError
+        raise OpenAI::Errors::RealtimeProtocolError.new(data: data), cause: nil
       rescue StandardError => e
-        raise OpenAI::Errors::RealtimeProtocolError.new(data: data, cause: e)
+        raise OpenAI::Errors::RealtimeProtocolError.new(data: data, cause: e), cause: nil
       end
 
       # Validate, encode, and send a typed client event.
@@ -61,6 +63,15 @@ module OpenAI
         send_raw(encode_client_event(event))
       end
 
+      private def write_text(text)
+        return super unless @recovery
+
+        # Recovery owns admission and uncertain sends; rejecting a full queue
+        # has not attempted a physical write and must leave this connection usable.
+        @recovery.write(text)
+        nil
+      end
+
       # Whether automatic recovery is opening or preparing a replacement socket.
       def reconnecting? = @recovery ? @recovery.reconnecting? : false
 
@@ -83,6 +94,10 @@ module OpenAI
           validate_discriminator!(event, @client_event_names, kind: "client")
         end
 
+        # Preserve permissive raw JSON keys while checking original typed models
+        # before union conversion can replace their identities or renamed fields.
+        validate_event_tree!(event, strict_keys: false)
+
         normalized = OpenAI::Internal::Type::Converter.dump(
           OpenAI::Realtime::RealtimeClientEvent,
           event
@@ -99,7 +114,9 @@ module OpenAI
 
         payload = OpenAI::Internal::Type::Converter.dump(OpenAI::Realtime::RealtimeClientEvent, coerced)
         validate_discriminator!(payload, @client_event_names, kind: "client")
-        JSON.generate(payload)
+        generate_json(payload)
+      rescue SystemStackError
+        raise ArgumentError, "Invalid Realtime client event.", cause: nil
       rescue StandardError => e
         raise ArgumentError.new("Invalid Realtime client event."), cause: e
       end

data/lib/openai/helpers/realtime/recovery.rb

@@ -76,7 +76,7 @@ module OpenAI
 
       def take_pending_messages
         @mutex.synchronize do
-          raise state_error("Cannot remove queued events while flushing.") if @flushing
+          raise state_error("Cannot remove queued events while flushing."), cause: nil if @flushing
 
           messages = @pending
           @pending = []
@@ -106,7 +106,7 @@ module OpenAI
 
           if @state != :open || @flushing
             if @max_queue_bytes.zero? || @pending_bytes + [text.bytesize, 1].max > @max_queue_bytes
-              raise OpenAI::Errors::RealtimeQueueFullError
+              raise OpenAI::Errors::RealtimeQueueFullError, cause: nil
             end
 
             @pending << text.dup.freeze
@@ -124,13 +124,15 @@ module OpenAI
 
       def flush_pending
         if Fiber.current.equal?(@owner_fiber)
-          raise state_error("Queue flush interrupted; remaining events were not sent.") unless flush
+          raise state_error("Queue flush interrupted; remaining events were not sent."), cause: nil unless flush
           return nil
         end
 
         reply = @mutex.synchronize do
           raise @error, cause: nil if @error
-          raise state_error("Cannot flush until the replacement connection is ready.") unless @state == :open
+          unless @state == :open
+            raise state_error("Cannot flush until the replacement connection is ready."), cause: nil
+          end
 
           register(:flush).tap { @commands << [:flush, nil, _1, @generation] }
         end
@@ -348,7 +350,11 @@ module OpenAI
               uncertain_message: @inflight
             )
           elsif @state != :closed
-            @state = :recovering
+            if recoverable?(e) && @attempts < @max_attempts
+              @state = :recovering
+            else
+              fail_locked("Realtime reconnect stopped; the connection could not be recovered.")
+            end
           end
         end