openai 0.102.0 → 0.104.0

data/rbi/openai/models/live/decisions_delegation_update_config.rbi

@@ -0,0 +1,412 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Live
+
+      class DecisionsDelegationUpdateConfig < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Live::DecisionsDelegationUpdateConfig,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :model
+
+        sig { params(model: String).void }
+        attr_writer :model
+
+        # Native Decision API questions evaluated together, in order.
+        sig {
+          returns(
+            T.nilable(
+              T::Array[
+                T.any(
+                  OpenAI::Live::DecisionsDelegationUpdateConfig::Question::Predicate,
+                  OpenAI::Live::DecisionsDelegationUpdateConfig::Question::Choice,
+                  OpenAI::Live::DecisionsDelegationUpdateConfig::Question::Score
+                )
+              ]
+            )
+          )
+        }
+        attr_reader :questions
+
+        sig {
+          params(
+            questions: T::Array[
+              T.any(
+                OpenAI::Live::DecisionsDelegationUpdateConfig::Question::Predicate::OrHash,
+                OpenAI::Live::DecisionsDelegationUpdateConfig::Question::Choice::OrHash,
+                OpenAI::Live::DecisionsDelegationUpdateConfig::Question::Score::OrHash
+              )
+            ]
+          )
+            .void
+        }
+        attr_writer :questions
+
+        sig do
+          params(
+
+            model: String,
+
+            questions: T::Array[
+              T.any(
+                OpenAI::Live::DecisionsDelegationUpdateConfig::Question::Predicate::OrHash,
+                OpenAI::Live::DecisionsDelegationUpdateConfig::Question::Choice::OrHash,
+                OpenAI::Live::DecisionsDelegationUpdateConfig::Question::Score::OrHash
+              )
+            ]
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          model: nil,
+
+          # Native Decision API questions evaluated together, in order.
+
+          questions: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              model: String,
+              questions: T::Array[
+                T.any(
+                  OpenAI::Live::DecisionsDelegationUpdateConfig::Question::Predicate,
+                  OpenAI::Live::DecisionsDelegationUpdateConfig::Question::Choice,
+                  OpenAI::Live::DecisionsDelegationUpdateConfig::Question::Score
+                )
+              ]
+            }
+          )
+        end
+        def to_hash
+        end
+
+        # A question about the request's input, with an optional correlation name.
+        module Question
+          extend OpenAI::Internal::Type::Union
+
+          Variants = T.type_alias {
+            T.any(
+              OpenAI::Live::DecisionsDelegationUpdateConfig::Question::Predicate,
+              OpenAI::Live::DecisionsDelegationUpdateConfig::Question::Choice,
+              OpenAI::Live::DecisionsDelegationUpdateConfig::Question::Score
+            )
+          }
+
+          class Predicate < OpenAI::Internal::Type::BaseModel
+            OrHash = T.type_alias do
+              T.any(
+                OpenAI::Live::DecisionsDelegationUpdateConfig::Question::Predicate,
+                OpenAI::Internal::AnyHash
+              )
+            end
+
+            sig { returns(String) }
+            attr_accessor :instructions
+
+            # The type of the object. Always `predicate`.
+            sig { returns(Symbol) }
+            attr_accessor :type
+
+            sig { returns(T.nilable(String)) }
+            attr_reader :name
+
+            sig { params(name: String).void }
+            attr_writer :name
+
+            # Estimate how likely it is that a statement about the input is true.
+            sig do
+              params(
+
+                instructions: String,
+
+                name: String,
+
+                type: Symbol
+              )
+                .returns(T.attached_class)
+            end
+            def self.new(
+
+              instructions:,
+
+              name: nil,
+
+              # The type of the object. Always `predicate`.
+
+              type: :predicate
+            )
+            end
+
+            sig do
+              override.returns(
+                {instructions: String, type: Symbol, name: String}
+              )
+            end
+            def to_hash
+            end
+
+          end
+
+          class Choice < OpenAI::Internal::Type::BaseModel
+            OrHash = T.type_alias do
+              T.any(
+                OpenAI::Live::DecisionsDelegationUpdateConfig::Question::Choice,
+                OpenAI::Internal::AnyHash
+              )
+            end
+
+            # Provide between 2 and 255 choices. Each choice must be unique.
+            sig { returns(T::Array[OpenAI::Live::DecisionsDelegationUpdateConfig::Question::Choice::Choice]) }
+            attr_accessor :choices
+
+            sig { returns(String) }
+            attr_accessor :instructions
+
+            # The type of the object. Always `choice`.
+            sig { returns(Symbol) }
+            attr_accessor :type
+
+            sig { returns(T.nilable(String)) }
+            attr_reader :name
+
+            sig { params(name: String).void }
+            attr_writer :name
+
+            # Choose from the supplied options based on the input.
+            sig do
+              params(
+
+                choices: T::Array[OpenAI::Live::DecisionsDelegationUpdateConfig::Question::Choice::Choice::OrHash],
+
+                instructions: String,
+
+                name: String,
+
+                type: Symbol
+              )
+                .returns(T.attached_class)
+            end
+            def self.new(
+
+              # Provide between 2 and 255 choices. Each choice must be unique.
+              choices:,
+
+              instructions:,
+
+              name: nil,
+
+              # The type of the object. Always `choice`.
+
+              type: :choice
+            )
+            end
+
+            sig do
+              override.returns(
+                {
+                  choices: T::Array[OpenAI::Live::DecisionsDelegationUpdateConfig::Question::Choice::Choice],
+                  instructions: String,
+                  type: Symbol,
+                  name: String
+                }
+              )
+            end
+            def to_hash
+            end
+
+            class Choice < OpenAI::Internal::Type::BaseModel
+              OrHash = T.type_alias do
+                T.any(
+                  OpenAI::Live::DecisionsDelegationUpdateConfig::Question::Choice::Choice,
+                  OpenAI::Internal::AnyHash
+                )
+              end
+
+              # Choice values are typed: a string and a boolean with the same text are distinct.
+              sig { returns(T.any(String, T::Boolean)) }
+              attr_accessor :value
+
+              sig { returns(T.nilable(String)) }
+              attr_reader :description
+
+              sig { params(description: String).void }
+              attr_writer :description
+
+              sig do
+                params(
+
+                  value: T.any(String, T::Boolean),
+
+                  description: String
+                )
+                  .returns(T.attached_class)
+              end
+              def self.new(
+
+                # Choice values are typed: a string and a boolean with the same text are distinct.
+                value:,
+
+                description: nil
+              )
+              end
+
+              sig do
+                override.returns(
+                  {value: T.any(String, T::Boolean), description: String}
+                )
+              end
+              def to_hash
+              end
+
+              # Choice values are typed: a string and a boolean with the same text are distinct.
+              module Value
+                extend OpenAI::Internal::Type::Union
+
+                Variants = T.type_alias { T.any(String, T::Boolean) }
+
+                sig {
+                  override.returns(
+                    T::Array[OpenAI::Live::DecisionsDelegationUpdateConfig::Question::Choice::Choice::Value::Variants]
+                  )
+                }
+                def self.variants
+                end
+
+              end
+            end
+          end
+
+          class Score < OpenAI::Internal::Type::BaseModel
+            OrHash = T.type_alias do
+              T.any(
+                OpenAI::Live::DecisionsDelegationUpdateConfig::Question::Score,
+                OpenAI::Internal::AnyHash
+              )
+            end
+
+            sig { returns(String) }
+            attr_accessor :instructions
+
+            sig { returns(T::Array[OpenAI::Live::DecisionsDelegationUpdateConfig::Question::Score::Level]) }
+            attr_accessor :levels
+
+            # The type of the object. Always `score`.
+            sig { returns(Symbol) }
+            attr_accessor :type
+
+            sig { returns(T.nilable(String)) }
+            attr_reader :name
+
+            sig { params(name: String).void }
+            attr_writer :name
+
+            # Rate the input against the supplied ordered levels.
+            sig do
+              params(
+
+                instructions: String,
+
+                levels: T::Array[OpenAI::Live::DecisionsDelegationUpdateConfig::Question::Score::Level::OrHash],
+
+                name: String,
+
+                type: Symbol
+              )
+                .returns(T.attached_class)
+            end
+            def self.new(
+
+              instructions:,
+
+              levels:,
+
+              name: nil,
+
+              # The type of the object. Always `score`.
+
+              type: :score
+            )
+            end
+
+            sig do
+              override.returns(
+                {
+                  instructions: String,
+                  levels: T::Array[OpenAI::Live::DecisionsDelegationUpdateConfig::Question::Score::Level],
+                  type: Symbol,
+                  name: String
+                }
+              )
+            end
+            def to_hash
+            end
+
+            class Level < OpenAI::Internal::Type::BaseModel
+              OrHash = T.type_alias do
+                T.any(
+                  OpenAI::Live::DecisionsDelegationUpdateConfig::Question::Score::Level,
+                  OpenAI::Internal::AnyHash
+                )
+              end
+
+              sig { returns(String) }
+              attr_accessor :label
+
+              sig { returns(T.nilable(String)) }
+              attr_reader :description
+
+              sig { params(description: String).void }
+              attr_writer :description
+
+              sig do
+                params(
+
+                  label: String,
+
+                  description: String
+                )
+                  .returns(T.attached_class)
+              end
+              def self.new(
+
+                label:,
+
+                description: nil
+              )
+              end
+
+              sig do
+                override.returns(
+                  {label: String, description: String}
+                )
+              end
+              def to_hash
+              end
+
+            end
+          end
+
+          sig { override.returns(T::Array[OpenAI::Live::DecisionsDelegationUpdateConfig::Question::Variants]) }
+          def self.variants
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+end

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

