openai 0.88.0 → 0.89.0

data/rbi/openai/models/live/commentary_appended_event.rbi

@@ -0,0 +1,97 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Live
+
+      class CommentaryAppendedEvent < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Live::CommentaryAppendedEvent,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # The end of this event on the Live session timeline, in milliseconds from the
+        # beginning of the session. For appended context, this can equal start_ms.
+        sig { returns(Integer) }
+        attr_accessor :end_ms
+
+        # The unique ID of the Live server event.
+        sig { returns(String) }
+        attr_accessor :event_id
+
+        # The start of this event on the Live session timeline, in milliseconds from the
+        # beginning of the session.
+        sig { returns(Integer) }
+        attr_accessor :start_ms
+
+        # The event type, always `session.commentary.appended`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # The event_id of the client command associated with this server event, when
+        # supplied.
+        sig { returns(T.nilable(String)) }
+        attr_reader :client_event_id
+
+        sig { params(client_event_id: String).void }
+        attr_writer :client_event_id
+
+        # Returned when a session.commentary.append command is accepted into the Live
+        # session timeline. Acknowledges the added commentary without guaranteeing exact
+        # wording or completed audio playback.
+        sig do
+          params(
+
+            end_ms: Integer,
+
+            event_id: String,
+
+            start_ms: Integer,
+
+            client_event_id: String,
+
+            type: Symbol
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # The end of this event on the Live session timeline, in milliseconds from the
+          # beginning of the session. For appended context, this can equal start_ms.
+          end_ms:,
+
+          # The unique ID of the Live server event.
+          event_id:,
+
+          # The start of this event on the Live session timeline, in milliseconds from the
+          # beginning of the session.
+          start_ms:,
+
+          # The event_id of the client command associated with this server event, when
+          # supplied.
+          client_event_id: nil,
+
+          # The event type, always `session.commentary.appended`.
+
+          type: :"session.commentary.appended"
+        )
+        end
+
+        sig do
+          override.returns(
+            {end_ms: Integer, event_id: String, start_ms: Integer, type: Symbol, client_event_id: T.nilable(String)}
+          )
+        end
+        def to_hash
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/live/custom_voice.rbi

@@ -0,0 +1,46 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Live
+
+      class CustomVoice < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Live::CustomVoice,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        sig { returns(String) }
+        attr_accessor :id
+
+        sig do
+          params(
+
+            id: String
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          id:
+        )
+        end
+
+        sig do
+          override.returns(
+            {id: String}
+          )
+        end
+        def to_hash
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/live/data_channel_config.rbi

