openai 0.88.0 → 0.89.0

data/rbi/openai/models/conversations/conversation_item.rbi

@@ -71,6 +71,24 @@ module OpenAI
           sig { returns(Symbol) }
           attr_accessor :type
 
+          # The action used for image generation.
+          sig {
+            returns(T.nilable(OpenAI::Conversations::ConversationItem::ImageGenerationCall::Action::TaggedSymbol))
+          }
+          attr_accessor :action
+
+          # The background setting used for generation.
+          sig {
+            returns(T.nilable(OpenAI::Conversations::ConversationItem::ImageGenerationCall::Background::TaggedSymbol))
+          }
+          attr_accessor :background
+
+          # The output format used for generation.
+          sig {
+            returns(T.nilable(OpenAI::Conversations::ConversationItem::ImageGenerationCall::OutputFormat::TaggedSymbol))
+          }
+          attr_accessor :output_format
+
           # The quality of the image generated by the image generation tool call. One of
           # `low`, `medium`, `high`, `xhigh`, `max`, or `auto`.
           sig {
@@ -78,6 +96,10 @@ module OpenAI
           }
           attr_accessor :quality
 
+          # The prompt that was used after any model prompt rewriting.
+          sig { returns(T.nilable(String)) }
+          attr_accessor :revised_prompt
+
           # The image dimensions as a `WIDTHxHEIGHT` string, for example `1536x864`.
           sig { returns(T.nilable(OpenAI::Conversations::ConversationItem::ImageGenerationCall::Size::Variants)) }
           attr_accessor :size
@@ -92,8 +114,18 @@ module OpenAI
 
               status: OpenAI::Conversations::ConversationItem::ImageGenerationCall::Status::OrSymbol,
 
+              action: T.nilable(OpenAI::Conversations::ConversationItem::ImageGenerationCall::Action::OrSymbol),
+
+              background: T.nilable(OpenAI::Conversations::ConversationItem::ImageGenerationCall::Background::OrSymbol),
+
+              output_format: T.nilable(
+                OpenAI::Conversations::ConversationItem::ImageGenerationCall::OutputFormat::OrSymbol
+              ),
+
               quality: T.nilable(OpenAI::Conversations::ConversationItem::ImageGenerationCall::Quality::OrSymbol),
 
+              revised_prompt: T.nilable(String),
+
               size: T.nilable(
                 T.any(String, OpenAI::Conversations::ConversationItem::ImageGenerationCall::Size::OrSymbol)
               ),
@@ -113,10 +145,22 @@ module OpenAI
             # The status of the image generation call.
             status:,
 
+            # The action used for image generation.
+            action: nil,
+
+            # The background setting used for generation.
+            background: nil,
+
+            # The output format used for generation.
+            output_format: nil,
+
             # The quality of the image generated by the image generation tool call. One of
             # `low`, `medium`, `high`, `xhigh`, `max`, or `auto`.
             quality: nil,
 
+            # The prompt that was used after any model prompt rewriting.
+            revised_prompt: nil,
+
             # The image dimensions as a `WIDTHxHEIGHT` string, for example `1536x864`.
             size: nil,
 
@@ -133,7 +177,15 @@ module OpenAI
                 result: T.nilable(String),
                 status: OpenAI::Conversations::ConversationItem::ImageGenerationCall::Status::TaggedSymbol,
                 type: Symbol,
+                action: T.nilable(OpenAI::Conversations::ConversationItem::ImageGenerationCall::Action::TaggedSymbol),
+                background: T.nilable(
+                  OpenAI::Conversations::ConversationItem::ImageGenerationCall::Background::TaggedSymbol
+                ),
+                output_format: T.nilable(
+                  OpenAI::Conversations::ConversationItem::ImageGenerationCall::OutputFormat::TaggedSymbol
+                ),
                 quality: T.nilable(OpenAI::Conversations::ConversationItem::ImageGenerationCall::Quality::TaggedSymbol),
+                revised_prompt: T.nilable(String),
                 size: T.nilable(OpenAI::Conversations::ConversationItem::ImageGenerationCall::Size::Variants)
               }
             )
@@ -173,6 +225,87 @@ module OpenAI
             end
           end
 
