openai 0.88.0 → 0.89.0

data/rbi/openai/models/live/live_create_params.rbi

@@ -0,0 +1,121 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Live
+
+      class LiveCreateParams < OpenAI::Internal::Type::BaseModel
+
+        extend OpenAI::Internal::Type::RequestParameters::Converter
+        include OpenAI::Internal::Type::RequestParameters
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Live::LiveCreateParams,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # Startup configuration for the Live session.
+        sig { returns(OpenAI::Live::MediaSessionConfig) }
+        attr_reader :session
+
+        sig { params(session: OpenAI::Live::MediaSessionConfig::OrHash).void }
+        attr_writer :session
+
+        # WebRTC transport with the browser's SDP offer.
+        sig { returns(OpenAI::Live::LiveCreateParams::Transport) }
+        attr_reader :transport
+
+        sig { params(transport: OpenAI::Live::LiveCreateParams::Transport::OrHash).void }
+        attr_writer :transport
+
+        sig do
+          params(
+
+            session: OpenAI::Live::MediaSessionConfig::OrHash,
+
+            transport: OpenAI::Live::LiveCreateParams::Transport::OrHash,
+
+            request_options: OpenAI::RequestOptions::OrHash
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # Startup configuration for the Live session.
+          session:,
+
+          # WebRTC transport with the browser's SDP offer.
+          transport:,
+
+          request_options: {}
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              session: OpenAI::Live::MediaSessionConfig,
+              transport: OpenAI::Live::LiveCreateParams::Transport,
+              request_options: OpenAI::RequestOptions
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class Transport < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Live::LiveCreateParams::Transport,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          # Session Description Protocol message for the WebRTC connection.
+          sig { returns(String) }
+          attr_accessor :sdp
+
+          # The transport used for the Live session. Always `webrtc`.
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # WebRTC transport with the browser's SDP offer.
+          sig do
+            params(
+
+              sdp: String,
+
+              type: Symbol
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            # Session Description Protocol message for the WebRTC connection.
+            sdp:,
+
+            # The transport used for the Live session. Always `webrtc`.
+
+            type: :webrtc
+          )
+          end
+
+          sig do
+            override.returns(
+              {sdp: String, type: Symbol}
+            )
+          end
+          def to_hash
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/live/live_create_response.rbi

@@ -0,0 +1,160 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Live
+
+      class LiveCreateResponse < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Models::Live::LiveCreateResponse,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # The newly created Live session. Use its ID for session controls and sideband
+        # connections.
+        sig { returns(OpenAI::Models::Live::LiveCreateResponse::Session) }
+        attr_reader :session
+
+        sig { params(session: OpenAI::Models::Live::LiveCreateResponse::Session::OrHash).void }
+        attr_writer :session
+
+        # WebRTC transport with the SDP answer.
+        sig { returns(OpenAI::Models::Live::LiveCreateResponse::Transport) }
+        attr_reader :transport
+
+        sig { params(transport: OpenAI::Models::Live::LiveCreateResponse::Transport::OrHash).void }
+        attr_writer :transport
+
+        # The created Live session identifier and WebRTC answer. Apply transport.sdp as
+        # the peer's remote answer and wait for session.started on the data channel before
+        # sending commands.
+        sig do
+          params(
+
+            session: OpenAI::Models::Live::LiveCreateResponse::Session::OrHash,
+
+            transport: OpenAI::Models::Live::LiveCreateResponse::Transport::OrHash
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # The newly created Live session. Use its ID for session controls and sideband
+          # connections.
+          session:,
+
+          # WebRTC transport with the SDP answer.
+
+          transport:
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              session: OpenAI::Models::Live::LiveCreateResponse::Session,
+              transport: OpenAI::Models::Live::LiveCreateResponse::Transport
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class Session < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Models::Live::LiveCreateResponse::Session,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          # Opaque session identifier. Preserve the returned value unchanged, including its
+          # prefix.
+          sig { returns(String) }
+          attr_accessor :id
+
+          # The newly created Live session. Use its ID for session controls and sideband
+          # connections.
+          sig do
+            params(
+
+              id: String
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            # Opaque session identifier. Preserve the returned value unchanged, including its
+            # prefix.
+
+            id:
+          )
+          end
+
+          sig do
+            override.returns(
+              {id: String}
+            )
+          end
+          def to_hash
+          end
+
+        end
+
+        class Transport < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Models::Live::LiveCreateResponse::Transport,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          # Session Description Protocol message for the WebRTC connection.
+          sig { returns(String) }
+          attr_accessor :sdp
+
+          # The transport used for the Live session. Always `webrtc`.
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # WebRTC transport with the SDP answer.
+          sig do
+            params(
+
+              sdp: String,
+
+              type: Symbol
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            # Session Description Protocol message for the WebRTC connection.
+            sdp:,
+
+            # The transport used for the Live session. Always `webrtc`.
+
+            type: :webrtc
+          )
+          end
+
+          sig do
+            override.returns(
+              {sdp: String, type: Symbol}
+            )
+          end
+          def to_hash
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/live/media_session_config.rbi

@@ -0,0 +1,390 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Live
+
+      class MediaSessionConfig < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Live::MediaSessionConfig,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # The Live model. Required in the session configuration for every transport; do
+        # not pass it as a URL query parameter.
+        sig { returns(T.any(String, OpenAI::Live::MediaSessionConfig::Model::OrSymbol)) }
+        attr_accessor :model
+
+        # Startup audio configuration. WebRTC and SIP negotiate their audio format on the
+        # media transport.
+        sig { returns(T.nilable(OpenAI::Live::MediaSessionConfig::Audio)) }
+        attr_reader :audio
+
+        sig { params(audio: OpenAI::Live::MediaSessionConfig::Audio::OrHash).void }
+        attr_writer :audio
+
+        # Startup-only capabilities for an untrusted frontend attached to a unified WebRTC
+        # session. Trusted sideband connections are unaffected.
+        sig { returns(T.nilable(OpenAI::Live::ClientConfig)) }
+        attr_reader :client
+
+        sig { params(client: OpenAI::Live::ClientConfig::OrHash).void }
+        attr_writer :client
+
+        # Who handles tasks delegated by the Live model. Omitted or null selects your
+        # application; use `responses` to let the API manage a Responses backend.
+        sig {
+          returns(
+            T.nilable(T.any(OpenAI::Live::ClientDelegation, OpenAI::Live::MediaSessionConfig::Delegation::Responses))
+          )
+        }
+        attr_accessor :delegation
+
+        # Ordered text-only history supplied before startup. Supports developer, user, and
+        # assistant messages with one text part each; at most 128 messages and 8,192
+        # rendered tokens in total.
+        sig {
+          returns(
+            T.nilable(
+              T::Array[
+                T.any(
+                  OpenAI::Live::InitialItem::Developer,
+                  OpenAI::Live::InitialItem::User,
+                  OpenAI::Live::InitialItem::Assistant
+                )
+              ]
+            )
+          )
+        }
+        attr_reader :input
+
+        sig {
+          params(
+            input: T::Array[
+              T.any(
+                OpenAI::Live::InitialItem::Developer::OrHash,
+                OpenAI::Live::InitialItem::User::OrHash,
+                OpenAI::Live::InitialItem::Assistant::OrHash
+              )
+            ]
+          )
+            .void
+        }
+        attr_writer :input
+
+        # Frontend instructions for voice, conversation, interruptions, and when to
+        # delegate. Start with the
+        # [Live prompting guide](https://developers.openai.com/api/docs/guides/live-prompting);
+        # put business rules and tool workflows in a separate
+        # [backend prompt](https://developers.openai.com/api/docs/guides/live-delegation#start-with-your-existing-backend-prompt).
+        # Limited to 16,384 client-supplied tokens. Omitted or blank instructions use
+        # server defaults. Immutable after startup.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :instructions
+
+        # Whether to store the session for later forking and recording download. Defaults
+        # to false for new sessions.
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :store
+
+        sig { params(store: T::Boolean).void }
+        attr_writer :store
+
+        # Startup configuration for a Live media session. Follow the
+        # [Live prompting guide](https://developers.openai.com/api/docs/guides/live-prompting)
+        # when writing frontend instructions and the backend prompt under
+        # delegation.responses.instructions.
+        sig do
+          params(
+
+            model: T.any(String, OpenAI::Live::MediaSessionConfig::Model::OrSymbol),
+
+            audio: OpenAI::Live::MediaSessionConfig::Audio::OrHash,
+
+            client: OpenAI::Live::ClientConfig::OrHash,
+
+            delegation: T.nilable(
+              T.any(
+                OpenAI::Live::ClientDelegation::OrHash,
+                OpenAI::Live::MediaSessionConfig::Delegation::Responses::OrHash
+              )
+            ),
+
+            input: T::Array[
+              T.any(
+                OpenAI::Live::InitialItem::Developer::OrHash,
+                OpenAI::Live::InitialItem::User::OrHash,
+                OpenAI::Live::InitialItem::Assistant::OrHash
+              )
+            ],
+
+            instructions: T.nilable(String),
+
+            store: T::Boolean
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # The Live model. Required in the session configuration for every transport; do
+          # not pass it as a URL query parameter.
+          model:,
+
+          # Startup audio configuration. WebRTC and SIP negotiate their audio format on the
+          # media transport.
+          audio: nil,
+
+          # Startup-only capabilities for an untrusted frontend attached to a unified WebRTC
+          # session. Trusted sideband connections are unaffected.
+          client: nil,
+
+          # Who handles tasks delegated by the Live model. Omitted or null selects your
+          # application; use `responses` to let the API manage a Responses backend.
+          delegation: nil,
+
+          # Ordered text-only history supplied before startup. Supports developer, user, and
+          # assistant messages with one text part each; at most 128 messages and 8,192
+          # rendered tokens in total.
+          input: nil,
+
+          # Frontend instructions for voice, conversation, interruptions, and when to
+          # delegate. Start with the
+          # [Live prompting guide](https://developers.openai.com/api/docs/guides/live-prompting);
+          # put business rules and tool workflows in a separate
+          # [backend prompt](https://developers.openai.com/api/docs/guides/live-delegation#start-with-your-existing-backend-prompt).
+          # Limited to 16,384 client-supplied tokens. Omitted or blank instructions use
+          # server defaults. Immutable after startup.
+          instructions: nil,
+
+          # Whether to store the session for later forking and recording download. Defaults
+          # to false for new sessions.
+
+          store: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              model: T.any(String, OpenAI::Live::MediaSessionConfig::Model::OrSymbol),
+              audio: OpenAI::Live::MediaSessionConfig::Audio,
+              client: OpenAI::Live::ClientConfig,
+              delegation: T.nilable(
+                T.any(OpenAI::Live::ClientDelegation, OpenAI::Live::MediaSessionConfig::Delegation::Responses)
+              ),
+              input: T::Array[
+                T.any(
+                  OpenAI::Live::InitialItem::Developer,
+                  OpenAI::Live::InitialItem::User,
+                  OpenAI::Live::InitialItem::Assistant
+                )
+              ],
+              instructions: T.nilable(String),
+              store: T::Boolean
+            }
+          )
+        end
+        def to_hash
+        end
+
+        # The Live model. Required in the session configuration for every transport; do
+        # not pass it as a URL query parameter.
+        module Model
+          extend OpenAI::Internal::Type::Union
+
+          Variants = T.type_alias { T.any(String, OpenAI::Live::MediaSessionConfig::Model::TaggedSymbol) }
+
+          sig { override.returns(T::Array[OpenAI::Live::MediaSessionConfig::Model::Variants]) }
+          def self.variants
+          end
+
+          TaggedSymbol = T.type_alias do
+            T.all(Symbol, OpenAI::Live::MediaSessionConfig::Model)
+          end
+
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          GPT_LIVE_1 = T.let(:"gpt-live-1", OpenAI::Live::MediaSessionConfig::Model::TaggedSymbol)
+
+        end
+
+        class Audio < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Live::MediaSessionConfig::Audio,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          # Settings for speech generated by the Live model. Choose the voice before
+          # starting the session.
+          sig { returns(T.nilable(OpenAI::Live::MediaSessionConfig::Audio::Output)) }
+          attr_reader :output
+
+          sig { params(output: OpenAI::Live::MediaSessionConfig::Audio::Output::OrHash).void }
+          attr_writer :output
+
+          # Startup audio configuration. WebRTC and SIP negotiate their audio format on the
+          # media transport.
+          sig do
+            params(
+
+              output: OpenAI::Live::MediaSessionConfig::Audio::Output::OrHash
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            # Settings for speech generated by the Live model. Choose the voice before
+            # starting the session.
+
+            output: nil
+          )
+          end
+
+          sig do
+            override.returns(
+              {output: OpenAI::Live::MediaSessionConfig::Audio::Output}
+            )
+          end
+          def to_hash
+          end
+
+          class Output < OpenAI::Internal::Type::BaseModel
+            OrHash = T.type_alias do
+              T.any(
+                OpenAI::Live::MediaSessionConfig::Audio::Output,
+                OpenAI::Internal::AnyHash
+              )
+            end
+
+            # The voice used for Live speech, as a built-in voice name or a custom voice
+            # object containing its ID. Defaults to `marin` and cannot change after startup.
+            sig { returns(T.nilable(T.any(String, OpenAI::Live::BuiltInVoice::OrSymbol, OpenAI::Live::CustomVoice))) }
+            attr_reader :voice
+
+            sig {
+              params(voice: T.any(String, OpenAI::Live::BuiltInVoice::OrSymbol, OpenAI::Live::CustomVoice::OrHash)).void
+            }
+            attr_writer :voice
+
+            # Settings for speech generated by the Live model. Choose the voice before
+            # starting the session.
+            sig do
+              params(
+
+                voice: T.any(String, OpenAI::Live::BuiltInVoice::OrSymbol, OpenAI::Live::CustomVoice::OrHash)
+              )
+                .returns(T.attached_class)
+            end
+            def self.new(
+
+              # The voice used for Live speech, as a built-in voice name or a custom voice
+              # object containing its ID. Defaults to `marin` and cannot change after startup.
+
+              voice: nil
+            )
+            end
+
+            sig do
+              override.returns(
+                {voice: T.any(String, OpenAI::Live::BuiltInVoice::OrSymbol, OpenAI::Live::CustomVoice)}
+              )
+            end
+            def to_hash
+            end
+
+            # The voice used for Live speech, as a built-in voice name or a custom voice
+            # object containing its ID. Defaults to `marin` and cannot change after startup.
+            module Voice
+              extend OpenAI::Internal::Type::Union
+
+              Variants = T.type_alias {
+                T.any(String, OpenAI::Live::BuiltInVoice::TaggedSymbol, OpenAI::Live::CustomVoice)
+              }
+
+              sig { override.returns(T::Array[OpenAI::Live::MediaSessionConfig::Audio::Output::Voice::Variants]) }
+              def self.variants
+              end
+
+            end
+          end
+        end
+
+        # Who handles tasks delegated by the Live model. Omitted or null selects your
+        # application; use `responses` to let the API manage a Responses backend.
+        module Delegation
+          extend OpenAI::Internal::Type::Union
+
+          Variants = T.type_alias {
+            T.any(OpenAI::Live::ClientDelegation, OpenAI::Live::MediaSessionConfig::Delegation::Responses)
+          }
+
+          class Responses < OpenAI::Internal::Type::BaseModel
+            OrHash = T.type_alias do
+              T.any(
+                OpenAI::Live::MediaSessionConfig::Delegation::Responses,
+                OpenAI::Internal::AnyHash
+              )
+            end
+
+            # Backend model, prompt, and tools used when the Live session delegates a task to
+            # Responses.
+            sig { returns(OpenAI::Live::ResponsesDelegationConfig) }
+            attr_reader :responses
+
+            sig { params(responses: OpenAI::Live::ResponsesDelegationConfig::OrHash).void }
+            attr_writer :responses
+
+            # The delegation owner. Always `responses` for tasks handled by the Responses API.
+            sig { returns(Symbol) }
+            attr_accessor :type
+
+            # Delegate tasks to a Responses model managed by the Live session.
+            sig do
+              params(
+
+                responses: OpenAI::Live::ResponsesDelegationConfig::OrHash,
+
+                type: Symbol
+              )
+                .returns(T.attached_class)
+            end
+            def self.new(
+
+              # Backend model, prompt, and tools used when the Live session delegates a task to
+              # Responses.
+              responses:,
+
+              # The delegation owner. Always `responses` for tasks handled by the Responses API.
+
+              type: :responses
+            )
+            end
+
+            sig do
+              override.returns(
+                {responses: OpenAI::Live::ResponsesDelegationConfig, type: Symbol}
+              )
+            end
+            def to_hash
+            end
+
+          end
+
+          sig { override.returns(T::Array[OpenAI::Live::MediaSessionConfig::Delegation::Variants]) }
+          def self.variants
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+end