openai 0.3.0 → 0.4.0.pre.beta.1

data/rbi/openai/models/completion.rbi

@@ -0,0 +1,97 @@
+# 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

@@ -0,0 +1,158 @@
+# 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

@@ -0,0 +1,445 @@
+# 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