openai 0.103.0 → 0.104.0

data/rbi/openai/models/live/output_audio_fixture_play_event.rbi

@@ -0,0 +1,76 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Live
+
+      class OutputAudioFixturePlayEvent < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Live::OutputAudioFixturePlayEvent,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # Base64-encoded raw mono PCM16 audio, little-endian, at 24 kHz. Do not include a
+        # WAV or other container header.
+        sig { returns(String) }
+        attr_accessor :audio
+
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # Optional client identifier for correlating this command with a server event's
+        # client_event_id or error.client_event_id.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :event_id
+
+        # 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.
+        sig do
+          params(
+
+            audio: String,
+
+            event_id: T.nilable(String),
+
+            type: Symbol
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # Base64-encoded raw mono PCM16 audio, little-endian, at 24 kHz. Do not include a
+          # WAV or other container header.
+          audio:,
+
+          # Optional client identifier for correlating this command with a server event's
+          # client_event_id or error.client_event_id.
+          event_id: nil,
+
+          type: :"session.output_audio.fixture.play"
+        )
+        end
+
+        sig do
+          override.returns(
+            {audio: String, type: Symbol, event_id: T.nilable(String)}
+          )
+        end
+        def to_hash
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/live/output_audio_fixture_played_event.rbi

@@ -0,0 +1,73 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Live
+
+      class OutputAudioFixturePlayedEvent < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Live::OutputAudioFixturePlayedEvent,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # The unique ID of the Live server event.
+        sig { returns(String) }
+        attr_accessor :event_id
+
+        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
+
+        # 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.
+        sig do
+          params(
+
+            event_id: String,
+
+            client_event_id: String,
+
+            type: Symbol
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # 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,
+
+          type: :"session.output_audio.fixture.played"
+        )
+        end
+
+        sig do
+          override.returns(
+            {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/output_audio_fixture_playing_event.rbi

@@ -0,0 +1,72 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Live
+
+      class OutputAudioFixturePlayingEvent < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Live::OutputAudioFixturePlayingEvent,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # The unique ID of the Live server event.
+        sig { returns(String) }
+        attr_accessor :event_id
+
+        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
+
+        # 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.
+        sig do
+          params(
+
+            event_id: String,
+
+            client_event_id: String,
+
+            type: Symbol
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # 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,
+
+          type: :"session.output_audio.fixture.playing"
+        )
+        end
+
+        sig do
+          override.returns(
+            {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/server_event.rbi

@@ -19,6 +19,8 @@ module OpenAI
             OpenAI::Live::SessionUpdatedEvent,
             OpenAI::Live::InputAudioMutedEvent,
             OpenAI::Live::InputAudioUnmutedEvent,
+            OpenAI::Live::OutputAudioFixturePlayingEvent,
+            OpenAI::Live::OutputAudioFixturePlayedEvent,
             OpenAI::Live::InstructionsAppendedEvent,
             OpenAI::Live::ThinkingAppendedEvent,
             OpenAI::Live::CommentaryAppendedEvent,
@@ -27,6 +29,9 @@ module OpenAI
             OpenAI::Live::InputTranscriptDeltaEvent,
             OpenAI::Live::OutputTranscriptDeltaEvent,
             OpenAI::Live::DelegationCreatedEvent,
+            OpenAI::Live::DecisionEvent,
+            OpenAI::Live::DecisionItemCreatedEvent,
+            OpenAI::Live::DecisionItemDeletedEvent,
             OpenAI::Live::ResponseEvent,
             OpenAI::Live::SessionUsageUpdatedEvent,
             OpenAI::Live::SessionClosedEvent,

data/rbi/openai/models/live/session_accept_params.rbi

@@ -89,19 +89,24 @@ module OpenAI
           attr_writer :audio
 
           # 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.
           sig {
             returns(
               T.nilable(
-                T.any(OpenAI::Live::ClientDelegation, OpenAI::Live::SessionAcceptParams::Session::Delegation::Responses)
+                T.any(
+                  OpenAI::Live::ClientDelegation,
+                  OpenAI::Live::SessionAcceptParams::Session::Delegation::Responses,
+                  OpenAI::Live::SessionAcceptParams::Session::Delegation::Decisions
+                )
               )
             )
           }
           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.
+          # assistant messages with one text part each; at most 128 messages and a
+          # configured rendered-token limit (8,192 by default).
           sig {
             returns(
               T.nilable(
@@ -149,6 +154,16 @@ module OpenAI
           sig { params(store: T::Boolean).void }
           attr_writer :store
 
+          # 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.
+          sig { returns(T.nilable(T::Array[OpenAI::Live::DecisionTrigger])) }
+          attr_reader :triggers
+
+          sig { params(triggers: T::Array[OpenAI::Live::DecisionTrigger::OrHash]).void }
+          attr_writer :triggers
+
           # Model and startup configuration for the Live session that answers the incoming
           # SIP call.
           sig do
@@ -161,7 +176,8 @@ module OpenAI
               delegation: T.nilable(
                 T.any(
                   OpenAI::Live::ClientDelegation::OrHash,
-                  OpenAI::Live::SessionAcceptParams::Session::Delegation::Responses::OrHash
+                  OpenAI::Live::SessionAcceptParams::Session::Delegation::Responses::OrHash,
+                  OpenAI::Live::SessionAcceptParams::Session::Delegation::Decisions::OrHash
                 )
               ),
 
@@ -177,6 +193,8 @@ module OpenAI
 
               store: T::Boolean,
 
+              triggers: T::Array[OpenAI::Live::DecisionTrigger::OrHash],
+
               type: Symbol
             )
               .returns(T.attached_class)
@@ -192,12 +210,13 @@ module OpenAI
             audio: 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.
             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.
+            # assistant messages with one text part each; at most 128 messages and a
+            # configured rendered-token limit (8,192 by default).
             input: nil,
 
             # Frontend instructions for voice, conversation, interruptions, and when to
@@ -213,6 +232,12 @@ module OpenAI
             # to false for new sessions.
             store: nil,
 
+            # 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.
+            triggers: nil,
+
             # The session type. Always `live`.
 
             type: :live
@@ -228,7 +253,8 @@ module OpenAI
                 delegation: T.nilable(
                   T.any(
                     OpenAI::Live::ClientDelegation,
-                    OpenAI::Live::SessionAcceptParams::Session::Delegation::Responses
+                    OpenAI::Live::SessionAcceptParams::Session::Delegation::Responses,
+                    OpenAI::Live::SessionAcceptParams::Session::Delegation::Decisions
                   )
                 ),
                 input: T::Array[
@@ -239,7 +265,8 @@ module OpenAI
                   )
                 ],
                 instructions: T.nilable(String),
-                store: T::Boolean
+                store: T::Boolean,
+                triggers: T::Array[OpenAI::Live::DecisionTrigger]
               }
             )
           end
@@ -376,12 +403,17 @@ 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.
           module Delegation
             extend OpenAI::Internal::Type::Union
 
             Variants = T.type_alias {
-              T.any(OpenAI::Live::ClientDelegation, OpenAI::Live::SessionAcceptParams::Session::Delegation::Responses)
+              T.any(
+                OpenAI::Live::ClientDelegation,
+                OpenAI::Live::SessionAcceptParams::Session::Delegation::Responses,
+                OpenAI::Live::SessionAcceptParams::Session::Delegation::Decisions
+              )
             }
 
             class Responses < OpenAI::Internal::Type::BaseModel
@@ -436,6 +468,50 @@ module OpenAI
 
             end
 
+            class Decisions < OpenAI::Internal::Type::BaseModel
+              OrHash = T.type_alias do
+                T.any(
+                  OpenAI::Live::SessionAcceptParams::Session::Delegation::Decisions,
+                  OpenAI::Internal::AnyHash
+                )
+              end
+
+              sig { returns(OpenAI::Live::DecisionsDelegationConfig) }
+              attr_reader :decisions
+
+              sig { params(decisions: OpenAI::Live::DecisionsDelegationConfig::OrHash).void }
+              attr_writer :decisions
+
+              sig { returns(Symbol) }
+              attr_accessor :type
+
+              sig do
+                params(
+
+                  decisions: OpenAI::Live::DecisionsDelegationConfig::OrHash,
+
+                  type: Symbol
+                )
+                  .returns(T.attached_class)
+              end
+              def self.new(
+
+                decisions:,
+
+                type: :decisions
+              )
+              end
+
+              sig do
+                override.returns(
+                  {decisions: OpenAI::Live::DecisionsDelegationConfig, type: Symbol}
+                )
+              end
+              def to_hash
+              end
+
+            end
+
             sig { override.returns(T::Array[OpenAI::Live::SessionAcceptParams::Session::Delegation::Variants]) }
             def self.variants
             end

data/rbi/openai/models/live/session_config.rbi

@@ -37,15 +37,24 @@ module OpenAI
         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.
+        # application; use `responses` or `decisions` to delegate to the corresponding
+        # API.
         sig {
-          returns(T.nilable(T.any(OpenAI::Live::ClientDelegation, OpenAI::Live::SessionConfig::Delegation::Responses)))
+          returns(
+            T.nilable(
+              T.any(
+                OpenAI::Live::ClientDelegation,
+                OpenAI::Live::SessionConfig::Delegation::Responses,
+                OpenAI::Live::SessionConfig::Delegation::Decisions
+              )
+            )
+          )
         }
         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.
+        # assistant messages with one text part each; at most 128 messages and a
+        # configured rendered-token limit (8,192 by default).
         sig {
           returns(
             T.nilable(
@@ -93,6 +102,16 @@ module OpenAI
         sig { params(store: T::Boolean).void }
         attr_writer :store
 
+        # 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.
+        sig { returns(T.nilable(T::Array[OpenAI::Live::DecisionTrigger])) }
+        attr_reader :triggers
+
+        sig { params(triggers: T::Array[OpenAI::Live::DecisionTrigger::OrHash]).void }
+        attr_writer :triggers
+
         # Initial configuration for a Live session, including its model, conversation
         # instructions, audio, and delegated task handling.
         sig do
@@ -105,7 +124,11 @@ module OpenAI
             client: OpenAI::Live::ClientConfig::OrHash,
 
             delegation: T.nilable(
-              T.any(OpenAI::Live::ClientDelegation::OrHash, OpenAI::Live::SessionConfig::Delegation::Responses::OrHash)
+              T.any(
+                OpenAI::Live::ClientDelegation::OrHash,
+                OpenAI::Live::SessionConfig::Delegation::Responses::OrHash,
+                OpenAI::Live::SessionConfig::Delegation::Decisions::OrHash
+              )
             ),
 
             input: T::Array[
@@ -118,7 +141,9 @@ module OpenAI
 
             instructions: T.nilable(String),
 
-            store: T::Boolean
+            store: T::Boolean,
+
+            triggers: T::Array[OpenAI::Live::DecisionTrigger::OrHash]
           )
             .returns(T.attached_class)
         end
@@ -138,12 +163,13 @@ module OpenAI
           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.
+          # application; use `responses` or `decisions` to delegate to the corresponding
+          # API.
           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.
+          # assistant messages with one text part each; at most 128 messages and a
+          # configured rendered-token limit (8,192 by default).
           input: nil,
 
           # Frontend instructions for voice, conversation, interruptions, and when to
@@ -157,8 +183,14 @@ module OpenAI
 
           # Whether to store the session for later forking and recording download. Defaults
           # to false for new sessions.
+          store: nil,
+
+          # 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.
 
-          store: nil
+          triggers: nil
         )
         end
 
@@ -169,7 +201,11 @@ module OpenAI
               audio: OpenAI::Live::SessionConfig::Audio,
               client: OpenAI::Live::ClientConfig,
               delegation: T.nilable(
-                T.any(OpenAI::Live::ClientDelegation, OpenAI::Live::SessionConfig::Delegation::Responses)
+                T.any(
+                  OpenAI::Live::ClientDelegation,
+                  OpenAI::Live::SessionConfig::Delegation::Responses,
+                  OpenAI::Live::SessionConfig::Delegation::Decisions
+                )
               ),
               input: T::Array[
                 T.any(
@@ -179,7 +215,8 @@ module OpenAI
                 )
               ],
               instructions: T.nilable(String),
-              store: T::Boolean
+              store: T::Boolean,
+              triggers: T::Array[OpenAI::Live::DecisionTrigger]
             }
           )
         end
@@ -353,12 +390,17 @@ 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.
         module Delegation
           extend OpenAI::Internal::Type::Union
 
           Variants = T.type_alias {
-            T.any(OpenAI::Live::ClientDelegation, OpenAI::Live::SessionConfig::Delegation::Responses)
+            T.any(
+              OpenAI::Live::ClientDelegation,
+              OpenAI::Live::SessionConfig::Delegation::Responses,
+              OpenAI::Live::SessionConfig::Delegation::Decisions
+            )
           }
 
           class Responses < OpenAI::Internal::Type::BaseModel
@@ -413,6 +455,50 @@ module OpenAI
 
           end
 
+          class Decisions < OpenAI::Internal::Type::BaseModel
+            OrHash = T.type_alias do
+              T.any(
+                OpenAI::Live::SessionConfig::Delegation::Decisions,
+                OpenAI::Internal::AnyHash
+              )
+            end
+
+            sig { returns(OpenAI::Live::DecisionsDelegationConfig) }
+            attr_reader :decisions
+
+            sig { params(decisions: OpenAI::Live::DecisionsDelegationConfig::OrHash).void }
+            attr_writer :decisions
+
+            sig { returns(Symbol) }
+            attr_accessor :type
+
+            sig do
+              params(
+
+                decisions: OpenAI::Live::DecisionsDelegationConfig::OrHash,
+
+                type: Symbol
+              )
+                .returns(T.attached_class)
+            end
+            def self.new(
+
+              decisions:,
+
+              type: :decisions
+            )
+            end
+
+            sig do
+              override.returns(
+                {decisions: OpenAI::Live::DecisionsDelegationConfig, type: Symbol}
+              )
+            end
+            def to_hash
+            end
+
+          end
+
           sig { override.returns(T::Array[OpenAI::Live::SessionConfig::Delegation::Variants]) }
           def self.variants
           end