openai 0.91.0 → 0.93.0

data/sig/openai/models/realtime/log_prob_properties.rbs

@@ -5,12 +5,21 @@ module OpenAI
         { token: String, bytes: ::Array[Integer], logprob: Float }
 
       class LogProbProperties < OpenAI::Internal::Type::BaseModel
+        # The token that was used to generate the log probability.
         attr_accessor token: String
 
+        # The bytes that were used to generate the log probability.
         attr_accessor bytes: ::Array[Integer]
 
+        # The log probability of the token.
         attr_accessor logprob: Float
 
+        # @param token
+        #   The token that was used to generate the log probability.
+        # @param bytes
+        #   The bytes that were used to generate the log probability.
+        # @param logprob
+        #   The log probability of the token.
         def initialize: (
           token: String,
           bytes: ::Array[Integer],

data/sig/openai/models/realtime/mcp_list_tools_completed.rbs

@@ -9,12 +9,21 @@ module OpenAI
         }
 
       class McpListToolsCompleted < OpenAI::Internal::Type::BaseModel
+        # The unique ID of the server event.
         attr_accessor event_id: String
 
+        # The ID of the MCP list tools item.
         attr_accessor item_id: String
 
+        # The event type, must be `mcp_list_tools.completed`.
         attr_accessor type: :"mcp_list_tools.completed"
 
