openai 0.103.0 → 0.105.0

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

@@ -28,15 +28,16 @@ module OpenAI
 
         # @!attribute delegation
         #   Who handles tasks delegated by the Live model. Omitted or null selects your
-        #   application; use `responses` to let the API manage a Responses backend.
+        #   application; use `responses` or `decisions` to delegate to the corresponding
+        #   API.
         #
-        #   @return [OpenAI::Models::Live::ClientDelegation, OpenAI::Models::Live::SessionConfig::Delegation::Responses, nil]
+        #   @return [OpenAI::Models::Live::ClientDelegation, OpenAI::Models::Live::SessionConfig::Delegation::Responses, OpenAI::Models::Live::SessionConfig::Delegation::Decisions, nil]
         optional :delegation, union: -> { OpenAI::Live::SessionConfig::Delegation }, nil?: true
 
         # @!attribute input
         #   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.
+        #   assistant messages with one text part each; at most 128 messages and a
+        #   configured rendered-token limit (8,192 by default).
         #
         #   @return [Array<OpenAI::Models::Live::InitialItem::Developer, OpenAI::Models::Live::InitialItem::User, OpenAI::Models::Live::InitialItem::Assistant>, nil]
         optional :input, -> { OpenAI::Internal::Type::ArrayOf[union: OpenAI::Live::InitialItem] }
@@ -60,7 +61,16 @@ module OpenAI
         #   @return [Boolean, nil]
         optional :store, OpenAI::Internal::Type::Boolean
 
-        # @!method initialize(model:, audio: nil, client: nil, delegation: nil, input: nil, instructions: nil, store: nil)
+        # @!attribute triggers
+        #   At most one Decisions trigger per transcript event type. Triggers run
+        #   independently of delegation. On update, omit triggers to keep the current
+        #   configuration, send a list to replace it, or send an empty list to disable
+        #   triggers.
+        #
+        #   @return [Array<OpenAI::Models::Live::DecisionTrigger>, nil]
+        optional :triggers, -> { OpenAI::Internal::Type::ArrayOf[OpenAI::Live::DecisionTrigger] }
+
+        # @!method initialize(model:, audio: nil, client: nil, delegation: nil, input: nil, instructions: nil, store: nil, triggers: nil)
         #   Initial configuration for a Live session, including its model, conversation
         #   instructions, audio, and delegated task handling.
         #
@@ -77,14 +87,15 @@ module OpenAI
         #     Startup-only capabilities for an untrusted frontend attached to a unified WebRTC
         #     session. Trusted sideband connections are unaffected.
         #
-        #   @param delegation [OpenAI::Models::Live::ClientDelegation, OpenAI::Models::Live::SessionConfig::Delegation::Responses, nil]
+        #   @param delegation [OpenAI::Models::Live::ClientDelegation, OpenAI::Models::Live::SessionConfig::Delegation::Responses, OpenAI::Models::Live::SessionConfig::Delegation::Decisions, 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.
+        #     application; use `responses` or `decisions` to delegate to the corresponding
+        #     API.
         #
         #   @param input [Array<OpenAI::Models::Live::InitialItem::Developer, OpenAI::Models::Live::InitialItem::User, OpenAI::Models::Live::InitialItem::Assistant>]
         #     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.
+        #     assistant messages with one text part each; at most 128 messages and a
+        #     configured rendered-token limit (8,192 by default).
         #
         #   @param instructions [String, nil]
         #     Frontend instructions for voice, conversation, interruptions, and when to
@@ -98,6 +109,12 @@ module OpenAI
         #   @param store [Boolean]
         #     Whether to store the session for later forking and recording download. Defaults
         #     to false for new sessions.
+        #
+        #   @param triggers [Array<OpenAI::Models::Live::DecisionTrigger>]
+        #     At most one Decisions trigger per transcript event type. Triggers run
+        #     independently of delegation. On update, omit triggers to keep the current
+        #     configuration, send a list to replace it, or send an empty list to disable
+        #     triggers.
 
         # The Live model. Required in the session configuration for every transport; do
         # not pass it as a URL query parameter.
@@ -188,7 +205,8 @@ module OpenAI
         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.
