openai 0.88.0 → 0.89.0

data/lib/openai/models/live/audio_format.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module OpenAI
+  module Models
+    module Live
+      # Audio encoding and sample rate for audio sent and received over a Live WebSocket
+      # connection. WebRTC and SIP negotiate their media format separately.
+      module AudioFormat
+        extend OpenAI::Internal::Type::Union
+
+        discriminator :type
+
+        # Raw, mono 16-bit little-endian PCM audio for a Live WebSocket connection.
+        variant :"audio/pcm", -> { OpenAI::Live::AudioFormat::AudioPCM }
+
+        # Raw, mono G.711 μ-law audio for a Live WebSocket connection.
+        variant :"audio/pcmu", -> { OpenAI::Live::AudioFormat::AudioPCMU }
+
+        # Raw, mono G.711 A-law audio for a Live WebSocket connection.
+        variant :"audio/pcma", -> { OpenAI::Live::AudioFormat::AudioPCMA }
+
+        class AudioPCM < OpenAI::Internal::Type::BaseModel
+          # @!attribute rate
+          #   Audio sample rate in hertz. Live WebSocket PCM audio supports 16000 or 24000 Hz.
+          #
+          #   @return [Integer, OpenAI::Models::Live::AudioFormat::AudioPCM::Rate]
+          required :rate, enum: -> { OpenAI::Live::AudioFormat::AudioPCM::Rate }
+
+          # @!attribute type
+          #   The audio encoding. Always `audio/pcm`.
+          #
+          #   @return [Symbol, :"audio/pcm"]
+          required :type, const: :"audio/pcm"
+
+          # @!method initialize(rate:, type: :"audio/pcm")
+          #   Raw, mono 16-bit little-endian PCM audio for a Live WebSocket connection.
+          #
+          #   @param rate [Integer, OpenAI::Models::Live::AudioFormat::AudioPCM::Rate]
+          #     Audio sample rate in hertz. Live WebSocket PCM audio supports 16000 or 24000 Hz.
+          #
+          #   @param type [Symbol, :"audio/pcm"]
+          #     The audio encoding. Always `audio/pcm`.
+
+          # Audio sample rate in hertz. Live WebSocket PCM audio supports 16000 or 24000 Hz.
+          #
+          # @see OpenAI::Models::Live::AudioFormat::AudioPCM#rate
+          module Rate
+            extend OpenAI::Internal::Type::Enum
+
+            RATE_16000 = 16_000
+            RATE_24000 = 24_000
+
+            # @!method self.values
+            #   @return [Array<Integer>]
+          end
+        end
+
+        class AudioPCMU < OpenAI::Internal::Type::BaseModel
+          # @!attribute rate
+          #   Audio sample rate in hertz. G.711 audio uses 8000 Hz.
+          #
+          #   @return [Integer]
+          required :rate, Integer
+
+          # @!attribute type
+          #   The audio encoding. Always `audio/pcmu`.
+          #
+          #   @return [Symbol, :"audio/pcmu"]
+          required :type, const: :"audio/pcmu"
+
+          # @!method initialize(rate:, type: :"audio/pcmu")
+          #   Raw, mono G.711 μ-law audio for a Live WebSocket connection.
+          #
+          #   @param rate [Integer]
+          #     Audio sample rate in hertz. G.711 audio uses 8000 Hz.
+          #
+          #   @param type [Symbol, :"audio/pcmu"]
+          #     The audio encoding. Always `audio/pcmu`.
+        end
+
+        class AudioPCMA < OpenAI::Internal::Type::BaseModel
+          # @!attribute rate
+          #   Audio sample rate in hertz. G.711 audio uses 8000 Hz.
+          #
+          #   @return [Integer]
+          required :rate, Integer
+
+          # @!attribute type
+          #   The audio encoding. Always `audio/pcma`.
+          #
+          #   @return [Symbol, :"audio/pcma"]
+          required :type, const: :"audio/pcma"
+
+          # @!method initialize(rate:, type: :"audio/pcma")
+          #   Raw, mono G.711 A-law audio for a Live WebSocket connection.
+          #
+          #   @param rate [Integer]
+          #     Audio sample rate in hertz. G.711 audio uses 8000 Hz.
+          #
+          #   @param type [Symbol, :"audio/pcma"]
+          #     The audio encoding. Always `audio/pcma`.
+        end
+
+        # @!method self.variants
+        #   @return [Array(OpenAI::Models::Live::AudioFormat::AudioPCM, OpenAI::Models::Live::AudioFormat::AudioPCMU, OpenAI::Models::Live::AudioFormat::AudioPCMA)]
+      end
+    end
+  end
+end

