openai 0.74.0 → 0.76.0

data/lib/openai.rb

@@ -656,6 +656,8 @@ require_relative "openai/models/containers/file_list_response"
 require_relative "openai/models/containers/file_retrieve_params"
 require_relative "openai/models/containers/file_retrieve_response"
 require_relative "openai/models/containers/files/content_retrieve_params"
+require_relative "openai/models/content_provenance_check"
+require_relative "openai/models/content_provenance_check_create_params"
 require_relative "openai/models/conversations/computer_screenshot_content"
 require_relative "openai/models/conversations/conversation"
 require_relative "openai/models/conversations/conversation_create_params"
@@ -1214,6 +1216,7 @@ require_relative "openai/resources/completions"
 require_relative "openai/resources/containers"
 require_relative "openai/resources/containers/files"
 require_relative "openai/resources/containers/files/content"
+require_relative "openai/resources/content_provenance_checks"
 require_relative "openai/resources/conversations"
 require_relative "openai/resources/conversations/items"
 require_relative "openai/resources/embeddings"

data/rbi/openai/client.rbi

@@ -47,6 +47,9 @@ module OpenAI
     sig { returns(OpenAI::Resources::Images) }
     attr_reader :images
 
+    sig { returns(OpenAI::Resources::ContentProvenanceChecks) }
+    attr_reader :content_provenance_checks
+
     sig { returns(OpenAI::Resources::Audio) }
     attr_reader :audio
 

data/rbi/openai/models/beta/response_compact_params.rbi

@@ -94,7 +94,21 @@ module OpenAI
         end
         attr_accessor :prompt_cache_retention
 