+        # application; use `responses` or `decisions` to delegate to the corresponding
+        # API.
         #
         # @see OpenAI::Models::Live::SessionConfig#delegation
         module Delegation
@@ -202,6 +220,8 @@ module OpenAI
           # Delegate tasks to a Responses model managed by the Live session.
           variant :responses, -> { OpenAI::Live::SessionConfig::Delegation::Responses }
 
+          variant :decisions, -> { OpenAI::Live::SessionConfig::Delegation::Decisions }
+
           class Responses < OpenAI::Internal::Type::BaseModel
             # @!attribute responses
             #   Backend model, prompt, and tools used when the Live session delegates a task to
@@ -227,8 +247,24 @@ module OpenAI
             #     The delegation owner. Always `responses` for tasks handled by the Responses API.
           end
 
+          class Decisions < OpenAI::Internal::Type::BaseModel
+            # @!attribute decisions
+            #
+            #   @return [OpenAI::Models::Live::DecisionsDelegationConfig]
+            required :decisions, -> { OpenAI::Live::DecisionsDelegationConfig }
+
+            # @!attribute type
+            #
+            #   @return [Symbol, :decisions]
+            required :type, const: :decisions
+
+            # @!method initialize(decisions:, type: :decisions)
+            #   @param decisions [OpenAI::Models::Live::DecisionsDelegationConfig]
+            #   @param type [Symbol, :decisions]
+          end
+
           # @!method self.variants
-          #   @return [Array(OpenAI::Models::Live::ClientDelegation, OpenAI::Models::Live::SessionConfig::Delegation::Responses)]
+          #   @return [Array(OpenAI::Models::Live::ClientDelegation, OpenAI::Models::Live::SessionConfig::Delegation::Responses, OpenAI::Models::Live::SessionConfig::Delegation::Decisions)]
         end
       end
     end

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

@@ -49,15 +49,16 @@ module OpenAI
 
         # @!attribute delegation
         #   Who handles tasks delegated by the Live model. Omitted or null selects your
-        #   application; use `responses` to let the API manage a Responses backend.
+        #   application; use `responses` or `decisions` to delegate to the corresponding
+        #   API.
         #
-        #   @return [OpenAI::Models::Live::ClientDelegation, OpenAI::Models::Live::SessionResource::Delegation::Responses, nil]
+        #   @return [OpenAI::Models::Live::ClientDelegation, OpenAI::Models::Live::SessionResource::Delegation::Responses, OpenAI::Models::Live::SessionResource::Delegation::Decisions, nil]
         optional :delegation, union: -> { OpenAI::Live::SessionResource::Delegation }, nil?: true
 
         # @!attribute input
         #   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.
+        #   assistant messages with one text part each; at most 128 messages and a
+        #   configured rendered-token limit (8,192 by default).
         #
         #   @return [Array<OpenAI::Models::Live::InitialItem::Developer, OpenAI::Models::Live::InitialItem::User, OpenAI::Models::Live::InitialItem::Assistant>, nil]
         optional :input, -> { OpenAI::Internal::Type::ArrayOf[union: OpenAI::Live::InitialItem] }
@@ -81,7 +82,16 @@ module OpenAI
         #   @return [Boolean, nil]
         optional :store, OpenAI::Internal::Type::Boolean
 
-        # @!method initialize(id:, expires_at:, model:, audio: nil, client: nil, delegation: nil, input: nil, instructions: nil, store: nil, status: :active)
+        # @!attribute triggers
+        #   At most one Decisions trigger per transcript event type. Triggers run
+        #   independently of delegation. On update, omit triggers to keep the current
+        #   configuration, send a list to replace it, or send an empty list to disable
+        #   triggers.
+        #
+        #   @return [Array<OpenAI::Models::Live::DecisionTrigger>, nil]
+        optional :triggers, -> { OpenAI::Internal::Type::ArrayOf[OpenAI::Live::DecisionTrigger] }
+
+        # @!method initialize(id:, expires_at:, model:, audio: nil, client: nil, delegation: nil, input: nil, instructions: nil, store: nil, triggers: nil, status: :active)
         #   The resolved Live session configuration and server-assigned session metadata.
         #
         #   @param id [String]
