openai 0.30.0 → 0.32.0

data/rbi/openai/models/audio/transcription_diarized.rbi

@@ -0,0 +1,281 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    module Audio
+      class TranscriptionDiarized < OpenAI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              OpenAI::Audio::TranscriptionDiarized,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+        # Duration of the input audio in seconds.
+        sig { returns(Float) }
+        attr_accessor :duration
+
+        # Segments of the transcript annotated with timestamps and speaker labels.
+        sig { returns(T::Array[OpenAI::Audio::TranscriptionDiarizedSegment]) }
+        attr_accessor :segments
+
+        # The type of task that was run. Always `transcribe`.
+        sig { returns(Symbol) }
+        attr_accessor :task
+
+        # The concatenated transcript text for the entire audio input.
+        sig { returns(String) }
+        attr_accessor :text
+
+        # Token or duration usage statistics for the request.
+        sig do
+          returns(
+            T.nilable(OpenAI::Audio::TranscriptionDiarized::Usage::Variants)
+          )
+        end
+        attr_reader :usage
+
+        sig do
+          params(
+            usage:
+              T.any(
+                OpenAI::Audio::TranscriptionDiarized::Usage::Tokens::OrHash,
+                OpenAI::Audio::TranscriptionDiarized::Usage::Duration::OrHash
+              )
+          ).void
+        end
+        attr_writer :usage
+
+        # Represents a diarized transcription response returned by the model, including
+        # the combined transcript and speaker-segment annotations.
+        sig do
+          params(
+            duration: Float,
+            segments:
+              T::Array[OpenAI::Audio::TranscriptionDiarizedSegment::OrHash],
+            text: String,
+            usage:
+              T.any(
+                OpenAI::Audio::TranscriptionDiarized::Usage::Tokens::OrHash,
+                OpenAI::Audio::TranscriptionDiarized::Usage::Duration::OrHash
+              ),
+            task: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Duration of the input audio in seconds.
+          duration:,
+          # Segments of the transcript annotated with timestamps and speaker labels.
+          segments:,
+          # The concatenated transcript text for the entire audio input.
+          text:,
+          # Token or duration usage statistics for the request.
+          usage: nil,
+          # The type of task that was run. Always `transcribe`.
+          task: :transcribe
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              duration: Float,
+              segments: T::Array[OpenAI::Audio::TranscriptionDiarizedSegment],
+              task: Symbol,
+              text: String,
+              usage: OpenAI::Audio::TranscriptionDiarized::Usage::Variants
+            }
+          )
+        end
+        def to_hash
+        end
+
+        # Token or duration usage statistics for the request.
+        module Usage
+          extend OpenAI::Internal::Type::Union
+
+          Variants =
+            T.type_alias do
+              T.any(
+                OpenAI::Audio::TranscriptionDiarized::Usage::Tokens,
+                OpenAI::Audio::TranscriptionDiarized::Usage::Duration
+              )
+            end
+
+          class Tokens < OpenAI::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  OpenAI::Audio::TranscriptionDiarized::Usage::Tokens,
+                  OpenAI::Internal::AnyHash
+                )
+              end
+
+            # Number of input tokens billed for this request.
+            sig { returns(Integer) }
+            attr_accessor :input_tokens
+
+            # Number of output tokens generated.
+            sig { returns(Integer) }
+            attr_accessor :output_tokens
+
+            # Total number of tokens used (input + output).
+            sig { returns(Integer) }
+            attr_accessor :total_tokens
+
+            # The type of the usage object. Always `tokens` for this variant.
+            sig { returns(Symbol) }
+            attr_accessor :type
+
+            # Details about the input tokens billed for this request.
+            sig do
+              returns(
+                T.nilable(
+                  OpenAI::Audio::TranscriptionDiarized::Usage::Tokens::InputTokenDetails
+                )
+              )
+            end
+            attr_reader :input_token_details
+
+            sig do
+              params(
+                input_token_details:
+                  OpenAI::Audio::TranscriptionDiarized::Usage::Tokens::InputTokenDetails::OrHash
+              ).void
+            end
+            attr_writer :input_token_details
+
+            # Usage statistics for models billed by token usage.
+            sig do
+              params(
+                input_tokens: Integer,
+                output_tokens: Integer,
+                total_tokens: Integer,
+                input_token_details:
+                  OpenAI::Audio::TranscriptionDiarized::Usage::Tokens::InputTokenDetails::OrHash,
+                type: Symbol
+              ).returns(T.attached_class)
+            end
+            def self.new(
+              # Number of input tokens billed for this request.
+              input_tokens:,
+              # Number of output tokens generated.
+              output_tokens:,
+              # Total number of tokens used (input + output).
+              total_tokens:,
+              # Details about the input tokens billed for this request.
+              input_token_details: nil,
+              # The type of the usage object. Always `tokens` for this variant.
+              type: :tokens
+            )
+            end
+
+            sig do
+              override.returns(
+                {
+                  input_tokens: Integer,
+                  output_tokens: Integer,
+                  total_tokens: Integer,
+                  type: Symbol,
+                  input_token_details:
+                    OpenAI::Audio::TranscriptionDiarized::Usage::Tokens::InputTokenDetails
+                }
+              )
+            end
+            def to_hash
+            end
+
+            class InputTokenDetails < OpenAI::Internal::Type::BaseModel
+              OrHash =
+                T.type_alias do
+                  T.any(
+                    OpenAI::Audio::TranscriptionDiarized::Usage::Tokens::InputTokenDetails,
+                    OpenAI::Internal::AnyHash
+                  )
+                end
+
+              # Number of audio tokens billed for this request.
+              sig { returns(T.nilable(Integer)) }
+              attr_reader :audio_tokens
+
+              sig { params(audio_tokens: Integer).void }
+              attr_writer :audio_tokens
+
+              # Number of text tokens billed for this request.
+              sig { returns(T.nilable(Integer)) }
+              attr_reader :text_tokens
+
+              sig { params(text_tokens: Integer).void }
+              attr_writer :text_tokens
+
+              # Details about the input tokens billed for this request.
+              sig do
+                params(audio_tokens: Integer, text_tokens: Integer).returns(
+                  T.attached_class
+                )
+              end
+              def self.new(
+                # Number of audio tokens billed for this request.
+                audio_tokens: nil,
+                # Number of text tokens billed for this request.
+                text_tokens: nil
+              )
+              end
+
+              sig do
+                override.returns(
+                  { audio_tokens: Integer, text_tokens: Integer }
+                )
+              end
+              def to_hash
+              end
+            end
+          end
+
+          class Duration < OpenAI::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  OpenAI::Audio::TranscriptionDiarized::Usage::Duration,
+                  OpenAI::Internal::AnyHash
+                )
+              end
+
+            # Duration of the input audio in seconds.
+            sig { returns(Float) }
+            attr_accessor :seconds
+
+            # The type of the usage object. Always `duration` for this variant.
+            sig { returns(Symbol) }
+            attr_accessor :type
+
+            # Usage statistics for models billed by audio input duration.
+            sig do
+              params(seconds: Float, type: Symbol).returns(T.attached_class)
+            end
+            def self.new(
+              # Duration of the input audio in seconds.
+              seconds:,
+              # The type of the usage object. Always `duration` for this variant.
+              type: :duration
+            )
+            end
+
+            sig { override.returns({ seconds: Float, type: Symbol }) }
+            def to_hash
+            end
+          end
+
+          sig do
+            override.returns(
+              T::Array[OpenAI::Audio::TranscriptionDiarized::Usage::Variants]
+            )
+          end
+          def self.variants
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/openai/models/audio/transcription_diarized_segment.rbi