-        # The service tier to use for this request.
+        # Specifies the processing type used for serving the request. - If set to 'auto',
+        # then the request will be processed with the service tier configured in the
+        # Project settings. Unless otherwise configured, the Project will use 'default'. -
+        # If set to 'default', then the request will be processed with the standard
+        # pricing and performance for the selected model. - If set to
+        # '[flex](https://platform.openai.com/docs/guides/flex-processing)', then the
+        # request will be processed with the Flex Processing service tier. - To opt-in to
+        # [Fast mode](/api/docs/guides/fast-mode) at the request level, include the
+        # `service_tier=fast` or `service_tier=priority` parameter for Responses or Chat
+        # Completions. The response will show `service_tier=priority` regardless of if you
+        # specify `service_tier=fast` or `priority` in your request. - When not set, the
+        # default behavior is 'auto'. When the `service_tier` parameter is set, the
+        # response body will include the `service_tier` value based on the processing mode
+        # actually used to serve the request. This response value may be different from
+        # the value set in the parameter.
         sig do
           returns(
             T.nilable(
@@ -184,7 +198,21 @@ module OpenAI
           prompt_cache_options: nil,
           # How long to retain a prompt cache entry created by this request.
           prompt_cache_retention: nil,
-          # The service tier to use for this request.
+          # Specifies the processing type used for serving the request. - If set to 'auto',
+          # then the request will be processed with the service tier configured in the
+          # Project settings. Unless otherwise configured, the Project will use 'default'. -
+          # If set to 'default', then the request will be processed with the standard
+          # pricing and performance for the selected model. - If set to
+          # '[flex](https://platform.openai.com/docs/guides/flex-processing)', then the
+          # request will be processed with the Flex Processing service tier. - To opt-in to
+          # [Fast mode](/api/docs/guides/fast-mode) at the request level, include the
+          # `service_tier=fast` or `service_tier=priority` parameter for Responses or Chat
+          # Completions. The response will show `service_tier=priority` regardless of if you
+          # specify `service_tier=fast` or `priority` in your request. - When not set, the
+          # default behavior is 'auto'. When the `service_tier` parameter is set, the
+          # response body will include the `service_tier` value based on the processing mode
+          # actually used to serve the request. This response value may be different from
+          # the value set in the parameter.
           service_tier: nil,
           betas: nil,
           request_options: {}
@@ -962,7 +990,21 @@ module OpenAI
           end
         end
 
-        # The service tier to use for this request.
+        # Specifies the processing type used for serving the request. - If set to 'auto',
+        # then the request will be processed with the service tier configured in the
+        # Project settings. Unless otherwise configured, the Project will use 'default'. -
+        # If set to 'default', then the request will be processed with the standard
+        # pricing and performance for the selected model. - If set to
+        # '[flex](https://platform.openai.com/docs/guides/flex-processing)', then the
+        # request will be processed with the Flex Processing service tier. - To opt-in to
+        # [Fast mode](/api/docs/guides/fast-mode) at the request level, include the
+        # `service_tier=fast` or `service_tier=priority` parameter for Responses or Chat
+        # Completions. The response will show `service_tier=priority` regardless of if you
+        # specify `service_tier=fast` or `priority` in your request. - When not set, the
+        # default behavior is 'auto'. When the `service_tier` parameter is set, the
+        # response body will include the `service_tier` value based on the processing mode
+        # actually used to serve the request. This response value may be different from
+        # the value set in the parameter.
         module ServiceTier
           extend OpenAI::Internal::Type::Enum
 
@@ -982,6 +1024,11 @@ module OpenAI
               :default,
               OpenAI::Beta::ResponseCompactParams::ServiceTier::TaggedSymbol
             )
+          FAST =
+            T.let(
+              :fast,
+              OpenAI::Beta::ResponseCompactParams::ServiceTier::TaggedSymbol
+            )
           FLEX =
             T.let(
               :flex,

data/rbi/openai/models/content_provenance_check.rbi

@@ -0,0 +1,413 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    class ContentProvenanceCheck < OpenAI::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(OpenAI::ContentProvenanceCheck, OpenAI::Internal::AnyHash)
+        end
+
+      # The Unix timestamp, in seconds, when the provenance check was created.
+      sig { returns(Integer) }
+      attr_accessor :created_at
+
+      # The object type. Always `content_provenance_check` for this endpoint.
+      sig { returns(OpenAI::ContentProvenanceCheck::Object::TaggedSymbol) }
+      attr_accessor :object
+
+      # The provenance results that apply to the uploaded file. Image results include
+      # C2PA and SynthID; audio results include SynthID.
+      sig do
+        returns(T::Array[OpenAI::ContentProvenanceCheck::Result::Variants])
+      end
+      attr_accessor :results
+
+      sig do
+        params(
+          created_at: Integer,
+          object: OpenAI::ContentProvenanceCheck::Object::OrSymbol,
+          results:
+            T::Array[
+              T.any(
+                OpenAI::ContentProvenanceCheck::Result::C2PA::OrHash,
+                OpenAI::ContentProvenanceCheck::Result::SynthID::OrHash
+              )
+            ]
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # The Unix timestamp, in seconds, when the provenance check was created.
+        created_at:,
+        # The object type. Always `content_provenance_check` for this endpoint.
+        object:,
+        # The provenance results that apply to the uploaded file. Image results include
+        # C2PA and SynthID; audio results include SynthID.
+        results:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            created_at: Integer,
+            object: OpenAI::ContentProvenanceCheck::Object::TaggedSymbol,
+            results: T::Array[OpenAI::ContentProvenanceCheck::Result::Variants]
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # The object type. Always `content_provenance_check` for this endpoint.
+      module Object
+        extend OpenAI::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, OpenAI::ContentProvenanceCheck::Object) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        CONTENT_PROVENANCE_CHECK =
+          T.let(
+            :content_provenance_check,
+            OpenAI::ContentProvenanceCheck::Object::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[OpenAI::ContentProvenanceCheck::Object::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+
+      module Result
+        extend OpenAI::Internal::Type::Union
+
+        Variants =
+          T.type_alias do
+            T.any(
+              OpenAI::ContentProvenanceCheck::Result::C2PA,
+              OpenAI::ContentProvenanceCheck::Result::SynthID
+            )
+          end
+
+        class C2PA < OpenAI::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                OpenAI::ContentProvenanceCheck::Result::C2PA,
+                OpenAI::Internal::AnyHash
+              )
+            end
+
+          # The UTC RFC 3339 timestamp recorded by the provenance signal for when the asset
+          # was generated, when available.
+          sig { returns(T.nilable(String)) }
+          attr_accessor :generated_at
+
+          # The C2PA manifest issuer, when available.
+          sig { returns(T.nilable(String)) }
+          attr_accessor :issuer
+
+          # The OpenAI model recorded by the provenance signal, when available.
+          sig { returns(T.nilable(String)) }
+          attr_accessor :model
+
+          # Whether a supported OpenAI C2PA provenance signal was detected. If
+          # `not_detected`, it means the tool did not find supported signals in the uploaded
+          # file. The content could still have been generated by OpenAI if the metadata was
+          # stripped or has evidence of tampering, the watermark was degraded, it comes from
+          # a legacy generation model, or it was created before provenance signals were
+          # available. Content could also still be AI-generated by another company's model,
+          # which the tool currently does not detect.
+          sig do
+            returns(
+              OpenAI::ContentProvenanceCheck::Result::C2PA::Outcome::TaggedSymbol
+            )
+          end
+          attr_accessor :outcome
+
+          # The provenance signal type. Always `c2pa`.
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # The validation status of the C2PA manifest in the uploaded image.
+          sig do
+            returns(
+              OpenAI::ContentProvenanceCheck::Result::C2PA::ValidationState::TaggedSymbol
+            )
+          end
+          attr_accessor :validation_state
+
+          sig do
+            params(
+              generated_at: T.nilable(String),
+              issuer: T.nilable(String),
+              model: T.nilable(String),
+              outcome:
+                OpenAI::ContentProvenanceCheck::Result::C2PA::Outcome::OrSymbol,
+              validation_state:
+                OpenAI::ContentProvenanceCheck::Result::C2PA::ValidationState::OrSymbol,
+              type: Symbol
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # The UTC RFC 3339 timestamp recorded by the provenance signal for when the asset
+            # was generated, when available.
+            generated_at:,
+            # The C2PA manifest issuer, when available.
+            issuer:,
+            # The OpenAI model recorded by the provenance signal, when available.
+            model:,
+            # Whether a supported OpenAI C2PA provenance signal was detected. If
+            # `not_detected`, it means the tool did not find supported signals in the uploaded
+            # file. The content could still have been generated by OpenAI if the metadata was
+            # stripped or has evidence of tampering, the watermark was degraded, it comes from
+            # a legacy generation model, or it was created before provenance signals were
+            # available. Content could also still be AI-generated by another company's model,
+            # which the tool currently does not detect.
+            outcome:,
+            # The validation status of the C2PA manifest in the uploaded image.
+            validation_state:,
+            # The provenance signal type. Always `c2pa`.
+            type: :c2pa
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                generated_at: T.nilable(String),
+                issuer: T.nilable(String),
+                model: T.nilable(String),
+                outcome:
+                  OpenAI::ContentProvenanceCheck::Result::C2PA::Outcome::TaggedSymbol,
+                type: Symbol,
+                validation_state:
+                  OpenAI::ContentProvenanceCheck::Result::C2PA::ValidationState::TaggedSymbol
+              }
+            )
+          end
+          def to_hash
+          end
+
+          # Whether a supported OpenAI C2PA provenance signal was detected. If
+          # `not_detected`, it means the tool did not find supported signals in the uploaded
+          # file. The content could still have been generated by OpenAI if the metadata was
+          # stripped or has evidence of tampering, the watermark was degraded, it comes from
+          # a legacy generation model, or it was created before provenance signals were
+          # available. Content could also still be AI-generated by another company's model,
+          # which the tool currently does not detect.
+          module Outcome
+            extend OpenAI::Internal::Type::Enum
+
+            TaggedSymbol =
+              T.type_alias do
+                T.all(
+                  Symbol,
+                  OpenAI::ContentProvenanceCheck::Result::C2PA::Outcome
+                )
+              end
+            OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+            DETECTED =
+              T.let(
+                :detected,
+                OpenAI::ContentProvenanceCheck::Result::C2PA::Outcome::TaggedSymbol
+              )
+            NOT_DETECTED =
+              T.let(
+                :not_detected,
+                OpenAI::ContentProvenanceCheck::Result::C2PA::Outcome::TaggedSymbol
+              )
+
+            sig do
+              override.returns(
+                T::Array[
+                  OpenAI::ContentProvenanceCheck::Result::C2PA::Outcome::TaggedSymbol
+                ]
+              )
+            end
+            def self.values
+            end
+          end
+
+          # The validation status of the C2PA manifest in the uploaded image.
+          module ValidationState
+            extend OpenAI::Internal::Type::Enum
+
+            TaggedSymbol =
+              T.type_alias do
+                T.all(
+                  Symbol,
+                  OpenAI::ContentProvenanceCheck::Result::C2PA::ValidationState
+                )
+              end
+            OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+            TRUSTED =
+              T.let(
+                :trusted,
+                OpenAI::ContentProvenanceCheck::Result::C2PA::ValidationState::TaggedSymbol
+              )
+            VALID =
+              T.let(
+                :valid,
+                OpenAI::ContentProvenanceCheck::Result::C2PA::ValidationState::TaggedSymbol
+              )
+            INVALID =
+              T.let(
+                :invalid,
+                OpenAI::ContentProvenanceCheck::Result::C2PA::ValidationState::TaggedSymbol
+              )
+            NOT_PRESENT =
+              T.let(
+                :not_present,
+                OpenAI::ContentProvenanceCheck::Result::C2PA::ValidationState::TaggedSymbol
+              )
+
+            sig do
+              override.returns(
+                T::Array[
+                  OpenAI::ContentProvenanceCheck::Result::C2PA::ValidationState::TaggedSymbol
+                ]
+              )
+            end
+            def self.values
+            end
+          end
+        end
+
+        class SynthID < OpenAI::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                OpenAI::ContentProvenanceCheck::Result::SynthID,
+                OpenAI::Internal::AnyHash
+              )
+            end
+
+          # The UTC RFC 3339 timestamp recorded by the provenance signal for when the asset
+          # was generated, when available.
+          sig { returns(T.nilable(String)) }
+          attr_accessor :generated_at
+
+          # The OpenAI model recorded by the provenance signal, when available.
+          sig { returns(T.nilable(String)) }
+          attr_accessor :model
+
+          # Whether a supported OpenAI SynthID watermark was detected. If `not_detected`, it
+          # means the tool did not find supported signals in the uploaded file. The content
+          # could still have been generated by OpenAI if the metadata was stripped or has
+          # evidence of tampering, the watermark was degraded, it comes from a legacy
+          # generation model, or it was created before provenance signals were available.
+          # Content could also still be AI-generated by another company's model, which the
+          # tool currently does not detect.
+          sig do
+            returns(
+              OpenAI::ContentProvenanceCheck::Result::SynthID::Outcome::TaggedSymbol
+            )
+          end
+          attr_accessor :outcome
+
+          # The provenance signal type. Always `synthid`.
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          sig do
+            params(
+              generated_at: T.nilable(String),
+              model: T.nilable(String),
+              outcome:
+                OpenAI::ContentProvenanceCheck::Result::SynthID::Outcome::OrSymbol,
+              type: Symbol
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # The UTC RFC 3339 timestamp recorded by the provenance signal for when the asset
+            # was generated, when available.
+            generated_at:,
+            # The OpenAI model recorded by the provenance signal, when available.
+            model:,
+            # Whether a supported OpenAI SynthID watermark was detected. If `not_detected`, it
+            # means the tool did not find supported signals in the uploaded file. The content
+            # could still have been generated by OpenAI if the metadata was stripped or has
+            # evidence of tampering, the watermark was degraded, it comes from a legacy
+            # generation model, or it was created before provenance signals were available.
+            # Content could also still be AI-generated by another company's model, which the
+            # tool currently does not detect.
+            outcome:,
+            # The provenance signal type. Always `synthid`.
+            type: :synthid
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                generated_at: T.nilable(String),
+                model: T.nilable(String),
+                outcome:
+                  OpenAI::ContentProvenanceCheck::Result::SynthID::Outcome::TaggedSymbol,
+                type: Symbol
+              }
+            )
+          end
+          def to_hash
+          end
+
+          # Whether a supported OpenAI SynthID watermark was detected. If `not_detected`, it
+          # means the tool did not find supported signals in the uploaded file. The content
+          # could still have been generated by OpenAI if the metadata was stripped or has
+          # evidence of tampering, the watermark was degraded, it comes from a legacy
+          # generation model, or it was created before provenance signals were available.
+          # Content could also still be AI-generated by another company's model, which the
+          # tool currently does not detect.
+          module Outcome
+            extend OpenAI::Internal::Type::Enum
+
+            TaggedSymbol =
+              T.type_alias do
+                T.all(
+                  Symbol,
+                  OpenAI::ContentProvenanceCheck::Result::SynthID::Outcome
+                )
+              end
+            OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+            DETECTED =
+              T.let(
+                :detected,
+                OpenAI::ContentProvenanceCheck::Result::SynthID::Outcome::TaggedSymbol
+              )
+            NOT_DETECTED =
+              T.let(
+                :not_detected,
+                OpenAI::ContentProvenanceCheck::Result::SynthID::Outcome::TaggedSymbol
+              )
+
+            sig do
+              override.returns(
+                T::Array[
+                  OpenAI::ContentProvenanceCheck::Result::SynthID::Outcome::TaggedSymbol
+                ]
+              )
+            end
+            def self.values
+            end
+          end
+        end
+
+        sig do
+          override.returns(
+            T::Array[OpenAI::ContentProvenanceCheck::Result::Variants]
+          )
+        end
+        def self.variants
+        end
+      end
+    end
+  end
+end