@@ -0,0 +1,119 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Live
+
+      class DataChannelConfig < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Live::DataChannelConfig,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # Client event types that the frontend data channel may send. Use 'all' to allow
+        # every client event; an empty array allows none. Omission preserves the existing
+        # allow-all behavior.
+        sig { returns(T.nilable(OpenAI::Live::DataChannelConfig::AllowedClientEvents::Variants)) }
+        attr_reader :allowed_client_events
+
+        sig { params(allowed_client_events: OpenAI::Live::DataChannelConfig::AllowedClientEvents::Variants).void }
+        attr_writer :allowed_client_events
+
+        # Server events that may be sent to the frontend data channel. Use 'all' to allow
+        # every server event; an empty array allows none. Omission preserves the existing
+        # allow-all behavior. Responses events use an object with type 'response.event'
+        # and a response_event selector.
+        sig { returns(T.nilable(T.any(Symbol, T::Array[OpenAI::Live::ServerEventSelector]))) }
+        attr_reader :allowed_server_events
+
+        sig { params(allowed_server_events: T.any(Symbol, T::Array[OpenAI::Live::ServerEventSelector::OrHash])).void }
+        attr_writer :allowed_server_events
+
+        # Control which Live events an untrusted WebRTC frontend can send and receive over
+        # its data channel. These restrictions do not apply to trusted sideband
+        # connections.
+        sig do
+          params(
+
+            allowed_client_events: OpenAI::Live::DataChannelConfig::AllowedClientEvents::Variants,
+
+            allowed_server_events: T.any(Symbol, T::Array[OpenAI::Live::ServerEventSelector::OrHash])
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # Client event types that the frontend data channel may send. Use 'all' to allow
+          # every client event; an empty array allows none. Omission preserves the existing
+          # allow-all behavior.
+          allowed_client_events: nil,
+
+          # Server events that may be sent to the frontend data channel. Use 'all' to allow
+          # every server event; an empty array allows none. Omission preserves the existing
+          # allow-all behavior. Responses events use an object with type 'response.event'
+          # and a response_event selector.
+
+          allowed_server_events: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              allowed_client_events: OpenAI::Live::DataChannelConfig::AllowedClientEvents::Variants,
+              allowed_server_events: T.any(Symbol, T::Array[OpenAI::Live::ServerEventSelector])
+            }
+          )
+        end
+        def to_hash
+        end
+
+        # Client event types that the frontend data channel may send. Use 'all' to allow
+        # every client event; an empty array allows none. Omission preserves the existing
+        # allow-all behavior.
+        module AllowedClientEvents
+          extend OpenAI::Internal::Type::Union
+
+          Variants = T.type_alias { T.any(Symbol, T::Array[String]) }
+
+          sig { override.returns(T::Array[OpenAI::Live::DataChannelConfig::AllowedClientEvents::Variants]) }
+          def self.variants
+          end
+
+          StringArray = T.let(
+            OpenAI::Internal::Type::ArrayOf[String],
+            OpenAI::Internal::Type::Converter
+          )
+
+        end
+
+        # Server events that may be sent to the frontend data channel. Use 'all' to allow
+        # every server event; an empty array allows none. Omission preserves the existing
+        # allow-all behavior. Responses events use an object with type 'response.event'
+        # and a response_event selector.
+        module AllowedServerEvents
+          extend OpenAI::Internal::Type::Union
+
+          Variants = T.type_alias { T.any(Symbol, T::Array[OpenAI::Live::ServerEventSelector]) }
+
+          sig { override.returns(T::Array[OpenAI::Live::DataChannelConfig::AllowedServerEvents::Variants]) }
+          def self.variants
+          end
+
+          ServerEventSelectorArray = T.let(
+            OpenAI::Internal::Type::ArrayOf[OpenAI::Live::ServerEventSelector],
+            OpenAI::Internal::Type::Converter
+          )
+
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/live/delegation_created_event.rbi

