openai 0.65.0 → 0.66.0

data/rbi/openai/models/chat/chat_completion.rbi

@@ -32,6 +32,19 @@ module OpenAI
         sig { returns(Symbol) }
         attr_accessor :object
 
+        # Moderation results for the request input and generated output, if moderated
+        # completions were requested.
+        sig { returns(T.nilable(OpenAI::Chat::ChatCompletion::Moderation)) }
+        attr_reader :moderation
+
+        sig do
+          params(
+            moderation:
+              T.nilable(OpenAI::Chat::ChatCompletion::Moderation::OrHash)
+          ).void
+        end
+        attr_writer :moderation
+
         # Specifies the processing type used for serving the request.
         #
         # - If set to 'auto', then the request will be processed with the service tier
@@ -80,6 +93,8 @@ module OpenAI
             choices: T::Array[OpenAI::Chat::ChatCompletion::Choice::OrHash],
             created: Integer,
             model: String,
+            moderation:
+              T.nilable(OpenAI::Chat::ChatCompletion::Moderation::OrHash),
             service_tier:
               T.nilable(OpenAI::Chat::ChatCompletion::ServiceTier::OrSymbol),
             system_fingerprint: String,
@@ -97,6 +112,9 @@ module OpenAI
           created:,
           # The model used for the chat completion.
           model:,
+          # Moderation results for the request input and generated output, if moderated
+          # completions were requested.
+          moderation: nil,
           # Specifies the processing type used for serving the request.
           #
           # - If set to 'auto', then the request will be processed with the service tier
@@ -134,6 +152,7 @@ module OpenAI
               created: Integer,
               model: String,
               object: Symbol,