@@ -104,14 +114,15 @@ module OpenAI
         #     Startup-only capabilities for an untrusted frontend attached to a unified WebRTC
         #     session. Trusted sideband connections are unaffected.
         #
-        #   @param delegation [OpenAI::Models::Live::ClientDelegation, OpenAI::Models::Live::SessionResource::Delegation::Responses, nil]
+        #   @param delegation [OpenAI::Models::Live::ClientDelegation, OpenAI::Models::Live::SessionResource::Delegation::Responses, OpenAI::Models::Live::SessionResource::Delegation::Decisions, 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.
+        #     application; use `responses` or `decisions` to delegate to the corresponding
+        #     API.
         #
         #   @param input [Array<OpenAI::Models::Live::InitialItem::Developer, OpenAI::Models::Live::InitialItem::User, OpenAI::Models::Live::InitialItem::Assistant>]
         #     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.
+        #     assistant messages with one text part each; at most 128 messages and a
+        #     configured rendered-token limit (8,192 by default).
         #
         #   @param instructions [String, nil]
         #     Frontend instructions for voice, conversation, interruptions, and when to
@@ -126,6 +137,12 @@ module OpenAI
         #     Whether to store the session for later forking and recording download. Defaults
         #     to false for new sessions.
         #
+        #   @param triggers [Array<OpenAI::Models::Live::DecisionTrigger>]
+        #     At most one Decisions trigger per transcript event type. Triggers run
+        #     independently of delegation. On update, omit triggers to keep the current
+        #     configuration, send a list to replace it, or send an empty list to disable
+        #     triggers.
+        #
         #   @param status [Symbol, :active]
         #     The status of the session snapshot. Always `active`, including the final
         #     snapshot in session.closed; use the event type to determine that the session has
@@ -220,7 +237,8 @@ module OpenAI
         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.
+        # application; use `responses` or `decisions` to delegate to the corresponding
+        # API.
         #
         # @see OpenAI::Models::Live::SessionResource#delegation
         module Delegation
@@ -234,6 +252,8 @@ module OpenAI
           # Delegate tasks to a Responses model managed by the Live session.
           variant :responses, -> { OpenAI::Live::SessionResource::Delegation::Responses }
 
+          variant :decisions, -> { OpenAI::Live::SessionResource::Delegation::Decisions }
+
           class Responses < OpenAI::Internal::Type::BaseModel
             # @!attribute responses
             #   Backend model, prompt, and tools used when the Live session delegates a task to
@@ -259,8 +279,24 @@ module OpenAI
             #     The delegation owner. Always `responses` for tasks handled by the Responses API.
           end
 
+          class Decisions < OpenAI::Internal::Type::BaseModel
+            # @!attribute decisions
+            #
+            #   @return [OpenAI::Models::Live::DecisionsDelegationConfig]
+            required :decisions, -> { OpenAI::Live::DecisionsDelegationConfig }
+
+            # @!attribute type
+            #
+            #   @return [Symbol, :decisions]
+            required :type, const: :decisions
+
+            # @!method initialize(decisions:, type: :decisions)
+            #   @param decisions [OpenAI::Models::Live::DecisionsDelegationConfig]
+            #   @param type [Symbol, :decisions]
+          end
+
           # @!method self.variants
-          #   @return [Array(OpenAI::Models::Live::ClientDelegation, OpenAI::Models::Live::SessionResource::Delegation::Responses)]
+          #   @return [Array(OpenAI::Models::Live::ClientDelegation, OpenAI::Models::Live::SessionResource::Delegation::Responses, OpenAI::Models::Live::SessionResource::Delegation::Decisions)]
         end
       end
     end

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

@@ -8,16 +8,30 @@ module OpenAI
         #   Delegation settings to update. The delegation type must match the current
         #   session; omitted settings retain their values.
         #
-        #   @return [OpenAI::Models::Live::ClientDelegation, OpenAI::Models::Live::SessionUpdateConfig::Delegation::Responses, nil]
+        #   @return [OpenAI::Models::Live::ClientDelegation, OpenAI::Models::Live::SessionUpdateConfig::Delegation::Responses, OpenAI::Models::Live::SessionUpdateConfig::Delegation::Decisions, nil]
         optional :delegation, union: -> { OpenAI::Live::SessionUpdateConfig::Delegation }, nil?: true
 
