openai 0.1.0.pre.beta.2 → 0.1.0

data/rbi/openai/models/completion.rbi

@@ -1,97 +0,0 @@
-# typed: strong
-
-module OpenAI
-  module Models
-    class Completion < OpenAI::Internal::Type::BaseModel
-      OrHash =
-        T.type_alias { T.any(OpenAI::Completion, OpenAI::Internal::AnyHash) }
-
-      # A unique identifier for the completion.
-      sig { returns(String) }
-      attr_accessor :id
-
-      # The list of completion choices the model generated for the input prompt.
-      sig { returns(T::Array[OpenAI::CompletionChoice]) }
-      attr_accessor :choices
-
-      # The Unix timestamp (in seconds) of when the completion was created.
-      sig { returns(Integer) }
-      attr_accessor :created
-
-      # The model used for completion.
-      sig { returns(String) }
-      attr_accessor :model
-
-      # The object type, which is always "text_completion"
-      sig { returns(Symbol) }
-      attr_accessor :object
-
-      # This fingerprint represents the backend configuration that the model runs with.
-      #
-      # Can be used in conjunction with the `seed` request parameter to understand when
-      # backend changes have been made that might impact determinism.
-      sig { returns(T.nilable(String)) }
-      attr_reader :system_fingerprint
-
-      sig { params(system_fingerprint: String).void }
-      attr_writer :system_fingerprint
-
-      # Usage statistics for the completion request.
-      sig { returns(T.nilable(OpenAI::CompletionUsage)) }
-      attr_reader :usage
-
-      sig { params(usage: OpenAI::CompletionUsage::OrHash).void }
-      attr_writer :usage
-
-      # Represents a completion response from the API. Note: both the streamed and
-      # non-streamed response objects share the same shape (unlike the chat endpoint).
-      sig do
-        params(
-          id: String,
-          choices: T::Array[OpenAI::CompletionChoice::OrHash],
-          created: Integer,
-          model: String,
-          system_fingerprint: String,
-          usage: OpenAI::CompletionUsage::OrHash,
-          object: Symbol
-        ).returns(T.attached_class)
-      end
-      def self.new(
-        # A unique identifier for the completion.
-        id:,
-        # The list of completion choices the model generated for the input prompt.
-        choices:,
-        # The Unix timestamp (in seconds) of when the completion was created.
-        created:,
-        # The model used for completion.
-        model:,
-        # This fingerprint represents the backend configuration that the model runs with.
-        #
-        # Can be used in conjunction with the `seed` request parameter to understand when
-        # backend changes have been made that might impact determinism.
-        system_fingerprint: nil,
-        # Usage statistics for the completion request.
-        usage: nil,
-        # The object type, which is always "text_completion"
-        object: :text_completion
-      )
-      end
-
-      sig do
-        override.returns(
-          {
-            id: String,
-            choices: T::Array[OpenAI::CompletionChoice],
-            created: Integer,
-            model: String,
-            object: Symbol,
-            system_fingerprint: String,
-            usage: OpenAI::CompletionUsage
-          }
-        )
-      end
-      def to_hash
-      end
-    end
-  end
-end

data/rbi/openai/models/completion_choice.rbi

