openai 0.20.0 → 0.21.0

data/rbi/openai/models/realtime/conversation_item_done.rbi

@@ -0,0 +1,105 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    module Realtime
+      class ConversationItemDone < OpenAI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              OpenAI::Realtime::ConversationItemDone,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+        # The unique ID of the server event.
+        sig { returns(String) }
+        attr_accessor :event_id
+
+        # A single item within a Realtime conversation.
+        sig do
+          returns(
+            T.any(
+              OpenAI::Realtime::RealtimeConversationItemSystemMessage,
+              OpenAI::Realtime::RealtimeConversationItemUserMessage,
+              OpenAI::Realtime::RealtimeConversationItemAssistantMessage,
+              OpenAI::Realtime::RealtimeConversationItemFunctionCall,
+              OpenAI::Realtime::RealtimeConversationItemFunctionCallOutput,
+              OpenAI::Realtime::RealtimeMcpApprovalResponse,
+              OpenAI::Realtime::RealtimeMcpListTools,
+              OpenAI::Realtime::RealtimeMcpToolCall,
+              OpenAI::Realtime::RealtimeMcpApprovalRequest
+            )
+          )
+        end
+        attr_accessor :item
+
+        # The event type, must be `conversation.item.done`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # The ID of the item that precedes this one, if any. This is used to maintain
+        # ordering when items are inserted.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :previous_item_id
+
+        # Returned when a conversation item is finalized.
+        sig do
+          params(
+            event_id: String,
+            item:
+              T.any(
+                OpenAI::Realtime::RealtimeConversationItemSystemMessage::OrHash,
+                OpenAI::Realtime::RealtimeConversationItemUserMessage::OrHash,
+                OpenAI::Realtime::RealtimeConversationItemAssistantMessage::OrHash,
+                OpenAI::Realtime::RealtimeConversationItemFunctionCall::OrHash,
+                OpenAI::Realtime::RealtimeConversationItemFunctionCallOutput::OrHash,
+                OpenAI::Realtime::RealtimeMcpApprovalResponse::OrHash,
+                OpenAI::Realtime::RealtimeMcpListTools::OrHash,
+                OpenAI::Realtime::RealtimeMcpToolCall::OrHash,
+                OpenAI::Realtime::RealtimeMcpApprovalRequest::OrHash
+              ),
+            previous_item_id: T.nilable(String),
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # The unique ID of the server event.
+          event_id:,
+          # A single item within a Realtime conversation.
+          item:,
+          # The ID of the item that precedes this one, if any. This is used to maintain
+          # ordering when items are inserted.
+          previous_item_id: nil,
+          # The event type, must be `conversation.item.done`.
+          type: :"conversation.item.done"
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              event_id: String,
+              item:
+                T.any(
+                  OpenAI::Realtime::RealtimeConversationItemSystemMessage,
+                  OpenAI::Realtime::RealtimeConversationItemUserMessage,
+                  OpenAI::Realtime::RealtimeConversationItemAssistantMessage,
+                  OpenAI::Realtime::RealtimeConversationItemFunctionCall,
+                  OpenAI::Realtime::RealtimeConversationItemFunctionCallOutput,
+                  OpenAI::Realtime::RealtimeMcpApprovalResponse,
+                  OpenAI::Realtime::RealtimeMcpListTools,
+                  OpenAI::Realtime::RealtimeMcpToolCall,
+                  OpenAI::Realtime::RealtimeMcpApprovalRequest
+                ),
+              type: Symbol,
+              previous_item_id: T.nilable(String)
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/openai/models/realtime/conversation_item_input_audio_transcription_completed_event.rbi

@@ -0,0 +1,305 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    module Realtime
+      class ConversationItemInputAudioTranscriptionCompletedEvent < OpenAI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              OpenAI::Realtime::ConversationItemInputAudioTranscriptionCompletedEvent,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+        # The index of the content part containing the audio.
+        sig { returns(Integer) }
+        attr_accessor :content_index
+
+        # The unique ID of the server event.
+        sig { returns(String) }
+        attr_accessor :event_id
+
+        # The ID of the user message item containing the audio.
+        sig { returns(String) }
+        attr_accessor :item_id
+
+        # The transcribed text.
+        sig { returns(String) }
+        attr_accessor :transcript
+
+        # The event type, must be `conversation.item.input_audio_transcription.completed`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # Usage statistics for the transcription.
+        sig do
+          returns(
+            T.any(
+              OpenAI::Realtime::ConversationItemInputAudioTranscriptionCompletedEvent::Usage::TranscriptTextUsageTokens,
+              OpenAI::Realtime::ConversationItemInputAudioTranscriptionCompletedEvent::Usage::TranscriptTextUsageDuration
+            )
+          )
+        end
+        attr_accessor :usage
+
+        # The log probabilities of the transcription.
+        sig do
+          returns(T.nilable(T::Array[OpenAI::Realtime::LogProbProperties]))
+        end
+        attr_accessor :logprobs
+
+        # This event is the output of audio transcription for user audio written to the
+        # user audio buffer. Transcription begins when the input audio buffer is committed
+        # by the client or server (in `server_vad` mode). Transcription runs
+        # asynchronously with Response creation, so this event may come before or after
+        # the Response events.
+        #
+        # Realtime API models accept audio natively, and thus input transcription is a
+        # separate process run on a separate ASR (Automatic Speech Recognition) model. The
+        # transcript may diverge somewhat from the model's interpretation, and should be
+        # treated as a rough guide.
+        sig do
+          params(
+            content_index: Integer,
+            event_id: String,
+            item_id: String,
+            transcript: String,
+            usage:
+              T.any(
+                OpenAI::Realtime::ConversationItemInputAudioTranscriptionCompletedEvent::Usage::TranscriptTextUsageTokens::OrHash,
+                OpenAI::Realtime::ConversationItemInputAudioTranscriptionCompletedEvent::Usage::TranscriptTextUsageDuration::OrHash
+              ),
+            logprobs:
+              T.nilable(T::Array[OpenAI::Realtime::LogProbProperties::OrHash]),
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # The index of the content part containing the audio.
+          content_index:,
+          # The unique ID of the server event.
+          event_id:,
+          # The ID of the user message item containing the audio.
+          item_id:,
+          # The transcribed text.
+          transcript:,
+          # Usage statistics for the transcription.
+          usage:,
+          # The log probabilities of the transcription.
+          logprobs: nil,
+          # The event type, must be `conversation.item.input_audio_transcription.completed`.
+          type: :"conversation.item.input_audio_transcription.completed"
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              content_index: Integer,
+              event_id: String,
+              item_id: String,
+              transcript: String,
+              type: Symbol,
+              usage:
+                T.any(
+                  OpenAI::Realtime::ConversationItemInputAudioTranscriptionCompletedEvent::Usage::TranscriptTextUsageTokens,
+                  OpenAI::Realtime::ConversationItemInputAudioTranscriptionCompletedEvent::Usage::TranscriptTextUsageDuration
+                ),
+              logprobs: T.nilable(T::Array[OpenAI::Realtime::LogProbProperties])
+            }
+          )
+        end
+        def to_hash
+        end
+
+        # Usage statistics for the transcription.
+        module Usage
+          extend OpenAI::Internal::Type::Union
+
+          Variants =
+            T.type_alias do
+              T.any(
+                OpenAI::Realtime::ConversationItemInputAudioTranscriptionCompletedEvent::Usage::TranscriptTextUsageTokens,
+                OpenAI::Realtime::ConversationItemInputAudioTranscriptionCompletedEvent::Usage::TranscriptTextUsageDuration
+              )
+            end
+
+          class TranscriptTextUsageTokens < OpenAI::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  OpenAI::Realtime::ConversationItemInputAudioTranscriptionCompletedEvent::Usage::TranscriptTextUsageTokens,
+                  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::Realtime::ConversationItemInputAudioTranscriptionCompletedEvent::Usage::TranscriptTextUsageTokens::InputTokenDetails
+                )
+              )
+            end
+            attr_reader :input_token_details
+
+            sig do
+              params(
+                input_token_details:
+                  OpenAI::Realtime::ConversationItemInputAudioTranscriptionCompletedEvent::Usage::TranscriptTextUsageTokens::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::Realtime::ConversationItemInputAudioTranscriptionCompletedEvent::Usage::TranscriptTextUsageTokens::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::Realtime::ConversationItemInputAudioTranscriptionCompletedEvent::Usage::TranscriptTextUsageTokens::InputTokenDetails
+                }
+              )
+            end
+            def to_hash
+            end
+
+            class InputTokenDetails < OpenAI::Internal::Type::BaseModel
+              OrHash =
+                T.type_alias do
+                  T.any(
+                    OpenAI::Realtime::ConversationItemInputAudioTranscriptionCompletedEvent::Usage::TranscriptTextUsageTokens::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 TranscriptTextUsageDuration < OpenAI::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  OpenAI::Realtime::ConversationItemInputAudioTranscriptionCompletedEvent::Usage::TranscriptTextUsageDuration,
+                  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::Realtime::ConversationItemInputAudioTranscriptionCompletedEvent::Usage::Variants
+              ]
+            )
+          end
+          def self.variants
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/openai/models/realtime/conversation_item_input_audio_transcription_delta_event.rbi