+              moderation: T.nilable(OpenAI::Chat::ChatCompletion::Moderation),
               service_tier:
                 T.nilable(
                   OpenAI::Chat::ChatCompletion::ServiceTier::TaggedSymbol
@@ -160,7 +179,8 @@ module OpenAI
           # number of tokens specified in the request was reached, `content_filter` if
           # content was omitted due to a flag from our content filters, `tool_calls` if the
           # model called a tool, or `function_call` (deprecated) if the model called a
-          # function.
+          # function. Read the [Model Spec](https://model-spec.openai.com/2025-12-18.html)
+          # for more.
           sig do
             returns(
               OpenAI::Chat::ChatCompletion::Choice::FinishReason::TaggedSymbol
@@ -215,7 +235,8 @@ module OpenAI
             # number of tokens specified in the request was reached, `content_filter` if
             # content was omitted due to a flag from our content filters, `tool_calls` if the
             # model called a tool, or `function_call` (deprecated) if the model called a
-            # function.
+            # function. Read the [Model Spec](https://model-spec.openai.com/2025-12-18.html)
+            # for more.
             finish_reason:,
             # The index of the choice in the list of choices.
             index:,
@@ -246,7 +267,8 @@ module OpenAI
           # number of tokens specified in the request was reached, `content_filter` if
           # content was omitted due to a flag from our content filters, `tool_calls` if the
           # model called a tool, or `function_call` (deprecated) if the model called a
-          # function.
+          # function. Read the [Model Spec](https://model-spec.openai.com/2025-12-18.html)
+          # for more.
           module FinishReason
             extend OpenAI::Internal::Type::Enum
 
@@ -361,6 +383,601 @@ module OpenAI
           end
         end
 
+        class Moderation < OpenAI::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                OpenAI::Chat::ChatCompletion::Moderation,
+                OpenAI::Internal::AnyHash
+              )
+            end
+
+          # Moderation for the request input.
+          sig do
+            returns(OpenAI::Chat::ChatCompletion::Moderation::Input::Variants)
+          end
+          attr_accessor :input
+
+          # Moderation for the generated output.
+          sig do
+            returns(OpenAI::Chat::ChatCompletion::Moderation::Output::Variants)
+          end
+          attr_accessor :output
+
+          # Moderation results for the request input and generated output, if moderated
+          # completions were requested.
+          sig do
+            params(
+              input:
+                T.any(
+                  OpenAI::Chat::ChatCompletion::Moderation::Input::ModerationResults::OrHash,
+                  OpenAI::Chat::ChatCompletion::Moderation::Input::Error::OrHash
+                ),
+              output:
+                T.any(
+                  OpenAI::Chat::ChatCompletion::Moderation::Output::ModerationResults::OrHash,
+                  OpenAI::Chat::ChatCompletion::Moderation::Output::Error::OrHash
+                )
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # Moderation for the request input.
+            input:,
+            # Moderation for the generated output.
+            output:
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                input:
+                  OpenAI::Chat::ChatCompletion::Moderation::Input::Variants,
+                output:
+                  OpenAI::Chat::ChatCompletion::Moderation::Output::Variants
+              }
+            )
+          end
+          def to_hash
+          end
+
+          # Moderation for the request input.
+          module Input
+            extend OpenAI::Internal::Type::Union
+
+            Variants =
+              T.type_alias do
+                T.any(
+                  OpenAI::Chat::ChatCompletion::Moderation::Input::ModerationResults,
+                  OpenAI::Chat::ChatCompletion::Moderation::Input::Error
+                )
+              end
+
+            class ModerationResults < OpenAI::Internal::Type::BaseModel
+              OrHash =
+                T.type_alias do
+                  T.any(
+                    OpenAI::Chat::ChatCompletion::Moderation::Input::ModerationResults,
+                    OpenAI::Internal::AnyHash
+                  )
+                end
+
+              # The moderation model used to generate the results.
+              sig { returns(String) }
+              attr_accessor :model
+
+              # A list of moderation results.
+              sig do
+                returns(
+                  T::Array[
+                    OpenAI::Chat::ChatCompletion::Moderation::Input::ModerationResults::Result
+                  ]
+                )
+              end
+              attr_accessor :results
+
+              # The object type, which is always `moderation_results`.
+              sig { returns(Symbol) }
+              attr_accessor :type
+
+              # Successful moderation results for the request input or generated output.
+              sig do
+                params(
+                  model: String,
+                  results:
+                    T::Array[
+                      OpenAI::Chat::ChatCompletion::Moderation::Input::ModerationResults::Result::OrHash
+                    ],
+                  type: Symbol
+                ).returns(T.attached_class)
+              end
+              def self.new(
+                # The moderation model used to generate the results.
+                model:,
+                # A list of moderation results.
+                results:,
+                # The object type, which is always `moderation_results`.
+                type: :moderation_results
+              )
+              end
+
+              sig do
+                override.returns(
+                  {
+                    model: String,
+                    results:
+                      T::Array[
+                        OpenAI::Chat::ChatCompletion::Moderation::Input::ModerationResults::Result
+                      ],
+                    type: Symbol
+                  }
+                )
+              end
+              def to_hash
+              end
+
+              class Result < OpenAI::Internal::Type::BaseModel
+                OrHash =
+                  T.type_alias do
+                    T.any(
+                      OpenAI::Chat::ChatCompletion::Moderation::Input::ModerationResults::Result,
+                      OpenAI::Internal::AnyHash
+                    )
+                  end
+
+                # A dictionary of moderation categories to booleans, True if the input is flagged
+                # under this category.
+                sig { returns(T::Hash[Symbol, T::Boolean]) }
+                attr_accessor :categories
+
+                # Which modalities of input are reflected by the score for each category.
+                sig do
+                  returns(
+                    T::Hash[
+                      Symbol,
+                      T::Array[
+                        OpenAI::Chat::ChatCompletion::Moderation::Input::ModerationResults::Result::CategoryAppliedInputType::TaggedSymbol
+                      ]
+                    ]
+                  )
+                end
+                attr_accessor :category_applied_input_types
+
+                # A dictionary of moderation categories to scores.
+                sig { returns(T::Hash[Symbol, Float]) }
+                attr_accessor :category_scores
+
+                # A boolean indicating whether the content was flagged by any category.
+                sig { returns(T::Boolean) }
+                attr_accessor :flagged
+
+                # The moderation model that produced this result.
+                sig { returns(String) }
+                attr_accessor :model
+
+                # The object type, which was always `moderation_result` for successful moderation
+                # results.
+                sig { returns(Symbol) }
+                attr_accessor :type
+
+                # A moderation result produced for the response input or output.
+                sig do
+                  params(
+                    categories: T::Hash[Symbol, T::Boolean],
+                    category_applied_input_types:
+                      T::Hash[
+                        Symbol,
+                        T::Array[
+                          OpenAI::Chat::ChatCompletion::Moderation::Input::ModerationResults::Result::CategoryAppliedInputType::OrSymbol
+                        ]
+                      ],
+                    category_scores: T::Hash[Symbol, Float],
+                    flagged: T::Boolean,
+                    model: String,
+                    type: Symbol
+                  ).returns(T.attached_class)
+                end
+                def self.new(
+                  # A dictionary of moderation categories to booleans, True if the input is flagged
+                  # under this category.
+                  categories:,
+                  # Which modalities of input are reflected by the score for each category.
+                  category_applied_input_types:,
+                  # A dictionary of moderation categories to scores.
+                  category_scores:,
+                  # A boolean indicating whether the content was flagged by any category.
+                  flagged:,
+                  # The moderation model that produced this result.
+                  model:,
+                  # The object type, which was always `moderation_result` for successful moderation
+                  # results.
+                  type: :moderation_result
+                )
+                end
+
+                sig do
+                  override.returns(
+                    {
+                      categories: T::Hash[Symbol, T::Boolean],
+                      category_applied_input_types:
+                        T::Hash[
+                          Symbol,
+                          T::Array[
+                            OpenAI::Chat::ChatCompletion::Moderation::Input::ModerationResults::Result::CategoryAppliedInputType::TaggedSymbol
+                          ]
+                        ],
+                      category_scores: T::Hash[Symbol, Float],
+                      flagged: T::Boolean,
+                      model: String,
+                      type: Symbol
+                    }
+                  )
+                end
+                def to_hash
+                end
+
+                module CategoryAppliedInputType
+                  extend OpenAI::Internal::Type::Enum
+
+                  TaggedSymbol =
+                    T.type_alias do
+                      T.all(
+                        Symbol,
+                        OpenAI::Chat::ChatCompletion::Moderation::Input::ModerationResults::Result::CategoryAppliedInputType
+                      )
+                    end
+                  OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+                  TEXT =
+                    T.let(
+                      :text,
+                      OpenAI::Chat::ChatCompletion::Moderation::Input::ModerationResults::Result::CategoryAppliedInputType::TaggedSymbol
+                    )
+                  IMAGE =
+                    T.let(
+                      :image,
+                      OpenAI::Chat::ChatCompletion::Moderation::Input::ModerationResults::Result::CategoryAppliedInputType::TaggedSymbol
+                    )
+
+                  sig do
+                    override.returns(
+                      T::Array[
+                        OpenAI::Chat::ChatCompletion::Moderation::Input::ModerationResults::Result::CategoryAppliedInputType::TaggedSymbol
+                      ]
+                    )
+                  end
+                  def self.values
+                  end
+                end
+              end
+            end
+
+            class Error < OpenAI::Internal::Type::BaseModel
+              OrHash =
+                T.type_alias do
+                  T.any(
+                    OpenAI::Chat::ChatCompletion::Moderation::Input::Error,
+                    OpenAI::Internal::AnyHash
+                  )
+                end
+
+              # The error code.
+              sig { returns(String) }
+              attr_accessor :code
+
+              # The error message.
+              sig { returns(String) }
+              attr_accessor :message
+
+              # The object type, which is always `error`.
+              sig { returns(Symbol) }
+              attr_accessor :type
+
+              # An error produced while attempting moderation.
+              sig do
+                params(code: String, message: String, type: Symbol).returns(
+                  T.attached_class
+                )
+              end
+              def self.new(
+                # The error code.
+                code:,
+                # The error message.
+                message:,
+                # The object type, which is always `error`.
+                type: :error
+              )
+              end
+
+              sig do
+                override.returns(
+                  { code: String, message: String, type: Symbol }
+                )
+              end
+              def to_hash
+              end
+            end
+
+            sig do
+              override.returns(
+                T::Array[
+                  OpenAI::Chat::ChatCompletion::Moderation::Input::Variants
+                ]
+              )
+            end
+            def self.variants
+            end
+          end
+
+          # Moderation for the generated output.
+          module Output
+            extend OpenAI::Internal::Type::Union
+
+            Variants =
+              T.type_alias do
+                T.any(
+                  OpenAI::Chat::ChatCompletion::Moderation::Output::ModerationResults,
+                  OpenAI::Chat::ChatCompletion::Moderation::Output::Error
+                )
+              end
+
+            class ModerationResults < OpenAI::Internal::Type::BaseModel
+              OrHash =
+                T.type_alias do
+                  T.any(
+                    OpenAI::Chat::ChatCompletion::Moderation::Output::ModerationResults,
+                    OpenAI::Internal::AnyHash
+                  )
+                end
+
+              # The moderation model used to generate the results.
+              sig { returns(String) }
+              attr_accessor :model
+
+              # A list of moderation results.
+              sig do
+                returns(
+                  T::Array[
+                    OpenAI::Chat::ChatCompletion::Moderation::Output::ModerationResults::Result
+                  ]
+                )
+              end
+              attr_accessor :results
+
+              # The object type, which is always `moderation_results`.
+              sig { returns(Symbol) }
+              attr_accessor :type
+
+              # Successful moderation results for the request input or generated output.
+              sig do
+                params(
+                  model: String,
+                  results:
+                    T::Array[
+                      OpenAI::Chat::ChatCompletion::Moderation::Output::ModerationResults::Result::OrHash
+                    ],
+                  type: Symbol
+                ).returns(T.attached_class)
+              end
+              def self.new(
+                # The moderation model used to generate the results.
+                model:,
+                # A list of moderation results.
+                results:,
+                # The object type, which is always `moderation_results`.
+                type: :moderation_results
+              )
+              end
+
+              sig do
+                override.returns(
+                  {
+                    model: String,
+                    results:
+                      T::Array[
+                        OpenAI::Chat::ChatCompletion::Moderation::Output::ModerationResults::Result
+                      ],
+                    type: Symbol
+                  }
+                )
+              end
+              def to_hash
+              end
+
+              class Result < OpenAI::Internal::Type::BaseModel
+                OrHash =
+                  T.type_alias do
+                    T.any(
+                      OpenAI::Chat::ChatCompletion::Moderation::Output::ModerationResults::Result,
+                      OpenAI::Internal::AnyHash
+                    )
+                  end
+
+                # A dictionary of moderation categories to booleans, True if the input is flagged
+                # under this category.
+                sig { returns(T::Hash[Symbol, T::Boolean]) }
+                attr_accessor :categories
+
+                # Which modalities of input are reflected by the score for each category.
+                sig do
+                  returns(
+                    T::Hash[
+                      Symbol,
+                      T::Array[
+                        OpenAI::Chat::ChatCompletion::Moderation::Output::ModerationResults::Result::CategoryAppliedInputType::TaggedSymbol
+                      ]
+                    ]
+                  )
+                end
+                attr_accessor :category_applied_input_types
+
+                # A dictionary of moderation categories to scores.
+                sig { returns(T::Hash[Symbol, Float]) }
+                attr_accessor :category_scores
+
+                # A boolean indicating whether the content was flagged by any category.
+                sig { returns(T::Boolean) }
+                attr_accessor :flagged
+
+                # The moderation model that produced this result.
+                sig { returns(String) }
+                attr_accessor :model
+
+                # The object type, which was always `moderation_result` for successful moderation
+                # results.
+                sig { returns(Symbol) }
+                attr_accessor :type
+
+                # A moderation result produced for the response input or output.
+                sig do
+                  params(
+                    categories: T::Hash[Symbol, T::Boolean],
+                    category_applied_input_types:
+                      T::Hash[
+                        Symbol,
+                        T::Array[
+                          OpenAI::Chat::ChatCompletion::Moderation::Output::ModerationResults::Result::CategoryAppliedInputType::OrSymbol
+                        ]
+                      ],
+                    category_scores: T::Hash[Symbol, Float],
+                    flagged: T::Boolean,
+                    model: String,
+                    type: Symbol
+                  ).returns(T.attached_class)
+                end
+                def self.new(
+                  # A dictionary of moderation categories to booleans, True if the input is flagged
+                  # under this category.
+                  categories:,
+                  # Which modalities of input are reflected by the score for each category.
+                  category_applied_input_types:,
+                  # A dictionary of moderation categories to scores.
+                  category_scores:,
+                  # A boolean indicating whether the content was flagged by any category.
+                  flagged:,
+                  # The moderation model that produced this result.
+                  model:,
+                  # The object type, which was always `moderation_result` for successful moderation
+                  # results.
+                  type: :moderation_result
+                )
+                end
+
+                sig do
+                  override.returns(
+                    {
+                      categories: T::Hash[Symbol, T::Boolean],
+                      category_applied_input_types:
+                        T::Hash[
+                          Symbol,
+                          T::Array[
+                            OpenAI::Chat::ChatCompletion::Moderation::Output::ModerationResults::Result::CategoryAppliedInputType::TaggedSymbol
+                          ]
+                        ],
+                      category_scores: T::Hash[Symbol, Float],
+                      flagged: T::Boolean,
+                      model: String,
+                      type: Symbol
+                    }
+                  )
+                end
+                def to_hash
+                end
+
+                module CategoryAppliedInputType
+                  extend OpenAI::Internal::Type::Enum
+
+                  TaggedSymbol =
+                    T.type_alias do
+                      T.all(
+                        Symbol,
+                        OpenAI::Chat::ChatCompletion::Moderation::Output::ModerationResults::Result::CategoryAppliedInputType
+                      )
+                    end
+                  OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+                  TEXT =
+                    T.let(
+                      :text,
+                      OpenAI::Chat::ChatCompletion::Moderation::Output::ModerationResults::Result::CategoryAppliedInputType::TaggedSymbol
+                    )
+                  IMAGE =
+                    T.let(
+                      :image,
+                      OpenAI::Chat::ChatCompletion::Moderation::Output::ModerationResults::Result::CategoryAppliedInputType::TaggedSymbol
+                    )
+
+                  sig do
+                    override.returns(
+                      T::Array[
+                        OpenAI::Chat::ChatCompletion::Moderation::Output::ModerationResults::Result::CategoryAppliedInputType::TaggedSymbol
+                      ]
+                    )
+                  end
+                  def self.values
+                  end
+                end
+              end
+            end
+
+            class Error < OpenAI::Internal::Type::BaseModel
+              OrHash =
+                T.type_alias do
+                  T.any(
+                    OpenAI::Chat::ChatCompletion::Moderation::Output::Error,
+                    OpenAI::Internal::AnyHash
+                  )
+                end
+
+              # The error code.
+              sig { returns(String) }
+              attr_accessor :code
+
+              # The error message.
+              sig { returns(String) }
+              attr_accessor :message
+
+              # The object type, which is always `error`.
+              sig { returns(Symbol) }
+              attr_accessor :type
+
+              # An error produced while attempting moderation.
+              sig do
+                params(code: String, message: String, type: Symbol).returns(
+                  T.attached_class
+                )
+              end
+              def self.new(
+                # The error code.
+                code:,
+                # The error message.
+                message:,
+                # The object type, which is always `error`.
+                type: :error
+              )
+              end
+
+              sig do
+                override.returns(
+                  { code: String, message: String, type: Symbol }
+                )
+              end
+              def to_hash
+              end
+            end
+
+            sig do
+              override.returns(
+                T::Array[
+                  OpenAI::Chat::ChatCompletion::Moderation::Output::Variants
+                ]
+              )
+            end
+            def self.variants
+            end
+          end
+        end
+
         # Specifies the processing type used for serving the request.
         #
         # - If set to 'auto', then the request will be processed with the service tier