openai 0.23.1 → 0.23.2

data/rbi/openai/models/realtime/realtime_session_create_response.rbi

@@ -525,30 +525,25 @@ module OpenAI
 
             # Configuration for turn detection, ether Server VAD or Semantic VAD. This can be
             # set to `null` to turn off, in which case the client must manually trigger model
-            # response. Server VAD means that the model will detect the start and end of
-            # speech based on audio volume and respond at the end of user speech. Semantic VAD
-            # is more advanced and uses a turn detection model (in conjunction with VAD) to
-            # semantically estimate whether the user has finished speaking, then dynamically
-            # sets a timeout based on this probability. For example, if user audio trails off
-            # with "uhhm", the model will score a low probability of turn end and wait longer
-            # for the user to continue speaking. This can be useful for more natural
-            # conversations, but may have a higher latency.
+            # response.
+            #
+            # Server VAD means that the model will detect the start and end of speech based on
+            # audio volume and respond at the end of user speech.
+            #
+            # Semantic VAD is more advanced and uses a turn detection model (in conjunction
+            # with VAD) to semantically estimate whether the user has finished speaking, then
+            # dynamically sets a timeout based on this probability. For example, if user audio
+            # trails off with "uhhm", the model will score a low probability of turn end and
+            # wait longer for the user to continue speaking. This can be useful for more
+            # natural conversations, but may have a higher latency.
             sig do
               returns(
                 T.nilable(
-                  OpenAI::Realtime::RealtimeSessionCreateResponse::Audio::Input::TurnDetection
+                  OpenAI::Realtime::RealtimeSessionCreateResponse::Audio::Input::TurnDetection::Variants
                 )
               )
             end
-            attr_reader :turn_detection
-
-            sig do
-              params(
-                turn_detection:
-                  OpenAI::Realtime::RealtimeSessionCreateResponse::Audio::Input::TurnDetection::OrHash
-              ).void
-            end
-            attr_writer :turn_detection
+            attr_accessor :turn_detection
 
             sig do
               params(
@@ -562,7 +557,12 @@ module OpenAI
                   OpenAI::Realtime::RealtimeSessionCreateResponse::Audio::Input::NoiseReduction::OrHash,
                 transcription: OpenAI::Realtime::AudioTranscription::OrHash,
                 turn_detection:
-                  OpenAI::Realtime::RealtimeSessionCreateResponse::Audio::Input::TurnDetection::OrHash
+                  T.nilable(
+                    T.any(
+                      OpenAI::Realtime::RealtimeSessionCreateResponse::Audio::Input::TurnDetection::ServerVad::OrHash,
+                      OpenAI::Realtime::RealtimeSessionCreateResponse::Audio::Input::TurnDetection::SemanticVad::OrHash
+                    )
+                  )
               ).returns(T.attached_class)
             end
             def self.new(
@@ -585,14 +585,17 @@ module OpenAI
               transcription: nil,
               # Configuration for turn detection, ether Server VAD or Semantic VAD. This can be
               # set to `null` to turn off, in which case the client must manually trigger model
-              # response. Server VAD means that the model will detect the start and end of
-              # speech based on audio volume and respond at the end of user speech. Semantic VAD
-              # is more advanced and uses a turn detection model (in conjunction with VAD) to
-              # semantically estimate whether the user has finished speaking, then dynamically
-              # sets a timeout based on this probability. For example, if user audio trails off
-              # with "uhhm", the model will score a low probability of turn end and wait longer
-              # for the user to continue speaking. This can be useful for more natural
-              # conversations, but may have a higher latency.
+              # response.
+              #
+              # Server VAD means that the model will detect the start and end of speech based on
+              # audio volume and respond at the end of user speech.
+              #
+              # Semantic VAD is more advanced and uses a turn detection model (in conjunction
+              # with VAD) to semantically estimate whether the user has finished speaking, then
+              # dynamically sets a timeout based on this probability. For example, if user audio
+              # trails off with "uhhm", the model will score a low probability of turn end and
+              # wait longer for the user to continue speaking. This can be useful for more
+              # natural conversations, but may have a higher latency.
               turn_detection: nil
             )
             end
@@ -605,7 +608,9 @@ module OpenAI
                     OpenAI::Realtime::RealtimeSessionCreateResponse::Audio::Input::NoiseReduction,
                   transcription: OpenAI::Realtime::AudioTranscription,
                   turn_detection:
-                    OpenAI::Realtime::RealtimeSessionCreateResponse::Audio::Input::TurnDetection
+                    T.nilable(
+                      OpenAI::Realtime::RealtimeSessionCreateResponse::Audio::Input::TurnDetection::Variants
+                    )
                 }
               )
             end
@@ -665,259 +670,320 @@ module OpenAI
               end
             end
 
-            class TurnDetection < OpenAI::Internal::Type::BaseModel
-              OrHash =
+            # Configuration for turn detection, ether Server VAD or Semantic VAD. This can be
+            # set to `null` to turn off, in which case the client must manually trigger model
+            # response.
+            #
+            # Server VAD means that the model will detect the start and end of speech based on
+            # audio volume and respond at the end of user speech.
+            #
+            # Semantic VAD is more advanced and uses a turn detection model (in conjunction
+            # with VAD) to semantically estimate whether the user has finished speaking, then
+            # dynamically sets a timeout based on this probability. For example, if user audio
+            # trails off with "uhhm", the model will score a low probability of turn end and
+            # wait longer for the user to continue speaking. This can be useful for more
+            # natural conversations, but may have a higher latency.
+            module TurnDetection
+              extend OpenAI::Internal::Type::Union
+
+              Variants =
                 T.type_alias do
                   T.any(
-                    OpenAI::Realtime::RealtimeSessionCreateResponse::Audio::Input::TurnDetection,
-                    OpenAI::Internal::AnyHash
+                    OpenAI::Realtime::RealtimeSessionCreateResponse::Audio::Input::TurnDetection::ServerVad,
+                    OpenAI::Realtime::RealtimeSessionCreateResponse::Audio::Input::TurnDetection::SemanticVad
                   )
                 end
 
-              # Whether or not to automatically generate a response when a VAD stop event
-              # occurs.
-              sig { returns(T.nilable(T::Boolean)) }
-              attr_reader :create_response
-
-              sig { params(create_response: T::Boolean).void }
-              attr_writer :create_response
-
-              # Used only for `semantic_vad` mode. The eagerness of the model to respond. `low`
-              # will wait longer for the user to continue speaking, `high` will respond more
-              # quickly. `auto` is the default and is equivalent to `medium`. `low`, `medium`,
-              # and `high` have max timeouts of 8s, 4s, and 2s respectively.
-              sig do
-                returns(
-                  T.nilable(
-                    OpenAI::Realtime::RealtimeSessionCreateResponse::Audio::Input::TurnDetection::Eagerness::TaggedSymbol
-                  )
-                )
-              end
-              attr_reader :eagerness
-
-              sig do
-                params(
-                  eagerness:
-                    OpenAI::Realtime::RealtimeSessionCreateResponse::Audio::Input::TurnDetection::Eagerness::OrSymbol
-                ).void
-              end
-              attr_writer :eagerness
-
-              # Optional idle timeout after which turn detection will auto-timeout when no
-              # additional audio is received and emits a `timeout_triggered` event.
-              sig { returns(T.nilable(Integer)) }
-              attr_accessor :idle_timeout_ms
-
-              # Whether or not to automatically interrupt any ongoing response with output to
-              # the default conversation (i.e. `conversation` of `auto`) when a VAD start event
-              # occurs.
-              sig { returns(T.nilable(T::Boolean)) }
-              attr_reader :interrupt_response
-
-              sig { params(interrupt_response: T::Boolean).void }
-              attr_writer :interrupt_response
-
-              # Used only for `server_vad` mode. Amount of audio to include before the VAD
-              # detected speech (in milliseconds). Defaults to 300ms.
-              sig { returns(T.nilable(Integer)) }
-              attr_reader :prefix_padding_ms
-
-              sig { params(prefix_padding_ms: Integer).void }
-              attr_writer :prefix_padding_ms
-
-              # Used only for `server_vad` mode. Duration of silence to detect speech stop (in
-              # milliseconds). Defaults to 500ms. With shorter values the model will respond
-              # more quickly, but may jump in on short pauses from the user.
-              sig { returns(T.nilable(Integer)) }
-              attr_reader :silence_duration_ms
-
-              sig { params(silence_duration_ms: Integer).void }
-              attr_writer :silence_duration_ms
-
-              # Used only for `server_vad` mode. Activation threshold for VAD (0.0 to 1.0), this
-              # defaults to 0.5. A higher threshold will require louder audio to activate the
-              # model, and thus might perform better in noisy environments.
-              sig { returns(T.nilable(Float)) }
-              attr_reader :threshold
-
-              sig { params(threshold: Float).void }
-              attr_writer :threshold
-
-              # Type of turn detection.
-              sig do
-                returns(
-                  T.nilable(
-                    OpenAI::Realtime::RealtimeSessionCreateResponse::Audio::Input::TurnDetection::Type::TaggedSymbol
-                  )
-                )
-              end
-              attr_reader :type
+              class ServerVad < OpenAI::Internal::Type::BaseModel
+                OrHash =
+                  T.type_alias do
+                    T.any(
+                      OpenAI::Realtime::RealtimeSessionCreateResponse::Audio::Input::TurnDetection::ServerVad,
+                      OpenAI::Internal::AnyHash
+                    )
+                  end
 