+          # The action used for image generation.
+          module Action
+            extend OpenAI::Internal::Type::Enum
+
+            TaggedSymbol = T.type_alias {
+              T.all(Symbol, OpenAI::Conversations::ConversationItem::ImageGenerationCall::Action)
+            }
+            OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+            GENERATE = T.let(
+              :generate,
+              OpenAI::Conversations::ConversationItem::ImageGenerationCall::Action::TaggedSymbol
+            )
+            EDIT = T.let(:edit, OpenAI::Conversations::ConversationItem::ImageGenerationCall::Action::TaggedSymbol)
+            AUTO = T.let(:auto, OpenAI::Conversations::ConversationItem::ImageGenerationCall::Action::TaggedSymbol)
+
+            sig {
+              override.returns(
+                T::Array[OpenAI::Conversations::ConversationItem::ImageGenerationCall::Action::TaggedSymbol]
+              )
+            }
+            def self.values
+            end
+          end
+
+          # The background setting used for generation.
+          module Background
+            extend OpenAI::Internal::Type::Enum
+
+            TaggedSymbol = T.type_alias {
+              T.all(Symbol, OpenAI::Conversations::ConversationItem::ImageGenerationCall::Background)
+            }
+            OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+            TRANSPARENT = T.let(
+              :transparent,
+              OpenAI::Conversations::ConversationItem::ImageGenerationCall::Background::TaggedSymbol
+            )
+            OPAQUE = T.let(
+              :opaque,
+              OpenAI::Conversations::ConversationItem::ImageGenerationCall::Background::TaggedSymbol
+            )
+            AUTO = T.let(:auto, OpenAI::Conversations::ConversationItem::ImageGenerationCall::Background::TaggedSymbol)
+
+            sig {
+              override.returns(
+                T::Array[OpenAI::Conversations::ConversationItem::ImageGenerationCall::Background::TaggedSymbol]
+              )
+            }
+            def self.values
+            end
+          end
+
+          # The output format used for generation.
+          module OutputFormat
+            extend OpenAI::Internal::Type::Enum
+
+            TaggedSymbol = T.type_alias {
+              T.all(Symbol, OpenAI::Conversations::ConversationItem::ImageGenerationCall::OutputFormat)
+            }
+            OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+            PNG = T.let(:png, OpenAI::Conversations::ConversationItem::ImageGenerationCall::OutputFormat::TaggedSymbol)
+            WEBP = T.let(
+              :webp,
+              OpenAI::Conversations::ConversationItem::ImageGenerationCall::OutputFormat::TaggedSymbol
+            )
+            JPEG = T.let(
+              :jpeg,
+              OpenAI::Conversations::ConversationItem::ImageGenerationCall::OutputFormat::TaggedSymbol
+            )
+
+            sig {
+              override.returns(
+                T::Array[OpenAI::Conversations::ConversationItem::ImageGenerationCall::OutputFormat::TaggedSymbol]
+              )
+            }
+            def self.values
+            end
+          end
+
           # The quality of the image generated by the image generation tool call. One of
           # `low`, `medium`, `high`, `xhigh`, `max`, or `auto`.
           module Quality

data/rbi/openai/models/live/audio_format.rbi

