openai 0.61.0 → 0.62.0

data/rbi/openai/models/realtime/realtime_transcription_session_audio_input.rbi

@@ -91,6 +91,9 @@ module OpenAI
         # 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.
         sig do
           returns(
             T.nilable(
@@ -154,6 +157,9 @@ module OpenAI
           # 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.
           turn_detection: nil
         )
         end

data/rbi/openai/models/realtime/realtime_transcription_session_audio_input_turn_detection.rbi

@@ -16,6 +16,9 @@ module OpenAI
       # 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.
       module RealtimeTranscriptionSessionAudioInputTurnDetection
         extend OpenAI::Internal::Type::Union
 

data/rbi/openai/models/realtime/realtime_transcription_session_create_response.rbi

@@ -224,7 +224,6 @@ module OpenAI
             end
             attr_writer :noise_reduction
 
-            # Configuration of the transcription model.
             sig { returns(T.nilable(OpenAI::Realtime::AudioTranscription)) }
             attr_reader :transcription
 
@@ -237,7 +236,8 @@ module OpenAI
 
             # Configuration for turn detection. Can be set to `null` to turn off. 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.
+            # volume and respond at the end of user speech. For `gpt-realtime-whisper`, this
+            # must be `null`; VAD is not supported.
             sig do
               returns(
                 T.nilable(
@@ -250,7 +250,9 @@ module OpenAI
             sig do
               params(
                 turn_detection:
-                  OpenAI::Realtime::RealtimeTranscriptionSessionTurnDetection::OrHash
+                  T.nilable(
+                    OpenAI::Realtime::RealtimeTranscriptionSessionTurnDetection::OrHash
+                  )
               ).void
             end
             attr_writer :turn_detection
@@ -267,7 +269,9 @@ module OpenAI
                   OpenAI::Realtime::RealtimeTranscriptionSessionCreateResponse::Audio::Input::NoiseReduction::OrHash,
                 transcription: OpenAI::Realtime::AudioTranscription::OrHash,
                 turn_detection:
-                  OpenAI::Realtime::RealtimeTranscriptionSessionTurnDetection::OrHash
+                  T.nilable(
+                    OpenAI::Realtime::RealtimeTranscriptionSessionTurnDetection::OrHash
+                  )
               ).returns(T.attached_class)
             end
             def self.new(
@@ -275,11 +279,11 @@ module OpenAI
               format_: nil,
               # Configuration for input audio noise reduction.
               noise_reduction: nil,
-              # Configuration of the transcription model.
               transcription: nil,
               # Configuration for turn detection. Can be set to `null` to turn off. 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.
+              # volume and respond at the end of user speech. For `gpt-realtime-whisper`, this
+              # must be `null`; VAD is not supported.
               turn_detection: nil
             )
             end
@@ -292,7 +296,9 @@ module OpenAI
                     OpenAI::Realtime::RealtimeTranscriptionSessionCreateResponse::Audio::Input::NoiseReduction,
                   transcription: OpenAI::Realtime::AudioTranscription,
                   turn_detection:
-                    OpenAI::Realtime::RealtimeTranscriptionSessionTurnDetection
+                    T.nilable(
+                      OpenAI::Realtime::RealtimeTranscriptionSessionTurnDetection
+                    )
                 }
               )
             end

data/rbi/openai/models/realtime/realtime_transcription_session_turn_detection.rbi

@@ -50,7 +50,8 @@ module OpenAI
 
         # Configuration for turn detection. Can be set to `null` to turn off. 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.