-              sig do
-                params(
-                  type:
-                    OpenAI::Realtime::RealtimeSessionCreateResponse::Audio::Input::TurnDetection::Type::OrSymbol
-                ).void
-              end
-              attr_writer :type
+                # Type of turn detection, `server_vad` to turn on simple Server VAD.
+                sig { returns(Symbol) }
+                attr_accessor :type
 
-              # Configuration for turn detection, ether Server VAD or Semantic VAD. This can be
-              # set to `null` to turn off, in which case the client must manually trigger model
-              # response. Server VAD means that the model will detect the start and end of
-              # speech based on audio volume and respond at the end of user speech. Semantic VAD
-              # is more advanced and uses a turn detection model (in conjunction with VAD) to
-              # semantically estimate whether the user has finished speaking, then dynamically
-              # sets a timeout based on this probability. For example, if user audio trails off
-              # with "uhhm", the model will score a low probability of turn end and wait longer
-              # for the user to continue speaking. This can be useful for more natural
-              # conversations, but may have a higher latency.
-              sig do
-                params(
-                  create_response: T::Boolean,
-                  eagerness:
-                    OpenAI::Realtime::RealtimeSessionCreateResponse::Audio::Input::TurnDetection::Eagerness::OrSymbol,
-                  idle_timeout_ms: T.nilable(Integer),
-                  interrupt_response: T::Boolean,
-                  prefix_padding_ms: Integer,
-                  silence_duration_ms: Integer,
-                  threshold: Float,
-                  type:
-                    OpenAI::Realtime::RealtimeSessionCreateResponse::Audio::Input::TurnDetection::Type::OrSymbol
-                ).returns(T.attached_class)
-              end
-              def self.new(
                 # Whether or not to automatically generate a response when a VAD stop event
                 # occurs.
-                create_response: nil,
-                # Used only for `semantic_vad` mode. The eagerness of the model to respond. `low`
-                # will wait longer for the user to continue speaking, `high` will respond more
-                # quickly. `auto` is the default and is equivalent to `medium`. `low`, `medium`,
-                # and `high` have max timeouts of 8s, 4s, and 2s respectively.
-                eagerness: nil,
-                # Optional idle timeout after which turn detection will auto-timeout when no
-                # additional audio is received and emits a `timeout_triggered` event.
-                idle_timeout_ms: nil,
+                sig { returns(T.nilable(T::Boolean)) }
+                attr_reader :create_response
+
+                sig { params(create_response: T::Boolean).void }
+                attr_writer :create_response
+
+                # Optional timeout after which a model response will be triggered automatically.
+                # This is useful for situations in which a long pause from the user is unexpected,
+                # such as a phone call. The model will effectively prompt the user to continue the
+                # conversation based on the current context.
+                #
+                # The timeout value will be applied after the last model response's audio has
+                # finished playing, i.e. it's set to the `response.done` time plus audio playback
+                # duration.
+                #
+                # An `input_audio_buffer.timeout_triggered` event (plus events associated with the
+                # Response) will be emitted when the timeout is reached. Idle timeout is currently
+                # only supported for `server_vad` mode.
+                sig { returns(T.nilable(Integer)) }
+                attr_accessor :idle_timeout_ms
+
                 # Whether or not to automatically interrupt any ongoing response with output to
                 # the default conversation (i.e. `conversation` of `auto`) when a VAD start event
                 # occurs.
-                interrupt_response: nil,
+                sig { returns(T.nilable(T::Boolean)) }
+                attr_reader :interrupt_response
+
+                sig { params(interrupt_response: T::Boolean).void }
+                attr_writer :interrupt_response
+
                 # Used only for `server_vad` mode. Amount of audio to include before the VAD
                 # detected speech (in milliseconds). Defaults to 300ms.
-                prefix_padding_ms: nil,
+                sig { returns(T.nilable(Integer)) }
+                attr_reader :prefix_padding_ms
+
+                sig { params(prefix_padding_ms: Integer).void }
+                attr_writer :prefix_padding_ms
+
                 # Used only for `server_vad` mode. Duration of silence to detect speech stop (in
                 # milliseconds). Defaults to 500ms. With shorter values the model will respond
                 # more quickly, but may jump in on short pauses from the user.
-                silence_duration_ms: nil,
+                sig { returns(T.nilable(Integer)) }
+                attr_reader :silence_duration_ms
+
+                sig { params(silence_duration_ms: Integer).void }
+                attr_writer :silence_duration_ms
+
                 # Used only for `server_vad` mode. Activation threshold for VAD (0.0 to 1.0), this
                 # defaults to 0.5. A higher threshold will require louder audio to activate the
                 # model, and thus might perform better in noisy environments.
-                threshold: nil,
-                # Type of turn detection.
-                type: nil
-              )
-              end
+                sig { returns(T.nilable(Float)) }
+                attr_reader :threshold
 