@@ -0,0 +1,207 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Live
+
+      class DelegationCreatedEvent < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Live::DelegationCreatedEvent,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # The delegated work identifier and destination. This object contains metadata,
+        # not the task text.
+        sig { returns(OpenAI::Live::DelegationCreatedEvent::Delegation) }
+        attr_reader :delegation
+
+        sig { params(delegation: OpenAI::Live::DelegationCreatedEvent::Delegation::OrHash).void }
+        attr_writer :delegation
+
+        # The unique ID of the Live server event.
+        sig { returns(String) }
+        attr_accessor :event_id
+
+        # The position on the Live session timeline where the delegation was created, in
+        # milliseconds from the beginning of the session.
+        sig { returns(Integer) }
+        attr_accessor :offset_ms
+
+        # The event type, always `session.delegation.created`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # The event_id of the client command associated with this server event, when
+        # supplied.
+        sig { returns(T.nilable(String)) }
+        attr_reader :client_event_id
+
+        sig { params(client_event_id: String).void }
+        attr_writer :client_event_id
+
+        # Returned when the Live model delegates work to your application or a Responses
+        # backend. Contains delegation metadata and the position on the session timeline
+        # where the work was delegated.
+        sig do
+          params(
+
+            delegation: OpenAI::Live::DelegationCreatedEvent::Delegation::OrHash,
+
+            event_id: String,
+
+            offset_ms: Integer,
+
+            client_event_id: String,
+
+            type: Symbol
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # The delegated work identifier and destination. This object contains metadata,
+          # not the task text.
+          delegation:,
+
+          # The unique ID of the Live server event.
+          event_id:,
+
+          # The position on the Live session timeline where the delegation was created, in
+          # milliseconds from the beginning of the session.
+          offset_ms:,
+
+          # The event_id of the client command associated with this server event, when
+          # supplied.
+          client_event_id: nil,
+
+          # The event type, always `session.delegation.created`.
+
+          type: :"session.delegation.created"
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              delegation: OpenAI::Live::DelegationCreatedEvent::Delegation,
+              event_id: String,
+              offset_ms: Integer,
+              type: Symbol,
+              client_event_id: T.nilable(String)
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class Delegation < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Live::DelegationCreatedEvent::Delegation,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          # The unique ID of the delegation. Use this as delegation_id when replying to
+          # client-owned work or correlating Responses events.
+          sig { returns(String) }
+          attr_accessor :id
+
+          # Where the Live model delegated the work: `client` for your application, or
+          # `responses` for the configured Responses backend.
+          sig { returns(OpenAI::Live::DelegationCreatedEvent::Delegation::Target::OrSymbol) }
+          attr_accessor :target
+
+          # The object type, always `delegation`.
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # The ID of the Responses API response associated with a Responses delegation.
+          # Omitted for client delegations.
+          sig { returns(T.nilable(String)) }
+          attr_reader :response_id
+
+          sig { params(response_id: String).void }
+          attr_writer :response_id
+
+          # The delegated work identifier and destination. This object contains metadata,
+          # not the task text.
+          sig do
+            params(
+
+              id: String,
+
+              target: OpenAI::Live::DelegationCreatedEvent::Delegation::Target::OrSymbol,
+
+              response_id: String,
+
+              type: Symbol
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            # The unique ID of the delegation. Use this as delegation_id when replying to
+            # client-owned work or correlating Responses events.
+            id:,
+
+            # Where the Live model delegated the work: `client` for your application, or
+            # `responses` for the configured Responses backend.
+            target:,
+
+            # The ID of the Responses API response associated with a Responses delegation.
+            # Omitted for client delegations.
+            response_id: nil,
+
+            # The object type, always `delegation`.
+
+            type: :delegation
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                id: String,
+                target: OpenAI::Live::DelegationCreatedEvent::Delegation::Target::OrSymbol,
+                type: Symbol,
+                response_id: T.nilable(String)
+              }
+            )
+          end
+          def to_hash
+          end
+
+          # Where the Live model delegated the work: `client` for your application, or
+          # `responses` for the configured Responses backend.
+          module Target
+            extend OpenAI::Internal::Type::Union
+
+            Variants = T.type_alias { OpenAI::Live::DelegationCreatedEvent::Delegation::Target::TaggedSymbol }
+
+            sig { override.returns(T::Array[OpenAI::Live::DelegationCreatedEvent::Delegation::Target::Variants]) }
+            def self.variants
+            end
+
+            TaggedSymbol = T.type_alias do
+              T.all(Symbol, OpenAI::Live::DelegationCreatedEvent::Delegation::Target)
+            end
+
+            OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+            CLIENT = T.let(:client, OpenAI::Live::DelegationCreatedEvent::Delegation::Target::TaggedSymbol)
+            RESPONSES = T.let(:responses, OpenAI::Live::DelegationCreatedEvent::Delegation::Target::TaggedSymbol)
+
+          end
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/live/error.rbi