+        # @param event_id
+        #   The unique ID of the server event.
+        # @param item_id
+        #   The ID of the MCP list tools item.
+        # @param type
+        #   The event type, must be `mcp_list_tools.completed`.
         def initialize: (
           event_id: String,
           item_id: String,

data/sig/openai/models/realtime/mcp_list_tools_failed.rbs

@@ -5,12 +5,21 @@ module OpenAI
         { event_id: String, item_id: String, ?type: :"mcp_list_tools.failed" }
 
       class McpListToolsFailed < OpenAI::Internal::Type::BaseModel
+        # The unique ID of the server event.
         attr_accessor event_id: String
 
+        # The ID of the MCP list tools item.
         attr_accessor item_id: String
 
+        # The event type, must be `mcp_list_tools.failed`.
         attr_accessor type: :"mcp_list_tools.failed"
 
+        # @param event_id
+        #   The unique ID of the server event.
+        # @param item_id
+        #   The ID of the MCP list tools item.
+        # @param type
+        #   The event type, must be `mcp_list_tools.failed`.
         def initialize: (
           event_id: String,
           item_id: String,

data/sig/openai/models/realtime/mcp_list_tools_in_progress.rbs

@@ -9,12 +9,21 @@ module OpenAI
         }
 
       class McpListToolsInProgress < OpenAI::Internal::Type::BaseModel
+        # The unique ID of the server event.
         attr_accessor event_id: String
 
+        # The ID of the MCP list tools item.
         attr_accessor item_id: String
 
+        # The event type, must be `mcp_list_tools.in_progress`.
         attr_accessor type: :"mcp_list_tools.in_progress"
 
+        # @param event_id
+        #   The unique ID of the server event.
+        # @param item_id
+        #   The ID of the MCP list tools item.
+        # @param type
+        #   The event type, must be `mcp_list_tools.in_progress`.
         def initialize: (
           event_id: String,
           item_id: String,

data/sig/openai/models/realtime/output_audio_buffer_clear_event.rbs

@@ -5,12 +5,19 @@ module OpenAI
         { ?type: :"output_audio_buffer.clear", ?event_id: String }
 
       class OutputAudioBufferClearEvent < OpenAI::Internal::Type::BaseModel
+        # The event type, must be `output_audio_buffer.clear`.
         attr_accessor type: :"output_audio_buffer.clear"
 
+        # The unique ID of the client event used for error handling.
         attr_reader event_id: String?
 
+        # The unique ID of the client event used for error handling.
         def event_id=: (String) -> String
 
+        # @param event_id
+        #   The unique ID of the client event used for error handling.
+        # @param type
+        #   The event type, must be `output_audio_buffer.clear`.
         def initialize: (
           ?event_id: String,
           ?type: :"output_audio_buffer.clear"

data/sig/openai/models/realtime/rate_limits_updated_event.rbs

@@ -9,12 +9,21 @@ module OpenAI
         }
 
       class RateLimitsUpdatedEvent < OpenAI::Internal::Type::BaseModel
+        # The unique ID of the server event.
         attr_accessor event_id: String
 
+        # List of rate limit information.
         attr_accessor rate_limits: ::Array[OpenAI::Realtime::RateLimitsUpdatedEvent::RateLimit]
 
+        # The event type, must be `rate_limits.updated`.
         attr_accessor type: :"rate_limits.updated"
 
+        # @param event_id
+        #   The unique ID of the server event.
+        # @param rate_limits
+        #   List of rate limit information.
+        # @param type
+        #   The event type, must be `rate_limits.updated`.
         def initialize: (
           event_id: String,
           rate_limits: ::Array[OpenAI::Realtime::RateLimitsUpdatedEvent::RateLimit],
@@ -36,24 +45,40 @@ module OpenAI
           }
 
         class RateLimit < OpenAI::Internal::Type::BaseModel
+          # The maximum allowed value for the rate limit.
           attr_reader limit: Integer?
 
+          # The maximum allowed value for the rate limit.
           def limit=: (Integer) -> Integer
 
+          # The name of the rate limit (`requests`, `tokens`).
           attr_reader name: OpenAI::Models::Realtime::RateLimitsUpdatedEvent::RateLimit::name_?
 
+          # The name of the rate limit (`requests`, `tokens`).
           def name=: (
             OpenAI::Models::Realtime::RateLimitsUpdatedEvent::RateLimit::name_
           ) -> OpenAI::Models::Realtime::RateLimitsUpdatedEvent::RateLimit::name_
 
+          # The remaining value before the limit is reached.
           attr_reader remaining: Integer?
 
+          # The remaining value before the limit is reached.
           def remaining=: (Integer) -> Integer
 
+          # Seconds until the rate limit resets.
           attr_reader reset_seconds: Float?
 
+          # Seconds until the rate limit resets.
           def reset_seconds=: (Float) -> Float
 
+          # @param limit
+          #   The maximum allowed value for the rate limit.
+          # @param name
+          #   The name of the rate limit (`requests`, `tokens`).
+          # @param remaining
+          #   The remaining value before the limit is reached.
+          # @param reset_seconds
+          #   Seconds until the rate limit resets.
           def initialize: (
             ?limit: Integer,
             ?name: OpenAI::Models::Realtime::RateLimitsUpdatedEvent::RateLimit::name_,

data/sig/openai/models/realtime/realtime_audio_config_input.rbs

@@ -10,26 +10,104 @@ module OpenAI
         }
 
       class RealtimeAudioConfigInput < OpenAI::Internal::Type::BaseModel
+        # The format of the input audio.
         attr_reader format_: OpenAI::Models::Realtime::realtime_audio_formats?
 
+        # The format of the input audio.
         def format_=: (
           OpenAI::Models::Realtime::realtime_audio_formats
         ) -> OpenAI::Models::Realtime::realtime_audio_formats
 
+        # Configuration for input audio noise reduction. This can be set to `null` to turn
+        # off. Noise reduction filters audio added to the input audio buffer before it is
+        # sent to VAD and the model. Filtering the audio can improve VAD and turn
+        # detection accuracy (reducing false positives) and model performance by improving
+        # perception of the input audio.
         attr_reader noise_reduction: OpenAI::Realtime::RealtimeAudioConfigInput::NoiseReduction?
 
+        # Configuration for input audio noise reduction. This can be set to `null` to turn
+        # off. Noise reduction filters audio added to the input audio buffer before it is
+        # sent to VAD and the model. Filtering the audio can improve VAD and turn
+        # detection accuracy (reducing false positives) and model performance by improving
+        # perception of the input audio.
         def noise_reduction=: (
           OpenAI::Realtime::RealtimeAudioConfigInput::NoiseReduction
         ) -> OpenAI::Realtime::RealtimeAudioConfigInput::NoiseReduction
 
+        # Configuration for input audio transcription, defaults to off and can be set to
+        # `null` to turn off once on. Input audio transcription is not native to the
+        # model, since the model consumes audio directly. Transcription runs
+        # asynchronously through
+        # [the /audio/transcriptions endpoint](https://developers.openai.com/api/reference/resources/audio/subresources/transcriptions/methods/create)
+        # and should be treated as guidance of input audio content rather than precisely
+        # what the model heard. The client can optionally set the language and prompt for
+        # transcription, these offer additional guidance to the transcription service.
         attr_reader transcription: OpenAI::Realtime::AudioTranscription?
 
+        # Configuration for input audio transcription, defaults to off and can be set to
+        # `null` to turn off once on. Input audio transcription is not native to the
+        # model, since the model consumes audio directly. Transcription runs
+        # asynchronously through
+        # [the /audio/transcriptions endpoint](https://developers.openai.com/api/reference/resources/audio/subresources/transcriptions/methods/create)
+        # and should be treated as guidance of input audio content rather than precisely
+        # what the model heard. The client can optionally set the language and prompt for
+        # transcription, these offer additional guidance to the transcription service.
         def transcription=: (
           OpenAI::Realtime::AudioTranscription
         ) -> OpenAI::Realtime::AudioTranscription
 
+        # 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.
+        #
+        # For `gpt-realtime-whisper` transcription sessions, turn detection must be set to
+        # `null`; VAD is not supported.
         attr_accessor turn_detection: OpenAI::Models::Realtime::realtime_audio_input_turn_detection?
 
+        # @param format_
+        #   The format of the input audio.
+        # @param noise_reduction
+        #   Configuration for input audio noise reduction. This can be set to `null` to turn
+        #   off. Noise reduction filters audio added to the input audio buffer before it is
+        #   sent to VAD and the model. Filtering the audio can improve VAD and turn
+        #   detection accuracy (reducing false positives) and model performance by improving
+        #   perception of the input audio.
+        # @param transcription
+        #   Configuration for input audio transcription, defaults to off and can be set to
+        #   `null` to turn off once on. Input audio transcription is not native to the
+        #   model, since the model consumes audio directly. Transcription runs
+        #   asynchronously through
+        #   [the /audio/transcriptions endpoint](https://developers.openai.com/api/reference/resources/audio/subresources/transcriptions/methods/create)
+        #   and should be treated as guidance of input audio content rather than precisely
+        #   what the model heard. The client can optionally set the language and prompt for
+        #   transcription, these offer additional guidance to the transcription service.
+        # @param turn_detection
+        #   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.
+        #
+        #   For `gpt-realtime-whisper` transcription sessions, turn detection must be set to
+        #   `null`; VAD is not supported.
         def initialize: (
           ?format_: OpenAI::Models::Realtime::realtime_audio_formats,
           ?noise_reduction: OpenAI::Realtime::RealtimeAudioConfigInput::NoiseReduction,
@@ -48,12 +126,22 @@ module OpenAI
           { ?type: OpenAI::Models::Realtime::noise_reduction_type }
 
         class NoiseReduction < OpenAI::Internal::Type::BaseModel
+          # Type of noise reduction. `near_field` is for close-talking microphones such as
+          # headphones, `far_field` is for far-field microphones such as laptop or
+          # conference room microphones.
           attr_reader type: OpenAI::Models::Realtime::noise_reduction_type?
 
+          # Type of noise reduction. `near_field` is for close-talking microphones such as
+          # headphones, `far_field` is for far-field microphones such as laptop or
+          # conference room microphones.
           def type=: (
             OpenAI::Models::Realtime::noise_reduction_type
           ) -> OpenAI::Models::Realtime::noise_reduction_type
 
+          # @param type
+          #   Type of noise reduction. `near_field` is for close-talking microphones such as
+          #   headphones, `far_field` is for far-field microphones such as laptop or
+          #   conference room microphones.
           def initialize: (
             ?type: OpenAI::Models::Realtime::noise_reduction_type
           ) -> void

data/sig/openai/models/realtime/realtime_audio_config_output.rbs

@@ -9,22 +9,67 @@ module OpenAI
         }
 
       class RealtimeAudioConfigOutput < OpenAI::Internal::Type::BaseModel
+        # The format of the output audio.
         attr_reader format_: OpenAI::Models::Realtime::realtime_audio_formats?
 
+        # The format of the output audio.
         def format_=: (
           OpenAI::Models::Realtime::realtime_audio_formats
         ) -> OpenAI::Models::Realtime::realtime_audio_formats
 
+        # The speed of the model's spoken response as a multiple of the original speed.
+        # 1.0 is the default speed. 0.25 is the minimum speed. 1.5 is the maximum speed.
+        # This value can only be changed in between model turns, not while a response is
+        # in progress.
+        #
+        # This parameter is a post-processing adjustment to the audio after it is
+        # generated, it's also possible to prompt the model to speak faster or slower.
         attr_reader speed: Float?
 
+        # The speed of the model's spoken response as a multiple of the original speed.
+        # 1.0 is the default speed. 0.25 is the minimum speed. 1.5 is the maximum speed.
+        # This value can only be changed in between model turns, not while a response is
+        # in progress.
+        #
+        # This parameter is a post-processing adjustment to the audio after it is
+        # generated, it's also possible to prompt the model to speak faster or slower.
         def speed=: (Float) -> Float
 
+        # The voice the model uses to respond. Supported built-in voices are `alloy`,
+        # `ash`, `ballad`, `coral`, `echo`, `sage`, `shimmer`, `verse`, `marin`, and
+        # `cedar`. You may also provide a custom voice object with an `id`, for example
+        # `{ "id": "voice_1234" }`. Voice cannot be changed during the session once the
+        # model has responded with audio at least once. We recommend `marin` and `cedar`
+        # for best quality.
         attr_reader voice: OpenAI::Models::Realtime::RealtimeAudioConfigOutput::voice?
 
+        # The voice the model uses to respond. Supported built-in voices are `alloy`,
+        # `ash`, `ballad`, `coral`, `echo`, `sage`, `shimmer`, `verse`, `marin`, and
+        # `cedar`. You may also provide a custom voice object with an `id`, for example
+        # `{ "id": "voice_1234" }`. Voice cannot be changed during the session once the
+        # model has responded with audio at least once. We recommend `marin` and `cedar`
+        # for best quality.
         def voice=: (
           OpenAI::Models::Realtime::RealtimeAudioConfigOutput::voice
         ) -> OpenAI::Models::Realtime::RealtimeAudioConfigOutput::voice
 
+        # @param format_
+        #   The format of the output audio.
+        # @param speed
+        #   The speed of the model's spoken response as a multiple of the original speed.
+        #   1.0 is the default speed. 0.25 is the minimum speed. 1.5 is the maximum speed.
+        #   This value can only be changed in between model turns, not while a response is
+        #   in progress.
+        #
+        #   This parameter is a post-processing adjustment to the audio after it is
+        #   generated, it's also possible to prompt the model to speak faster or slower.
+        # @param voice
+        #   The voice the model uses to respond. Supported built-in voices are `alloy`,
+        #   `ash`, `ballad`, `coral`, `echo`, `sage`, `shimmer`, `verse`, `marin`, and
+        #   `cedar`. You may also provide a custom voice object with an `id`, for example
+        #   `{ "id": "voice_1234" }`. Voice cannot be changed during the session once the
+        #   model has responded with audio at least once. We recommend `marin` and `cedar`
+        #   for best quality.
         def initialize: (
           ?format_: OpenAI::Models::Realtime::realtime_audio_formats,
           ?speed: Float,
@@ -57,8 +102,11 @@ module OpenAI
           type id = { id: String }
 
           class ID < OpenAI::Internal::Type::BaseModel
+            # The custom voice ID, e.g. `voice_1234`.
             attr_accessor id: String
 
+            # @param id
+            #   The custom voice ID, e.g. `voice_1234`.
             def initialize: (id: String) -> void
 
             def to_hash: -> { id: String }

data/sig/openai/models/realtime/realtime_audio_formats.rbs

@@ -16,18 +16,26 @@ module OpenAI
           }
 
         class AudioPCM < OpenAI::Internal::Type::BaseModel
+          # The sample rate of the audio. Always `24000`.
           attr_reader rate: OpenAI::Models::Realtime::RealtimeAudioFormats::AudioPCM::rate?
 
+          # The sample rate of the audio. Always `24000`.
           def rate=: (
             OpenAI::Models::Realtime::RealtimeAudioFormats::AudioPCM::rate
           ) -> OpenAI::Models::Realtime::RealtimeAudioFormats::AudioPCM::rate
 
+          # The audio format. Always `audio/pcm`.
           attr_reader type: OpenAI::Models::Realtime::RealtimeAudioFormats::AudioPCM::type_?
 
+          # The audio format. Always `audio/pcm`.
           def type=: (
             OpenAI::Models::Realtime::RealtimeAudioFormats::AudioPCM::type_
           ) -> OpenAI::Models::Realtime::RealtimeAudioFormats::AudioPCM::type_
 
+          # @param rate
+          #   The sample rate of the audio. Always `24000`.
+          # @param type
+          #   The audio format. Always `audio/pcm`.
           def initialize: (
             ?rate: OpenAI::Models::Realtime::RealtimeAudioFormats::AudioPCM::rate,
             ?type: OpenAI::Models::Realtime::RealtimeAudioFormats::AudioPCM::type_
@@ -65,12 +73,16 @@ module OpenAI
           }
 
         class AudioPCMU < OpenAI::Internal::Type::BaseModel
+          # The audio format. Always `audio/pcmu`.
           attr_reader type: OpenAI::Models::Realtime::RealtimeAudioFormats::AudioPCMU::type_?
 
+          # The audio format. Always `audio/pcmu`.
           def type=: (
             OpenAI::Models::Realtime::RealtimeAudioFormats::AudioPCMU::type_
           ) -> OpenAI::Models::Realtime::RealtimeAudioFormats::AudioPCMU::type_
 
+          # @param type
+          #   The audio format. Always `audio/pcmu`.
           def initialize: (
             ?type: OpenAI::Models::Realtime::RealtimeAudioFormats::AudioPCMU::type_
           ) -> void
@@ -96,12 +108,16 @@ module OpenAI
           }
 
         class AudioPCMA < OpenAI::Internal::Type::BaseModel
+          # The audio format. Always `audio/pcma`.
           attr_reader type: OpenAI::Models::Realtime::RealtimeAudioFormats::AudioPCMA::type_?
 
+          # The audio format. Always `audio/pcma`.
           def type=: (
             OpenAI::Models::Realtime::RealtimeAudioFormats::AudioPCMA::type_
           ) -> OpenAI::Models::Realtime::RealtimeAudioFormats::AudioPCMA::type_
 
+          # @param type
+          #   The audio format. Always `audio/pcma`.
           def initialize: (
             ?type: OpenAI::Models::Realtime::RealtimeAudioFormats::AudioPCMA::type_
           ) -> void

data/sig/openai/models/realtime/realtime_audio_input_turn_detection.rbs

@@ -20,30 +20,126 @@ module OpenAI
           }
 
         class ServerVad < OpenAI::Internal::Type::BaseModel