data/lib/openai/models/live/built_in_voice.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module OpenAI
+  module Models
+    module Live
+      # A built-in voice available for Live speech.
+      module BuiltInVoice
+        extend OpenAI::Internal::Type::Enum
+
+        ALLOY = :alloy
+        ASH = :ash
+        BALLAD = :ballad
+        BEACON = :beacon
+        BOSSA = :bossa
+        CEDAR = :cedar
+        CINDER = :cinder
+        CORAL = :coral
+        DELTA = :delta
+        ECHO = :echo
+        GLEAM = :gleam
+        MARIN = :marin
+        MERIDIAN = :meridian
+        QUARTZ = :quartz
+        RIPPLE = :ripple
+        SAGE = :sage
+        SHIMMER = :shimmer
+        STONE = :stone
+        TEMPO = :tempo
+        VERSE = :verse
+        VESPER = :vesper
+        WILLOW = :willow
+
+        # @!method self.values
+        #   @return [Array<Symbol>]
+      end
+    end
+  end
+end

data/lib/openai/models/live/client_config.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module OpenAI
+  module Models
+    module Live
+      class ClientConfig < OpenAI::Internal::Type::BaseModel
+        # @!attribute data_channel
+        #   Client and server event permissions for the WebRTC frontend data channel.
+        #
+        #   @return [OpenAI::Models::Live::DataChannelConfig]
+        required :data_channel, -> { OpenAI::Live::DataChannelConfig }
+
+        # @!method initialize(data_channel:)
+        #   Startup-only capabilities for an untrusted frontend attached to a unified WebRTC
+        #   session. Trusted sideband connections are unaffected.
+        #
+        #   @param data_channel [OpenAI::Models::Live::DataChannelConfig]
+        #     Client and server event permissions for the WebRTC frontend data channel.
+      end
+    end
+  end
+end

data/lib/openai/models/live/client_delegation.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module OpenAI
+  module Models
+    module Live
+      class ClientDelegation < OpenAI::Internal::Type::BaseModel
+        # @!attribute type
+        #   The delegation owner. Always `client` for tasks handled by your application.
+        #
+        #   @return [Symbol, :client]
+        required :type, const: :client
+
+        # @!method initialize(type: :client)
+        #   Delegate tasks to your application. The Live session emits delegation events
+        #   that your backend handles.
+        #
+        #   @param type [Symbol, :client]
+        #     The delegation owner. Always `client` for tasks handled by your application.
+      end
+    end
+  end
+end