@@ -0,0 +1,95 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Live
+
+      class Error < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Live::Error,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # A machine-readable code identifying the Live error, such as `unknown_parameter`.
+        sig { returns(String) }
+        attr_accessor :code
+
+        # A human-readable explanation of the Live error.
+        sig { returns(String) }
+        attr_accessor :message
+
+        # The category of error, such as `invalid_request_error` for an invalid Live
+        # client command.
+        sig { returns(String) }
+        attr_accessor :type
+
+        # The event_id of the client command that caused the error, when supplied.
+        sig { returns(T.nilable(String)) }
+        attr_reader :client_event_id
+
+        sig { params(client_event_id: String).void }
+        attr_writer :client_event_id
+
+        # The parameter that caused the error, when applicable, such as `session.voice`.
+        sig { returns(T.nilable(String)) }
+        attr_reader :param
+
+        sig { params(param: String).void }
+        attr_writer :param
+
+        # Details of an error encountered by the Live session, including the affected
+        # parameter or client command when available.
+        sig do
+          params(
+
+            code: String,
+
+            message: String,
+
+            type: String,
+
+            client_event_id: String,
+
+            param: String
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # A machine-readable code identifying the Live error, such as `unknown_parameter`.
+          code:,
+
+          # A human-readable explanation of the Live error.
+          message:,
+
+          # The category of error, such as `invalid_request_error` for an invalid Live
+          # client command.
+          type:,
+
+          # The event_id of the client command that caused the error, when supplied.
+          client_event_id: nil,
+
+          # The parameter that caused the error, when applicable, such as `session.voice`.
+
+          param: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {code: String, message: String, type: String, client_event_id: String, param: String}
+          )
+        end
+        def to_hash
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/live/error_event.rbi

@@ -0,0 +1,87 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Live
+
+      class ErrorEvent < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Live::ErrorEvent,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # Details of the Live error and the client command that caused it, when known.
+        sig { returns(OpenAI::Live::Error) }
+        attr_reader :error
+
+        sig { params(error: OpenAI::Live::Error::OrHash).void }
+        attr_writer :error
+
+        # The unique ID of the Live server event.
+        sig { returns(String) }
+        attr_accessor :event_id
+
+        # The event type, always `error`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # The event_id of the client command associated with this server event, when
+        # supplied.
+        sig { returns(T.nilable(String)) }
+        attr_reader :client_event_id
+
+        sig { params(client_event_id: String).void }
+        attr_writer :client_event_id
+
+        # Reports an error in the Live session, such as an invalid client command. Use
+        # error.client_event_id, when present, to identify the command that caused the
+        # error.
+        sig do
+          params(
+
+            error: OpenAI::Live::Error::OrHash,
+
+            event_id: String,
+
+            client_event_id: String,
+
+            type: Symbol
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # Details of the Live error and the client command that caused it, when known.
+          error:,
+
+          # The unique ID of the Live server event.
+          event_id:,
+
+          # The event_id of the client command associated with this server event, when
+          # supplied.
+          client_event_id: nil,
+
+          # The event type, always `error`.
+
+          type: :error
+        )
+        end
+
+        sig do
+          override.returns(
+            {error: OpenAI::Live::Error, event_id: String, type: Symbol, client_event_id: T.nilable(String)}
+          )
+        end
+        def to_hash
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/live/fork_client_event.rbi

@@ -0,0 +1,40 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Live
+
+      # Client events for a Live fork WebSocket. First send session.start with an
+      # overrides object (which may be empty), then wait for session.started before
+      # sending other commands. The model and conversation are inherited from the stored
+      # session.
+      module ForkClientEvent
+        extend OpenAI::Internal::Type::Union
+
+        Variants = T.type_alias do
+          T.any(
+            OpenAI::Live::ForkSessionStartEvent,
+            OpenAI::Live::SessionUpdateEvent,
+            OpenAI::Live::InputAudioAppendEvent,
+            OpenAI::Live::InputAudioMuteEvent,
+            OpenAI::Live::InputAudioUnmuteEvent,
+            OpenAI::Live::InstructionsAppendEvent,
+            OpenAI::Live::ThinkingAppendEvent,
+            OpenAI::Live::CommentaryAppendEvent,
+            OpenAI::Live::ResponseItemCreateEvent,
+            OpenAI::Live::ResponseCreateEvent,
+            OpenAI::Live::SessionCloseEvent
+          )
+        end
+
+        sig { override.returns(T::Array[OpenAI::Live::ForkClientEvent::Variants]) }
+        def self.variants
+        end
+
+      end
+
+    end
+
+  end
+end