openai 0.61.0 → 0.63.0

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

data/rbi/openai/models/realtime/realtime_translation_output_transcript_delta_event.rbi

@@ -0,0 +1,76 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    module Realtime
+      class RealtimeTranslationOutputTranscriptDeltaEvent < OpenAI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              OpenAI::Realtime::RealtimeTranslationOutputTranscriptDeltaEvent,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+        # Append-only transcript text for the translated output audio.
+        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_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 translated transcript text is available.
+        #
+        # 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 transcript text for the translated output audio.
+          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.output_transcript.delta`.
+          type: :"session.output_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_server_event.rbi

@@ -0,0 +1,33 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    module Realtime
+      # A Realtime translation server event.
+      module RealtimeTranslationServerEvent
+        extend OpenAI::Internal::Type::Union
+
+        Variants =
+          T.type_alias do
+            T.any(
+              OpenAI::Realtime::RealtimeErrorEvent,
+              OpenAI::Realtime::RealtimeTranslationSessionCreatedEvent,
+              OpenAI::Realtime::RealtimeTranslationSessionUpdatedEvent,
+              OpenAI::Realtime::RealtimeTranslationSessionClosedEvent,
+              OpenAI::Realtime::RealtimeTranslationInputTranscriptDeltaEvent,
+              OpenAI::Realtime::RealtimeTranslationOutputTranscriptDeltaEvent,
+              OpenAI::Realtime::RealtimeTranslationOutputAudioDeltaEvent
+            )
+          end
+
+        sig do
+          override.returns(
+            T::Array[OpenAI::Realtime::RealtimeTranslationServerEvent::Variants]
+          )
+        end
+        def self.variants
+        end
+      end
+    end
+  end
+end