@@ -43,8 +43,8 @@ module OpenAI
         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
+        # 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.
         sig do
           params(
@@ -107,12 +107,11 @@ module OpenAI
           end
 
           # The unique ID of the delegation. Use this as delegation_id when replying to
-          # client-owned work or correlating Responses events.
+          # client-owned work or correlating backend 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.
+          # Where the Live model delegated the work: `client`, `responses`, or `decisions`.
           sig { returns(OpenAI::Live::DelegationCreatedEvent::Delegation::Target::OrSymbol) }
           attr_accessor :target
 
@@ -146,11 +145,10 @@ module OpenAI
           def self.new(
 
             # The unique ID of the delegation. Use this as delegation_id when replying to
-            # client-owned work or correlating Responses events.
+            # client-owned work or correlating backend events.
             id:,
 
-            # Where the Live model delegated the work: `client` for your application, or
-            # `responses` for the configured Responses backend.
+            # Where the Live model delegated the work: `client`, `responses`, or `decisions`.
             target:,
 
             # The ID of the Responses API response associated with a Responses delegation.
@@ -176,8 +174,7 @@ module OpenAI
           def to_hash
           end
 
-          # Where the Live model delegated the work: `client` for your application, or
-          # `responses` for the configured Responses backend.
+          # Where the Live model delegated the work: `client`, `responses`, or `decisions`.
           module Target
             extend OpenAI::Internal::Type::Union
 
@@ -195,6 +192,7 @@ module OpenAI
 
             CLIENT = T.let(:client, OpenAI::Live::DelegationCreatedEvent::Delegation::Target::TaggedSymbol)
             RESPONSES = T.let(:responses, OpenAI::Live::DelegationCreatedEvent::Delegation::Target::TaggedSymbol)
+            DECISIONS = T.let(:decisions, OpenAI::Live::DelegationCreatedEvent::Delegation::Target::TaggedSymbol)
 
           end
         end

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

@@ -19,9 +19,13 @@ module OpenAI
             OpenAI::Live::InputAudioAppendEvent,
             OpenAI::Live::InputAudioMuteEvent,
             OpenAI::Live::InputAudioUnmuteEvent,
+            OpenAI::Live::OutputAudioFixturePlayEvent,
             OpenAI::Live::InstructionsAppendEvent,
             OpenAI::Live::ThinkingAppendEvent,
             OpenAI::Live::CommentaryAppendEvent,
+            OpenAI::Live::DecisionCreateEvent,
+            OpenAI::Live::DecisionItemCreateEvent,
+            OpenAI::Live::DecisionItemDeleteEvent,
             OpenAI::Live::ResponseItemCreateEvent,
             OpenAI::Live::ResponseCreateEvent,
             OpenAI::Live::SessionCloseEvent

data/rbi/openai/models/live/fork_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/media_session_config.rbi

@@ -36,17 +36,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::MediaSessionConfig::Delegation::Responses))
+            T.nilable(
+              T.any(
+                OpenAI::Live::ClientDelegation,
+                OpenAI::Live::MediaSessionConfig::Delegation::Responses,
+                OpenAI::Live::MediaSessionConfig::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(
@@ -94,6 +101,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
+
         # Startup configuration for a Live media session. Follow the
         # [Live prompting guide](https://developers.openai.com/api/docs/guides/live-prompting)
         # when writing frontend instructions and the backend prompt under
@@ -110,7 +127,8 @@ module OpenAI
             delegation: T.nilable(
               T.any(
                 OpenAI::Live::ClientDelegation::OrHash,
-                OpenAI::Live::MediaSessionConfig::Delegation::Responses::OrHash
+                OpenAI::Live::MediaSessionConfig::Delegation::Responses::OrHash,
+                OpenAI::Live::MediaSessionConfig::Delegation::Decisions::OrHash
               )
             ),
 
@@ -124,7 +142,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
@@ -143,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
@@ -162,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
 
@@ -174,7 +201,11 @@ module OpenAI
               audio: OpenAI::Live::MediaSessionConfig::Audio,
               client: OpenAI::Live::ClientConfig,
               delegation: T.nilable(
-                T.any(OpenAI::Live::ClientDelegation, OpenAI::Live::MediaSessionConfig::Delegation::Responses)
+                T.any(
+                  OpenAI::Live::ClientDelegation,
+                  OpenAI::Live::MediaSessionConfig::Delegation::Responses,
+                  OpenAI::Live::MediaSessionConfig::Delegation::Decisions
+                )
               ),
               input: T::Array[
                 T.any(
@@ -184,7 +215,8 @@ module OpenAI
                 )
               ],
               instructions: T.nilable(String),
-              store: T::Boolean
+              store: T::Boolean,
+              triggers: T::Array[OpenAI::Live::DecisionTrigger]
             }
           )
         end
@@ -316,12 +348,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::MediaSessionConfig::Delegation::Responses)
+            T.any(
+              OpenAI::Live::ClientDelegation,
+              OpenAI::Live::MediaSessionConfig::Delegation::Responses,
+              OpenAI::Live::MediaSessionConfig::Delegation::Decisions
+            )
           }
 
           class Responses < OpenAI::Internal::Type::BaseModel
@@ -376,6 +413,50 @@ module OpenAI
 
           end
 
+          class Decisions < OpenAI::Internal::Type::BaseModel
+            OrHash = T.type_alias do
+              T.any(
+                OpenAI::Live::MediaSessionConfig::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::MediaSessionConfig::Delegation::Variants]) }
           def self.variants
           end