-        # @!method initialize(delegation: nil)
-        #   Changes to an active Live session. Only delegation backend settings can be
-        #   updated after startup.
+        # @!attribute triggers
+        #   At most one Decisions trigger per transcript event type. Triggers run
+        #   independently of delegation. On update, omit triggers to keep the current
+        #   configuration, send a list to replace it, or send an empty list to disable
+        #   triggers.
         #
-        #   @param delegation [OpenAI::Models::Live::ClientDelegation, OpenAI::Models::Live::SessionUpdateConfig::Delegation::Responses, nil]
+        #   @return [Array<OpenAI::Models::Live::DecisionTrigger>, nil]
+        optional :triggers, -> { OpenAI::Internal::Type::ArrayOf[OpenAI::Live::DecisionTrigger] }
+
+        # @!method initialize(delegation: nil, triggers: nil)
+        #   Changes to an active Live session's delegation settings and transcript triggers.
+        #
+        #   @param delegation [OpenAI::Models::Live::ClientDelegation, OpenAI::Models::Live::SessionUpdateConfig::Delegation::Responses, OpenAI::Models::Live::SessionUpdateConfig::Delegation::Decisions, nil]
         #     Delegation settings to update. The delegation type must match the current
         #     session; omitted settings retain their values.
+        #
+        #   @param triggers [Array<OpenAI::Models::Live::DecisionTrigger>]
+        #     At most one Decisions trigger per transcript event type. Triggers run
+        #     independently of delegation. On update, omit triggers to keep the current
+        #     configuration, send a list to replace it, or send an empty list to disable
+        #     triggers.
 
         # Delegation settings to update. The delegation type must match the current
         # session; omitted settings retain their values.
@@ -34,6 +48,8 @@ module OpenAI
           # Update the Responses backend for an existing Live session without changing delegation ownership.
           variant :responses, -> { OpenAI::Live::SessionUpdateConfig::Delegation::Responses }
 
+          variant :decisions, -> { OpenAI::Live::SessionUpdateConfig::Delegation::Decisions }
+
           class Responses < OpenAI::Internal::Type::BaseModel
             # @!attribute type
             #   The delegation owner. Always `responses` for tasks handled by the Responses API.
@@ -60,8 +76,24 @@ module OpenAI
             #     The delegation owner. Always `responses` for tasks handled by the Responses API.
           end
 
+          class Decisions < OpenAI::Internal::Type::BaseModel
+            # @!attribute type
+            #
+            #   @return [Symbol, :decisions]
+            required :type, const: :decisions
+
+            # @!attribute decisions
+            #
+            #   @return [OpenAI::Models::Live::DecisionsDelegationUpdateConfig, nil]
+            optional :decisions, -> { OpenAI::Live::DecisionsDelegationUpdateConfig }
+
+            # @!method initialize(decisions: nil, type: :decisions)
+            #   @param decisions [OpenAI::Models::Live::DecisionsDelegationUpdateConfig]
+            #   @param type [Symbol, :decisions]
+          end
+
           # @!method self.variants
-          #   @return [Array(OpenAI::Models::Live::ClientDelegation, OpenAI::Models::Live::SessionUpdateConfig::Delegation::Responses)]
+          #   @return [Array(OpenAI::Models::Live::ClientDelegation, OpenAI::Models::Live::SessionUpdateConfig::Delegation::Responses, OpenAI::Models::Live::SessionUpdateConfig::Delegation::Decisions)]
         end
       end
     end

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

@@ -5,9 +5,9 @@ module OpenAI
     module Live
       class SessionUpdateEvent < OpenAI::Internal::Type::BaseModel
         # @!attribute session