data/lib/openai/models/live/client_event.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module OpenAI
+  module Models
+    module Live
+      # Client events for Live. Initialize a primary WebSocket with session.start and
+      # wait for session.started. WebRTC creation already starts the session. Audio
+      # append is primary WebSocket-only. See the
+      # [Live prompting guide](https://developers.openai.com/api/docs/guides/live-prompting)
+      # before writing frontend instructions and delegation policies.
+      module ClientEvent
+        extend OpenAI::Internal::Type::Union
+
+        discriminator :type
+
+        # Start a Live session on a primary WebSocket. Send this event before other commands and wait for `session.started`.
+        variant :"session.start", -> { OpenAI::Live::SessionStartEvent }
+
+        # Update the delegation settings of an active Live session. The server acknowledges accepted changes with `session.updated`.
+        variant :"session.update", -> { OpenAI::Live::SessionUpdateEvent }
+
+        # Send audio to a Live session over its primary WebSocket. WebRTC and SIP sessions send audio over their media transport.
+        variant :"session.input_audio.append", -> { OpenAI::Live::InputAudioAppendEvent }
+
+        # Mute audio input to the Live model without closing the session. The server acknowledges with `session.input_audio.muted`.
+        variant :"session.input_audio.mute", -> { OpenAI::Live::InputAudioMuteEvent }
+
+        # Resume audio input to a Live model after muting it. The server acknowledges with `session.input_audio.unmuted`.
+        variant :"session.input_audio.unmute", -> { OpenAI::Live::InputAudioUnmuteEvent }
+
+        # Append instructions to the Live conversation while it is running, optionally associating them with an existing client delegation.
+        variant :"session.instructions.append", -> { OpenAI::Live::InstructionsAppendEvent }
+
+        # Provide silent reasoning or progress context to the Live model, optionally for an existing client delegation.
+        variant :"session.thinking.append", -> { OpenAI::Live::ThinkingAppendEvent }
+
+        # Provide context the Live model can communicate to the user, optionally for an existing client delegation.
+        variant :"session.commentary.append", -> { OpenAI::Live::CommentaryAppendEvent }
+
+        # Add an input item to the Live session’s Responses backend. Requires Responses delegation; use `response.create` to request a response.
+        variant :"response.item.create", -> { OpenAI::Live::ResponseItemCreateEvent }
+
+        # Request a response from the Live session’s Responses backend, or continue a delegated response waiting for tool results. Requires Responses delegation.
+        variant :"response.create", -> { OpenAI::Live::ResponseCreateEvent }
+
+        # Request that the Live session close. The terminal `session.closed` event contains the close reason and final usage.
+        variant :"session.close", -> { OpenAI::Live::SessionCloseEvent }
+
+        # @!method self.variants
+        #   @return [Array(OpenAI::Models::Live::SessionStartEvent, OpenAI::Models::Live::SessionUpdateEvent, OpenAI::Models::Live::InputAudioAppendEvent, OpenAI::Models::Live::InputAudioMuteEvent, OpenAI::Models::Live::InputAudioUnmuteEvent, OpenAI::Models::Live::InstructionsAppendEvent, OpenAI::Models::Live::ThinkingAppendEvent, OpenAI::Models::Live::CommentaryAppendEvent, OpenAI::Models::Live::ResponseItemCreateEvent, OpenAI::Models::Live::ResponseCreateEvent, OpenAI::Models::Live::SessionCloseEvent)]
+      end
+    end
+  end
+end

data/lib/openai/models/live/commentary_append_event.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module OpenAI
+  module Models
+    module Live
+      class CommentaryAppendEvent < OpenAI::Internal::Type::BaseModel
+        # @!attribute content
+        #   Speakable context for the Live model, limited to 500 tokens. Use this for a
+        #   result the model should communicate; use session.thinking.append for silent
+        #   context.
+        #
+        #   @return [String]
+        required :content, String
+
+        # @!attribute delegation_id
+        #   Required, nullable. Set null for general session context, or use the ID from
+        #   session.delegation.created for an existing client delegation. Non-null IDs are
+        #   not accepted with Responses delegation.
+        #
+        #   @return [String, nil]
+        required :delegation_id, String, nil?: true
+
+        # @!attribute type
+        #   The Live client event type. Always `session.commentary.append`.
+        #
+        #   @return [Symbol, :"session.commentary.append"]
+        required :type, const: :"session.commentary.append"
+
+        # @!attribute event_id
+        #   Optional client identifier for correlating this command with a server event's
+        #   client_event_id or error.client_event_id.
+        #
+        #   @return [String, nil]
+        optional :event_id, String, nil?: true
+
+        # @!method initialize(content:, delegation_id:, event_id: nil, type: :"session.commentary.append")
+        #   Provide context the Live model can communicate to the user, optionally for an
+        #   existing client delegation.
+        #
+        #   @param content [String]
+        #     Speakable context for the Live model, limited to 500 tokens. Use this for a
+        #     result the model should communicate; use session.thinking.append for silent
+        #     context.
+        #
+        #   @param delegation_id [String, nil]
+        #     Required, nullable. Set null for general session context, or use the ID from
+        #     session.delegation.created for an existing client delegation. Non-null IDs are
+        #     not accepted with Responses delegation.
+        #
+        #   @param event_id [String, nil]
+        #     Optional client identifier for correlating this command with a server event's
+        #     client_event_id or error.client_event_id.
+        #
+        #   @param type [Symbol, :"session.commentary.append"]
+        #     The Live client event type. Always `session.commentary.append`.
+      end
+    end
+  end
+end