+          # Type of turn detection, `server_vad` to turn on simple Server VAD.
           attr_accessor type: :server_vad
 
+          # Whether or not to automatically generate a response when a VAD stop event
+          # occurs. If `interrupt_response` is set to `false` this may fail to create a
+          # response if the model is already responding.
+          #
+          # If both `create_response` and `interrupt_response` are set to `false`, the model
+          # will never respond automatically but VAD events will still be emitted.
           attr_reader create_response: bool?
 
+          # Whether or not to automatically generate a response when a VAD stop event
+          # occurs. If `interrupt_response` is set to `false` this may fail to create a
+          # response if the model is already responding.
+          #
+          # If both `create_response` and `interrupt_response` are set to `false`, the model
+          # will never respond automatically but VAD events will still be emitted.
           def create_response=: (bool) -> bool
 
+          # 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.
           attr_accessor idle_timeout_ms: Integer?
 
+          # Whether or not to automatically interrupt (cancel) any ongoing response with
+          # output to the default conversation (i.e. `conversation` of `auto`) when a VAD
+          # start event occurs. If `true` then the response will be cancelled, otherwise it
+          # will continue until complete.
+          #
+          # If both `create_response` and `interrupt_response` are set to `false`, the model
+          # will never respond automatically but VAD events will still be emitted.
           attr_reader interrupt_response: bool?
 