@@ -0,0 +1,185 @@
+# typed: strong
+
+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
+
+        Variants = T.type_alias do
+          T.any(
+            OpenAI::Live::AudioFormat::AudioPCM,
+            OpenAI::Live::AudioFormat::AudioPCMU,
+            OpenAI::Live::AudioFormat::AudioPCMA
+          )
+        end
+
+        class AudioPCM < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Live::AudioFormat::AudioPCM,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          # Audio sample rate in hertz. Live WebSocket PCM audio supports 16000 or 24000 Hz.
+          sig { returns(OpenAI::Live::AudioFormat::AudioPCM::Rate::OrInteger) }
+          attr_accessor :rate
+
+          # The audio encoding. Always `audio/pcm`.
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # Raw, mono 16-bit little-endian PCM audio for a Live WebSocket connection.
+          sig do
+            params(
+
+              rate: OpenAI::Live::AudioFormat::AudioPCM::Rate::OrInteger,
+
+              type: Symbol
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            # Audio sample rate in hertz. Live WebSocket PCM audio supports 16000 or 24000 Hz.
+            rate:,
+
+            # The audio encoding. Always `audio/pcm`.
+
+            type: :"audio/pcm"
+          )
+          end
+
+          sig do
+            override.returns(
+              {rate: OpenAI::Live::AudioFormat::AudioPCM::Rate::OrInteger, type: Symbol}
+            )
+          end
+          def to_hash
+          end
+
+          # Audio sample rate in hertz. Live WebSocket PCM audio supports 16000 or 24000 Hz.
+          module Rate
+            extend OpenAI::Internal::Type::Enum
+
+            TaggedInteger = T.type_alias { T.all(Integer, OpenAI::Live::AudioFormat::AudioPCM::Rate) }
+            OrInteger = T.type_alias { Integer }
+
+            RATE_16000 = T.let(16_000, OpenAI::Live::AudioFormat::AudioPCM::Rate::TaggedInteger)
+            RATE_24000 = T.let(24_000, OpenAI::Live::AudioFormat::AudioPCM::Rate::TaggedInteger)
+
+            sig { override.returns(T::Array[OpenAI::Live::AudioFormat::AudioPCM::Rate::TaggedInteger]) }
+            def self.values
+            end
+          end
+        end
+
+        class AudioPCMU < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Live::AudioFormat::AudioPCMU,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          # Audio sample rate in hertz. G.711 audio uses 8000 Hz.
+          sig { returns(Integer) }
+          attr_accessor :rate
+
+          # The audio encoding. Always `audio/pcmu`.
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # Raw, mono G.711 μ-law audio for a Live WebSocket connection.
+          sig do
+            params(
+
+              rate: Integer,
+
+              type: Symbol
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            # Audio sample rate in hertz. G.711 audio uses 8000 Hz.
+            rate:,
+
+            # The audio encoding. Always `audio/pcmu`.
+
+            type: :"audio/pcmu"
+          )
+          end
+
+          sig do
+            override.returns(
+              {rate: Integer, type: Symbol}
+            )
+          end
+          def to_hash
+          end
+
+        end
+
+        class AudioPCMA < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Live::AudioFormat::AudioPCMA,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          # Audio sample rate in hertz. G.711 audio uses 8000 Hz.
+          sig { returns(Integer) }
+          attr_accessor :rate
+
+          # The audio encoding. Always `audio/pcma`.
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # Raw, mono G.711 A-law audio for a Live WebSocket connection.
+          sig do
+            params(
+
+              rate: Integer,
+
+              type: Symbol
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            # Audio sample rate in hertz. G.711 audio uses 8000 Hz.
+            rate:,
+
+            # The audio encoding. Always `audio/pcma`.
+
+            type: :"audio/pcma"
+          )
+          end
+
+          sig do
+            override.returns(
+              {rate: Integer, type: Symbol}
+            )
+          end
+          def to_hash
+          end
+
+        end
+
+        sig { override.returns(T::Array[OpenAI::Live::AudioFormat::Variants]) }
+        def self.variants
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/live/built_in_voice.rbi

@@ -0,0 +1,46 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Live
+
+      # A built-in voice available for Live speech.
+      module BuiltInVoice
+        extend OpenAI::Internal::Type::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, OpenAI::Live::BuiltInVoice) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        ALLOY = T.let(:alloy, OpenAI::Live::BuiltInVoice::TaggedSymbol)
+        ASH = T.let(:ash, OpenAI::Live::BuiltInVoice::TaggedSymbol)
+        BALLAD = T.let(:ballad, OpenAI::Live::BuiltInVoice::TaggedSymbol)
+        BEACON = T.let(:beacon, OpenAI::Live::BuiltInVoice::TaggedSymbol)
+        BOSSA = T.let(:bossa, OpenAI::Live::BuiltInVoice::TaggedSymbol)
+        CEDAR = T.let(:cedar, OpenAI::Live::BuiltInVoice::TaggedSymbol)
+        CINDER = T.let(:cinder, OpenAI::Live::BuiltInVoice::TaggedSymbol)
+        CORAL = T.let(:coral, OpenAI::Live::BuiltInVoice::TaggedSymbol)
+        DELTA = T.let(:delta, OpenAI::Live::BuiltInVoice::TaggedSymbol)
+        ECHO = T.let(:echo, OpenAI::Live::BuiltInVoice::TaggedSymbol)
+        GLEAM = T.let(:gleam, OpenAI::Live::BuiltInVoice::TaggedSymbol)
+        MARIN = T.let(:marin, OpenAI::Live::BuiltInVoice::TaggedSymbol)
+        MERIDIAN = T.let(:meridian, OpenAI::Live::BuiltInVoice::TaggedSymbol)
+        QUARTZ = T.let(:quartz, OpenAI::Live::BuiltInVoice::TaggedSymbol)
+        RIPPLE = T.let(:ripple, OpenAI::Live::BuiltInVoice::TaggedSymbol)
+        SAGE = T.let(:sage, OpenAI::Live::BuiltInVoice::TaggedSymbol)
+        SHIMMER = T.let(:shimmer, OpenAI::Live::BuiltInVoice::TaggedSymbol)
+        STONE = T.let(:stone, OpenAI::Live::BuiltInVoice::TaggedSymbol)
+        TEMPO = T.let(:tempo, OpenAI::Live::BuiltInVoice::TaggedSymbol)
+        VERSE = T.let(:verse, OpenAI::Live::BuiltInVoice::TaggedSymbol)
+        VESPER = T.let(:vesper, OpenAI::Live::BuiltInVoice::TaggedSymbol)
+        WILLOW = T.let(:willow, OpenAI::Live::BuiltInVoice::TaggedSymbol)
+
+        sig { override.returns(T::Array[OpenAI::Live::BuiltInVoice::TaggedSymbol]) }
+        def self.values
+        end
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/live/client_config.rbi

