openai 0.20.0 → 0.21.0

data/rbi/openai/models/realtime/realtime_response_status.rbi

@@ -0,0 +1,233 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    module Realtime
+      class RealtimeResponseStatus < OpenAI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              OpenAI::Realtime::RealtimeResponseStatus,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+        # A description of the error that caused the response to fail, populated when the
+        # `status` is `failed`.
+        sig do
+          returns(T.nilable(OpenAI::Realtime::RealtimeResponseStatus::Error))
+        end
+        attr_reader :error
+
+        sig do
+          params(
+            error: OpenAI::Realtime::RealtimeResponseStatus::Error::OrHash
+          ).void
+        end
+        attr_writer :error
+
+        # The reason the Response did not complete. For a `cancelled` Response, one of
+        # `turn_detected` (the server VAD detected a new start of speech) or
+        # `client_cancelled` (the client sent a cancel event). For an `incomplete`
+        # Response, one of `max_output_tokens` or `content_filter` (the server-side safety
+        # filter activated and cut off the response).
+        sig do
+          returns(
+            T.nilable(
+              OpenAI::Realtime::RealtimeResponseStatus::Reason::OrSymbol
+            )
+          )
+        end
+        attr_reader :reason
+
+        sig do
+          params(
+            reason: OpenAI::Realtime::RealtimeResponseStatus::Reason::OrSymbol
+          ).void
+        end
+        attr_writer :reason
+
+        # The type of error that caused the response to fail, corresponding with the
+        # `status` field (`completed`, `cancelled`, `incomplete`, `failed`).
+        sig do
+          returns(
+            T.nilable(OpenAI::Realtime::RealtimeResponseStatus::Type::OrSymbol)
+          )
+        end
+        attr_reader :type
+
+        sig do
+          params(
+            type: OpenAI::Realtime::RealtimeResponseStatus::Type::OrSymbol
+          ).void
+        end
+        attr_writer :type
+
+        # Additional details about the status.
+        sig do
+          params(
+            error: OpenAI::Realtime::RealtimeResponseStatus::Error::OrHash,
+            reason: OpenAI::Realtime::RealtimeResponseStatus::Reason::OrSymbol,
+            type: OpenAI::Realtime::RealtimeResponseStatus::Type::OrSymbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # A description of the error that caused the response to fail, populated when the
+          # `status` is `failed`.
+          error: nil,
+          # The reason the Response did not complete. For a `cancelled` Response, one of
+          # `turn_detected` (the server VAD detected a new start of speech) or
+          # `client_cancelled` (the client sent a cancel event). For an `incomplete`
+          # Response, one of `max_output_tokens` or `content_filter` (the server-side safety
+          # filter activated and cut off the response).
+          reason: nil,
+          # The type of error that caused the response to fail, corresponding with the
+          # `status` field (`completed`, `cancelled`, `incomplete`, `failed`).
+          type: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              error: OpenAI::Realtime::RealtimeResponseStatus::Error,
+              reason:
+                OpenAI::Realtime::RealtimeResponseStatus::Reason::OrSymbol,
+              type: OpenAI::Realtime::RealtimeResponseStatus::Type::OrSymbol
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class Error < OpenAI::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                OpenAI::Realtime::RealtimeResponseStatus::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
+
+          # The type of error.
+          sig { returns(T.nilable(String)) }
+          attr_reader :type
+
+          sig { params(type: String).void }
+          attr_writer :type
+
+          # A description of the error that caused the response to fail, populated when the
+          # `status` is `failed`.
+          sig { params(code: String, type: String).returns(T.attached_class) }
+          def self.new(
+            # Error code, if any.
+            code: nil,
+            # The type of error.
+            type: nil
+          )
+          end
+
+          sig { override.returns({ code: String, type: String }) }
+          def to_hash
+          end
+        end
+
+        # The reason the Response did not complete. For a `cancelled` Response, one of
+        # `turn_detected` (the server VAD detected a new start of speech) or
+        # `client_cancelled` (the client sent a cancel event). For an `incomplete`
+        # Response, one of `max_output_tokens` or `content_filter` (the server-side safety
+        # filter activated and cut off the response).
+        module Reason
+          extend OpenAI::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(Symbol, OpenAI::Realtime::RealtimeResponseStatus::Reason)
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          TURN_DETECTED =
+            T.let(
+              :turn_detected,
+              OpenAI::Realtime::RealtimeResponseStatus::Reason::TaggedSymbol
+            )
+          CLIENT_CANCELLED =
+            T.let(
+              :client_cancelled,
+              OpenAI::Realtime::RealtimeResponseStatus::Reason::TaggedSymbol
+            )
+          MAX_OUTPUT_TOKENS =
+            T.let(
+              :max_output_tokens,
+              OpenAI::Realtime::RealtimeResponseStatus::Reason::TaggedSymbol
+            )
+          CONTENT_FILTER =
+            T.let(
+              :content_filter,
+              OpenAI::Realtime::RealtimeResponseStatus::Reason::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                OpenAI::Realtime::RealtimeResponseStatus::Reason::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+
+        # The type of error that caused the response to fail, corresponding with the
+        # `status` field (`completed`, `cancelled`, `incomplete`, `failed`).
+        module Type
+          extend OpenAI::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(Symbol, OpenAI::Realtime::RealtimeResponseStatus::Type)
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          COMPLETED =
+            T.let(
+              :completed,
+              OpenAI::Realtime::RealtimeResponseStatus::Type::TaggedSymbol
+            )
+          CANCELLED =
+            T.let(
+              :cancelled,
+              OpenAI::Realtime::RealtimeResponseStatus::Type::TaggedSymbol
+            )
+          INCOMPLETE =
+            T.let(
+              :incomplete,
+              OpenAI::Realtime::RealtimeResponseStatus::Type::TaggedSymbol
+            )
+          FAILED =
+            T.let(
+              :failed,
+              OpenAI::Realtime::RealtimeResponseStatus::Type::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                OpenAI::Realtime::RealtimeResponseStatus::Type::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/openai/models/realtime/realtime_response_usage.rbi

@@ -0,0 +1,121 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    module Realtime
+      class RealtimeResponseUsage < OpenAI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              OpenAI::Realtime::RealtimeResponseUsage,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+        # Details about the input tokens used in the Response.
+        sig do
+          returns(
+            T.nilable(OpenAI::Realtime::RealtimeResponseUsageInputTokenDetails)
+          )
+        end
+        attr_reader :input_token_details
+
+        sig do
+          params(
+            input_token_details:
+              OpenAI::Realtime::RealtimeResponseUsageInputTokenDetails::OrHash
+          ).void
+        end
+        attr_writer :input_token_details
+
+        # The number of input tokens used in the Response, including text and audio
+        # tokens.
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :input_tokens
+
+        sig { params(input_tokens: Integer).void }
+        attr_writer :input_tokens
+
+        # Details about the output tokens used in the Response.
+        sig do
+          returns(
+            T.nilable(OpenAI::Realtime::RealtimeResponseUsageOutputTokenDetails)
+          )
+        end
+        attr_reader :output_token_details
+
+        sig do
+          params(
+            output_token_details:
+              OpenAI::Realtime::RealtimeResponseUsageOutputTokenDetails::OrHash
+          ).void
+        end
+        attr_writer :output_token_details
+
+        # The number of output tokens sent in the Response, including text and audio
+        # tokens.
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :output_tokens
+
+        sig { params(output_tokens: Integer).void }
+        attr_writer :output_tokens
+
+        # The total number of tokens in the Response including input and output text and
+        # audio tokens.
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :total_tokens
+
+        sig { params(total_tokens: Integer).void }
+        attr_writer :total_tokens
+
+        # Usage statistics for the Response, this will correspond to billing. A Realtime
+        # API session will maintain a conversation context and append new Items to the
+        # Conversation, thus output from previous turns (text and audio tokens) will
+        # become the input for later turns.
+        sig do
+          params(
+            input_token_details:
+              OpenAI::Realtime::RealtimeResponseUsageInputTokenDetails::OrHash,
+            input_tokens: Integer,
+            output_token_details:
+              OpenAI::Realtime::RealtimeResponseUsageOutputTokenDetails::OrHash,
+            output_tokens: Integer,
+            total_tokens: Integer
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Details about the input tokens used in the Response.
+          input_token_details: nil,
+          # The number of input tokens used in the Response, including text and audio
+          # tokens.
+          input_tokens: nil,
+          # Details about the output tokens used in the Response.
+          output_token_details: nil,
+          # The number of output tokens sent in the Response, including text and audio
+          # tokens.
+          output_tokens: nil,
+          # The total number of tokens in the Response including input and output text and
+          # audio tokens.
+          total_tokens: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              input_token_details:
+                OpenAI::Realtime::RealtimeResponseUsageInputTokenDetails,
+              input_tokens: Integer,
+              output_token_details:
+                OpenAI::Realtime::RealtimeResponseUsageOutputTokenDetails,
+              output_tokens: Integer,
+              total_tokens: Integer
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/openai/models/realtime/realtime_response_usage_input_token_details.rbi

@@ -0,0 +1,68 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    module Realtime
+      class RealtimeResponseUsageInputTokenDetails < OpenAI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              OpenAI::Realtime::RealtimeResponseUsageInputTokenDetails,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+        # The number of audio tokens used in the Response.
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :audio_tokens
+
+        sig { params(audio_tokens: Integer).void }
+        attr_writer :audio_tokens
+
+        # The number of cached tokens used in the Response.
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :cached_tokens
+
+        sig { params(cached_tokens: Integer).void }
+        attr_writer :cached_tokens
+
+        # The number of text tokens used in the Response.
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :text_tokens
+
+        sig { params(text_tokens: Integer).void }
+        attr_writer :text_tokens
+
+        # Details about the input tokens used in the Response.
+        sig do
+          params(
+            audio_tokens: Integer,
+            cached_tokens: Integer,
+            text_tokens: Integer
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # The number of audio tokens used in the Response.
+          audio_tokens: nil,
+          # The number of cached tokens used in the Response.
+          cached_tokens: nil,
+          # The number of text tokens used in the Response.
+          text_tokens: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              audio_tokens: Integer,
+              cached_tokens: Integer,
+              text_tokens: Integer
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/openai/models/realtime/realtime_response_usage_output_token_details.rbi

@@ -0,0 +1,51 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    module Realtime
+      class RealtimeResponseUsageOutputTokenDetails < OpenAI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              OpenAI::Realtime::RealtimeResponseUsageOutputTokenDetails,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+        # The number of audio tokens used in the Response.
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :audio_tokens
+
+        sig { params(audio_tokens: Integer).void }
+        attr_writer :audio_tokens
+
+        # The number of text tokens used in the Response.
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :text_tokens
+
+        sig { params(text_tokens: Integer).void }
+        attr_writer :text_tokens
+
+        # Details about the output tokens used in the Response.
+        sig do
+          params(audio_tokens: Integer, text_tokens: Integer).returns(
+            T.attached_class
+          )
+        end
+        def self.new(
+          # The number of audio tokens used in the Response.
+          audio_tokens: nil,
+          # The number of text tokens used in the Response.
+          text_tokens: nil
+        )
+        end
+
+        sig do
+          override.returns({ audio_tokens: Integer, text_tokens: Integer })
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end