+          # Whether or not to automatically interrupt (cancel) any ongoing response with
+          # output to the default conversation (i.e. `conversation` of `auto`) when a VAD
+          # start event occurs. If `true` then the response will be cancelled, otherwise it
+          # will continue until complete.
+          #
+          # If both `create_response` and `interrupt_response` are set to `false`, the model
+          # will never respond automatically but VAD events will still be emitted.
           def interrupt_response=: (bool) -> bool
 
+          # Used only for `server_vad` mode. Amount of audio to include before the VAD
+          # detected speech (in milliseconds). Defaults to 300ms.
           attr_reader prefix_padding_ms: Integer?
 
+          # Used only for `server_vad` mode. Amount of audio to include before the VAD
+          # detected speech (in milliseconds). Defaults to 300ms.
           def prefix_padding_ms=: (Integer) -> Integer
 
+          # 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.
           attr_reader silence_duration_ms: Integer?
 
+          # 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.
           def silence_duration_ms=: (Integer) -> Integer
 
+          # 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.
           attr_reader threshold: Float?
 
+          # 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.
           def threshold=: (Float) -> Float
 
+          # @param create_response
+          #   Whether or not to automatically generate a response when a VAD stop event
+          #   occurs. If `interrupt_response` is set to `false` this may fail to create a
+          #   response if the model is already responding.
+          #
+          #   If both `create_response` and `interrupt_response` are set to `false`, the model
+          #   will never respond automatically but VAD events will still be emitted.
+          # @param idle_timeout_ms
+          #   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.
+          # @param interrupt_response
+          #   Whether or not to automatically interrupt (cancel) any ongoing response with
+          #   output to the default conversation (i.e. `conversation` of `auto`) when a VAD
+          #   start event occurs. If `true` then the response will be cancelled, otherwise it
+          #   will continue until complete.
+          #
+          #   If both `create_response` and `interrupt_response` are set to `false`, the model
+          #   will never respond automatically but VAD events will still be emitted.
+          # @param prefix_padding_ms
+          #   Used only for `server_vad` mode. Amount of audio to include before the VAD
+          #   detected speech (in milliseconds). Defaults to 300ms.
+          # @param silence_duration_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.
+          # @param threshold
+          #   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.
+          # @param type
+          #   Type of turn detection, `server_vad` to turn on simple Server VAD.
           def initialize: (
             ?create_response: bool,
             ?idle_timeout_ms: Integer?,
@@ -74,22 +170,55 @@ module OpenAI
           }
 
         class SemanticVad < OpenAI::Internal::Type::BaseModel