-        #   Sparse delegation updates. Omitted settings retain their values. The delegation
-        #   type cannot change, including resetting Responses delegation to null or client.
-        #   Model, frontend instructions, audio, and startup input are immutable.
+        #   Sparse delegation and trigger updates. Omitted settings retain their values. The
+        #   delegation type cannot change. Model, frontend instructions, audio, and startup
+        #   input are immutable.
         #
         #   @return [OpenAI::Models::Live::SessionUpdateConfig]
         required :session, -> { OpenAI::Live::SessionUpdateConfig }
@@ -26,13 +26,13 @@ module OpenAI
         optional :event_id, String, nil?: true
 
         # @!method initialize(session:, event_id: nil, type: :"session.update")
-        #   Update the delegation settings of an active Live session. The server
-        #   acknowledges accepted changes with `session.updated`.
+        #   Update the delegation settings or transcript triggers of an active Live session.
+        #   The server acknowledges accepted changes with `session.updated`.
         #
         #   @param session [OpenAI::Models::Live::SessionUpdateConfig]
-        #     Sparse delegation updates. Omitted settings retain their values. The delegation
-        #     type cannot change, including resetting Responses delegation to null or client.
-        #     Model, frontend instructions, audio, and startup input are immutable.
+        #     Sparse delegation and trigger updates. Omitted settings retain their values. The
+        #     delegation type cannot change. Model, frontend instructions, audio, and startup
+        #     input are immutable.
         #
         #   @param event_id [String, nil]
         #     Optional client identifier for correlating this command with a server event's

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module OpenAI
+  module Models
+    module Live
+      # Client events accepted by an attached Live sideband WebSocket. The session has
+      # already started. Send input audio over the primary connection.
+      module SidebandClientEvent
+        extend OpenAI::Internal::Type::Union
+
+        discriminator :type
+
+        # Update the delegation settings or transcript triggers of an active Live session. The server acknowledges accepted changes with `session.updated`.
+        variant :"session.update", -> { OpenAI::Live::SessionUpdateEvent }
+
+        # 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 }
+
+        # Play one complete audio fixture through the session output. Send this event over the primary WebSocket or a server sideband. Audio must be raw mono PCM16 little-endian at 24 kHz, regardless of the session audio format, and at most 30 seconds. The entire payload is validated before model speech is interrupted and input is muted. Only one fixture can be active. fixture.playing acknowledges acceptance and fixture.played reports server mixer drain. These notifications are not exact transport-media boundaries. Input arriving during playback is dropped and not replayed.
+        variant :"session.output_audio.fixture.play", -> { OpenAI::Live::OutputAudioFixturePlayEvent }
+
+        # 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 }
+
+        # Evaluate the configured questions using the current conversation and Decision inputs. Reusing an event_id is rejected for the lifetime of the session.
+        variant :"decision.create", -> { OpenAI::Live::DecisionCreateEvent }
+
+        # Append an input item for future decisions without starting an evaluation or changing Live voice context.
+        variant :"decision.item.create", -> { OpenAI::Live::DecisionItemCreateEvent }
+
+        # Delete an input item from future decisions without starting an evaluation or changing Live voice context.
+        variant :"decision.item.delete", -> { OpenAI::Live::DecisionItemDeleteEvent }
+
+        # 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::SessionUpdateEvent, OpenAI::Models::Live::InputAudioMuteEvent, OpenAI::Models::Live::InputAudioUnmuteEvent, OpenAI::Models::Live::OutputAudioFixturePlayEvent, OpenAI::Models::Live::InstructionsAppendEvent, OpenAI::Models::Live::ThinkingAppendEvent, OpenAI::Models::Live::CommentaryAppendEvent, OpenAI::Models::Live::DecisionCreateEvent, OpenAI::Models::Live::DecisionItemCreateEvent, OpenAI::Models::Live::DecisionItemDeleteEvent, OpenAI::Models::Live::ResponseItemCreateEvent, OpenAI::Models::Live::ResponseCreateEvent, OpenAI::Models::Live::SessionCloseEvent)]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module OpenAI
+  module Models
+    module Live
+      # Server events received by an attached Live sideband WebSocket. Audio deltas are
+      # delivered over the primary connection.
+      module SidebandServerEvent
+        extend OpenAI::Internal::Type::Union
+
+        discriminator :type
+
+        # Returned when a Live session has started. Contains the resolved session configuration, including server defaults.
+        variant :"session.started", -> { OpenAI::Live::SessionStartedEvent }
+
+        # Returned when a Live session update is accepted. Contains the resolved session configuration after the update.
+        variant :"session.updated", -> { OpenAI::Live::SessionUpdatedEvent }
+
+        # Returned when a session.input_audio.mute command is accepted. Input audio is no longer sent to the model; sideband audio reflection continues.
+        variant :"session.input_audio.muted", -> { OpenAI::Live::InputAudioMutedEvent }
+
+        # Returned when a session.input_audio.unmute command is accepted. Input audio is sent to the model again.
+        variant :"session.input_audio.unmuted", -> { OpenAI::Live::InputAudioUnmutedEvent }
+
+        # The existing playback path has accepted the validated audio fixture. This acknowledgment does not identify when the listener receives the first sample. The optional client_event_id echoes the play command.
+        variant :"session.output_audio.fixture.playing", -> { OpenAI::Live::OutputAudioFixturePlayingEvent }
+
+        # The complete audio fixture has drained from the server mixer and normal inference has resumed. Transport buffers may still contain audio; this event does not prove listener-side completion. The optional client_event_id echoes the play command. This event is not emitted for canceled or failed playback.
+        variant :"session.output_audio.fixture.played", -> { OpenAI::Live::OutputAudioFixturePlayedEvent }
+
+        # Returned when a session.instructions.append command is accepted into the Live session timeline. Acknowledges the appended instructions without guaranteeing that the model has acted on them.
+        variant :"session.instructions.appended", -> { OpenAI::Live::InstructionsAppendedEvent }
+
+        # Returned when a session.thinking.append command is accepted into the Live session timeline. Acknowledges the added reasoning context without guaranteeing any spoken output.
+        variant :"session.thinking.appended", -> { OpenAI::Live::ThinkingAppendedEvent }
+
+        # 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.
+        variant :"session.commentary.appended", -> { OpenAI::Live::CommentaryAppendedEvent }
+
+        # A transcript fragment for user input audio in the Live session. Accumulate fragments in delivery order; these events do not define complete turns or include a transcript-done event.
+        variant :"session.input_transcript.delta", -> { OpenAI::Live::InputTranscriptDeltaEvent }
+
+        # A transcript fragment for assistant output audio in the Live session. Accumulate fragments in delivery order; these events do not define complete turns or include a transcript-done event.
+        variant :"session.output_transcript.delta", -> { OpenAI::Live::OutputTranscriptDeltaEvent }
+
+        # Returned when the Live model delegates work to your application, Responses, or Decisions. Contains delegation metadata and the position on the session timeline where the work was delegated.
+        variant :"session.delegation.created", -> { OpenAI::Live::DelegationCreatedEvent }
+
+        # A Decision API event for a Live delegation or transcript trigger. For a trigger, source_event_id identifies the transcript delta that caused this evaluation.
+        variant :"decision.event", -> { OpenAI::Live::DecisionEvent }
+
+        # An input item was appended for future decisions.
+        variant :"decision.item.created", -> { OpenAI::Live::DecisionItemCreatedEvent }
+
+        # An input item was removed from future decisions.
+        variant :"decision.item.deleted", -> { OpenAI::Live::DecisionItemDeletedEvent }
+
+        # A streaming Responses API event from a backend delegated to by the Live session. Use the outer delegation_id to associate the nested stream with its Live delegation.
+        variant :"response.event", -> { OpenAI::Live::ResponseEvent }
+
+        # Reports cumulative Live audio usage and, when available, the most recent context-window usage. Delegated Responses token usage is reported separately in response.event events.
+        variant :"session.usage.updated", -> { OpenAI::Live::SessionUsageUpdatedEvent }
+
+        # Returned after the Live session finishes finalizing, with the close reason, final session snapshot, and cumulative audio usage. A connection closing without this event does not confirm successful finalization.
+        variant :"session.closed", -> { OpenAI::Live::SessionClosedEvent }
+
+        # 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.
+        variant :error, -> { OpenAI::Live::ErrorEvent }
+
+        # An informational notice about the Live session, such as the event permissions applied to a frontend data channel.
+        variant :info, -> { OpenAI::Live::InfoEvent }
+
+        # @!method self.variants
+        #   @return [Array(OpenAI::Models::Live::SessionStartedEvent, OpenAI::Models::Live::SessionUpdatedEvent, OpenAI::Models::Live::InputAudioMutedEvent, OpenAI::Models::Live::InputAudioUnmutedEvent, OpenAI::Models::Live::OutputAudioFixturePlayingEvent, OpenAI::Models::Live::OutputAudioFixturePlayedEvent, OpenAI::Models::Live::InstructionsAppendedEvent, OpenAI::Models::Live::ThinkingAppendedEvent, OpenAI::Models::Live::CommentaryAppendedEvent, OpenAI::Models::Live::InputTranscriptDeltaEvent, OpenAI::Models::Live::OutputTranscriptDeltaEvent, OpenAI::Models::Live::DelegationCreatedEvent, OpenAI::Models::Live::DecisionEvent, OpenAI::Models::Live::DecisionItemCreatedEvent, OpenAI::Models::Live::DecisionItemDeletedEvent, OpenAI::Models::Live::ResponseEvent, OpenAI::Models::Live::SessionUsageUpdatedEvent, OpenAI::Models::Live::SessionClosedEvent, OpenAI::Models::Live::ErrorEvent, OpenAI::Models::Live::InfoEvent)]
+      end
+    end
+  end
+end