@@ -0,0 +1,87 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    module Audio
+      class TranscriptionDiarizedSegment < OpenAI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              OpenAI::Audio::TranscriptionDiarizedSegment,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+        # Unique identifier for the segment.
+        sig { returns(String) }
+        attr_accessor :id
+
+        # End timestamp of the segment in seconds.
+        sig { returns(Float) }
+        attr_accessor :end_
+
+        # Speaker label for this segment. When known speakers are provided, the label
+        # matches `known_speaker_names[]`. Otherwise speakers are labeled sequentially
+        # using capital letters (`A`, `B`, ...).
+        sig { returns(String) }
+        attr_accessor :speaker
+
+        # Start timestamp of the segment in seconds.
+        sig { returns(Float) }
+        attr_accessor :start
+
+        # Transcript text for this segment.
+        sig { returns(String) }
+        attr_accessor :text
+
+        # The type of the segment. Always `transcript.text.segment`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # A segment of diarized transcript text with speaker metadata.
+        sig do
+          params(
+            id: String,
+            end_: Float,
+            speaker: String,
+            start: Float,
+            text: String,
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Unique identifier for the segment.
+          id:,
+          # End timestamp of the segment in seconds.
+          end_:,
+          # Speaker label for this segment. When known speakers are provided, the label
+          # matches `known_speaker_names[]`. Otherwise speakers are labeled sequentially
+          # using capital letters (`A`, `B`, ...).
+          speaker:,
+          # Start timestamp of the segment in seconds.
+          start:,
+          # Transcript text for this segment.
+          text:,
+          # The type of the segment. Always `transcript.text.segment`.
+          type: :"transcript.text.segment"
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              id: String,
+              end_: Float,
+              speaker: String,
+              start: Float,
+              text: String,
+              type: Symbol
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/openai/models/audio/transcription_stream_event.rbi

@@ -3,16 +3,17 @@
 module OpenAI
   module Models
     module Audio
-      # Emitted when there is an additional text delta. This is also the first event
-      # emitted when the transcription starts. Only emitted when you
+      # Emitted when a diarized transcription returns a completed segment with speaker
+      # information. Only emitted when you
       # [create a transcription](https://platform.openai.com/docs/api-reference/audio/create-transcription)
-      # with the `Stream` parameter set to `true`.
+      # with `stream` set to `true` and `response_format` set to `diarized_json`.
       module TranscriptionStreamEvent
         extend OpenAI::Internal::Type::Union
 
         Variants =
           T.type_alias do
             T.any(
+              OpenAI::Audio::TranscriptionTextSegmentEvent,
               OpenAI::Audio::TranscriptionTextDeltaEvent,
               OpenAI::Audio::TranscriptionTextDoneEvent
             )

data/rbi/openai/models/audio/transcription_text_delta_event.rbi

@@ -42,6 +42,14 @@ module OpenAI
         end
         attr_writer :logprobs
 
+        # Identifier of the diarized segment that this delta belongs to. Only present when
+        # using `gpt-4o-transcribe-diarize`.
+        sig { returns(T.nilable(String)) }
+        attr_reader :segment_id
+
+        sig { params(segment_id: String).void }
+        attr_writer :segment_id
+
         # Emitted when there is an additional text delta. This is also the first event
         # emitted when the transcription starts. Only emitted when you
         # [create a transcription](https://platform.openai.com/docs/api-reference/audio/create-transcription)
@@ -53,6 +61,7 @@ module OpenAI
               T::Array[
                 OpenAI::Audio::TranscriptionTextDeltaEvent::Logprob::OrHash
               ],
+            segment_id: String,
             type: Symbol
           ).returns(T.attached_class)
         end