@@ -1,158 +0,0 @@
-# typed: strong
-
-module OpenAI
-  module Models
-    class CompletionChoice < OpenAI::Internal::Type::BaseModel
-      OrHash =
-        T.type_alias do
-          T.any(OpenAI::CompletionChoice, OpenAI::Internal::AnyHash)
-        end
-
-      # The reason the model stopped generating tokens. This will be `stop` if the model
-      # hit a natural stop point or a provided stop sequence, `length` if the maximum
-      # number of tokens specified in the request was reached, or `content_filter` if
-      # content was omitted due to a flag from our content filters.
-      sig { returns(OpenAI::CompletionChoice::FinishReason::TaggedSymbol) }
-      attr_accessor :finish_reason
-
-      sig { returns(Integer) }
-      attr_accessor :index
-
-      sig { returns(T.nilable(OpenAI::CompletionChoice::Logprobs)) }
-      attr_reader :logprobs
-
-      sig do
-        params(
-          logprobs: T.nilable(OpenAI::CompletionChoice::Logprobs::OrHash)
-        ).void
-      end
-      attr_writer :logprobs
-
-      sig { returns(String) }
-      attr_accessor :text
-
-      sig do
-        params(
-          finish_reason: OpenAI::CompletionChoice::FinishReason::OrSymbol,
-          index: Integer,
-          logprobs: T.nilable(OpenAI::CompletionChoice::Logprobs::OrHash),
-          text: String
-        ).returns(T.attached_class)
-      end
-      def self.new(
-        # The reason the model stopped generating tokens. This will be `stop` if the model
-        # hit a natural stop point or a provided stop sequence, `length` if the maximum
-        # number of tokens specified in the request was reached, or `content_filter` if
-        # content was omitted due to a flag from our content filters.
-        finish_reason:,
-        index:,
-        logprobs:,
-        text:
-      )
-      end
-
-      sig do
-        override.returns(
-          {
-            finish_reason: OpenAI::CompletionChoice::FinishReason::TaggedSymbol,
-            index: Integer,
-            logprobs: T.nilable(OpenAI::CompletionChoice::Logprobs),
-            text: String
-          }
-        )
-      end
-      def to_hash
-      end
-
-      # The reason the model stopped generating tokens. This will be `stop` if the model
-      # hit a natural stop point or a provided stop sequence, `length` if the maximum
-      # number of tokens specified in the request was reached, or `content_filter` if
-      # content was omitted due to a flag from our content filters.
-      module FinishReason
-        extend OpenAI::Internal::Type::Enum
-
-        TaggedSymbol =
-          T.type_alias { T.all(Symbol, OpenAI::CompletionChoice::FinishReason) }
-        OrSymbol = T.type_alias { T.any(Symbol, String) }
-
-        STOP =
-          T.let(:stop, OpenAI::CompletionChoice::FinishReason::TaggedSymbol)
-        LENGTH =
-          T.let(:length, OpenAI::CompletionChoice::FinishReason::TaggedSymbol)
-        CONTENT_FILTER =
-          T.let(
-            :content_filter,
-            OpenAI::CompletionChoice::FinishReason::TaggedSymbol
-          )
-
-        sig do
-          override.returns(
-            T::Array[OpenAI::CompletionChoice::FinishReason::TaggedSymbol]
-          )
-        end
-        def self.values
-        end
-      end
-
-      class Logprobs < OpenAI::Internal::Type::BaseModel
-        OrHash =
-          T.type_alias do
-            T.any(OpenAI::CompletionChoice::Logprobs, OpenAI::Internal::AnyHash)
-          end
-
-        sig { returns(T.nilable(T::Array[Integer])) }
-        attr_reader :text_offset
-
-        sig { params(text_offset: T::Array[Integer]).void }
-        attr_writer :text_offset
-
-        sig { returns(T.nilable(T::Array[Float])) }
-        attr_reader :token_logprobs
-
-        sig { params(token_logprobs: T::Array[Float]).void }
-        attr_writer :token_logprobs
-
-        sig { returns(T.nilable(T::Array[String])) }
-        attr_reader :tokens
-
-        sig { params(tokens: T::Array[String]).void }
-        attr_writer :tokens
-
-        sig { returns(T.nilable(T::Array[T::Hash[Symbol, Float]])) }
-        attr_reader :top_logprobs
-
-        sig { params(top_logprobs: T::Array[T::Hash[Symbol, Float]]).void }
-        attr_writer :top_logprobs
-
-        sig do
-          params(
-            text_offset: T::Array[Integer],
-            token_logprobs: T::Array[Float],
-            tokens: T::Array[String],
-            top_logprobs: T::Array[T::Hash[Symbol, Float]]
-          ).returns(T.attached_class)
-        end
-        def self.new(
-          text_offset: nil,
-          token_logprobs: nil,
-          tokens: nil,
-          top_logprobs: nil
-        )
-        end
-
-        sig do
-          override.returns(
-            {
-              text_offset: T::Array[Integer],
-              token_logprobs: T::Array[Float],
-              tokens: T::Array[String],
-              top_logprobs: T::Array[T::Hash[Symbol, Float]]
-            }
-          )
-        end
-        def to_hash
-        end
-      end
-    end
-  end
-end

data/rbi/openai/models/completion_create_params.rbi