data/lib/openai/models/realtime/realtime_audio_config_output.rb

@@ -28,7 +28,8 @@ module OpenAI
         #   `cedar`. You may also provide a custom voice object with an `id`, for example
         #   `{ "id": "voice_1234" }`. Voice cannot be changed during the session once the
         #   model has responded with audio at least once. Custom voices must be created from
-        #   audio samples. We recommend `marin` and `cedar` for best quality.
+        #   audio samples. Voices created from text prompts are supported only in Live. We
+        #   recommend `marin` and `cedar` for best quality.
         #
         #   @return [String, Symbol, OpenAI::Models::Realtime::RealtimeAudioConfigOutput::Voice::ID, OpenAI::Models::Realtime::RealtimeAudioConfigOutput::Voice, nil]
         optional :voice, union: -> { OpenAI::Realtime::RealtimeAudioConfigOutput::Voice }
@@ -52,14 +53,16 @@ module OpenAI
         #     `cedar`. You may also provide a custom voice object with an `id`, for example
         #     `{ "id": "voice_1234" }`. Voice cannot be changed during the session once the
         #     model has responded with audio at least once. Custom voices must be created from
-        #     audio samples. We recommend `marin` and `cedar` for best quality.
+        #     audio samples. Voices created from text prompts are supported only in Live. We
+        #     recommend `marin` and `cedar` for best quality.
 
         # The voice the model uses to respond. Supported built-in voices are `alloy`,
         # `ash`, `ballad`, `coral`, `echo`, `sage`, `shimmer`, `verse`, `marin`, and
         # `cedar`. You may also provide a custom voice object with an `id`, for example
         # `{ "id": "voice_1234" }`. Voice cannot be changed during the session once the
         # model has responded with audio at least once. Custom voices must be created from
