openai 0.60.0 → 0.62.0

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

data/rbi/openai/models/realtime/realtime_translation_session.rbi

@@ -0,0 +1,339 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    module Realtime
+      class RealtimeTranslationSession < OpenAI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              OpenAI::Realtime::RealtimeTranslationSession,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+        # Unique identifier for the session that looks like `sess_1234567890abcdef`.
+        sig { returns(String) }
+        attr_accessor :id
+
+        # Configuration for translation input and output audio.
+        sig { returns(OpenAI::Realtime::RealtimeTranslationSession::Audio) }
+        attr_reader :audio
+
+        sig do
+          params(
+            audio: OpenAI::Realtime::RealtimeTranslationSession::Audio::OrHash
+          ).void
+        end
+        attr_writer :audio
+
+        # Expiration timestamp for the session, in seconds since epoch.
+        sig { returns(Integer) }
+        attr_accessor :expires_at
+
+        # The Realtime translation model used for this session. This field is set at
+        # session creation and cannot be changed with `session.update`.
+        sig { returns(String) }
+        attr_accessor :model
+
+        # The session type. Always `translation` for Realtime translation sessions.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # A Realtime translation session. Translation sessions continuously translate
+        # input audio into the configured output language.
+        sig do
+          params(
+            id: String,
+            audio: OpenAI::Realtime::RealtimeTranslationSession::Audio::OrHash,
+            expires_at: Integer,
+            model: String,
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Unique identifier for the session that looks like `sess_1234567890abcdef`.
+          id:,
+          # Configuration for translation input and output audio.
+          audio:,
+          # Expiration timestamp for the session, in seconds since epoch.
+          expires_at:,
+          # The Realtime translation model used for this session. This field is set at
+          # session creation and cannot be changed with `session.update`.
+          model:,
+          # The session type. Always `translation` for Realtime translation sessions.
+          type: :translation
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              id: String,
+              audio: OpenAI::Realtime::RealtimeTranslationSession::Audio,
+              expires_at: Integer,
+              model: String,
+              type: Symbol
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class Audio < OpenAI::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                OpenAI::Realtime::RealtimeTranslationSession::Audio,
+                OpenAI::Internal::AnyHash
+              )
+            end
+
+          sig do
+            returns(
+              T.nilable(
+                OpenAI::Realtime::RealtimeTranslationSession::Audio::Input
+              )
+            )
+          end
+          attr_reader :input
+
+          sig do
+            params(
+              input:
+                OpenAI::Realtime::RealtimeTranslationSession::Audio::Input::OrHash
+            ).void
+          end
+          attr_writer :input
+
+          sig do
+            returns(
+              T.nilable(
+                OpenAI::Realtime::RealtimeTranslationSession::Audio::Output
+              )
+            )
+          end
+          attr_reader :output
+
+          sig do
+            params(
+              output:
+                OpenAI::Realtime::RealtimeTranslationSession::Audio::Output::OrHash
+            ).void
+          end
+          attr_writer :output
+
+          # Configuration for translation input and output audio.
+          sig do
+            params(
+              input:
+                OpenAI::Realtime::RealtimeTranslationSession::Audio::Input::OrHash,
+              output:
+                OpenAI::Realtime::RealtimeTranslationSession::Audio::Output::OrHash
+            ).returns(T.attached_class)
+          end
+          def self.new(input: nil, output: nil)
+          end
+
+          sig do
+            override.returns(
+              {
+                input:
+                  OpenAI::Realtime::RealtimeTranslationSession::Audio::Input,
+                output:
+                  OpenAI::Realtime::RealtimeTranslationSession::Audio::Output
+              }
+            )
+          end
+          def to_hash
+          end
+
+          class Input < OpenAI::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  OpenAI::Realtime::RealtimeTranslationSession::Audio::Input,
+                  OpenAI::Internal::AnyHash
+                )
+              end
+
+            # Optional input noise reduction.
+            sig do
+              returns(
+                T.nilable(
+                  OpenAI::Realtime::RealtimeTranslationSession::Audio::Input::NoiseReduction
+                )
+              )
+            end
+            attr_reader :noise_reduction
+
+            sig do
+              params(
+                noise_reduction:
+                  T.nilable(
+                    OpenAI::Realtime::RealtimeTranslationSession::Audio::Input::NoiseReduction::OrHash
+                  )
+              ).void
+            end
+            attr_writer :noise_reduction
+
+            # Optional source-language transcription. When configured, the server emits
+            # `session.input_transcript.delta` events. Translation itself still runs from the
+            # input audio stream.
+            sig do
+              returns(
+                T.nilable(
+                  OpenAI::Realtime::RealtimeTranslationSession::Audio::Input::Transcription
+                )
+              )
+            end
+            attr_reader :transcription
+
+            sig do
+              params(
+                transcription:
+                  T.nilable(
+                    OpenAI::Realtime::RealtimeTranslationSession::Audio::Input::Transcription::OrHash
+                  )
+              ).void
+            end
+            attr_writer :transcription
+
+            sig do
+              params(
+                noise_reduction:
+                  T.nilable(
+                    OpenAI::Realtime::RealtimeTranslationSession::Audio::Input::NoiseReduction::OrHash
+                  ),
+                transcription:
+                  T.nilable(
+                    OpenAI::Realtime::RealtimeTranslationSession::Audio::Input::Transcription::OrHash
+                  )
+              ).returns(T.attached_class)
+            end
+            def self.new(
+              # Optional input noise reduction.
+              noise_reduction: nil,
+              # Optional source-language transcription. When configured, the server emits
+              # `session.input_transcript.delta` events. Translation itself still runs from the
+              # input audio stream.
+              transcription: nil
+            )
+            end
+
+            sig do
+              override.returns(
+                {
+                  noise_reduction:
+                    T.nilable(
+                      OpenAI::Realtime::RealtimeTranslationSession::Audio::Input::NoiseReduction
+                    ),
+                  transcription:
+                    T.nilable(
+                      OpenAI::Realtime::RealtimeTranslationSession::Audio::Input::Transcription
+                    )
+                }
+              )
+            end
+            def to_hash
+            end
+
+            class NoiseReduction < OpenAI::Internal::Type::BaseModel
+              OrHash =
+                T.type_alias do
+                  T.any(
+                    OpenAI::Realtime::RealtimeTranslationSession::Audio::Input::NoiseReduction,
+                    OpenAI::Internal::AnyHash
+                  )
+                end
+
+              # 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.
+              sig { returns(OpenAI::Realtime::NoiseReductionType::OrSymbol) }
+              attr_accessor :type
+
+              # Optional input noise reduction.
+              sig do
+                params(
+                  type: OpenAI::Realtime::NoiseReductionType::OrSymbol
+                ).returns(T.attached_class)
+              end
+              def self.new(
+                # 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.
+                type:
+              )
+              end
+
+              sig do
+                override.returns(
+                  { type: OpenAI::Realtime::NoiseReductionType::OrSymbol }
+                )
+              end
+              def to_hash
+              end
+            end
+
+            class Transcription < OpenAI::Internal::Type::BaseModel
+              OrHash =
+                T.type_alias do
+                  T.any(
+                    OpenAI::Realtime::RealtimeTranslationSession::Audio::Input::Transcription,
+                    OpenAI::Internal::AnyHash
+                  )
+                end
+
+              # The transcription model used for source transcript deltas.
+              sig { returns(String) }
+              attr_accessor :model
+
+              # Optional source-language transcription. When configured, the server emits
+              # `session.input_transcript.delta` events. Translation itself still runs from the
+              # input audio stream.
+              sig { params(model: String).returns(T.attached_class) }
+              def self.new(
+                # The transcription model used for source transcript deltas.
+                model:
+              )
+              end
+
+              sig { override.returns({ model: String }) }
+              def to_hash
+              end
+            end
+          end
+
+          class Output < OpenAI::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  OpenAI::Realtime::RealtimeTranslationSession::Audio::Output,
+                  OpenAI::Internal::AnyHash
+                )
+              end
+
+            # Target language for translated output audio and transcript deltas.
+            sig { returns(T.nilable(String)) }
+            attr_reader :language
+
+            sig { params(language: String).void }
+            attr_writer :language
+
+            sig { params(language: String).returns(T.attached_class) }
+            def self.new(
+              # Target language for translated output audio and transcript deltas.
+              language: nil
+            )
+            end
+
+            sig { override.returns({ language: String }) }
+            def to_hash
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/openai/models/realtime/realtime_translation_session_close_event.rbi