data/rbi/openai/models/content_provenance_check_create_params.rbi

@@ -0,0 +1,46 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    class ContentProvenanceCheckCreateParams < OpenAI::Internal::Type::BaseModel
+      extend OpenAI::Internal::Type::RequestParameters::Converter
+      include OpenAI::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            OpenAI::ContentProvenanceCheckCreateParams,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+      # The image or audio file to check for supported OpenAI provenance signals.
+      sig { returns(OpenAI::Internal::FileInput) }
+      attr_accessor :file
+
+      sig do
+        params(
+          file: OpenAI::Internal::FileInput,
+          request_options: OpenAI::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # The image or audio file to check for supported OpenAI provenance signals.
+        file:,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            file: OpenAI::Internal::FileInput,
+            request_options: OpenAI::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/openai/models/responses/response_compact_params.rbi

@@ -96,7 +96,21 @@ module OpenAI
         end
         attr_accessor :prompt_cache_retention
 
-        # The service tier to use for this request.
+        # Specifies the processing type used for serving the request. - If set to 'auto',
+        # then the request will be processed with the service tier configured in the
+        # Project settings. Unless otherwise configured, the Project will use 'default'. -
+        # If set to 'default', then the request will be processed with the standard
+        # pricing and performance for the selected model. - If set to
+        # '[flex](https://platform.openai.com/docs/guides/flex-processing)', then the
+        # request will be processed with the Flex Processing service tier. - To opt-in to
+        # [Fast mode](/api/docs/guides/fast-mode) at the request level, include the
+        # `service_tier=fast` or `service_tier=priority` parameter for Responses or Chat
+        # Completions. The response will show `service_tier=priority` regardless of if you
+        # specify `service_tier=fast` or `priority` in your request. - When not set, the
+        # default behavior is 'auto'. When the `service_tier` parameter is set, the
+        # response body will include the `service_tier` value based on the processing mode
+        # actually used to serve the request. This response value may be different from
+        # the value set in the parameter.
         sig do
           returns(
             T.nilable(
@@ -170,7 +184,21 @@ module OpenAI
           prompt_cache_options: nil,
           # How long to retain a prompt cache entry created by this request.
           prompt_cache_retention: nil,
-          # The service tier to use for this request.
+          # Specifies the processing type used for serving the request. - If set to 'auto',
+          # then the request will be processed with the service tier configured in the
+          # Project settings. Unless otherwise configured, the Project will use 'default'. -
+          # If set to 'default', then the request will be processed with the standard
+          # pricing and performance for the selected model. - If set to
+          # '[flex](https://platform.openai.com/docs/guides/flex-processing)', then the
+          # request will be processed with the Flex Processing service tier. - To opt-in to
+          # [Fast mode](/api/docs/guides/fast-mode) at the request level, include the
+          # `service_tier=fast` or `service_tier=priority` parameter for Responses or Chat
+          # Completions. The response will show `service_tier=priority` regardless of if you
+          # specify `service_tier=fast` or `priority` in your request. - When not set, the
+          # default behavior is 'auto'. When the `service_tier` parameter is set, the
+          # response body will include the `service_tier` value based on the processing mode
+          # actually used to serve the request. This response value may be different from
+          # the value set in the parameter.
           service_tier: nil,
           request_options: {}
         )
@@ -957,7 +985,21 @@ module OpenAI
           end
         end
 
-        # The service tier to use for this request.
+        # Specifies the processing type used for serving the request. - If set to 'auto',
+        # then the request will be processed with the service tier configured in the
+        # Project settings. Unless otherwise configured, the Project will use 'default'. -
+        # If set to 'default', then the request will be processed with the standard
+        # pricing and performance for the selected model. - If set to
+        # '[flex](https://platform.openai.com/docs/guides/flex-processing)', then the
+        # request will be processed with the Flex Processing service tier. - To opt-in to
+        # [Fast mode](/api/docs/guides/fast-mode) at the request level, include the
+        # `service_tier=fast` or `service_tier=priority` parameter for Responses or Chat
+        # Completions. The response will show `service_tier=priority` regardless of if you
+        # specify `service_tier=fast` or `priority` in your request. - When not set, the
+        # default behavior is 'auto'. When the `service_tier` parameter is set, the
+        # response body will include the `service_tier` value based on the processing mode
+        # actually used to serve the request. This response value may be different from
+        # the value set in the parameter.
         module ServiceTier
           extend OpenAI::Internal::Type::Enum
 
@@ -980,6 +1022,11 @@ module OpenAI
               :default,
               OpenAI::Responses::ResponseCompactParams::ServiceTier::TaggedSymbol
             )
+          FAST =
+            T.let(
+              :fast,
+              OpenAI::Responses::ResponseCompactParams::ServiceTier::TaggedSymbol
+            )
           FLEX =
             T.let(
               :flex,

data/rbi/openai/models.rbi

@@ -57,6 +57,11 @@ module OpenAI
 
   Containers = OpenAI::Models::Containers
 
+  ContentProvenanceCheck = OpenAI::Models::ContentProvenanceCheck
+
+  ContentProvenanceCheckCreateParams =
+    OpenAI::Models::ContentProvenanceCheckCreateParams
+
   Conversations = OpenAI::Models::Conversations
 
   CreateEmbeddingResponse = OpenAI::Models::CreateEmbeddingResponse

data/rbi/openai/resources/beta/responses.rbi

@@ -893,7 +893,21 @@ module OpenAI
           prompt_cache_options: nil,
           # Body param: How long to retain a prompt cache entry created by this request.
           prompt_cache_retention: nil,
-          # Body param: The service tier to use for this request.
+          # Body param: Specifies the processing type used for serving the request. - If set
+          # to 'auto', then the request will be processed with the service tier configured
+          # in the Project settings. Unless otherwise configured, the Project will use
+          # 'default'. - If set to 'default', then the request will be processed with the
+          # standard pricing and performance for the selected model. - If set to
+          # '[flex](https://platform.openai.com/docs/guides/flex-processing)', then the
+          # request will be processed with the Flex Processing service tier. - To opt-in to
+          # [Fast mode](/api/docs/guides/fast-mode) at the request level, include the
+          # `service_tier=fast` or `service_tier=priority` parameter for Responses or Chat
+          # Completions. The response will show `service_tier=priority` regardless of if you
+          # specify `service_tier=fast` or `priority` in your request. - When not set, the
+          # default behavior is 'auto'. When the `service_tier` parameter is set, the
+          # response body will include the `service_tier` value based on the processing mode
+          # actually used to serve the request. This response value may be different from
+          # the value set in the parameter.
           service_tier: nil,
           # Header param: Optional beta features to enable for this request.
           betas: nil,