+        # volume and respond at the end of user speech. For `gpt-realtime-whisper`, this
+        # must be `null`; VAD is not supported.
         sig do
           params(
             prefix_padding_ms: Integer,

data/rbi/openai/models/realtime/realtime_translation_client_event.rbi

@@ -0,0 +1,29 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    module Realtime
+      # A Realtime translation client event.
+      module RealtimeTranslationClientEvent
+        extend OpenAI::Internal::Type::Union
+
+        Variants =
+          T.type_alias do
+            T.any(
+              OpenAI::Realtime::RealtimeTranslationSessionUpdateEvent,
+              OpenAI::Realtime::RealtimeTranslationInputAudioBufferAppendEvent,
+              OpenAI::Realtime::RealtimeTranslationSessionCloseEvent
+            )
+          end
+
+        sig do
+          override.returns(
+            T::Array[OpenAI::Realtime::RealtimeTranslationClientEvent::Variants]
+          )
+        end
+        def self.variants
+        end
+      end
+    end
+  end
+end

data/rbi/openai/models/realtime/realtime_translation_client_secret_create_request.rbi

@@ -0,0 +1,193 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    module Realtime
+      class RealtimeTranslationClientSecretCreateRequest < OpenAI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              OpenAI::Realtime::RealtimeTranslationClientSecretCreateRequest,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+        # Realtime translation session configuration. Translation sessions stream source
+        # audio in and translated audio plus transcript deltas out continuously.
+        sig do
+          returns(OpenAI::Realtime::RealtimeTranslationSessionCreateRequest)
+        end
+        attr_reader :session
+
+        sig do
+          params(
+            session:
+              OpenAI::Realtime::RealtimeTranslationSessionCreateRequest::OrHash
+          ).void
+        end
+        attr_writer :session
+
+        # Configuration for the client secret expiration. Expiration refers to the time
+        # after which a client secret will no longer be valid for creating sessions. The
+        # session itself may continue after that time once started. A secret can be used
+        # to create multiple sessions until it expires.
+        sig do
+          returns(
+            T.nilable(
+              OpenAI::Realtime::RealtimeTranslationClientSecretCreateRequest::ExpiresAfter
+            )
+          )
+        end
+        attr_reader :expires_after
+
+        sig do
+          params(
+            expires_after:
+              OpenAI::Realtime::RealtimeTranslationClientSecretCreateRequest::ExpiresAfter::OrHash
+          ).void
+        end
+        attr_writer :expires_after
+
+        # Create a translation session and client secret for the Realtime API.
+        sig do
+          params(
+            session:
+              OpenAI::Realtime::RealtimeTranslationSessionCreateRequest::OrHash,
+            expires_after:
+              OpenAI::Realtime::RealtimeTranslationClientSecretCreateRequest::ExpiresAfter::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Realtime translation session configuration. Translation sessions stream source
+          # audio in and translated audio plus transcript deltas out continuously.
+          session:,
+          # Configuration for the client secret expiration. Expiration refers to the time
+          # after which a client secret will no longer be valid for creating sessions. The
+          # session itself may continue after that time once started. A secret can be used
+          # to create multiple sessions until it expires.
+          expires_after: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              session:
+                OpenAI::Realtime::RealtimeTranslationSessionCreateRequest,
+              expires_after:
+                OpenAI::Realtime::RealtimeTranslationClientSecretCreateRequest::ExpiresAfter
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class ExpiresAfter < OpenAI::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                OpenAI::Realtime::RealtimeTranslationClientSecretCreateRequest::ExpiresAfter,
+                OpenAI::Internal::AnyHash
+              )
+            end
+
+          # The anchor point for the client secret expiration, meaning that `seconds` will
+          # be added to the `created_at` time of the client secret to produce an expiration
+          # timestamp. Only `created_at` is currently supported.
+          sig do
+            returns(
+              T.nilable(
+                OpenAI::Realtime::RealtimeTranslationClientSecretCreateRequest::ExpiresAfter::Anchor::OrSymbol
+              )
+            )
+          end
+          attr_reader :anchor
+
+          sig do
+            params(
+              anchor:
+                OpenAI::Realtime::RealtimeTranslationClientSecretCreateRequest::ExpiresAfter::Anchor::OrSymbol
+            ).void
+          end
+          attr_writer :anchor
+
+          # The number of seconds from the anchor point to the expiration. Select a value
+          # between `10` and `7200` (2 hours). This default to 600 seconds (10 minutes) if
+          # not specified.
+          sig { returns(T.nilable(Integer)) }
+          attr_reader :seconds
+
+          sig { params(seconds: Integer).void }
+          attr_writer :seconds
+
+          # Configuration for the client secret expiration. Expiration refers to the time
+          # after which a client secret will no longer be valid for creating sessions. The
+          # session itself may continue after that time once started. A secret can be used
+          # to create multiple sessions until it expires.
+          sig do
+            params(
+              anchor:
+                OpenAI::Realtime::RealtimeTranslationClientSecretCreateRequest::ExpiresAfter::Anchor::OrSymbol,
+              seconds: Integer
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # The anchor point for the client secret expiration, meaning that `seconds` will
+            # be added to the `created_at` time of the client secret to produce an expiration
+            # timestamp. Only `created_at` is currently supported.
+            anchor: nil,
+            # The number of seconds from the anchor point to the expiration. Select a value
+            # between `10` and `7200` (2 hours). This default to 600 seconds (10 minutes) if
+            # not specified.
+            seconds: nil
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                anchor:
+                  OpenAI::Realtime::RealtimeTranslationClientSecretCreateRequest::ExpiresAfter::Anchor::OrSymbol,
+                seconds: Integer
+              }
+            )
+          end
+          def to_hash
+          end
+
+          # The anchor point for the client secret expiration, meaning that `seconds` will
+          # be added to the `created_at` time of the client secret to produce an expiration
+          # timestamp. Only `created_at` is currently supported.
+          module Anchor
+            extend OpenAI::Internal::Type::Enum
+
+            TaggedSymbol =
+              T.type_alias do
+                T.all(
+                  Symbol,
+                  OpenAI::Realtime::RealtimeTranslationClientSecretCreateRequest::ExpiresAfter::Anchor
+                )
+              end
+            OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+            CREATED_AT =
+              T.let(
+                :created_at,
+                OpenAI::Realtime::RealtimeTranslationClientSecretCreateRequest::ExpiresAfter::Anchor::TaggedSymbol
+              )
+
+            sig do
+              override.returns(
+                T::Array[
+                  OpenAI::Realtime::RealtimeTranslationClientSecretCreateRequest::ExpiresAfter::Anchor::TaggedSymbol
+                ]
+              )
+            end
+            def self.values
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/openai/models/realtime/realtime_translation_client_secret_create_response.rbi

