openai 0.88.0 → 0.89.0

data/rbi/openai/models/live/fork_server_event.rbi

@@ -0,0 +1,436 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Live
+
+      # Server events for Live. Response lifecycle events are wrapped inside
+      # response.event; dispatch the nested event by its full type and tolerate new
+      # response event types. Follow the
+      # [Live prompting guide](https://developers.openai.com/api/docs/guides/live-prompting)
+      # when designing the conversation and delegation policy.
+      module ForkServerEvent
+        extend OpenAI::Internal::Type::Union
+
+        Variants = T.type_alias do
+          T.any(
+            OpenAI::Live::SessionStartedEvent,
+            OpenAI::Live::SessionUpdatedEvent,
+            OpenAI::Live::InputAudioMutedEvent,
+            OpenAI::Live::InputAudioUnmutedEvent,
+            OpenAI::Live::InstructionsAppendedEvent,
+            OpenAI::Live::ThinkingAppendedEvent,
+            OpenAI::Live::CommentaryAppendedEvent,
+            OpenAI::Live::ForkServerEvent::SessionInputAudioAppend,
+            OpenAI::Live::OutputAudioDeltaEvent,
+            OpenAI::Live::InputTranscriptDeltaEvent,
+            OpenAI::Live::OutputTranscriptDeltaEvent,
+            OpenAI::Live::DelegationCreatedEvent,
+            OpenAI::Live::ResponseEvent,
+            OpenAI::Live::SessionUsageUpdatedEvent,
+            OpenAI::Live::SessionClosedEvent,
+            OpenAI::Live::ErrorEvent,
+            OpenAI::Live::InfoEvent,
+            OpenAI::Live::ForkServerEvent::TransportDtmfReceived,
+            OpenAI::Live::ForkServerEvent::TransportDtmfSend,
+            OpenAI::Live::ForkServerEvent::TransportRinging,
+            OpenAI::Live::ForkServerEvent::TransportAnswered,
+            OpenAI::Live::ForkServerEvent::TransportFailed
+          )
+        end
+
+        class SessionInputAudioAppend < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Live::ForkServerEvent::SessionInputAudioAppend,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          # Base64-encoded raw mono PCM16LE at 24 kHz received from the primary transport,
+          # reflected to the sideband before model-input muting. This server event uses the
+          # same audio key as the client command, but is not an acknowledgment of it.
+          sig { returns(String) }
+          attr_accessor :audio
+
+          # The event type, always `session.input_audio.append`.
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # Input audio received from the primary transport and reflected to a Live sideband
+          # connection before model-input muting.
+          sig do
+            params(
+
+              audio: String,
+
+              type: Symbol
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            # Base64-encoded raw mono PCM16LE at 24 kHz received from the primary transport,
+            # reflected to the sideband before model-input muting. This server event uses the
+            # same audio key as the client command, but is not an acknowledgment of it.
+            audio:,
+
+            # The event type, always `session.input_audio.append`.
+
+            type: :"session.input_audio.append"
+          )
+          end
+
+          sig do
+            override.returns(
+              {audio: String, type: Symbol}
+            )
+          end
+          def to_hash
+          end
+
+        end
+
+        class TransportDtmfReceived < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Live::ForkServerEvent::TransportDtmfReceived,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          sig { returns(String) }
+          attr_accessor :event
+
+          sig { returns(String) }
+          attr_accessor :event_id
+
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # A SIP DTMF keypress received from the caller. Delivered only to sideband
+          # observers.
+          sig do
+            params(
+
+              event: String,
+
+              event_id: String,
+
+              type: Symbol
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            event:,
+
+            event_id:,
+
+            type: :"transport.dtmf.received"
+          )
+          end
+
+          sig do
+            override.returns(
+              {event: String, event_id: String, type: Symbol}
+            )
+          end
+          def to_hash
+          end
+
+        end
+
+        class TransportDtmfSend < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Live::ForkServerEvent::TransportDtmfSend,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          sig { returns(String) }
+          attr_accessor :event
+
+          sig { returns(String) }
+          attr_accessor :event_id
+
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # A SIP DTMF keypress successfully sent by the hosted tool. Delivered only to
+          # sideband observers; this is not a client command.
+          sig do
+            params(
+
+              event: String,
+
+              event_id: String,
+
+              type: Symbol
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            event:,
+
+            event_id:,
+
+            type: :"transport.dtmf.send"
+          )
+          end
+
+          sig do
+            override.returns(
+              {event: String, event_id: String, type: Symbol}
+            )
+          end
+          def to_hash
+          end
+
+        end
+
+        class TransportRinging < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Live::ForkServerEvent::TransportRinging,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          sig { returns(String) }
+          attr_accessor :event_id
+
+          # The canonical Live session ID.
+          sig { returns(String) }
+          attr_accessor :session_id
+
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # The outbound SIP provider leg is ringing or providing early media. Delivered
+          # only to sideband observers.
+          sig do
+            params(
+
+              event_id: String,
+
+              session_id: String,
+
+              type: Symbol
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            event_id:,
+
+            # The canonical Live session ID.
+            session_id:,
+
+            type: :"transport.ringing"
+          )
+          end
+
+          sig do
+            override.returns(
+              {event_id: String, session_id: String, type: Symbol}
+            )
+          end
+          def to_hash
+          end
+
+        end
+
+        class TransportAnswered < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Live::ForkServerEvent::TransportAnswered,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          sig { returns(String) }
+          attr_accessor :event_id
+
+          # The canonical Live session ID.
+          sig { returns(String) }
+          attr_accessor :session_id
+
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # The outbound SIP provider leg answered and media is established. Delivered only
+          # to sideband observers.
+          sig do
+            params(
+
+              event_id: String,
+
+              session_id: String,
+
+              type: Symbol
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            event_id:,
+
+            # The canonical Live session ID.
+            session_id:,
+
+            type: :"transport.answered"
+          )
+          end
+
+          sig do
+            override.returns(
+              {event_id: String, session_id: String, type: Symbol}
+            )
+          end
+          def to_hash
+          end
+
+        end
+
+        class TransportFailed < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Live::ForkServerEvent::TransportFailed,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          sig { returns(OpenAI::Live::ForkServerEvent::TransportFailed::Error) }
+          attr_reader :error
+
+          sig { params(error: OpenAI::Live::ForkServerEvent::TransportFailed::Error::OrHash).void }
+          attr_writer :error
+
+          sig { returns(String) }
+          attr_accessor :event_id
+
+          # The canonical Live session ID.
+          sig { returns(String) }
+          attr_accessor :session_id
+
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # An asynchronous outbound SIP setup failure. Delivered only to sideband
+          # observers.
+          sig do
+            params(
+
+              error: OpenAI::Live::ForkServerEvent::TransportFailed::Error::OrHash,
+
+              event_id: String,
+
+              session_id: String,
+
+              type: Symbol
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            error:,
+
+            event_id:,
+
+            # The canonical Live session ID.
+            session_id:,
+
+            type: :"transport.failed"
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                error: OpenAI::Live::ForkServerEvent::TransportFailed::Error,
+                event_id: String,
+                session_id: String,
+                type: Symbol
+              }
+            )
+          end
+          def to_hash
+          end
+
+          class Error < OpenAI::Internal::Type::BaseModel
+            OrHash = T.type_alias do
+              T.any(
+                OpenAI::Live::ForkServerEvent::TransportFailed::Error,
+                OpenAI::Internal::AnyHash
+              )
+            end
+
+            # The call setup failure code.
+            sig { returns(String) }
+            attr_accessor :code
+
+            sig { returns(String) }
+            attr_accessor :message
+
+            sig { returns(Symbol) }
+            attr_accessor :type
+
+            # The parameter related to the error, if any. Empty when no parameter applies.
+            sig { returns(T.nilable(String)) }
+            attr_reader :param
+
+            sig { params(param: String).void }
+            attr_writer :param
+
+            sig do
+              params(
+
+                code: String,
+
+                message: String,
+
+                param: String,
+
+                type: Symbol
+              )
+                .returns(T.attached_class)
+            end
+            def self.new(
+
+              # The call setup failure code.
+              code:,
+
+              message:,
+
+              # The parameter related to the error, if any. Empty when no parameter applies.
+              param: nil,
+
+              type: :call_error
+            )
+            end
+
+            sig do
+              override.returns(
+                {code: String, message: String, type: Symbol, param: T.nilable(String)}
+              )
+            end
+            def to_hash
+            end
+
+          end
+        end
+
+        sig { override.returns(T::Array[OpenAI::Live::ForkServerEvent::Variants]) }
+        def self.variants
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/live/fork_session_config.rbi