-        # audio samples. We recommend `marin` and `cedar` for best quality.
+        # audio samples. Voices created from text prompts are supported only in Live. We
+        # recommend `marin` and `cedar` for best quality.
         #
         # @see OpenAI::Models::Realtime::RealtimeAudioConfigOutput#voice
         module Voice

data/lib/openai/models/realtime/realtime_response_create_audio_output.rb

@@ -28,7 +28,8 @@ module OpenAI
           #   `cedar`. You may also provide a custom voice object with an `id`, for example
           #   `{ "id": "voice_1234" }`. Voice cannot be changed during the session once the
           #   model has responded with audio at least once. Custom voices must be created from
-          #   audio samples. We recommend `marin` and `cedar` for best quality.
+          #   audio samples. Voices created from text prompts are supported only in Live. We
+          #   recommend `marin` and `cedar` for best quality.
           #
           #   @return [String, Symbol, OpenAI::Models::Realtime::RealtimeResponseCreateAudioOutput::Output::Voice::ID, OpenAI::Models::Realtime::RealtimeResponseCreateAudioOutput::Output::Voice, nil]
           optional :voice, union: -> { OpenAI::Realtime::RealtimeResponseCreateAudioOutput::Output::Voice }
@@ -43,14 +44,16 @@ module OpenAI
           #     `cedar`. You may also provide a custom voice object with an `id`, for example
           #     `{ "id": "voice_1234" }`. Voice cannot be changed during the session once the
           #     model has responded with audio at least once. Custom voices must be created from