@@ -63,6 +72,9 @@ module OpenAI
           # [create a transcription](https://platform.openai.com/docs/api-reference/audio/create-transcription)
           # with the `include[]` parameter set to `logprobs`.
           logprobs: nil,
+          # Identifier of the diarized segment that this delta belongs to. Only present when
+          # using `gpt-4o-transcribe-diarize`.
+          segment_id: nil,
           # The type of the event. Always `transcript.text.delta`.
           type: :"transcript.text.delta"
         )
@@ -74,7 +86,8 @@ module OpenAI
               delta: String,
               type: Symbol,
               logprobs:
-                T::Array[OpenAI::Audio::TranscriptionTextDeltaEvent::Logprob]
+                T::Array[OpenAI::Audio::TranscriptionTextDeltaEvent::Logprob],
+              segment_id: String
             }
           )
         end

data/rbi/openai/models/audio/transcription_text_segment_event.rbi

@@ -0,0 +1,86 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    module Audio
+      class TranscriptionTextSegmentEvent < OpenAI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              OpenAI::Audio::TranscriptionTextSegmentEvent,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+        # Unique identifier for the segment.
+        sig { returns(String) }
+        attr_accessor :id
+
+        # End timestamp of the segment in seconds.
+        sig { returns(Float) }
+        attr_accessor :end_
+
+        # Speaker label for this segment.
+        sig { returns(String) }
+        attr_accessor :speaker
+
+        # Start timestamp of the segment in seconds.
+        sig { returns(Float) }
+        attr_accessor :start
+
+        # Transcript text for this segment.
+        sig { returns(String) }
+        attr_accessor :text
+
+        # The type of the event. Always `transcript.text.segment`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # Emitted when a diarized transcription returns a completed segment with speaker
+        # information. Only emitted when you
+        # [create a transcription](https://platform.openai.com/docs/api-reference/audio/create-transcription)
+        # with `stream` set to `true` and `response_format` set to `diarized_json`.
+        sig do
+          params(
+            id: String,
+            end_: Float,
+            speaker: String,
+            start: Float,
+            text: String,
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Unique identifier for the segment.
+          id:,
+          # End timestamp of the segment in seconds.
+          end_:,
+          # Speaker label for this segment.
+          speaker:,
+          # Start timestamp of the segment in seconds.
+          start:,
+          # Transcript text for this segment.
+          text:,
+          # The type of the event. Always `transcript.text.segment`.
+          type: :"transcript.text.segment"
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              id: String,
+              end_: Float,
+              speaker: String,
+              start: Float,
+              text: String,
+              type: Symbol
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/openai/models/audio_model.rbi

@@ -13,6 +13,8 @@ module OpenAI
         T.let(:"gpt-4o-transcribe", OpenAI::AudioModel::TaggedSymbol)
       GPT_4O_MINI_TRANSCRIBE =
         T.let(:"gpt-4o-mini-transcribe", OpenAI::AudioModel::TaggedSymbol)
+      GPT_4O_TRANSCRIBE_DIARIZE =
+        T.let(:"gpt-4o-transcribe-diarize", OpenAI::AudioModel::TaggedSymbol)
 
       sig { override.returns(T::Array[OpenAI::AudioModel::TaggedSymbol]) }
       def self.values

data/rbi/openai/models/audio_response_format.rbi

@@ -3,8 +3,10 @@
 module OpenAI
   module Models
     # The format of the output, in one of these options: `json`, `text`, `srt`,
-    # `verbose_json`, or `vtt`. For `gpt-4o-transcribe` and `gpt-4o-mini-transcribe`,
-    # the only supported format is `json`.
+    # `verbose_json`, `vtt`, or `diarized_json`. For `gpt-4o-transcribe` and
+    # `gpt-4o-mini-transcribe`, the only supported format is `json`. For
+    # `gpt-4o-transcribe-diarize`, the supported formats are `json`, `text`, and
+    # `diarized_json`, with `diarized_json` required to receive speaker annotations.
     module AudioResponseFormat
       extend OpenAI::Internal::Type::Enum
 
@@ -17,6 +19,8 @@ module OpenAI
       VERBOSE_JSON =
         T.let(:verbose_json, OpenAI::AudioResponseFormat::TaggedSymbol)
       VTT = T.let(:vtt, OpenAI::AudioResponseFormat::TaggedSymbol)
+      DIARIZED_JSON =
+        T.let(:diarized_json, OpenAI::AudioResponseFormat::TaggedSymbol)
 
       sig do
         override.returns(T::Array[OpenAI::AudioResponseFormat::TaggedSymbol])

data/rbi/openai/models/beta/assistant_create_params.rbi

@@ -50,6 +50,9 @@ module OpenAI
         # supported values are `minimal`, `low`, `medium`, and `high`. Reducing reasoning
         # effort can result in faster responses and fewer tokens used on reasoning in a
         # response.
+        #
+        # Note: The `gpt-5-pro` model defaults to (and only supports) `high` reasoning
+        # effort.
         sig { returns(T.nilable(OpenAI::ReasoningEffort::OrSymbol)) }
         attr_accessor :reasoning_effort
 
@@ -212,6 +215,9 @@ module OpenAI
           # supported values are `minimal`, `low`, `medium`, and `high`. Reducing reasoning
           # effort can result in faster responses and fewer tokens used on reasoning in a
           # response.
+          #
+          # Note: The `gpt-5-pro` model defaults to (and only supports) `high` reasoning
+          # effort.
           reasoning_effort: nil,
           # Specifies the format that the model must output. Compatible with
           # [GPT-4o](https://platform.openai.com/docs/models#gpt-4o),

data/rbi/openai/models/beta/assistant_update_params.rbi

@@ -70,6 +70,9 @@ module OpenAI
         # supported values are `minimal`, `low`, `medium`, and `high`. Reducing reasoning
         # effort can result in faster responses and fewer tokens used on reasoning in a
         # response.
+        #
+        # Note: The `gpt-5-pro` model defaults to (and only supports) `high` reasoning
+        # effort.
         sig { returns(T.nilable(OpenAI::ReasoningEffort::OrSymbol)) }
         attr_accessor :reasoning_effort
 
@@ -236,6 +239,9 @@ module OpenAI
           # supported values are `minimal`, `low`, `medium`, and `high`. Reducing reasoning
           # effort can result in faster responses and fewer tokens used on reasoning in a
           # response.
+          #
+          # Note: The `gpt-5-pro` model defaults to (and only supports) `high` reasoning
+          # effort.
           reasoning_effort: nil,
           # Specifies the format that the model must output. Compatible with
           # [GPT-4o](https://platform.openai.com/docs/models#gpt-4o),

data/rbi/openai/models/beta/threads/run_create_params.rbi

@@ -116,6 +116,9 @@ module OpenAI
           # supported values are `minimal`, `low`, `medium`, and `high`. Reducing reasoning
           # effort can result in faster responses and fewer tokens used on reasoning in a
           # response.
+          #
+          # Note: The `gpt-5-pro` model defaults to (and only supports) `high` reasoning
+          # effort.
           sig { returns(T.nilable(OpenAI::ReasoningEffort::OrSymbol)) }
           attr_accessor :reasoning_effort
 
@@ -334,6 +337,9 @@ module OpenAI
             # supported values are `minimal`, `low`, `medium`, and `high`. Reducing reasoning
             # effort can result in faster responses and fewer tokens used on reasoning in a
             # response.
+            #
+            # Note: The `gpt-5-pro` model defaults to (and only supports) `high` reasoning
+            # effort.
             reasoning_effort: nil,
             # Specifies the format that the model must output. Compatible with
             # [GPT-4o](https://platform.openai.com/docs/models#gpt-4o),

data/rbi/openai/models/chat/completion_create_params.rbi

@@ -230,6 +230,9 @@ module OpenAI
         # supported values are `minimal`, `low`, `medium`, and `high`. Reducing reasoning
         # effort can result in faster responses and fewer tokens used on reasoning in a
         # response.
+        #
+        # Note: The `gpt-5-pro` model defaults to (and only supports) `high` reasoning
+        # effort.
         sig { returns(T.nilable(OpenAI::ReasoningEffort::OrSymbol)) }
         attr_accessor :reasoning_effort
 
@@ -667,6 +670,9 @@ module OpenAI
           # supported values are `minimal`, `low`, `medium`, and `high`. Reducing reasoning
           # effort can result in faster responses and fewer tokens used on reasoning in a
           # response.
+          #
+          # Note: The `gpt-5-pro` model defaults to (and only supports) `high` reasoning
+          # effort.
           reasoning_effort: nil,
           # An object specifying the format that the model must output.
           #