data/lib/openai/models/live/commentary_appended_event.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module OpenAI
+  module Models
+    module Live
+      class CommentaryAppendedEvent < OpenAI::Internal::Type::BaseModel
+        # @!attribute end_ms
+        #   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.
+        #
+        #   @return [Integer]
+        required :end_ms, Integer
+
+        # @!attribute event_id
+        #   The unique ID of the Live server event.
+        #
+        #   @return [String]
+        required :event_id, String
+
+        # @!attribute start_ms
+        #   The start of this event on the Live session timeline, in milliseconds from the
+        #   beginning of the session.
+        #
+        #   @return [Integer]
+        required :start_ms, Integer
+
+        # @!attribute type
+        #   The event type, always `session.commentary.appended`.
+        #
+        #   @return [Symbol, :"session.commentary.appended"]
+        required :type, const: :"session.commentary.appended"
+
+        # @!attribute client_event_id
+        #   The event_id of the client command associated with this server event, when
+        #   supplied.
+        #
+        #   @return [String, nil]
+        optional :client_event_id, String
+
+        # @!method initialize(end_ms:, event_id:, start_ms:, client_event_id: nil, type: :"session.commentary.appended")
+        #   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.
+        #
+        #   @param end_ms [Integer]
+        #     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.
+        #
+        #   @param event_id [String]
+        #     The unique ID of the Live server event.
+        #
+        #   @param start_ms [Integer]
+        #     The start of this event on the Live session timeline, in milliseconds from the
+        #     beginning of the session.
+        #
+        #   @param client_event_id [String]
+        #     The event_id of the client command associated with this server event, when
+        #     supplied.
+        #
+        #   @param type [Symbol, :"session.commentary.appended"]
+        #     The event type, always `session.commentary.appended`.
+      end
+    end
+  end
+end

data/lib/openai/models/live/custom_voice.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module OpenAI
+  module Models
+    module Live
+      class CustomVoice < OpenAI::Internal::Type::BaseModel
+        # @!attribute id
+        #
+        #   @return [String]
+        required :id, String
+
+        # @!method initialize(id:)
+        #   @param id [String]
+      end
+    end
+  end
+end