@@ -0,0 +1,69 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    module Realtime
+      class RealtimeTranslationClientSecretCreateResponse < OpenAI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              OpenAI::Realtime::RealtimeTranslationClientSecretCreateResponse,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+        # Expiration timestamp for the client secret, in seconds since epoch.
+        sig { returns(Integer) }
+        attr_accessor :expires_at
+
+        # A Realtime translation session. Translation sessions continuously translate
+        # input audio into the configured output language.
+        sig { returns(OpenAI::Realtime::RealtimeTranslationSession) }
+        attr_reader :session
+
+        sig do
+          params(
+            session: OpenAI::Realtime::RealtimeTranslationSession::OrHash
+          ).void
+        end
+        attr_writer :session
+
+        # The generated client secret value.
+        sig { returns(String) }
+        attr_accessor :value
+
+        # Response from creating a translation session and client secret for the Realtime
+        # API.
+        sig do
+          params(
+            expires_at: Integer,
+            session: OpenAI::Realtime::RealtimeTranslationSession::OrHash,
+            value: String
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Expiration timestamp for the client secret, in seconds since epoch.
+          expires_at:,
+          # A Realtime translation session. Translation sessions continuously translate
+          # input audio into the configured output language.
+          session:,
+          # The generated client secret value.
+          value:
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              expires_at: Integer,
+              session: OpenAI::Realtime::RealtimeTranslationSession,
+              value: String
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/openai/models/realtime/realtime_translation_input_audio_buffer_append_event.rbi

@@ -0,0 +1,69 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    module Realtime
+      class RealtimeTranslationInputAudioBufferAppendEvent < OpenAI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              OpenAI::Realtime::RealtimeTranslationInputAudioBufferAppendEvent,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+        # Base64-encoded 24 kHz PCM16 mono audio bytes.
+        sig { returns(String) }
+        attr_accessor :audio
+
+        # The event type, must be `session.input_audio_buffer.append`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # Optional client-generated ID used to identify this event.
+        sig { returns(T.nilable(String)) }
+        attr_reader :event_id
+
+        sig { params(event_id: String).void }
+        attr_writer :event_id
+
+        # Send this event to append audio bytes to the translation session input audio
+        # buffer.
+        #
+        # WebSocket translation sessions accept base64-encoded 24 kHz PCM16 mono
+        # little-endian raw audio bytes. Unsupported websocket audio formats return a
+        # validation error because lower-quality audio materially degrades translation
+        # quality.
+        #
+        # Translation consumes 200 ms engine frames. For best realtime behavior, append
+        # audio in 200 ms chunks. If a chunk is shorter, the server buffers it until it
+        # has enough audio for one frame. If a chunk is longer, the server splits it into
+        # 200 ms frames and enqueues them back-to-back.
+        #
+        # Keep appending silence while the session is active. If a client stops sending
+        # audio and later resumes, model time treats the resumed audio as contiguous with
+        # the previous audio rather than as a real-world pause.
+        sig do
+          params(audio: String, event_id: String, type: Symbol).returns(
+            T.attached_class
+          )
+        end
+        def self.new(
+          # Base64-encoded 24 kHz PCM16 mono audio bytes.
+          audio:,
+          # Optional client-generated ID used to identify this event.
+          event_id: nil,
+          # The event type, must be `session.input_audio_buffer.append`.
+          type: :"session.input_audio_buffer.append"
+        )
+        end
+
+        sig do
+          override.returns({ audio: String, type: Symbol, event_id: String })
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/openai/models/realtime/realtime_translation_input_transcript_delta_event.rbi

@@ -0,0 +1,77 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    module Realtime
+      class RealtimeTranslationInputTranscriptDeltaEvent < OpenAI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              OpenAI::Realtime::RealtimeTranslationInputTranscriptDeltaEvent,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+        # Append-only source-language transcript text.
+        sig { returns(String) }
+        attr_accessor :delta
+
+        # The unique ID of the server event.
+        sig { returns(String) }
+        attr_accessor :event_id
+
+        # The event type, must be `session.input_transcript.delta`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # Timing metadata for stream alignment, derived from the translation frame when
+        # available. It advances in 200 ms increments, but multiple transcript deltas may
+        # share the same `elapsed_ms`. Treat it as alignment metadata, not a unique
+        # transcript-delta identifier.
+        sig { returns(T.nilable(Integer)) }
+        attr_accessor :elapsed_ms
+
+        # Returned when optional source-language transcript text is available. This event
+        # is emitted only when `audio.input.transcription` is configured.
+        #
+        # Transcript deltas are append-only text fragments. Clients should not insert
+        # unconditional spaces between deltas.
+        sig do
+          params(
+            delta: String,
+            event_id: String,
+            elapsed_ms: T.nilable(Integer),
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Append-only source-language transcript text.
+          delta:,
+          # The unique ID of the server event.
+          event_id:,
+          # Timing metadata for stream alignment, derived from the translation frame when
+          # available. It advances in 200 ms increments, but multiple transcript deltas may
+          # share the same `elapsed_ms`. Treat it as alignment metadata, not a unique
+          # transcript-delta identifier.
+          elapsed_ms: nil,
+          # The event type, must be `session.input_transcript.delta`.
+          type: :"session.input_transcript.delta"
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              delta: String,
+              event_id: String,
+              type: Symbol,
+              elapsed_ms: T.nilable(Integer)
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/openai/models/realtime/realtime_translation_output_audio_delta_event.rbi

@@ -0,0 +1,148 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    module Realtime
+      class RealtimeTranslationOutputAudioDeltaEvent < OpenAI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              OpenAI::Realtime::RealtimeTranslationOutputAudioDeltaEvent,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+        # Base64-encoded translated audio data.
+        sig { returns(String) }
+        attr_accessor :delta
+
+        # The unique ID of the server event.
+        sig { returns(String) }
+        attr_accessor :event_id
+
+        # The event type, must be `session.output_audio.delta`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # Number of audio channels.
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :channels
+
+        sig { params(channels: Integer).void }
+        attr_writer :channels
+
+        # Timing metadata for stream alignment, derived from the translation frame when
+        # available. Treat `elapsed_ms` as alignment metadata, not a unique event
+        # identifier.
+        sig { returns(T.nilable(Integer)) }
+        attr_accessor :elapsed_ms
+
+        # Audio encoding for `delta`.
+        sig do
+          returns(
+            T.nilable(
+              OpenAI::Realtime::RealtimeTranslationOutputAudioDeltaEvent::Format::OrSymbol
+            )
+          )
+        end
+        attr_reader :format_
+
+        sig do
+          params(
+            format_:
+              OpenAI::Realtime::RealtimeTranslationOutputAudioDeltaEvent::Format::OrSymbol
+          ).void
+        end
+        attr_writer :format_
+
+        # Sample rate of the audio delta.
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :sample_rate
+
+        sig { params(sample_rate: Integer).void }
+        attr_writer :sample_rate
+
+        # Returned when translated output audio is available. Output audio deltas are 200
+        # ms frames of PCM16 audio.
+        sig do
+          params(
+            delta: String,
+            event_id: String,
+            channels: Integer,
+            elapsed_ms: T.nilable(Integer),
+            format_:
+              OpenAI::Realtime::RealtimeTranslationOutputAudioDeltaEvent::Format::OrSymbol,
+            sample_rate: Integer,
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Base64-encoded translated audio data.
+          delta:,
+          # The unique ID of the server event.
+          event_id:,
+          # Number of audio channels.
+          channels: nil,
+          # Timing metadata for stream alignment, derived from the translation frame when
+          # available. Treat `elapsed_ms` as alignment metadata, not a unique event
+          # identifier.
+          elapsed_ms: nil,
+          # Audio encoding for `delta`.
+          format_: nil,
+          # Sample rate of the audio delta.
+          sample_rate: nil,
+          # The event type, must be `session.output_audio.delta`.
+          type: :"session.output_audio.delta"
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              delta: String,
+              event_id: String,
+              type: Symbol,
+              channels: Integer,
+              elapsed_ms: T.nilable(Integer),
+              format_:
+                OpenAI::Realtime::RealtimeTranslationOutputAudioDeltaEvent::Format::OrSymbol,
+              sample_rate: Integer
+            }
+          )
+        end
+        def to_hash
+        end
+
+        # Audio encoding for `delta`.
+        module Format
+          extend OpenAI::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(
+                Symbol,
+                OpenAI::Realtime::RealtimeTranslationOutputAudioDeltaEvent::Format
+              )
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          PCM16 =
+            T.let(
+              :pcm16,
+              OpenAI::Realtime::RealtimeTranslationOutputAudioDeltaEvent::Format::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                OpenAI::Realtime::RealtimeTranslationOutputAudioDeltaEvent::Format::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end