@@ -0,0 +1,54 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Live
+
+      class ClientConfig < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Live::ClientConfig,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # Client and server event permissions for the WebRTC frontend data channel.
+        sig { returns(OpenAI::Live::DataChannelConfig) }
+        attr_reader :data_channel
+
+        sig { params(data_channel: OpenAI::Live::DataChannelConfig::OrHash).void }
+        attr_writer :data_channel
+
+        # Startup-only capabilities for an untrusted frontend attached to a unified WebRTC
+        # session. Trusted sideband connections are unaffected.
+        sig do
+          params(
+
+            data_channel: OpenAI::Live::DataChannelConfig::OrHash
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # Client and server event permissions for the WebRTC frontend data channel.
+
+          data_channel:
+        )
+        end
+
+        sig do
+          override.returns(
+            {data_channel: OpenAI::Live::DataChannelConfig}
+          )
+        end
+        def to_hash
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/live/client_delegation.rbi

@@ -0,0 +1,51 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Live
+
+      class ClientDelegation < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Live::ClientDelegation,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # The delegation owner. Always `client` for tasks handled by your application.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # Delegate tasks to your application. The Live session emits delegation events
+        # that your backend handles.
+        sig do
+          params(
+
+            type: Symbol
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # The delegation owner. Always `client` for tasks handled by your application.
+
+          type: :client
+        )
+        end
+
+        sig do
+          override.returns(
+            {type: Symbol}
+          )
+        end
+        def to_hash
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/live/client_event.rbi

@@ -0,0 +1,41 @@
+# typed: strong
+
+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
+
+        Variants = T.type_alias do
+          T.any(
+            OpenAI::Live::SessionStartEvent,
+            OpenAI::Live::SessionUpdateEvent,
+            OpenAI::Live::InputAudioAppendEvent,
+            OpenAI::Live::InputAudioMuteEvent,
+            OpenAI::Live::InputAudioUnmuteEvent,
+            OpenAI::Live::InstructionsAppendEvent,
+            OpenAI::Live::ThinkingAppendEvent,
+            OpenAI::Live::CommentaryAppendEvent,
+            OpenAI::Live::ResponseItemCreateEvent,
+            OpenAI::Live::ResponseCreateEvent,
+            OpenAI::Live::SessionCloseEvent
+          )
+        end
+
+        sig { override.returns(T::Array[OpenAI::Live::ClientEvent::Variants]) }
+        def self.variants
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/live/commentary_append_event.rbi

@@ -0,0 +1,88 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Live
+
+      class CommentaryAppendEvent < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Live::CommentaryAppendEvent,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # 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.
+        sig { returns(String) }
+        attr_accessor :content
+
+        # 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.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :delegation_id
+
+        # The Live client event type. Always `session.commentary.append`.
+        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
+
+        # Provide context the Live model can communicate to the user, optionally for an
+        # existing client delegation.
+        sig do
+          params(
+
+            content: String,
+
+            delegation_id: T.nilable(String),
+
+            event_id: T.nilable(String),
+
+            type: Symbol
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # 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.
+          content:,
+
+          # 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.
+          delegation_id:,
+
+          # Optional client identifier for correlating this command with a server event's
+          # client_event_id or error.client_event_id.
+          event_id: nil,
+
+          # The Live client event type. Always `session.commentary.append`.
+
+          type: :"session.commentary.append"
+        )
+        end
+
+        sig do
+          override.returns(
+            {content: String, delegation_id: T.nilable(String), type: Symbol, event_id: T.nilable(String)}
+          )
+        end
+        def to_hash
+        end
+
+      end
+
+    end
+
+  end
+end