data/lib/openai/models/live/data_channel_config.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module OpenAI
+  module Models
+    module Live
+      class DataChannelConfig < OpenAI::Internal::Type::BaseModel
+        # @!attribute allowed_client_events
+        #   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.
+        #
+        #   @return [Symbol, :all, Array<String>, nil]
+        optional :allowed_client_events, union: -> { OpenAI::Live::DataChannelConfig::AllowedClientEvents }
+
+        # @!attribute allowed_server_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.
+        #
+        #   @return [Symbol, :all, Array<OpenAI::Models::Live::ServerEventSelector>, nil]
+        optional :allowed_server_events, union: -> { OpenAI::Live::DataChannelConfig::AllowedServerEvents }
+
+        # @!method initialize(allowed_client_events: nil, allowed_server_events: nil)
+        #   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.
+        #
+        #   @param allowed_client_events [Symbol, :all, Array<String>]
+        #     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.
+        #
+        #   @param allowed_server_events [Symbol, :all, Array<OpenAI::Models::Live::ServerEventSelector>]
+        #     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.
+
+        # 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.
+        #
+        # @see OpenAI::Models::Live::DataChannelConfig#allowed_client_events
+        module AllowedClientEvents
+          extend OpenAI::Internal::Type::Union
+
+          variant const: :all
+
+          variant -> { OpenAI::Models::Live::DataChannelConfig::AllowedClientEvents::StringArray }
+
+          # @!method self.variants
+          #   @return [Array(Symbol, :all, Array<String>)]
+
+          # @type [OpenAI::Internal::Type::Converter]
+          StringArray = OpenAI::Internal::Type::ArrayOf[String]
+        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.
+        #
+        # @see OpenAI::Models::Live::DataChannelConfig#allowed_server_events
+        module AllowedServerEvents
+          extend OpenAI::Internal::Type::Union
+
+          variant const: :all
+
+          variant -> { OpenAI::Models::Live::DataChannelConfig::AllowedServerEvents::ServerEventSelectorArray }
+
+          # @!method self.variants
+          #   @return [Array(Symbol, :all, Array<OpenAI::Models::Live::ServerEventSelector>)]
+
+          # @type [OpenAI::Internal::Type::Converter]
+          ServerEventSelectorArray = OpenAI::Internal::Type::ArrayOf[-> { OpenAI::Live::ServerEventSelector }]
+        end
+      end
+    end
+  end
+end

data/lib/openai/models/live/delegation_created_event.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module OpenAI
+  module Models
+    module Live
+      class DelegationCreatedEvent < OpenAI::Internal::Type::BaseModel
+        # @!attribute delegation
+        #   The delegated work identifier and destination. This object contains metadata,
+        #   not the task text.
+        #
+        #   @return [OpenAI::Models::Live::DelegationCreatedEvent::Delegation]
+        required :delegation, -> { OpenAI::Live::DelegationCreatedEvent::Delegation }
+
+        # @!attribute event_id
+        #   The unique ID of the Live server event.
+        #
+        #   @return [String]
+        required :event_id, String
+
+        # @!attribute offset_ms
+        #   The position on the Live session timeline where the delegation was created, in
+        #   milliseconds from the beginning of the session.
+        #
+        #   @return [Integer]
+        required :offset_ms, Integer
+
+        # @!attribute type
+        #   The event type, always `session.delegation.created`.
+        #
+        #   @return [Symbol, :"session.delegation.created"]
+        required :type, const: :"session.delegation.created"
+
+        # @!attribute client_event_id
+        #   The event_id of the client command associated with this server event, when
+        #   supplied.
+        #
+        #   @return [String, nil]
+        optional :client_event_id, String
+
+        # @!method initialize(delegation:, event_id:, offset_ms:, client_event_id: nil, type: :"session.delegation.created")
+        #   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.
+        #
+        #   @param delegation [OpenAI::Models::Live::DelegationCreatedEvent::Delegation]
+        #     The delegated work identifier and destination. This object contains metadata,
+        #     not the task text.
+        #
+        #   @param event_id [String]
+        #     The unique ID of the Live server event.
+        #
+        #   @param offset_ms [Integer]
+        #     The position on the Live session timeline where the delegation was created, in
+        #     milliseconds from the beginning of the session.
+        #
+        #   @param client_event_id [String]
+        #     The event_id of the client command associated with this server event, when
+        #     supplied.
+        #
+        #   @param type [Symbol, :"session.delegation.created"]
+        #     The event type, always `session.delegation.created`.
+
+        # @see OpenAI::Models::Live::DelegationCreatedEvent#delegation
+        class Delegation < OpenAI::Internal::Type::BaseModel
+          # @!attribute id
+          #   The unique ID of the delegation. Use this as delegation_id when replying to
+          #   client-owned work or correlating Responses events.
+          #
+          #   @return [String]
+          required :id, String
+
+          # @!attribute target
+          #   Where the Live model delegated the work: `client` for your application, or
+          #   `responses` for the configured Responses backend.
+          #
+          #   @return [Symbol, OpenAI::Models::Live::DelegationCreatedEvent::Delegation::Target]
+          required :target, union: -> { OpenAI::Live::DelegationCreatedEvent::Delegation::Target }
+
+          # @!attribute type
+          #   The object type, always `delegation`.
+          #
+          #   @return [Symbol, :delegation]
+          required :type, const: :delegation
+
+          # @!attribute response_id
+          #   The ID of the Responses API response associated with a Responses delegation.
+          #   Omitted for client delegations.
+          #
+          #   @return [String, nil]
+          optional :response_id, String
+
+          # @!method initialize(id:, target:, response_id: nil, type: :delegation)
+          #   The delegated work identifier and destination. This object contains metadata,
+          #   not the task text.
+          #
+          #   @param id [String]
+          #     The unique ID of the delegation. Use this as delegation_id when replying to
+          #     client-owned work or correlating Responses events.
+          #
+          #   @param target [Symbol, OpenAI::Models::Live::DelegationCreatedEvent::Delegation::Target]
+          #     Where the Live model delegated the work: `client` for your application, or
+          #     `responses` for the configured Responses backend.
+          #
+          #   @param response_id [String]
+          #     The ID of the Responses API response associated with a Responses delegation.
+          #     Omitted for client delegations.
+          #
+          #   @param type [Symbol, :delegation]
+          #     The object type, always `delegation`.
+
+          # Where the Live model delegated the work: `client` for your application, or
+          # `responses` for the configured Responses backend.
+          #
+          # @see OpenAI::Models::Live::DelegationCreatedEvent::Delegation#target
+          module Target
+            extend OpenAI::Internal::Type::Union
+
+            variant const: -> { OpenAI::Models::Live::DelegationCreatedEvent::Delegation::Target::CLIENT }
+
+            variant const: -> { OpenAI::Models::Live::DelegationCreatedEvent::Delegation::Target::RESPONSES }
+
+            # @!method self.variants
+            #   @return [Array(Symbol)]
+
+            define_sorbet_constant!(:Variants) do
+              T.type_alias { OpenAI::Live::DelegationCreatedEvent::Delegation::Target::TaggedSymbol }
+            end
+
+            # @!group
+
+            CLIENT = :client
+            RESPONSES = :responses
+
+            # @!endgroup
+          end
+        end
+      end
+    end
+  end
+end