@@ -0,0 +1,93 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    module Realtime
+      class ConversationItemInputAudioTranscriptionDeltaEvent < OpenAI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              OpenAI::Realtime::ConversationItemInputAudioTranscriptionDeltaEvent,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+        # The unique ID of the server event.
+        sig { returns(String) }
+        attr_accessor :event_id
+
+        # The ID of the item.
+        sig { returns(String) }
+        attr_accessor :item_id
+
+        # The event type, must be `conversation.item.input_audio_transcription.delta`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # The index of the content part in the item's content array.
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :content_index
+
+        sig { params(content_index: Integer).void }
+        attr_writer :content_index
+
+        # The text delta.
+        sig { returns(T.nilable(String)) }
+        attr_reader :delta
+
+        sig { params(delta: String).void }
+        attr_writer :delta
+
+        # The log probabilities of the transcription.
+        sig do
+          returns(T.nilable(T::Array[OpenAI::Realtime::LogProbProperties]))
+        end
+        attr_accessor :logprobs
+
+        # Returned when the text value of an input audio transcription content part is
+        # updated.
+        sig do
+          params(
+            event_id: String,
+            item_id: String,
+            content_index: Integer,
+            delta: String,
+            logprobs:
+              T.nilable(T::Array[OpenAI::Realtime::LogProbProperties::OrHash]),
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # The unique ID of the server event.
+          event_id:,
+          # The ID of the item.
+          item_id:,
+          # The index of the content part in the item's content array.
+          content_index: nil,
+          # The text delta.
+          delta: nil,
+          # The log probabilities of the transcription.
+          logprobs: nil,
+          # The event type, must be `conversation.item.input_audio_transcription.delta`.
+          type: :"conversation.item.input_audio_transcription.delta"
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              event_id: String,
+              item_id: String,
+              type: Symbol,
+              content_index: Integer,
+              delta: String,
+              logprobs: T.nilable(T::Array[OpenAI::Realtime::LogProbProperties])
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/openai/models/realtime/conversation_item_input_audio_transcription_failed_event.rbi

@@ -0,0 +1,158 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    module Realtime
+      class ConversationItemInputAudioTranscriptionFailedEvent < OpenAI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              OpenAI::Realtime::ConversationItemInputAudioTranscriptionFailedEvent,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+        # The index of the content part containing the audio.
+        sig { returns(Integer) }
+        attr_accessor :content_index
+
+        # Details of the transcription error.
+        sig do
+          returns(
+            OpenAI::Realtime::ConversationItemInputAudioTranscriptionFailedEvent::Error
+          )
+        end
+        attr_reader :error
+
+        sig do
+          params(
+            error:
+              OpenAI::Realtime::ConversationItemInputAudioTranscriptionFailedEvent::Error::OrHash
+          ).void
+        end
+        attr_writer :error
+
+        # The unique ID of the server event.
+        sig { returns(String) }
+        attr_accessor :event_id
+
+        # The ID of the user message item.
+        sig { returns(String) }
+        attr_accessor :item_id
+
+        # The event type, must be `conversation.item.input_audio_transcription.failed`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # Returned when input audio transcription is configured, and a transcription
+        # request for a user message failed. These events are separate from other `error`
+        # events so that the client can identify the related Item.
+        sig do
+          params(
+            content_index: Integer,
+            error:
+              OpenAI::Realtime::ConversationItemInputAudioTranscriptionFailedEvent::Error::OrHash,
+            event_id: String,
+            item_id: String,
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # The index of the content part containing the audio.
+          content_index:,
+          # Details of the transcription error.
+          error:,
+          # The unique ID of the server event.
+          event_id:,
+          # The ID of the user message item.
+          item_id:,
+          # The event type, must be `conversation.item.input_audio_transcription.failed`.
+          type: :"conversation.item.input_audio_transcription.failed"
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              content_index: Integer,
+              error:
+                OpenAI::Realtime::ConversationItemInputAudioTranscriptionFailedEvent::Error,
+              event_id: String,
+              item_id: String,
+              type: Symbol
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class Error < OpenAI::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                OpenAI::Realtime::ConversationItemInputAudioTranscriptionFailedEvent::Error,
+                OpenAI::Internal::AnyHash
+              )
+            end
+
+          # Error code, if any.
+          sig { returns(T.nilable(String)) }
+          attr_reader :code
+
+          sig { params(code: String).void }
+          attr_writer :code
+
+          # A human-readable error message.
+          sig { returns(T.nilable(String)) }
+          attr_reader :message
+
+          sig { params(message: String).void }
+          attr_writer :message
+
+          # Parameter related to the error, if any.
+          sig { returns(T.nilable(String)) }
+          attr_reader :param
+
+          sig { params(param: String).void }
+          attr_writer :param
+
+          # The type of error.
+          sig { returns(T.nilable(String)) }
+          attr_reader :type
+
+          sig { params(type: String).void }
+          attr_writer :type
+
+          # Details of the transcription error.
+          sig do
+            params(
+              code: String,
+              message: String,
+              param: String,
+              type: String
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # Error code, if any.
+            code: nil,
+            # A human-readable error message.
+            message: nil,
+            # Parameter related to the error, if any.
+            param: nil,
+            # The type of error.
+            type: nil
+          )
+          end
+
+          sig do
+            override.returns(
+              { code: String, message: String, param: String, type: String }
+            )
+          end
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end