openai 0.22.1 → 0.23.0

data/rbi/openai/models/realtime/realtime_transcription_session_create_response.rbi

@@ -0,0 +1,195 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    RealtimeTranscriptionSessionCreateResponse =
+      Realtime::RealtimeTranscriptionSessionCreateResponse
+
+    module Realtime
+      class RealtimeTranscriptionSessionCreateResponse < OpenAI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              OpenAI::Realtime::RealtimeTranscriptionSessionCreateResponse,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+        # Ephemeral key returned by the API. Only present when the session is created on
+        # the server via REST API.
+        sig do
+          returns(OpenAI::Realtime::RealtimeTranscriptionSessionClientSecret)
+        end
+        attr_reader :client_secret
+
+        sig do
+          params(
+            client_secret:
+              OpenAI::Realtime::RealtimeTranscriptionSessionClientSecret::OrHash
+          ).void
+        end
+        attr_writer :client_secret
+
+        # The format of input audio. Options are `pcm16`, `g711_ulaw`, or `g711_alaw`.
+        sig { returns(T.nilable(String)) }
+        attr_reader :input_audio_format
+
+        sig { params(input_audio_format: String).void }
+        attr_writer :input_audio_format
+
+        # Configuration of the transcription model.
+        sig do
+          returns(
+            T.nilable(
+              OpenAI::Realtime::RealtimeTranscriptionSessionInputAudioTranscription
+            )
+          )
+        end
+        attr_reader :input_audio_transcription
+
+        sig do
+          params(
+            input_audio_transcription:
+              OpenAI::Realtime::RealtimeTranscriptionSessionInputAudioTranscription::OrHash
+          ).void
+        end
+        attr_writer :input_audio_transcription
+
+        # The set of modalities the model can respond with. To disable audio, set this to
+        # ["text"].
+        sig do
+          returns(
+            T.nilable(
+              T::Array[
+                OpenAI::Realtime::RealtimeTranscriptionSessionCreateResponse::Modality::TaggedSymbol
+              ]
+            )
+          )
+        end
+        attr_reader :modalities
+
+        sig do
+          params(
+            modalities:
+              T::Array[
+                OpenAI::Realtime::RealtimeTranscriptionSessionCreateResponse::Modality::OrSymbol
+              ]
+          ).void
+        end
+        attr_writer :modalities
+
+        # Configuration for turn detection. Can be set to `null` to turn off. Server VAD
+        # means that the model will detect the start and end of speech based on audio
+        # volume and respond at the end of user speech.
+        sig do
+          returns(
+            T.nilable(
+              OpenAI::Realtime::RealtimeTranscriptionSessionTurnDetection
+            )
+          )
+        end
+        attr_reader :turn_detection
+
+        sig do
+          params(
+            turn_detection:
+              OpenAI::Realtime::RealtimeTranscriptionSessionTurnDetection::OrHash
+          ).void
+        end
+        attr_writer :turn_detection
+
+        # A new Realtime transcription session configuration.
+        #
+        # When a session is created on the server via REST API, the session object also
+        # contains an ephemeral key. Default TTL for keys is 10 minutes. This property is
+        # not present when a session is updated via the WebSocket API.
+        sig do
+          params(
+            client_secret:
+              OpenAI::Realtime::RealtimeTranscriptionSessionClientSecret::OrHash,
+            input_audio_format: String,
+            input_audio_transcription:
+              OpenAI::Realtime::RealtimeTranscriptionSessionInputAudioTranscription::OrHash,
+            modalities:
+              T::Array[
+                OpenAI::Realtime::RealtimeTranscriptionSessionCreateResponse::Modality::OrSymbol
+              ],
+            turn_detection:
+              OpenAI::Realtime::RealtimeTranscriptionSessionTurnDetection::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Ephemeral key returned by the API. Only present when the session is created on
+          # the server via REST API.
+          client_secret:,
+          # The format of input audio. Options are `pcm16`, `g711_ulaw`, or `g711_alaw`.
+          input_audio_format: nil,
+          # Configuration of the transcription model.
+          input_audio_transcription: nil,
+          # The set of modalities the model can respond with. To disable audio, set this to
+          # ["text"].
+          modalities: nil,
+          # Configuration for turn detection. Can be set to `null` to turn off. Server VAD
+          # means that the model will detect the start and end of speech based on audio
+          # volume and respond at the end of user speech.
+          turn_detection: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              client_secret:
+                OpenAI::Realtime::RealtimeTranscriptionSessionClientSecret,
+              input_audio_format: String,
+              input_audio_transcription:
+                OpenAI::Realtime::RealtimeTranscriptionSessionInputAudioTranscription,
+              modalities:
+                T::Array[
+                  OpenAI::Realtime::RealtimeTranscriptionSessionCreateResponse::Modality::TaggedSymbol
+                ],
+              turn_detection:
+                OpenAI::Realtime::RealtimeTranscriptionSessionTurnDetection
+            }
+          )
+        end
+        def to_hash
+        end
+
+        module Modality
+          extend OpenAI::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(
+                Symbol,
+                OpenAI::Realtime::RealtimeTranscriptionSessionCreateResponse::Modality
+              )
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          TEXT =
+            T.let(
+              :text,
+              OpenAI::Realtime::RealtimeTranscriptionSessionCreateResponse::Modality::TaggedSymbol
+            )
+          AUDIO =
+            T.let(
+              :audio,
+              OpenAI::Realtime::RealtimeTranscriptionSessionCreateResponse::Modality::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                OpenAI::Realtime::RealtimeTranscriptionSessionCreateResponse::Modality::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/openai/models/realtime/realtime_transcription_session_input_audio_transcription.rbi

@@ -0,0 +1,144 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    RealtimeTranscriptionSessionInputAudioTranscription =
+      Realtime::RealtimeTranscriptionSessionInputAudioTranscription
+
+    module Realtime
+      class RealtimeTranscriptionSessionInputAudioTranscription < OpenAI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              OpenAI::Realtime::RealtimeTranscriptionSessionInputAudioTranscription,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+        # The language of the input audio. Supplying the input language in
+        # [ISO-639-1](https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes) (e.g. `en`)
+        # format will improve accuracy and latency.
+        sig { returns(T.nilable(String)) }
+        attr_reader :language
+
+        sig { params(language: String).void }
+        attr_writer :language
+
+        # The model to use for transcription. Current options are `whisper-1`,
+        # `gpt-4o-transcribe-latest`, `gpt-4o-mini-transcribe`, and `gpt-4o-transcribe`.
+        sig do
+          returns(
+            T.nilable(
+              OpenAI::Realtime::RealtimeTranscriptionSessionInputAudioTranscription::Model::TaggedSymbol
+            )
+          )
+        end
+        attr_reader :model
+
+        sig do
+          params(
+            model:
+              OpenAI::Realtime::RealtimeTranscriptionSessionInputAudioTranscription::Model::OrSymbol
+          ).void
+        end
+        attr_writer :model
+
+        # An optional text to guide the model's style or continue a previous audio
+        # segment. For `whisper-1`, the
+        # [prompt is a list of keywords](https://platform.openai.com/docs/guides/speech-to-text#prompting).
+        # For `gpt-4o-transcribe` models, the prompt is a free text string, for example
+        # "expect words related to technology".
+        sig { returns(T.nilable(String)) }
+        attr_reader :prompt
+
+        sig { params(prompt: String).void }
+        attr_writer :prompt
+
+        # Configuration of the transcription model.
+        sig do
+          params(
+            language: String,
+            model:
+              OpenAI::Realtime::RealtimeTranscriptionSessionInputAudioTranscription::Model::OrSymbol,
+            prompt: String
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # The language of the input audio. Supplying the input language in
+          # [ISO-639-1](https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes) (e.g. `en`)
+          # format will improve accuracy and latency.
+          language: nil,
+          # The model to use for transcription. Current options are `whisper-1`,
+          # `gpt-4o-transcribe-latest`, `gpt-4o-mini-transcribe`, and `gpt-4o-transcribe`.
+          model: nil,
+          # An optional text to guide the model's style or continue a previous audio
+          # segment. For `whisper-1`, the
+          # [prompt is a list of keywords](https://platform.openai.com/docs/guides/speech-to-text#prompting).
+          # For `gpt-4o-transcribe` models, the prompt is a free text string, for example
+          # "expect words related to technology".
+          prompt: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              language: String,
+              model:
+                OpenAI::Realtime::RealtimeTranscriptionSessionInputAudioTranscription::Model::TaggedSymbol,
+              prompt: String
+            }
+          )
+        end
+        def to_hash
+        end
+
+        # The model to use for transcription. Current options are `whisper-1`,
+        # `gpt-4o-transcribe-latest`, `gpt-4o-mini-transcribe`, and `gpt-4o-transcribe`.
+        module Model
+          extend OpenAI::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(
+                Symbol,
+                OpenAI::Realtime::RealtimeTranscriptionSessionInputAudioTranscription::Model
+              )
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          WHISPER_1 =
+            T.let(
+              :"whisper-1",
+              OpenAI::Realtime::RealtimeTranscriptionSessionInputAudioTranscription::Model::TaggedSymbol
+            )
+          GPT_4O_TRANSCRIBE_LATEST =
+            T.let(
+              :"gpt-4o-transcribe-latest",
+              OpenAI::Realtime::RealtimeTranscriptionSessionInputAudioTranscription::Model::TaggedSymbol
+            )
+          GPT_4O_MINI_TRANSCRIBE =
+            T.let(
+              :"gpt-4o-mini-transcribe",
+              OpenAI::Realtime::RealtimeTranscriptionSessionInputAudioTranscription::Model::TaggedSymbol
+            )
+          GPT_4O_TRANSCRIBE =
+            T.let(
+              :"gpt-4o-transcribe",
+              OpenAI::Realtime::RealtimeTranscriptionSessionInputAudioTranscription::Model::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                OpenAI::Realtime::RealtimeTranscriptionSessionInputAudioTranscription::Model::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/openai/models/realtime/realtime_transcription_session_turn_detection.rbi

@@ -0,0 +1,94 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    RealtimeTranscriptionSessionTurnDetection =
+      Realtime::RealtimeTranscriptionSessionTurnDetection
+
+    module Realtime
+      class RealtimeTranscriptionSessionTurnDetection < OpenAI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              OpenAI::Realtime::RealtimeTranscriptionSessionTurnDetection,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+        # Amount of audio to include before the VAD detected speech (in milliseconds).
+        # Defaults to 300ms.
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :prefix_padding_ms
+
+        sig { params(prefix_padding_ms: Integer).void }
+        attr_writer :prefix_padding_ms
+
+        # Duration of silence to detect speech stop (in milliseconds). Defaults to 500ms.
+        # With shorter values the model will respond more quickly, but may jump in on
+        # short pauses from the user.
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :silence_duration_ms
+
+        sig { params(silence_duration_ms: Integer).void }
+        attr_writer :silence_duration_ms
+
+        # Activation threshold for VAD (0.0 to 1.0), this defaults to 0.5. A higher
+        # threshold will require louder audio to activate the model, and thus might
+        # perform better in noisy environments.
+        sig { returns(T.nilable(Float)) }
+        attr_reader :threshold
+
+        sig { params(threshold: Float).void }
+        attr_writer :threshold
+
+        # Type of turn detection, only `server_vad` is currently supported.
+        sig { returns(T.nilable(String)) }
+        attr_reader :type
+
+        sig { params(type: String).void }
+        attr_writer :type
+
+        # Configuration for turn detection. Can be set to `null` to turn off. Server VAD
+        # means that the model will detect the start and end of speech based on audio
+        # volume and respond at the end of user speech.
+        sig do
+          params(
+            prefix_padding_ms: Integer,
+            silence_duration_ms: Integer,
+            threshold: Float,
+            type: String
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Amount of audio to include before the VAD detected speech (in milliseconds).
+          # Defaults to 300ms.
+          prefix_padding_ms: nil,
+          # Duration of silence to detect speech stop (in milliseconds). Defaults to 500ms.
+          # With shorter values the model will respond more quickly, but may jump in on
+          # short pauses from the user.
+          silence_duration_ms: nil,
+          # Activation threshold for VAD (0.0 to 1.0), this defaults to 0.5. A higher
+          # threshold will require louder audio to activate the model, and thus might
+          # perform better in noisy environments.
+          threshold: nil,
+          # Type of turn detection, only `server_vad` is currently supported.
+          type: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              prefix_padding_ms: Integer,
+              silence_duration_ms: Integer,
+              threshold: Float,
+              type: String
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/openai/models/realtime/realtime_truncation.rbi

@@ -4,8 +4,7 @@ module OpenAI
   module Models
     module Realtime
       # Controls how the realtime conversation is truncated prior to model inference.
-      # The default is `auto`. When set to `retention_ratio`, the server retains a
-      # fraction of the conversation tokens prior to the instructions.
+      # The default is `auto`.
       module RealtimeTruncation
         extend OpenAI::Internal::Type::Union
 
@@ -13,11 +12,13 @@ module OpenAI
           T.type_alias do
             T.any(
               OpenAI::Realtime::RealtimeTruncation::RealtimeTruncationStrategy::TaggedSymbol,
-              OpenAI::Realtime::RealtimeTruncation::RetentionRatioTruncation
+              OpenAI::Realtime::RealtimeTruncationRetentionRatio
             )
           end
 
-        # The truncation strategy to use for the session.
+        # The truncation strategy to use for the session. `auto` is the default truncation
+        # strategy. `disabled` will disable truncation and emit errors when the
+        # conversation exceeds the input token limit.
         module RealtimeTruncationStrategy
           extend OpenAI::Internal::Type::Enum
 
@@ -52,58 +53,6 @@ module OpenAI
           end
         end
 
-        class RetentionRatioTruncation < OpenAI::Internal::Type::BaseModel
-          OrHash =
-            T.type_alias do
-              T.any(
-                OpenAI::Realtime::RealtimeTruncation::RetentionRatioTruncation,
-                OpenAI::Internal::AnyHash
-              )
-            end
-
-          # Fraction of pre-instruction conversation tokens to retain (0.0 - 1.0).
-          sig { returns(Float) }
-          attr_accessor :retention_ratio
-
-          # Use retention ratio truncation.
-          sig { returns(Symbol) }
-          attr_accessor :type
-
-          # Optional cap on tokens allowed after the instructions.
-          sig { returns(T.nilable(Integer)) }
-          attr_accessor :post_instructions_token_limit
-
-          # Retain a fraction of the conversation tokens.
-          sig do
-            params(
-              retention_ratio: Float,
-              post_instructions_token_limit: T.nilable(Integer),
-              type: Symbol
-            ).returns(T.attached_class)
-          end
-          def self.new(
-            # Fraction of pre-instruction conversation tokens to retain (0.0 - 1.0).
-            retention_ratio:,
-            # Optional cap on tokens allowed after the instructions.
-            post_instructions_token_limit: nil,
-            # Use retention ratio truncation.
-            type: :retention_ratio
-          )
-          end
-
-          sig do
-            override.returns(
-              {
-                retention_ratio: Float,
-                type: Symbol,
-                post_instructions_token_limit: T.nilable(Integer)
-              }
-            )
-          end
-          def to_hash
-          end
-        end
-
         sig do
           override.returns(
             T::Array[OpenAI::Realtime::RealtimeTruncation::Variants]

data/rbi/openai/models/realtime/realtime_truncation_retention_ratio.rbi

@@ -0,0 +1,45 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    module Realtime
+      class RealtimeTruncationRetentionRatio < OpenAI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              OpenAI::Realtime::RealtimeTruncationRetentionRatio,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+        # Fraction of post-instruction conversation tokens to retain (0.0 - 1.0) when the
+        # conversation exceeds the input token limit.
+        sig { returns(Float) }
+        attr_accessor :retention_ratio
+
+        # Use retention ratio truncation.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # Retain a fraction of the conversation tokens when the conversation exceeds the
+        # input token limit. This allows you to amortize truncations across multiple
+        # turns, which can help improve cached token usage.
+        sig do
+          params(retention_ratio: Float, type: Symbol).returns(T.attached_class)
+        end
+        def self.new(
+          # Fraction of post-instruction conversation tokens to retain (0.0 - 1.0) when the
+          # conversation exceeds the input token limit.
+          retention_ratio:,
+          # Use retention ratio truncation.
+          type: :retention_ratio
+        )
+        end
+
+        sig { override.returns({ retention_ratio: Float, type: Symbol }) }
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/openai/models/realtime/response_cancel_event.rbi

@@ -33,7 +33,9 @@ module OpenAI
 
         # Send this event to cancel an in-progress response. The server will respond with
         # a `response.done` event with a status of `response.status=cancelled`. If there
-        # is no response to cancel, the server will respond with an error.
+        # is no response to cancel, the server will respond with an error. It's safe to
+        # call `response.cancel` even if no response is in progress, an error will be
+        # returned the session will remain unaffected.
         sig do
           params(event_id: String, response_id: String, type: Symbol).returns(
             T.attached_class