data/lib/openai/models/live/error.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module OpenAI
+  module Models
+    module Live
+      class Error < OpenAI::Internal::Type::BaseModel
+        # @!attribute code
+        #   A machine-readable code identifying the Live error, such as `unknown_parameter`.
+        #
+        #   @return [String]
+        required :code, String
+
+        # @!attribute message
+        #   A human-readable explanation of the Live error.
+        #
+        #   @return [String]
+        required :message, String
+
+        # @!attribute type
+        #   The category of error, such as `invalid_request_error` for an invalid Live
+        #   client command.
+        #
+        #   @return [String]
+        required :type, String
+
+        # @!attribute client_event_id
+        #   The event_id of the client command that caused the error, when supplied.
+        #
+        #   @return [String, nil]
+        optional :client_event_id, String
+
+        # @!attribute param
+        #   The parameter that caused the error, when applicable, such as `session.voice`.
+        #
+        #   @return [String, nil]
+        optional :param, String
+
+        # @!method initialize(code:, message:, type:, client_event_id: nil, param: nil)
+        #   Details of an error encountered by the Live session, including the affected
+        #   parameter or client command when available.
+        #
+        #   @param code [String]
+        #     A machine-readable code identifying the Live error, such as `unknown_parameter`.
+        #
+        #   @param message [String]
+        #     A human-readable explanation of the Live error.
+        #
+        #   @param type [String]
+        #     The category of error, such as `invalid_request_error` for an invalid Live
+        #     client command.
+        #
+        #   @param client_event_id [String]
+        #     The event_id of the client command that caused the error, when supplied.
+        #
+        #   @param param [String]
+        #     The parameter that caused the error, when applicable, such as `session.voice`.
+      end
+    end
+  end
+end