-              sig do
-                override.returns(
-                  {
+                sig { params(threshold: Float).void }
+                attr_writer :threshold
+
+                # Server-side voice activity detection (VAD) which flips on when user speech is
+                # detected and off after a period of silence.
+                sig do
+                  params(
                     create_response: T::Boolean,
-                    eagerness:
-                      OpenAI::Realtime::RealtimeSessionCreateResponse::Audio::Input::TurnDetection::Eagerness::TaggedSymbol,
                     idle_timeout_ms: T.nilable(Integer),
                     interrupt_response: T::Boolean,
                     prefix_padding_ms: Integer,
                     silence_duration_ms: Integer,
                     threshold: Float,
-                    type:
-                      OpenAI::Realtime::RealtimeSessionCreateResponse::Audio::Input::TurnDetection::Type::TaggedSymbol
-                  }
+                    type: Symbol
+                  ).returns(T.attached_class)
+                end
+                def self.new(
+                  # Whether or not to automatically generate a response when a VAD stop event
+                  # occurs.
+                  create_response: nil,
+                  # Optional timeout after which a model response will be triggered automatically.
+                  # This is useful for situations in which a long pause from the user is unexpected,
+                  # such as a phone call. The model will effectively prompt the user to continue the
+                  # conversation based on the current context.
+                  #
+                  # The timeout value will be applied after the last model response's audio has
+                  # finished playing, i.e. it's set to the `response.done` time plus audio playback
+                  # duration.
+                  #
+                  # An `input_audio_buffer.timeout_triggered` event (plus events associated with the
+                  # Response) will be emitted when the timeout is reached. Idle timeout is currently
+                  # only supported for `server_vad` mode.
+                  idle_timeout_ms: nil,
+                  # Whether or not to automatically interrupt any ongoing response with output to
+                  # the default conversation (i.e. `conversation` of `auto`) when a VAD start event
+                  # occurs.
+                  interrupt_response: nil,
+                  # Used only for `server_vad` mode. Amount of audio to include before the VAD
+                  # detected speech (in milliseconds). Defaults to 300ms.
+                  prefix_padding_ms: nil,
+                  # Used only for `server_vad` mode. Duration of silence to detect speech stop (in
+                  # milliseconds). Defaults to 500ms. With shorter values the model will respond
+                  # more quickly, but may jump in on short pauses from the user.
+                  silence_duration_ms: nil,
+                  # Used only for `server_vad` mode. Activation threshold for VAD (0.0 to 1.0), this
+                  # defaults to 0.5. A higher threshold will require louder audio to activate the
+                  # model, and thus might perform better in noisy environments.
+                  threshold: nil,
+                  # Type of turn detection, `server_vad` to turn on simple Server VAD.
+                  type: :server_vad
                 )
-              end
-              def to_hash
-              end
+                end
 
-              # Used only for `semantic_vad` mode. The eagerness of the model to respond. `low`
-              # will wait longer for the user to continue speaking, `high` will respond more
-              # quickly. `auto` is the default and is equivalent to `medium`. `low`, `medium`,
-              # and `high` have max timeouts of 8s, 4s, and 2s respectively.
-              module Eagerness
-                extend OpenAI::Internal::Type::Enum
+                sig do
+                  override.returns(
+                    {
+                      type: Symbol,
+                      create_response: T::Boolean,
+                      idle_timeout_ms: T.nilable(Integer),
+                      interrupt_response: T::Boolean,
+                      prefix_padding_ms: Integer,
+                      silence_duration_ms: Integer,
+                      threshold: Float
+                    }
+                  )
+                end
+                def to_hash
+                end
+              end
 
-                TaggedSymbol =
+              class SemanticVad < OpenAI::Internal::Type::BaseModel
+                OrHash =
                   T.type_alias do
-                    T.all(
-                      Symbol,
-                      OpenAI::Realtime::RealtimeSessionCreateResponse::Audio::Input::TurnDetection::Eagerness
+                    T.any(
+                      OpenAI::Realtime::RealtimeSessionCreateResponse::Audio::Input::TurnDetection::SemanticVad,
+                      OpenAI::Internal::AnyHash
                     )
                   end
-                OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-                LOW =
-                  T.let(
-                    :low,
-                    OpenAI::Realtime::RealtimeSessionCreateResponse::Audio::Input::TurnDetection::Eagerness::TaggedSymbol
-                  )
-                MEDIUM =
-                  T.let(
-                    :medium,
-                    OpenAI::Realtime::RealtimeSessionCreateResponse::Audio::Input::TurnDetection::Eagerness::TaggedSymbol
-                  )
-                HIGH =
-                  T.let(
-                    :high,
-                    OpenAI::Realtime::RealtimeSessionCreateResponse::Audio::Input::TurnDetection::Eagerness::TaggedSymbol
-                  )
-                AUTO =
-                  T.let(
-                    :auto,
-                    OpenAI::Realtime::RealtimeSessionCreateResponse::Audio::Input::TurnDetection::Eagerness::TaggedSymbol
-                  )
+                # Type of turn detection, `semantic_vad` to turn on Semantic VAD.
+                sig { returns(Symbol) }
+                attr_accessor :type
 
+                # Whether or not to automatically generate a response when a VAD stop event
+                # occurs.
+                sig { returns(T.nilable(T::Boolean)) }
+                attr_reader :create_response
+
+                sig { params(create_response: T::Boolean).void }
+                attr_writer :create_response
+
+                # Used only for `semantic_vad` mode. The eagerness of the model to respond. `low`
+                # will wait longer for the user to continue speaking, `high` will respond more
+                # quickly. `auto` is the default and is equivalent to `medium`. `low`, `medium`,
+                # and `high` have max timeouts of 8s, 4s, and 2s respectively.
                 sig do
-                  override.returns(
-                    T::Array[
-                      OpenAI::Realtime::RealtimeSessionCreateResponse::Audio::Input::TurnDetection::Eagerness::TaggedSymbol
-                    ]
+                  returns(
+                    T.nilable(
+                      OpenAI::Realtime::RealtimeSessionCreateResponse::Audio::Input::TurnDetection::SemanticVad::Eagerness::TaggedSymbol
+                    )
                   )
                 end
-                def self.values
+                attr_reader :eagerness
+
+                sig do
+                  params(
+                    eagerness:
+                      OpenAI::Realtime::RealtimeSessionCreateResponse::Audio::Input::TurnDetection::SemanticVad::Eagerness::OrSymbol
+                  ).void
                 end
-              end
+                attr_writer :eagerness
 
-              # Type of turn detection.
-              module Type
-                extend OpenAI::Internal::Type::Enum
+                # Whether or not to automatically interrupt any ongoing response with output to
+                # the default conversation (i.e. `conversation` of `auto`) when a VAD start event
+                # occurs.
+                sig { returns(T.nilable(T::Boolean)) }
+                attr_reader :interrupt_response
 
-                TaggedSymbol =
-                  T.type_alias do
-                    T.all(
-                      Symbol,
-                      OpenAI::Realtime::RealtimeSessionCreateResponse::Audio::Input::TurnDetection::Type
-                    )
-                  end
-                OrSymbol = T.type_alias { T.any(Symbol, String) }
+                sig { params(interrupt_response: T::Boolean).void }
+                attr_writer :interrupt_response
 
-                SERVER_VAD =
-                  T.let(
-                    :server_vad,
-                    OpenAI::Realtime::RealtimeSessionCreateResponse::Audio::Input::TurnDetection::Type::TaggedSymbol
-                  )
-                SEMANTIC_VAD =
-                  T.let(
-                    :semantic_vad,
-                    OpenAI::Realtime::RealtimeSessionCreateResponse::Audio::Input::TurnDetection::Type::TaggedSymbol
-                  )
+                # Server-side semantic turn detection which uses a model to determine when the
+                # user has finished speaking.
+                sig do
+                  params(
+                    create_response: T::Boolean,
+                    eagerness:
+                      OpenAI::Realtime::RealtimeSessionCreateResponse::Audio::Input::TurnDetection::SemanticVad::Eagerness::OrSymbol,
+                    interrupt_response: T::Boolean,
+                    type: Symbol
+                  ).returns(T.attached_class)
+                end
+                def self.new(
+                  # Whether or not to automatically generate a response when a VAD stop event
+                  # occurs.
+                  create_response: nil,
+                  # Used only for `semantic_vad` mode. The eagerness of the model to respond. `low`
+                  # will wait longer for the user to continue speaking, `high` will respond more
+                  # quickly. `auto` is the default and is equivalent to `medium`. `low`, `medium`,
+                  # and `high` have max timeouts of 8s, 4s, and 2s respectively.
+                  eagerness: nil,
+                  # Whether or not to automatically interrupt any ongoing response with output to
+                  # the default conversation (i.e. `conversation` of `auto`) when a VAD start event
+                  # occurs.
+                  interrupt_response: nil,
+                  # Type of turn detection, `semantic_vad` to turn on Semantic VAD.
+                  type: :semantic_vad
+                )
+                end
 
                 sig do
                   override.returns(
-                    T::Array[
-                      OpenAI::Realtime::RealtimeSessionCreateResponse::Audio::Input::TurnDetection::Type::TaggedSymbol
-                    ]
+                    {
+                      type: Symbol,
+                      create_response: T::Boolean,
+                      eagerness:
+                        OpenAI::Realtime::RealtimeSessionCreateResponse::Audio::Input::TurnDetection::SemanticVad::Eagerness::TaggedSymbol,
+                      interrupt_response: T::Boolean
+                    }
                   )
                 end
-                def self.values
+                def to_hash
+                end
+
+                # Used only for `semantic_vad` mode. The eagerness of the model to respond. `low`
+                # will wait longer for the user to continue speaking, `high` will respond more
+                # quickly. `auto` is the default and is equivalent to `medium`. `low`, `medium`,
+                # and `high` have max timeouts of 8s, 4s, and 2s respectively.
+                module Eagerness
+                  extend OpenAI::Internal::Type::Enum
+
+                  TaggedSymbol =
+                    T.type_alias do
+                      T.all(
+                        Symbol,
+                        OpenAI::Realtime::RealtimeSessionCreateResponse::Audio::Input::TurnDetection::SemanticVad::Eagerness
+                      )
+                    end
+                  OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+                  LOW =
+                    T.let(
+                      :low,
+                      OpenAI::Realtime::RealtimeSessionCreateResponse::Audio::Input::TurnDetection::SemanticVad::Eagerness::TaggedSymbol
+                    )
+                  MEDIUM =
+                    T.let(
+                      :medium,
+                      OpenAI::Realtime::RealtimeSessionCreateResponse::Audio::Input::TurnDetection::SemanticVad::Eagerness::TaggedSymbol
+                    )
+                  HIGH =
+                    T.let(
+                      :high,
+                      OpenAI::Realtime::RealtimeSessionCreateResponse::Audio::Input::TurnDetection::SemanticVad::Eagerness::TaggedSymbol
+                    )
+                  AUTO =
+                    T.let(
+                      :auto,
+                      OpenAI::Realtime::RealtimeSessionCreateResponse::Audio::Input::TurnDetection::SemanticVad::Eagerness::TaggedSymbol
+                    )
+
+                  sig do
+                    override.returns(
+                      T::Array[
+                        OpenAI::Realtime::RealtimeSessionCreateResponse::Audio::Input::TurnDetection::SemanticVad::Eagerness::TaggedSymbol
+                      ]
+                    )
+                  end
+                  def self.values
+                  end
                 end
               end
+
+              sig do
+                override.returns(
+                  T::Array[
+                    OpenAI::Realtime::RealtimeSessionCreateResponse::Audio::Input::TurnDetection::Variants
+                  ]
+                )
+              end
+              def self.variants
+              end
             end
           end