@@ -0,0 +1,44 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    module Realtime
+      class RealtimeTranslationSessionCloseEvent < OpenAI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              OpenAI::Realtime::RealtimeTranslationSessionCloseEvent,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+        # The event type, must be `session.close`.
+        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
+
+        # Gracefully close the realtime translation session. The server flushes pending
+        # input audio and emits any remaining translated output before closing the
+        # session.
+        sig { params(event_id: String, type: Symbol).returns(T.attached_class) }
+        def self.new(
+          # Optional client-generated ID used to identify this event.
+          event_id: nil,
+          # The event type, must be `session.close`.
+          type: :"session.close"
+        )
+        end
+
+        sig { override.returns({ type: Symbol, event_id: String }) }
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/openai/models/realtime/realtime_translation_session_closed_event.rbi

@@ -0,0 +1,39 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    module Realtime
+      class RealtimeTranslationSessionClosedEvent < OpenAI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              OpenAI::Realtime::RealtimeTranslationSessionClosedEvent,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+        # The unique ID of the server event.
+        sig { returns(String) }
+        attr_accessor :event_id
+
+        # The event type, must be `session.closed`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # Returned when a realtime translation session is closed.
+        sig { params(event_id: String, type: Symbol).returns(T.attached_class) }
+        def self.new(
+          # The unique ID of the server event.
+          event_id:,
+          # The event type, must be `session.closed`.
+          type: :"session.closed"
+        )
+        end
+
+        sig { override.returns({ event_id: String, type: Symbol }) }
+        def to_hash
+        end
+      end
+    end
+  end
+end