+          # Type of turn detection, `semantic_vad` to turn on Semantic VAD.
           attr_accessor type: :semantic_vad
 
+          # Whether or not to automatically generate a response when a VAD stop event
+          # occurs.
           attr_reader create_response: bool?
 
+          # Whether or not to automatically generate a response when a VAD stop event
+          # occurs.
           def create_response=: (bool) -> bool
 
+          # 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.
           attr_reader eagerness: OpenAI::Models::Realtime::RealtimeAudioInputTurnDetection::SemanticVad::eagerness?
 
+          # 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.
           def eagerness=: (
             OpenAI::Models::Realtime::RealtimeAudioInputTurnDetection::SemanticVad::eagerness
           ) -> OpenAI::Models::Realtime::RealtimeAudioInputTurnDetection::SemanticVad::eagerness
 
+          # 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.
           attr_reader interrupt_response: bool?
 
+          # 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.
           def interrupt_response=: (bool) -> bool
 
+          # @param create_response
+          #   Whether or not to automatically generate a response when a VAD stop event
+          #   occurs.
+          # @param eagerness
+          #   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.
+          # @param interrupt_response
+          #   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.
+          # @param type
+          #   Type of turn detection, `semantic_vad` to turn on Semantic VAD.
           def initialize: (
             ?create_response: bool,
             ?eagerness: OpenAI::Models::Realtime::RealtimeAudioInputTurnDetection::SemanticVad::eagerness,