@@ -1,445 +0,0 @@
-# typed: strong
-
-module OpenAI
-  module Models
-    class CompletionCreateParams < OpenAI::Internal::Type::BaseModel
-      extend OpenAI::Internal::Type::RequestParameters::Converter
-      include OpenAI::Internal::Type::RequestParameters
-
-      OrHash =
-        T.type_alias do
-          T.any(OpenAI::CompletionCreateParams, OpenAI::Internal::AnyHash)
-        end
-
-      # ID of the model to use. You can use the
-      # [List models](https://platform.openai.com/docs/api-reference/models/list) API to
-      # see all of your available models, or see our
-      # [Model overview](https://platform.openai.com/docs/models) for descriptions of
-      # them.
-      sig do
-        returns(T.any(String, OpenAI::CompletionCreateParams::Model::OrSymbol))
-      end
-      attr_accessor :model
-
-      # The prompt(s) to generate completions for, encoded as a string, array of
-      # strings, array of tokens, or array of token arrays.
-      #
-      # Note that <|endoftext|> is the document separator that the model sees during
-      # training, so if a prompt is not specified the model will generate as if from the
-      # beginning of a new document.
-      sig do
-        returns(T.nilable(OpenAI::CompletionCreateParams::Prompt::Variants))
-      end
-      attr_accessor :prompt
-
-      # Generates `best_of` completions server-side and returns the "best" (the one with
-      # the highest log probability per token). Results cannot be streamed.
-      #
-      # When used with `n`, `best_of` controls the number of candidate completions and
-      # `n` specifies how many to return – `best_of` must be greater than `n`.
-      #
-      # **Note:** Because this parameter generates many completions, it can quickly
-      # consume your token quota. Use carefully and ensure that you have reasonable
-      # settings for `max_tokens` and `stop`.
-      sig { returns(T.nilable(Integer)) }
-      attr_accessor :best_of
-
-      # Echo back the prompt in addition to the completion
-      sig { returns(T.nilable(T::Boolean)) }
-      attr_accessor :echo
-
-      # Number between -2.0 and 2.0. Positive values penalize new tokens based on their
-      # existing frequency in the text so far, decreasing the model's likelihood to
-      # repeat the same line verbatim.
-      #
-      # [See more information about frequency and presence penalties.](https://platform.openai.com/docs/guides/text-generation)
-      sig { returns(T.nilable(Float)) }
-      attr_accessor :frequency_penalty
-
-      # Modify the likelihood of specified tokens appearing in the completion.
-      #
-      # Accepts a JSON object that maps tokens (specified by their token ID in the GPT
-      # tokenizer) to an associated bias value from -100 to 100. You can use this
-      # [tokenizer tool](/tokenizer?view=bpe) to convert text to token IDs.
-      # Mathematically, the bias is added to the logits generated by the model prior to
-      # sampling. The exact effect will vary per model, but values between -1 and 1
-      # should decrease or increase likelihood of selection; values like -100 or 100
-      # should result in a ban or exclusive selection of the relevant token.
-      #
-      # As an example, you can pass `{"50256": -100}` to prevent the <|endoftext|> token
-      # from being generated.
-      sig { returns(T.nilable(T::Hash[Symbol, Integer])) }
-      attr_accessor :logit_bias
-
-      # Include the log probabilities on the `logprobs` most likely output tokens, as
-      # well the chosen tokens. For example, if `logprobs` is 5, the API will return a
-      # list of the 5 most likely tokens. The API will always return the `logprob` of
-      # the sampled token, so there may be up to `logprobs+1` elements in the response.
-      #
-      # The maximum value for `logprobs` is 5.
-      sig { returns(T.nilable(Integer)) }
-      attr_accessor :logprobs
-
-      # The maximum number of [tokens](/tokenizer) that can be generated in the
-      # completion.
-      #
-      # The token count of your prompt plus `max_tokens` cannot exceed the model's
-      # context length.
-      # [Example Python code](https://cookbook.openai.com/examples/how_to_count_tokens_with_tiktoken)
-      # for counting tokens.
-      sig { returns(T.nilable(Integer)) }
-      attr_accessor :max_tokens
-
-      # How many completions to generate for each prompt.
-      #
-      # **Note:** Because this parameter generates many completions, it can quickly
-      # consume your token quota. Use carefully and ensure that you have reasonable
-      # settings for `max_tokens` and `stop`.
-      sig { returns(T.nilable(Integer)) }
-      attr_accessor :n
-
-      # Number between -2.0 and 2.0. Positive values penalize new tokens based on
-      # whether they appear in the text so far, increasing the model's likelihood to
-      # talk about new topics.
-      #
-      # [See more information about frequency and presence penalties.](https://platform.openai.com/docs/guides/text-generation)
-      sig { returns(T.nilable(Float)) }
-      attr_accessor :presence_penalty
-
-      # If specified, our system will make a best effort to sample deterministically,
-      # such that repeated requests with the same `seed` and parameters should return
-      # the same result.
-      #
-      # Determinism is not guaranteed, and you should refer to the `system_fingerprint`
-      # response parameter to monitor changes in the backend.
-      sig { returns(T.nilable(Integer)) }
-      attr_accessor :seed
-
-      # Not supported with latest reasoning models `o3` and `o4-mini`.
-      #
-      # Up to 4 sequences where the API will stop generating further tokens. The
-      # returned text will not contain the stop sequence.
-      sig { returns(T.nilable(OpenAI::CompletionCreateParams::Stop::Variants)) }
-      attr_accessor :stop
-
-      # Options for streaming response. Only set this when you set `stream: true`.
-      sig { returns(T.nilable(OpenAI::Chat::ChatCompletionStreamOptions)) }
-      attr_reader :stream_options
-
-      sig do
-        params(
-          stream_options:
-            T.nilable(OpenAI::Chat::ChatCompletionStreamOptions::OrHash)
-        ).void
-      end
-      attr_writer :stream_options
-
-      # The suffix that comes after a completion of inserted text.
-      #
-      # This parameter is only supported for `gpt-3.5-turbo-instruct`.
-      sig { returns(T.nilable(String)) }
-      attr_accessor :suffix
-
-      # What sampling temperature to use, between 0 and 2. Higher values like 0.8 will
-      # make the output more random, while lower values like 0.2 will make it more
-      # focused and deterministic.
-      #
-      # We generally recommend altering this or `top_p` but not both.
-      sig { returns(T.nilable(Float)) }
-      attr_accessor :temperature
-
-      # An alternative to sampling with temperature, called nucleus sampling, where the
-      # model considers the results of the tokens with top_p probability mass. So 0.1
-      # means only the tokens comprising the top 10% probability mass are considered.
-      #
-      # We generally recommend altering this or `temperature` but not both.
-      sig { returns(T.nilable(Float)) }
-      attr_accessor :top_p
-
-      # A unique identifier representing your end-user, which can help OpenAI to monitor
-      # and detect abuse.
-      # [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#end-user-ids).
-      sig { returns(T.nilable(String)) }
-      attr_reader :user
-
-      sig { params(user: String).void }
-      attr_writer :user
-
-      sig do
-        params(
-          model: T.any(String, OpenAI::CompletionCreateParams::Model::OrSymbol),
-          prompt: T.nilable(OpenAI::CompletionCreateParams::Prompt::Variants),
-          best_of: T.nilable(Integer),
-          echo: T.nilable(T::Boolean),
-          frequency_penalty: T.nilable(Float),
-          logit_bias: T.nilable(T::Hash[Symbol, Integer]),
-          logprobs: T.nilable(Integer),
-          max_tokens: T.nilable(Integer),
-          n: T.nilable(Integer),
-          presence_penalty: T.nilable(Float),
-          seed: T.nilable(Integer),
-          stop: T.nilable(OpenAI::CompletionCreateParams::Stop::Variants),
-          stream_options:
-            T.nilable(OpenAI::Chat::ChatCompletionStreamOptions::OrHash),
-          suffix: T.nilable(String),
-          temperature: T.nilable(Float),
-          top_p: T.nilable(Float),
-          user: String,
-          request_options: OpenAI::RequestOptions::OrHash
-        ).returns(T.attached_class)
-      end
-      def self.new(
-        # ID of the model to use. You can use the
-        # [List models](https://platform.openai.com/docs/api-reference/models/list) API to
-        # see all of your available models, or see our
-        # [Model overview](https://platform.openai.com/docs/models) for descriptions of
-        # them.
-        model:,
-        # The prompt(s) to generate completions for, encoded as a string, array of
-        # strings, array of tokens, or array of token arrays.
-        #
-        # Note that <|endoftext|> is the document separator that the model sees during
-        # training, so if a prompt is not specified the model will generate as if from the
-        # beginning of a new document.
-        prompt:,
-        # Generates `best_of` completions server-side and returns the "best" (the one with
-        # the highest log probability per token). Results cannot be streamed.
-        #
-        # When used with `n`, `best_of` controls the number of candidate completions and
-        # `n` specifies how many to return – `best_of` must be greater than `n`.
-        #
-        # **Note:** Because this parameter generates many completions, it can quickly
-        # consume your token quota. Use carefully and ensure that you have reasonable
-        # settings for `max_tokens` and `stop`.
-        best_of: nil,
-        # Echo back the prompt in addition to the completion
-        echo: nil,
-        # Number between -2.0 and 2.0. Positive values penalize new tokens based on their
-        # existing frequency in the text so far, decreasing the model's likelihood to
-        # repeat the same line verbatim.
-        #
-        # [See more information about frequency and presence penalties.](https://platform.openai.com/docs/guides/text-generation)
-        frequency_penalty: nil,
-        # Modify the likelihood of specified tokens appearing in the completion.
-        #
-        # Accepts a JSON object that maps tokens (specified by their token ID in the GPT
-        # tokenizer) to an associated bias value from -100 to 100. You can use this
-        # [tokenizer tool](/tokenizer?view=bpe) to convert text to token IDs.
-        # Mathematically, the bias is added to the logits generated by the model prior to
-        # sampling. The exact effect will vary per model, but values between -1 and 1
-        # should decrease or increase likelihood of selection; values like -100 or 100
-        # should result in a ban or exclusive selection of the relevant token.
-        #
-        # As an example, you can pass `{"50256": -100}` to prevent the <|endoftext|> token
-        # from being generated.
-        logit_bias: nil,
-        # Include the log probabilities on the `logprobs` most likely output tokens, as
-        # well the chosen tokens. For example, if `logprobs` is 5, the API will return a
-        # list of the 5 most likely tokens. The API will always return the `logprob` of
-        # the sampled token, so there may be up to `logprobs+1` elements in the response.
-        #
-        # The maximum value for `logprobs` is 5.
-        logprobs: nil,
-        # The maximum number of [tokens](/tokenizer) that can be generated in the
-        # completion.
-        #
-        # The token count of your prompt plus `max_tokens` cannot exceed the model's
-        # context length.
-        # [Example Python code](https://cookbook.openai.com/examples/how_to_count_tokens_with_tiktoken)
-        # for counting tokens.
-        max_tokens: nil,
-        # How many completions to generate for each prompt.
-        #
-        # **Note:** Because this parameter generates many completions, it can quickly
-        # consume your token quota. Use carefully and ensure that you have reasonable
-        # settings for `max_tokens` and `stop`.
-        n: nil,
-        # Number between -2.0 and 2.0. Positive values penalize new tokens based on
-        # whether they appear in the text so far, increasing the model's likelihood to
-        # talk about new topics.
-        #
-        # [See more information about frequency and presence penalties.](https://platform.openai.com/docs/guides/text-generation)
-        presence_penalty: nil,
-        # If specified, our system will make a best effort to sample deterministically,
-        # such that repeated requests with the same `seed` and parameters should return
-        # the same result.
-        #
-        # Determinism is not guaranteed, and you should refer to the `system_fingerprint`
-        # response parameter to monitor changes in the backend.
-        seed: nil,
-        # Not supported with latest reasoning models `o3` and `o4-mini`.
-        #
-        # Up to 4 sequences where the API will stop generating further tokens. The
-        # returned text will not contain the stop sequence.
-        stop: nil,
-        # Options for streaming response. Only set this when you set `stream: true`.
-        stream_options: nil,
-        # The suffix that comes after a completion of inserted text.
-        #
-        # This parameter is only supported for `gpt-3.5-turbo-instruct`.
-        suffix: nil,
-        # What sampling temperature to use, between 0 and 2. Higher values like 0.8 will
-        # make the output more random, while lower values like 0.2 will make it more
-        # focused and deterministic.
-        #
-        # We generally recommend altering this or `top_p` but not both.
-        temperature: nil,
-        # An alternative to sampling with temperature, called nucleus sampling, where the
-        # model considers the results of the tokens with top_p probability mass. So 0.1
-        # means only the tokens comprising the top 10% probability mass are considered.
-        #
-        # We generally recommend altering this or `temperature` but not both.
-        top_p: nil,
-        # A unique identifier representing your end-user, which can help OpenAI to monitor
-        # and detect abuse.
-        # [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#end-user-ids).
-        user: nil,
-        request_options: {}
-      )
-      end
-
-      sig do
-        override.returns(
-          {
-            model:
-              T.any(String, OpenAI::CompletionCreateParams::Model::OrSymbol),
-            prompt: T.nilable(OpenAI::CompletionCreateParams::Prompt::Variants),
-            best_of: T.nilable(Integer),
-            echo: T.nilable(T::Boolean),
-            frequency_penalty: T.nilable(Float),
-            logit_bias: T.nilable(T::Hash[Symbol, Integer]),
-            logprobs: T.nilable(Integer),
-            max_tokens: T.nilable(Integer),
-            n: T.nilable(Integer),
-            presence_penalty: T.nilable(Float),
-            seed: T.nilable(Integer),
-            stop: T.nilable(OpenAI::CompletionCreateParams::Stop::Variants),
-            stream_options:
-              T.nilable(OpenAI::Chat::ChatCompletionStreamOptions),
-            suffix: T.nilable(String),
-            temperature: T.nilable(Float),
-            top_p: T.nilable(Float),
-            user: String,
-            request_options: OpenAI::RequestOptions
-          }
-        )
-      end
-      def to_hash
-      end
-
-      # ID of the model to use. You can use the
-      # [List models](https://platform.openai.com/docs/api-reference/models/list) API to
-      # see all of your available models, or see our
-      # [Model overview](https://platform.openai.com/docs/models) for descriptions of
-      # them.
-      module Model
-        extend OpenAI::Internal::Type::Union
-
-        Variants =
-          T.type_alias do
-            T.any(String, OpenAI::CompletionCreateParams::Model::TaggedSymbol)
-          end
-
-        sig do
-          override.returns(
-            T::Array[OpenAI::CompletionCreateParams::Model::Variants]
-          )
-        end
-        def self.variants
-        end
-
-        TaggedSymbol =
-          T.type_alias { T.all(Symbol, OpenAI::CompletionCreateParams::Model) }
-        OrSymbol = T.type_alias { T.any(Symbol, String) }
-
-        GPT_3_5_TURBO_INSTRUCT =
-          T.let(
-            :"gpt-3.5-turbo-instruct",
-            OpenAI::CompletionCreateParams::Model::TaggedSymbol
-          )
-        DAVINCI_002 =
-          T.let(
-            :"davinci-002",
-            OpenAI::CompletionCreateParams::Model::TaggedSymbol
-          )
-        BABBAGE_002 =
-          T.let(
-            :"babbage-002",
-            OpenAI::CompletionCreateParams::Model::TaggedSymbol
-          )
-      end
-
-      # The prompt(s) to generate completions for, encoded as a string, array of
-      # strings, array of tokens, or array of token arrays.
-      #
-      # Note that <|endoftext|> is the document separator that the model sees during
-      # training, so if a prompt is not specified the model will generate as if from the
-      # beginning of a new document.
-      module Prompt
-        extend OpenAI::Internal::Type::Union
-
-        Variants =
-          T.type_alias do
-            T.any(
-              String,
-              T::Array[String],
-              T::Array[Integer],
-              T::Array[T::Array[Integer]]
-            )
-          end
-
-        sig do
-          override.returns(
-            T::Array[OpenAI::CompletionCreateParams::Prompt::Variants]
-          )
-        end
-        def self.variants
-        end
-
-        StringArray =
-          T.let(
-            OpenAI::Internal::Type::ArrayOf[String],
-            OpenAI::Internal::Type::Converter
-          )
-
-        IntegerArray =
-          T.let(
-            OpenAI::Internal::Type::ArrayOf[Integer],
-            OpenAI::Internal::Type::Converter
-          )
-
-        ArrayOfToken2DArray =
-          T.let(
-            OpenAI::Internal::Type::ArrayOf[
-              OpenAI::Internal::Type::ArrayOf[Integer]
-            ],
-            OpenAI::Internal::Type::Converter
-          )
-      end
-
-      # Not supported with latest reasoning models `o3` and `o4-mini`.
-      #
-      # Up to 4 sequences where the API will stop generating further tokens. The
-      # returned text will not contain the stop sequence.
-      module Stop
-        extend OpenAI::Internal::Type::Union
-
-        Variants = T.type_alias { T.nilable(T.any(String, T::Array[String])) }
-
-        sig do
-          override.returns(
-            T::Array[OpenAI::CompletionCreateParams::Stop::Variants]
-          )
-        end
-        def self.variants
-        end
-
-        StringArray =
-          T.let(
-            OpenAI::Internal::Type::ArrayOf[String],
-            OpenAI::Internal::Type::Converter
-          )
-      end
-    end
-  end
-end