-          #     audio samples. We recommend `marin` and `cedar` for best quality.
+          #     audio samples. Voices created from text prompts are supported only in Live. We
+          #     recommend `marin` and `cedar` for best quality.
 
           # The voice the model uses to respond. Supported built-in voices are `alloy`,
           # `ash`, `ballad`, `coral`, `echo`, `sage`, `shimmer`, `verse`, `marin`, and
           # `cedar`. You may also provide a custom voice object with an `id`, for example
           # `{ "id": "voice_1234" }`. Voice cannot be changed during the session once the
           # model has responded with audio at least once. Custom voices must be created from
-          # audio samples. We recommend `marin` and `cedar` for best quality.
+          # audio samples. Voices created from text prompts are supported only in Live. We
+          # recommend `marin` and `cedar` for best quality.
           #
           # @see OpenAI::Models::Realtime::RealtimeResponseCreateAudioOutput::Output#voice
           module Voice

data/lib/openai/models/realtime/realtime_response_status.rb

@@ -54,19 +54,28 @@ module OpenAI
           #   @return [String, nil]
           optional :code, String
 
+          # @!attribute message
+          #   A human-readable error message.
+          #
+          #   @return [String, nil]
+          optional :message, String
+
           # @!attribute type
           #   The type of error.
           #
           #   @return [String, nil]
           optional :type, String
 
-          # @!method initialize(code: nil, type: nil)
+          # @!method initialize(code: nil, message: nil, type: nil)
           #   A description of the error that caused the response to fail, populated when the
           #   `status` is `failed`.
           #
           #   @param code [String]
           #     Error code, if any.
           #
+          #   @param message [String]
+          #     A human-readable error message.
+          #
           #   @param type [String]
           #     The type of error.
         end

data/lib/openai/models/response_format_json_schema.rb

@@ -46,7 +46,7 @@ module OpenAI
         #   The schema for the response format, described as a JSON Schema object. Learn how
         #   to build JSON schemas [here](https://json-schema.org/).
         #
-        #   @return [Hash{Symbol=>Object}, nil]
+        #   @return [Hash{Symbol=>Object}, OpenAI::StructuredOutput::JsonSchemaConverter, nil]
         optional(
           :schema,
           union: -> {

data/lib/openai/models/responses/function_tool.rb

@@ -13,13 +13,15 @@ module OpenAI
         # @!attribute parameters
         #   A JSON schema object describing the parameters of the function.
         #
-        #   @return [Hash{Symbol=>Object}, nil]
+        #   @return [Hash{Symbol=>Object}, OpenAI::StructuredOutput::JsonSchemaConverter, nil]
         required(
           :parameters,
-          union: OpenAI::UnionOf[
-            OpenAI::Internal::Type::HashOf[OpenAI::Internal::Type::Unknown],
-            OpenAI::StructuredOutput::JsonSchemaConverter
-          ],
+          union: -> {
+            OpenAI::UnionOf[
+              OpenAI::Internal::Type::HashOf[OpenAI::Internal::Type::Unknown],
+              OpenAI::StructuredOutput::JsonSchemaConverter
+            ]
+          },
           nil?: true
         )
 
@@ -78,7 +80,7 @@ module OpenAI
         #   @param name [String]
         #     The name of the function to call.
         #
-        #   @param parameters [Hash{Symbol=>Object}, nil]
+        #   @param parameters [Hash{Symbol=>Object}, OpenAI::StructuredOutput::JsonSchemaConverter, nil]
         #     A JSON schema object describing the parameters of the function.
         #
         #   @param strict [Boolean, nil]