@@ -0,0 +1,234 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Live
+
+      class ForkSessionConfig < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Live::ForkSessionConfig,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # Audio format for a WebSocket fork. WebRTC forks negotiate their audio format and
+        # must omit this field.
+        sig { returns(T.nilable(OpenAI::Live::ForkSessionConfig::Audio)) }
+        attr_reader :audio
+
+        sig { params(audio: OpenAI::Live::ForkSessionConfig::Audio::OrHash).void }
+        attr_writer :audio
+
+        # Frontend data-channel permissions for a WebRTC fork. Omitted permissions inherit
+        # the stored values. Not supported for WebSocket forks.
+        sig { returns(T.nilable(OpenAI::Live::ClientConfig)) }
+        attr_reader :client
+
+        sig { params(client: OpenAI::Live::ClientConfig::OrHash).void }
+        attr_writer :client
+
+        # Overrides for the stored session’s Responses backend. Only supported when the
+        # stored session already uses Responses delegation; the delegation type cannot
+        # change.
+        sig { returns(T.nilable(OpenAI::Live::ForkSessionConfig::Delegation)) }
+        attr_reader :delegation
+
+        sig { params(delegation: OpenAI::Live::ForkSessionConfig::Delegation::OrHash).void }
+        attr_writer :delegation
+
+        # Whether to store the forked session. Omission inherits the stored session's
+        # setting.
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :store
+
+        sig { params(store: T::Boolean).void }
+        attr_writer :store
+
+        # Overrides for a stored session after connecting to the fork WebSocket. An empty
+        # object inherits the stored configuration; do not supply a new model.
+        # audio.format applies only to the new WebSocket connection. client overrides are
+        # only supported for WebRTC forks.
+        sig do
+          params(
+
+            audio: OpenAI::Live::ForkSessionConfig::Audio::OrHash,
+
+            client: OpenAI::Live::ClientConfig::OrHash,
+
+            delegation: OpenAI::Live::ForkSessionConfig::Delegation::OrHash,
+
+            store: T::Boolean
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # Audio format for a WebSocket fork. WebRTC forks negotiate their audio format and
+          # must omit this field.
+          audio: nil,
+
+          # Frontend data-channel permissions for a WebRTC fork. Omitted permissions inherit
+          # the stored values. Not supported for WebSocket forks.
+          client: nil,
+
+          # Overrides for the stored session’s Responses backend. Only supported when the
+          # stored session already uses Responses delegation; the delegation type cannot
+          # change.
+          delegation: nil,
+
+          # Whether to store the forked session. Omission inherits the stored session's
+          # setting.
+
+          store: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              audio: OpenAI::Live::ForkSessionConfig::Audio,
+              client: OpenAI::Live::ClientConfig,
+              delegation: OpenAI::Live::ForkSessionConfig::Delegation,
+              store: T::Boolean
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class Audio < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Live::ForkSessionConfig::Audio,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          # Audio encoding and sample rate for audio sent and received over a Live WebSocket
+          # connection. WebRTC and SIP negotiate their media format separately.
+          sig {
+            returns(
+              T.nilable(
+                T.any(
+                  OpenAI::Live::AudioFormat::AudioPCM,
+                  OpenAI::Live::AudioFormat::AudioPCMU,
+                  OpenAI::Live::AudioFormat::AudioPCMA
+                )
+              )
+            )
+          }
+          attr_reader :format_
+
+          sig {
+            params(
+              format_: T.any(
+                OpenAI::Live::AudioFormat::AudioPCM::OrHash,
+                OpenAI::Live::AudioFormat::AudioPCMU::OrHash,
+                OpenAI::Live::AudioFormat::AudioPCMA::OrHash
+              )
+            )
+              .void
+          }
+          attr_writer :format_
+
+          # Audio format for a WebSocket fork. WebRTC forks negotiate their audio format and
+          # must omit this field.
+          sig do
+            params(
+
+              format_: T.any(
+                OpenAI::Live::AudioFormat::AudioPCM::OrHash,
+                OpenAI::Live::AudioFormat::AudioPCMU::OrHash,
+                OpenAI::Live::AudioFormat::AudioPCMA::OrHash
+              )
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            # Audio encoding and sample rate for audio sent and received over a Live WebSocket
+            # connection. WebRTC and SIP negotiate their media format separately.
+
+            format_: nil
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                format_: T.any(
+                  OpenAI::Live::AudioFormat::AudioPCM,
+                  OpenAI::Live::AudioFormat::AudioPCMU,
+                  OpenAI::Live::AudioFormat::AudioPCMA
+                )
+              }
+            )
+          end
+          def to_hash
+          end
+
+        end
+
+        class Delegation < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Live::ForkSessionConfig::Delegation,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          # The delegation owner. Always `responses` for tasks handled by the Responses API.
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # Responses backend settings to update. Omitted settings keep their existing
+          # values.
+          sig { returns(T.nilable(OpenAI::Live::ResponsesDelegationUpdateConfig)) }
+          attr_reader :responses
+
+          sig { params(responses: OpenAI::Live::ResponsesDelegationUpdateConfig::OrHash).void }
+          attr_writer :responses
+
+          # Overrides for the stored session’s Responses backend. Only supported when the
+          # stored session already uses Responses delegation; the delegation type cannot
+          # change.
+          sig do
+            params(
+
+              responses: OpenAI::Live::ResponsesDelegationUpdateConfig::OrHash,
+
+              type: Symbol
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            # Responses backend settings to update. Omitted settings keep their existing
+            # values.
+            responses: nil,
+
+            # The delegation owner. Always `responses` for tasks handled by the Responses API.
+
+            type: :responses
+          )
+          end
+
+          sig do
+            override.returns(
+              {type: Symbol, responses: OpenAI::Live::ResponsesDelegationUpdateConfig}
+            )
+          end
+          def to_hash
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+end