openai 0.80.0 → 0.82.0

data/rbi/openai/models/evals/run_create_response.rbi

@@ -2,15 +2,17 @@
 
 module OpenAI
   module Models
+
     module Evals
+
       class RunCreateResponse < OpenAI::Internal::Type::BaseModel
-        OrHash =
-          T.type_alias do
-            T.any(
-              OpenAI::Models::Evals::RunCreateResponse,
-              OpenAI::Internal::AnyHash
-            )
-          end
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Models::Evals::RunCreateResponse,
+            OpenAI::Internal::AnyHash
+          )
+        end
 
         # Unique identifier for the evaluation run.
         sig { returns(String) }
@@ -21,11 +23,7 @@ module OpenAI
         attr_accessor :created_at
 
         # Information about the run's data source.
-        sig do
-          returns(
-            OpenAI::Models::Evals::RunCreateResponse::DataSource::Variants
-          )
-        end
+        sig { returns(OpenAI::Models::Evals::RunCreateResponse::DataSource::Variants) }
         attr_accessor :data_source
 
         # An object representing an error response from the Eval API.
@@ -61,21 +59,11 @@ module OpenAI
         attr_accessor :object
 
         # Usage statistics for each model during the evaluation run.
-        sig do
-          returns(
-            T::Array[OpenAI::Models::Evals::RunCreateResponse::PerModelUsage]
-          )
-        end
+        sig { returns(T::Array[OpenAI::Models::Evals::RunCreateResponse::PerModelUsage]) }
         attr_accessor :per_model_usage
 
         # Results per testing criteria applied during the evaluation run.
-        sig do
-          returns(
-            T::Array[
-              OpenAI::Models::Evals::RunCreateResponse::PerTestingCriteriaResult
-            ]
-          )
-        end
+        sig { returns(T::Array[OpenAI::Models::Evals::RunCreateResponse::PerTestingCriteriaResult]) }
         attr_accessor :per_testing_criteria_results
 
         # The URL to the rendered evaluation run report on the UI dashboard.
@@ -86,12 +74,7 @@ module OpenAI
         sig { returns(OpenAI::Models::Evals::RunCreateResponse::ResultCounts) }
         attr_reader :result_counts
 
-        sig do
-          params(
-            result_counts:
-              OpenAI::Models::Evals::RunCreateResponse::ResultCounts::OrHash
-          ).void
-        end
+        sig { params(result_counts: OpenAI::Models::Evals::RunCreateResponse::ResultCounts::OrHash).void }
         attr_writer :result_counts
 
         # The status of the evaluation run.
@@ -101,45 +84,60 @@ module OpenAI
         # A schema representing an evaluation run.
         sig do
           params(
+
             id: String,
+
             created_at: Integer,
-            data_source:
-              T.any(
-                OpenAI::Evals::CreateEvalJSONLRunDataSource::OrHash,
-                OpenAI::Evals::CreateEvalCompletionsRunDataSource::OrHash,
-                OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::OrHash
-              ),
+
+            data_source: T.any(
+              OpenAI::Evals::CreateEvalJSONLRunDataSource::OrHash,
+              OpenAI::Evals::CreateEvalCompletionsRunDataSource::OrHash,
+              OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::OrHash
+            ),
+
             error: OpenAI::Evals::EvalAPIError::OrHash,
+
             eval_id: String,
+
             metadata: T.nilable(T::Hash[Symbol, String]),
+
             model: String,
+
             name: String,
-            per_model_usage:
-              T::Array[
-                OpenAI::Models::Evals::RunCreateResponse::PerModelUsage::OrHash
-              ],
-            per_testing_criteria_results:
-              T::Array[
-                OpenAI::Models::Evals::RunCreateResponse::PerTestingCriteriaResult::OrHash
-              ],
+
+            per_model_usage: T::Array[OpenAI::Models::Evals::RunCreateResponse::PerModelUsage::OrHash],
+
+            per_testing_criteria_results: T::Array[
+              OpenAI::Models::Evals::RunCreateResponse::PerTestingCriteriaResult::OrHash
+            ],
+
             report_url: String,
-            result_counts:
-              OpenAI::Models::Evals::RunCreateResponse::ResultCounts::OrHash,
+
+            result_counts: OpenAI::Models::Evals::RunCreateResponse::ResultCounts::OrHash,
+
             status: String,
+
             object: Symbol
-          ).returns(T.attached_class)
+          )
+            .returns(T.attached_class)
         end
         def self.new(
+
           # Unique identifier for the evaluation run.
           id:,
+
           # Unix timestamp (in seconds) when the evaluation run was created.
           created_at:,
+
           # Information about the run's data source.
           data_source:,
+
           # An object representing an error response from the Eval API.
           error:,
+
           # The identifier of the associated evaluation.
           eval_id:,
+
           # Set of 16 key-value pairs that can be attached to an object. This can be useful
           # for storing additional information about the object in a structured format, and
           # querying for objects via API or the dashboard.
@@ -147,21 +145,30 @@ module OpenAI
           # Keys are strings with a maximum length of 64 characters. Values are strings with
           # a maximum length of 512 characters.
           metadata:,
+
           # The model that is evaluated, if applicable.
           model:,
+
           # The name of the evaluation run.
           name:,
+
           # Usage statistics for each model during the evaluation run.
           per_model_usage:,
+
           # Results per testing criteria applied during the evaluation run.
           per_testing_criteria_results:,
+
           # The URL to the rendered evaluation run report on the UI dashboard.
           report_url:,
+
           # Counters summarizing the outcomes of the evaluation run.
           result_counts:,
+
           # The status of the evaluation run.
           status:,
+
           # The type of the object. Always "eval.run".
+
           object: :"eval.run"
         )
         end
@@ -171,25 +178,17 @@ module OpenAI
             {
               id: String,
               created_at: Integer,
-              data_source:
-                OpenAI::Models::Evals::RunCreateResponse::DataSource::Variants,
+              data_source: OpenAI::Models::Evals::RunCreateResponse::DataSource::Variants,
               error: OpenAI::Evals::EvalAPIError,
               eval_id: String,
               metadata: T.nilable(T::Hash[Symbol, String]),
               model: String,
               name: String,
               object: Symbol,
-              per_model_usage:
-                T::Array[
-                  OpenAI::Models::Evals::RunCreateResponse::PerModelUsage
-                ],
-              per_testing_criteria_results:
-                T::Array[
-                  OpenAI::Models::Evals::RunCreateResponse::PerTestingCriteriaResult
-                ],
+              per_model_usage: T::Array[OpenAI::Models::Evals::RunCreateResponse::PerModelUsage],
+              per_testing_criteria_results: T::Array[OpenAI::Models::Evals::RunCreateResponse::PerTestingCriteriaResult],
               report_url: String,
-              result_counts:
-                OpenAI::Models::Evals::RunCreateResponse::ResultCounts,
+              result_counts: OpenAI::Models::Evals::RunCreateResponse::ResultCounts,
               status: String
             }
           )
@@ -201,30 +200,24 @@ module OpenAI
         module DataSource
           extend OpenAI::Internal::Type::Union
 
-          Variants =
-            T.type_alias do
+          Variants = T.type_alias {
+            T.any(
+              OpenAI::Evals::CreateEvalJSONLRunDataSource,
+              OpenAI::Evals::CreateEvalCompletionsRunDataSource,
+              OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses
+            )
+          }
+
+          class Responses < OpenAI::Internal::Type::BaseModel
+            OrHash = T.type_alias do
               T.any(
-                OpenAI::Evals::CreateEvalJSONLRunDataSource,
-                OpenAI::Evals::CreateEvalCompletionsRunDataSource,
-                OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses
+                OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses,
+                OpenAI::Internal::AnyHash
               )
             end
 
-          class Responses < OpenAI::Internal::Type::BaseModel
-            OrHash =
-              T.type_alias do
-                T.any(
-                  OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses,
-                  OpenAI::Internal::AnyHash
-                )
-              end
-
             # Determines what populates the `item` namespace in this run's data source.
-            sig do
-              returns(
-                OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::Source::Variants
-              )
-            end
+            sig { returns(OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::Source::Variants) }
             attr_accessor :source
 
             # The type of run data source. Always `responses`.
@@ -235,24 +228,22 @@ module OpenAI
             # into the model. Can either be a reference to a prebuilt trajectory (ie,
             # `item.input_trajectory`), or a template with variable references to the `item`
             # namespace.
-            sig do
+            sig {
               returns(
-                T.nilable(
-                  OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::Variants
-                )
+                T.nilable(OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::Variants)
               )
-            end
+            }
             attr_reader :input_messages
 
-            sig do
+            sig {
               params(
-                input_messages:
-                  T.any(
-                    OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::Template::OrHash,
-                    OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::ItemReference::OrHash
-                  )
-              ).void
-            end
+                input_messages: T.any(
+                  OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::Template::OrHash,
+                  OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::ItemReference::OrHash
+                )
+              )
+                .void
+            }
             attr_writer :input_messages
 
             # The name of the model to use for generating completions (e.g. "o3-mini").
@@ -262,55 +253,58 @@ module OpenAI
             sig { params(model: String).void }
             attr_writer :model
 
-            sig do
-              returns(
-                T.nilable(
-                  OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::SamplingParams
-                )
-              )
-            end
+            sig { returns(T.nilable(OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::SamplingParams)) }
             attr_reader :sampling_params
 
-            sig do
+            sig {
               params(
-                sampling_params:
-                  OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::SamplingParams::OrHash
-              ).void
-            end
+                sampling_params: OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::SamplingParams::OrHash
+              )
+                .void
+            }
             attr_writer :sampling_params
 
             # A ResponsesRunDataSource object describing a model sampling configuration.
             sig do
               params(
-                source:
-                  T.any(
-                    OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::Source::FileContent::OrHash,
-                    OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::Source::FileID::OrHash,
-                    OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::Source::Responses::OrHash
-                  ),
-                input_messages:
-                  T.any(
-                    OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::Template::OrHash,
-                    OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::ItemReference::OrHash
-                  ),
+
+                source: T.any(
+                  OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::Source::FileContent::OrHash,
+                  OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::Source::FileID::OrHash,
+                  OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::Source::Responses::OrHash
+                ),
+
+                input_messages: T.any(
+                  OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::Template::OrHash,
+                  OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::ItemReference::OrHash
+                ),
+
                 model: String,
-                sampling_params:
-                  OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::SamplingParams::OrHash,
+
+                sampling_params: OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::SamplingParams::OrHash,
+
                 type: Symbol
-              ).returns(T.attached_class)
+              )
+                .returns(T.attached_class)
             end
             def self.new(
+
               # Determines what populates the `item` namespace in this run's data source.
               source:,
+
               # Used when sampling from a model. Dictates the structure of the messages passed
               # into the model. Can either be a reference to a prebuilt trajectory (ie,
               # `item.input_trajectory`), or a template with variable references to the `item`
               # namespace.
               input_messages: nil,
+
               # The name of the model to use for generating completions (e.g. "o3-mini").
               model: nil,
+
               sampling_params: nil,
+
               # The type of run data source. Always `responses`.
+
               type: :responses
             )
             end
@@ -318,14 +312,11 @@ module OpenAI
             sig do
               override.returns(
                 {
-                  source:
-                    OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::Source::Variants,
+                  source: OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::Source::Variants,
                   type: Symbol,
-                  input_messages:
-                    OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::Variants,
+                  input_messages: OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::Variants,
                   model: String,
-                  sampling_params:
-                    OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::SamplingParams
+                  sampling_params: OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::SamplingParams
                 }
               )
             end
@@ -336,32 +327,30 @@ module OpenAI
             module Source
               extend OpenAI::Internal::Type::Union
 
-              Variants =
-                T.type_alias do
+              Variants = T.type_alias {
+                T.any(
+                  OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::Source::FileContent,
+                  OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::Source::FileID,
+                  OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::Source::Responses
+                )
+              }
+
+              class FileContent < OpenAI::Internal::Type::BaseModel
+                OrHash = T.type_alias do
                   T.any(
                     OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::Source::FileContent,
-                    OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::Source::FileID,
-                    OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::Source::Responses
+                    OpenAI::Internal::AnyHash
                   )
                 end
 
-              class FileContent < OpenAI::Internal::Type::BaseModel
-                OrHash =
-                  T.type_alias do
-                    T.any(
-                      OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::Source::FileContent,
-                      OpenAI::Internal::AnyHash
-                    )
-                  end
-
                 # The content of the jsonl file.
-                sig do
+                sig {
                   returns(
                     T::Array[
                       OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::Source::FileContent::Content
                     ]
                   )
-                end
+                }
                 attr_accessor :content
 
                 # The type of jsonl source. Always `file_content`.
@@ -370,17 +359,22 @@ module OpenAI
 
                 sig do
                   params(
-                    content:
-                      T::Array[
-                        OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::Source::FileContent::Content::OrHash
-                      ],
+
+                    content: T::Array[
+                      OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::Source::FileContent::Content::OrHash
+                    ],
+
                     type: Symbol
-                  ).returns(T.attached_class)
+                  )
+                    .returns(T.attached_class)
                 end
                 def self.new(
+
                   # The content of the jsonl file.
                   content:,
+
                   # The type of jsonl source. Always `file_content`.
+
                   type: :file_content
                 )
                 end
@@ -388,10 +382,9 @@ module OpenAI
                 sig do
                   override.returns(
                     {
-                      content:
-                        T::Array[
-                          OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::Source::FileContent::Content
-                        ],
+                      content: T::Array[
+                        OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::Source::FileContent::Content
+                      ],
                       type: Symbol
                     }
                   )
@@ -400,13 +393,12 @@ module OpenAI
                 end
 
                 class Content < OpenAI::Internal::Type::BaseModel
-                  OrHash =
-                    T.type_alias do
-                      T.any(
-                        OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::Source::FileContent::Content,
-                        OpenAI::Internal::AnyHash
-                      )
-                    end
+                  OrHash = T.type_alias do
+                    T.any(
+                      OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::Source::FileContent::Content,
+                      OpenAI::Internal::AnyHash
+                    )
+                  end
 
                   sig { returns(T::Hash[Symbol, T.anything]) }
                   attr_accessor :item
@@ -419,34 +411,39 @@ module OpenAI
 
                   sig do
                     params(
+
                       item: T::Hash[Symbol, T.anything],
+
                       sample: T::Hash[Symbol, T.anything]
-                    ).returns(T.attached_class)
+                    )
+                      .returns(T.attached_class)
                   end
-                  def self.new(item:, sample: nil)
+                  def self.new(
+
+                    item:,
+
+                    sample: nil
+                  )
                   end
 
                   sig do
                     override.returns(
-                      {
-                        item: T::Hash[Symbol, T.anything],
-                        sample: T::Hash[Symbol, T.anything]
-                      }
+                      {item: T::Hash[Symbol, T.anything], sample: T::Hash[Symbol, T.anything]}
                     )
                   end
                   def to_hash
                   end
+
                 end
               end
 
               class FileID < OpenAI::Internal::Type::BaseModel
-                OrHash =
-                  T.type_alias do
-                    T.any(
-                      OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::Source::FileID,
-                      OpenAI::Internal::AnyHash
-                    )
-                  end
+                OrHash = T.type_alias do
+                  T.any(
+                    OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::Source::FileID,
+                    OpenAI::Internal::AnyHash
+                  )
+                end
 
                 # The identifier of the file.
                 sig { returns(String) }
@@ -457,29 +454,42 @@ module OpenAI
                 attr_accessor :type
 
                 sig do
-                  params(id: String, type: Symbol).returns(T.attached_class)
+                  params(
+
+                    id: String,
+
+                    type: Symbol
+                  )
+                    .returns(T.attached_class)
                 end
                 def self.new(
+
                   # The identifier of the file.
                   id:,
+
                   # The type of jsonl source. Always `file_id`.
+
                   type: :file_id
                 )
                 end
 
-                sig { override.returns({ id: String, type: Symbol }) }
+                sig do
+                  override.returns(
+                    {id: String, type: Symbol}
+                  )
+                end
                 def to_hash
                 end
+
               end
 
               class Responses < OpenAI::Internal::Type::BaseModel
-                OrHash =
-                  T.type_alias do
-                    T.any(
-                      OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::Source::Responses,
-                      OpenAI::Internal::AnyHash
-                    )
-                  end
+                OrHash = T.type_alias do
+                  T.any(
+                    OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::Source::Responses,
+                    OpenAI::Internal::AnyHash
+                  )
+                end
 
                 # The type of run data source. Always `responses`.
                 sig { returns(Symbol) }
@@ -516,9 +526,7 @@ module OpenAI
                 # reasoning in a response. Not all reasoning models support every value. See the
                 # [reasoning guide](https://platform.openai.com/docs/guides/reasoning) for
                 # model-specific support.
-                sig do
-                  returns(T.nilable(OpenAI::ReasoningEffort::TaggedSymbol))
-                end
+                sig { returns(T.nilable(OpenAI::ReasoningEffort::TaggedSymbol)) }
                 attr_accessor :reasoning_effort
 
                 # Sampling temperature. This is a query parameter used to select responses.
@@ -540,36 +548,53 @@ module OpenAI
                 # A EvalResponsesSource object describing a run data source configuration.
                 sig do
                   params(
+
                     created_after: T.nilable(Integer),
+
                     created_before: T.nilable(Integer),
+
                     instructions_search: T.nilable(String),
+
                     metadata: T.nilable(T.anything),
+
                     model: T.nilable(String),
-                    reasoning_effort:
-                      T.nilable(OpenAI::ReasoningEffort::OrSymbol),
+
+                    reasoning_effort: T.nilable(OpenAI::ReasoningEffort::OrSymbol),
+
                     temperature: T.nilable(Float),
+
                     tools: T.nilable(T::Array[String]),
+
                     top_p: T.nilable(Float),
+
                     users: T.nilable(T::Array[String]),
+
                     type: Symbol
-                  ).returns(T.attached_class)
+                  )
+                    .returns(T.attached_class)
                 end
                 def self.new(
+
                   # Only include items created after this timestamp (inclusive). This is a query
                   # parameter used to select responses.
                   created_after: nil,
+
                   # Only include items created before this timestamp (inclusive). This is a query
                   # parameter used to select responses.
                   created_before: nil,
+
                   # Optional string to search the 'instructions' field. This is a query parameter
                   # used to select responses.
                   instructions_search: nil,
+
                   # Metadata filter for the responses. This is a query parameter used to select
                   # responses.
                   metadata: nil,
+
                   # The name of the model to find responses for. This is a query parameter used to
                   # select responses.
                   model: nil,
+
                   # Constrains effort on reasoning for reasoning models. Currently supported values
                   # are `none`, `minimal`, `low`, `medium`, `high`, `xhigh`, and `max`. Reducing
                   # reasoning effort can result in faster responses and fewer tokens used on
@@ -577,15 +602,21 @@ module OpenAI
                   # [reasoning guide](https://platform.openai.com/docs/guides/reasoning) for
                   # model-specific support.
                   reasoning_effort: nil,
+
                   # Sampling temperature. This is a query parameter used to select responses.
                   temperature: nil,
+
                   # List of tool names. This is a query parameter used to select responses.
                   tools: nil,
+
                   # Nucleus sampling parameter. This is a query parameter used to select responses.
                   top_p: nil,
+
                   # List of user identifiers. This is a query parameter used to select responses.
                   users: nil,
+
                   # The type of run data source. Always `responses`.
+
                   type: :responses
                 )
                 end
@@ -599,8 +630,7 @@ module OpenAI
                       instructions_search: T.nilable(String),
                       metadata: T.nilable(T.anything),
                       model: T.nilable(String),
-                      reasoning_effort:
-                        T.nilable(OpenAI::ReasoningEffort::TaggedSymbol),
+                      reasoning_effort: T.nilable(OpenAI::ReasoningEffort::TaggedSymbol),
                       temperature: T.nilable(Float),
                       tools: T.nilable(T::Array[String]),
                       top_p: T.nilable(Float),
@@ -610,17 +640,17 @@ module OpenAI
                 end
                 def to_hash
                 end
+
               end
 
-              sig do
+              sig {
                 override.returns(
-                  T::Array[
-                    OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::Source::Variants
-                  ]
+                  T::Array[OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::Source::Variants]
                 )
-              end
+              }
               def self.variants
               end
+
             end
 
             # Used when sampling from a model. Dictates the structure of the messages passed
@@ -630,32 +660,30 @@ module OpenAI
             module InputMessages
               extend OpenAI::Internal::Type::Union
 
-              Variants =
-                T.type_alias do
+              Variants = T.type_alias {
+                T.any(
+                  OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::Template,
+                  OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::ItemReference
+                )
+              }
+
+              class Template < OpenAI::Internal::Type::BaseModel
+                OrHash = T.type_alias do
                   T.any(
                     OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::Template,
-                    OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::ItemReference
+                    OpenAI::Internal::AnyHash
                   )
                 end
 
-              class Template < OpenAI::Internal::Type::BaseModel
-                OrHash =
-                  T.type_alias do
-                    T.any(
-                      OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::Template,
-                      OpenAI::Internal::AnyHash
-                    )
-                  end
-
                 # A list of chat messages forming the prompt or context. May include variable
                 # references to the `item` namespace, ie {{item.name}}.
-                sig do
+                sig {
                   returns(
                     T::Array[
                       OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::Template::Template::Variants
                     ]
                   )
-                end
+                }
                 attr_accessor :template
 
                 # The type of input messages. Always `template`.
@@ -664,21 +692,26 @@ module OpenAI
 
                 sig do
                   params(
-                    template:
-                      T::Array[
-                        T.any(
-                          OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::Template::Template::ChatMessage::OrHash,
-                          OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::Template::Template::EvalItem::OrHash
-                        )
-                      ],
+
+                    template: T::Array[
+                      T.any(
+                        OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::Template::Template::ChatMessage::OrHash,
+                        OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::Template::Template::EvalItem::OrHash
+                      )
+                    ],
+
                     type: Symbol
-                  ).returns(T.attached_class)
+                  )
+                    .returns(T.attached_class)
                 end
                 def self.new(
+
                   # A list of chat messages forming the prompt or context. May include variable
                   # references to the `item` namespace, ie {{item.name}}.
                   template:,
+
                   # The type of input messages. Always `template`.
+
                   type: :template
                 )
                 end
@@ -686,10 +719,9 @@ module OpenAI
                 sig do
                   override.returns(
                     {
-                      template:
-                        T::Array[
-                          OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::Template::Template::Variants
-                        ],
+                      template: T::Array[
+                        OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::Template::Template::Variants
+                      ],
                       type: Symbol
                     }
                   )
@@ -705,23 +737,21 @@ module OpenAI
                 module Template
                   extend OpenAI::Internal::Type::Union
 
-                  Variants =
-                    T.type_alias do
+                  Variants = T.type_alias {
+                    T.any(
+                      OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::Template::Template::ChatMessage,
+                      OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::Template::Template::EvalItem
+                    )
+                  }
+
+                  class ChatMessage < OpenAI::Internal::Type::BaseModel
+                    OrHash = T.type_alias do
                       T.any(
                         OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::Template::Template::ChatMessage,
-                        OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::Template::Template::EvalItem
+                        OpenAI::Internal::AnyHash
                       )
                     end
 
-                  class ChatMessage < OpenAI::Internal::Type::BaseModel
-                    OrHash =
-                      T.type_alias do
-                        T.any(
-                          OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::Template::Template::ChatMessage,
-                          OpenAI::Internal::AnyHash
-                        )
-                      end
-
                     # The content of the message.
                     sig { returns(String) }
                     attr_accessor :content
@@ -731,66 +761,77 @@ module OpenAI
                     attr_accessor :role
 
                     sig do
-                      params(content: String, role: String).returns(
-                        T.attached_class
+                      params(
+
+                        content: String,
+
+                        role: String
                       )
+                        .returns(T.attached_class)
                     end
                     def self.new(
+
                       # The content of the message.
                       content:,
+
                       # The role of the message (e.g. "system", "assistant", "user").
+
                       role:
                     )
                     end
 
-                    sig { override.returns({ content: String, role: String }) }
+                    sig do
+                      override.returns(
+                        {content: String, role: String}
+                      )
+                    end
                     def to_hash
                     end
+
                   end
 
                   class EvalItem < OpenAI::Internal::Type::BaseModel
-                    OrHash =
-                      T.type_alias do
-                        T.any(
-                          OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::Template::Template::EvalItem,
-                          OpenAI::Internal::AnyHash
-                        )
-                      end
+                    OrHash = T.type_alias do
+                      T.any(
+                        OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::Template::Template::EvalItem,
+                        OpenAI::Internal::AnyHash
+                      )
+                    end
 
                     # Inputs to the model - can contain template strings. Supports text, output text,
                     # input images, and input audio, either as a single item or an array of items.
-                    sig do
+                    sig {
                       returns(
                         OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::Template::Template::EvalItem::Content::Variants
                       )
-                    end
+                    }
                     attr_accessor :content
 
                     # The role of the message input. One of `user`, `assistant`, `system`, or
                     # `developer`.
-                    sig do
+                    sig {
                       returns(
                         OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::Template::Template::EvalItem::Role::TaggedSymbol
                       )
-                    end
+                    }
                     attr_accessor :role
 
                     # The type of the message input. Always `message`.
-                    sig do
+                    sig {
                       returns(
                         T.nilable(
                           OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::Template::Template::EvalItem::Type::TaggedSymbol
                         )
                       )
-                    end
+                    }
                     attr_reader :type
 
-                    sig do
+                    sig {
                       params(
-                        type:
-                          OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::Template::Template::EvalItem::Type::OrSymbol
-                      ).void
-                    end
+                        type: OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::Template::Template::EvalItem::Type::OrSymbol
+                      )
+                        .void
+                    }
                     attr_writer :type
 
                     # A message input to the model with a role indicating instruction following
@@ -800,37 +841,42 @@ module OpenAI
                     # interactions.
                     sig do
                       params(
-                        content:
-                          T.any(
-                            String,
-                            OpenAI::Responses::ResponseInputText::OrHash,
-                            OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::Template::Template::EvalItem::Content::OutputText::OrHash,
-                            OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::Template::Template::EvalItem::Content::InputImage::OrHash,
-                            OpenAI::Responses::ResponseInputAudio::OrHash,
-                            T::Array[
-                              T.any(
-                                String,
-                                OpenAI::Responses::ResponseInputText::OrHash,
-                                OpenAI::Graders::GraderInputItem::OutputText::OrHash,
-                                OpenAI::Graders::GraderInputItem::InputImage::OrHash,
-                                OpenAI::Responses::ResponseInputAudio::OrHash
-                              )
-                            ]
-                          ),
-                        role:
-                          OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::Template::Template::EvalItem::Role::OrSymbol,
-                        type:
-                          OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::Template::Template::EvalItem::Type::OrSymbol
-                      ).returns(T.attached_class)
+
+                        content: T.any(
+                          String,
+                          OpenAI::Responses::ResponseInputText::OrHash,
+                          OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::Template::Template::EvalItem::Content::OutputText::OrHash,
+                          OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::Template::Template::EvalItem::Content::InputImage::OrHash,
+                          OpenAI::Responses::ResponseInputAudio::OrHash,
+                          T::Array[
+                            T.any(
+                              String,
+                              OpenAI::Responses::ResponseInputText::OrHash,
+                              OpenAI::Graders::GraderInputItem::OutputText::OrHash,
+                              OpenAI::Graders::GraderInputItem::InputImage::OrHash,
+                              OpenAI::Responses::ResponseInputAudio::OrHash
+                            )
+                          ]
+                        ),
+
+                        role: OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::Template::Template::EvalItem::Role::OrSymbol,
+
+                        type: OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::Template::Template::EvalItem::Type::OrSymbol
+                      )
+                        .returns(T.attached_class)
                     end
                     def self.new(
+
                       # Inputs to the model - can contain template strings. Supports text, output text,
                       # input images, and input audio, either as a single item or an array of items.
                       content:,
+
                       # The role of the message input. One of `user`, `assistant`, `system`, or
                       # `developer`.
                       role:,
+
                       # The type of the message input. Always `message`.
+
                       type: nil
                     )
                     end
@@ -838,12 +884,9 @@ module OpenAI
                     sig do
                       override.returns(
                         {
-                          content:
-                            OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::Template::Template::EvalItem::Content::Variants,
-                          role:
-                            OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::Template::Template::EvalItem::Role::TaggedSymbol,
-                          type:
-                            OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::Template::Template::EvalItem::Type::TaggedSymbol
+                          content: OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::Template::Template::EvalItem::Content::Variants,
+                          role: OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::Template::Template::EvalItem::Role::TaggedSymbol,
+                          type: OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::Template::Template::EvalItem::Type::TaggedSymbol
                         }
                       )
                     end
@@ -855,27 +898,25 @@ module OpenAI
                     module Content
                       extend OpenAI::Internal::Type::Union
 
-                      Variants =
-                        T.type_alias do
+                      Variants = T.type_alias {
+                        T.any(
+                          String,
+                          OpenAI::Responses::ResponseInputText,
+                          OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::Template::Template::EvalItem::Content::OutputText,
+                          OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::Template::Template::EvalItem::Content::InputImage,
+                          OpenAI::Responses::ResponseInputAudio,
+                          T::Array[OpenAI::Graders::GraderInputItem::Variants]
+                        )
+                      }
+
+                      class OutputText < OpenAI::Internal::Type::BaseModel
+                        OrHash = T.type_alias do
                           T.any(
-                            String,
-                            OpenAI::Responses::ResponseInputText,
                             OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::Template::Template::EvalItem::Content::OutputText,
-                            OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::Template::Template::EvalItem::Content::InputImage,
-                            OpenAI::Responses::ResponseInputAudio,
-                            T::Array[OpenAI::Graders::GraderInputItem::Variants]
+                            OpenAI::Internal::AnyHash
                           )
                         end
 
-                      class OutputText < OpenAI::Internal::Type::BaseModel
-                        OrHash =
-                          T.type_alias do
-                            T.any(
-                              OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::Template::Template::EvalItem::Content::OutputText,
-                              OpenAI::Internal::AnyHash
-                            )
-                          end
-
                         # The text output from the model.
                         sig { returns(String) }
                         attr_accessor :text
@@ -886,31 +927,42 @@ module OpenAI
 
                         # A text output from the model.
                         sig do
-                          params(text: String, type: Symbol).returns(
-                            T.attached_class
+                          params(
+
+                            text: String,
+
+                            type: Symbol
                           )
+                            .returns(T.attached_class)
                         end
                         def self.new(
+
                           # The text output from the model.
                           text:,
+
                           # The type of the output text. Always `output_text`.
+
                           type: :output_text
                         )
                         end
 
-                        sig { override.returns({ text: String, type: Symbol }) }
+                        sig do
+                          override.returns(
+                            {text: String, type: Symbol}
+                          )
+                        end
                         def to_hash
                         end
+
                       end
 
                       class InputImage < OpenAI::Internal::Type::BaseModel
-                        OrHash =
-                          T.type_alias do
-                            T.any(
-                              OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::Template::Template::EvalItem::Content::InputImage,
-                              OpenAI::Internal::AnyHash
-                            )
-                          end
+                        OrHash = T.type_alias do
+                          T.any(
+                            OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::Template::Template::EvalItem::Content::InputImage,
+                            OpenAI::Internal::AnyHash
+                          )
+                        end
 
                         # The URL of the image input.
                         sig { returns(String) }
@@ -931,40 +983,50 @@ module OpenAI
                         # An image input block used within EvalItem content arrays.
                         sig do
                           params(
+
                             image_url: String,
+
                             detail: String,
+
                             type: Symbol
-                          ).returns(T.attached_class)
+                          )
+                            .returns(T.attached_class)
                         end
                         def self.new(
+
                           # The URL of the image input.
                           image_url:,
+
                           # The detail level of the image to be sent to the model. One of `high`, `low`, or
                           # `auto`. Defaults to `auto`.
                           detail: nil,
+
                           # The type of the image input. Always `input_image`.
+
                           type: :input_image
                         )
                         end
 
                         sig do
                           override.returns(
-                            { image_url: String, type: Symbol, detail: String }
+                            {image_url: String, type: Symbol, detail: String}
                           )
                         end
                         def to_hash
                         end
+
                       end
 
-                      sig do
+                      sig {
                         override.returns(
                           T::Array[
                             OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::Template::Template::EvalItem::Content::Variants
                           ]
                         )
-                      end
+                      }
                       def self.variants
                       end
+
                     end
 
                     # The role of the message input. One of `user`, `assistant`, `system`, or
@@ -972,43 +1034,38 @@ module OpenAI
                     module Role
                       extend OpenAI::Internal::Type::Enum
 
-                      TaggedSymbol =
-                        T.type_alias do
-                          T.all(
-                            Symbol,
-                            OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::Template::Template::EvalItem::Role
-                          )
-                        end
+                      TaggedSymbol = T.type_alias {
+                        T.all(
+                          Symbol,
+                          OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::Template::Template::EvalItem::Role
+                        )
+                      }
                       OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-                      USER =
-                        T.let(
-                          :user,
-                          OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::Template::Template::EvalItem::Role::TaggedSymbol
-                        )
-                      ASSISTANT =
-                        T.let(
-                          :assistant,
-                          OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::Template::Template::EvalItem::Role::TaggedSymbol
-                        )
-                      SYSTEM =
-                        T.let(
-                          :system,
-                          OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::Template::Template::EvalItem::Role::TaggedSymbol
-                        )
-                      DEVELOPER =
-                        T.let(
-                          :developer,
-                          OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::Template::Template::EvalItem::Role::TaggedSymbol
-                        )
+                      USER = T.let(
+                        :user,
+                        OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::Template::Template::EvalItem::Role::TaggedSymbol
+                      )
+                      ASSISTANT = T.let(
+                        :assistant,
+                        OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::Template::Template::EvalItem::Role::TaggedSymbol
+                      )
+                      SYSTEM = T.let(
+                        :system,
+                        OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::Template::Template::EvalItem::Role::TaggedSymbol
+                      )
+                      DEVELOPER = T.let(
+                        :developer,
+                        OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::Template::Template::EvalItem::Role::TaggedSymbol
+                      )
 
-                      sig do
+                      sig {
                         override.returns(
                           T::Array[
                             OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::Template::Template::EvalItem::Role::TaggedSymbol
                           ]
                         )
-                      end
+                      }
                       def self.values
                       end
                     end
@@ -1017,53 +1074,51 @@ module OpenAI
                     module Type
                       extend OpenAI::Internal::Type::Enum
 
-                      TaggedSymbol =
-                        T.type_alias do
-                          T.all(
-                            Symbol,
-                            OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::Template::Template::EvalItem::Type
-                          )
-                        end
+                      TaggedSymbol = T.type_alias {
+                        T.all(
+                          Symbol,
+                          OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::Template::Template::EvalItem::Type
+                        )
+                      }
                       OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-                      MESSAGE =
-                        T.let(
-                          :message,
-                          OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::Template::Template::EvalItem::Type::TaggedSymbol
-                        )
+                      MESSAGE = T.let(
+                        :message,
+                        OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::Template::Template::EvalItem::Type::TaggedSymbol
+                      )
 
-                      sig do
+                      sig {
                         override.returns(
                           T::Array[
                             OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::Template::Template::EvalItem::Type::TaggedSymbol
                           ]
                         )
-                      end
+                      }
                       def self.values
                       end
                     end
                   end
 
-                  sig do
+                  sig {
                     override.returns(
                       T::Array[
                         OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::Template::Template::Variants
                       ]
                     )
-                  end
+                  }
                   def self.variants
                   end
+
                 end
               end
 
               class ItemReference < OpenAI::Internal::Type::BaseModel
-                OrHash =
-                  T.type_alias do
-                    T.any(
-                      OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::ItemReference,
-                      OpenAI::Internal::AnyHash
-                    )
-                  end
+                OrHash = T.type_alias do
+                  T.any(
+                    OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::ItemReference,
+                    OpenAI::Internal::AnyHash
+                  )
+                end
 
                 # A reference to a variable in the `item` namespace. Ie, "item.name"
                 sig { returns(String) }
@@ -1074,44 +1129,52 @@ module OpenAI
                 attr_accessor :type
 
                 sig do
-                  params(item_reference: String, type: Symbol).returns(
-                    T.attached_class
+                  params(
+
+                    item_reference: String,
+
+                    type: Symbol
                   )
+                    .returns(T.attached_class)
                 end
                 def self.new(
+
                   # A reference to a variable in the `item` namespace. Ie, "item.name"
                   item_reference:,
+
                   # The type of input messages. Always `item_reference`.
+
                   type: :item_reference
                 )
                 end
 
                 sig do
-                  override.returns({ item_reference: String, type: Symbol })
+                  override.returns(
+                    {item_reference: String, type: Symbol}
+                  )
                 end
                 def to_hash
                 end
+
               end
 
-              sig do
+              sig {
                 override.returns(
-                  T::Array[
-                    OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::Variants
-                  ]
+                  T::Array[OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::InputMessages::Variants]
                 )
-              end
+              }
               def self.variants
               end
+
             end
 
             class SamplingParams < OpenAI::Internal::Type::BaseModel
-              OrHash =
-                T.type_alias do
-                  T.any(
-                    OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::SamplingParams,
-                    OpenAI::Internal::AnyHash
-                  )
-                end
+              OrHash = T.type_alias do
+                T.any(
+                  OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::SamplingParams,
+                  OpenAI::Internal::AnyHash
+                )
+              end
 
               # The maximum number of tokens in the generated output.
               sig { returns(T.nilable(Integer)) }
@@ -1148,21 +1211,19 @@ module OpenAI
               #
               # - [Text inputs and outputs](https://platform.openai.com/docs/guides/text)
               # - [Structured Outputs](https://platform.openai.com/docs/guides/structured-outputs)
-              sig do
+              sig {
                 returns(
-                  T.nilable(
-                    OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::SamplingParams::Text
-                  )
+                  T.nilable(OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::SamplingParams::Text)
                 )
-              end
+              }
               attr_reader :text
 
-              sig do
+              sig {
                 params(
-                  text:
-                    OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::SamplingParams::Text::OrHash
-                ).void
-              end
+                  text: OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::SamplingParams::Text::OrHash
+                )
+                  .void
+              }
               attr_writer :text
 
               # An array of tools the model may call while generating a response. You can
@@ -1179,36 +1240,34 @@ module OpenAI
               # - **Function calls (custom tools)**: Functions that are defined by you, enabling
               #   the model to call your own code. Learn more about
               #   [function calling](https://platform.openai.com/docs/guides/function-calling).
-              sig do
-                returns(T.nilable(T::Array[OpenAI::Responses::Tool::Variants]))
-              end
+              sig { returns(T.nilable(T::Array[OpenAI::Responses::Tool::Variants])) }
               attr_reader :tools
 
-              sig do
+              sig {
                 params(
-                  tools:
-                    T::Array[
-                      T.any(
-                        OpenAI::Responses::FunctionTool::OrHash,
-                        OpenAI::Responses::FileSearchTool::OrHash,
-                        OpenAI::Responses::ComputerTool::OrHash,
-                        OpenAI::Responses::ComputerUsePreviewTool::OrHash,
-                        OpenAI::Responses::Tool::Mcp::OrHash,
-                        OpenAI::Responses::Tool::CodeInterpreter::OrHash,
-                        OpenAI::Responses::Tool::ProgrammaticToolCalling::OrHash,
-                        OpenAI::Responses::Tool::ImageGeneration::OrHash,
-                        OpenAI::Responses::Tool::LocalShell::OrHash,
-                        OpenAI::Responses::FunctionShellTool::OrHash,
-                        OpenAI::Responses::CustomTool::OrHash,
-                        OpenAI::Responses::NamespaceTool::OrHash,
-                        OpenAI::Responses::ToolSearchTool::OrHash,
-                        OpenAI::Responses::ApplyPatchTool::OrHash,
-                        OpenAI::Responses::WebSearchTool::OrHash,
-                        OpenAI::Responses::WebSearchPreviewTool::OrHash
-                      )
-                    ]
-                ).void
-              end
+                  tools: T::Array[
+                    T.any(
+                      OpenAI::Responses::FunctionTool::OrHash,
+                      OpenAI::Responses::FileSearchTool::OrHash,
+                      OpenAI::Responses::ComputerTool::OrHash,
+                      OpenAI::Responses::ComputerUsePreviewTool::OrHash,
+                      OpenAI::Responses::Tool::Mcp::OrHash,
+                      OpenAI::Responses::Tool::CodeInterpreter::OrHash,
+                      OpenAI::Responses::Tool::ProgrammaticToolCalling::OrHash,
+                      OpenAI::Responses::Tool::ImageGeneration::OrHash,
+                      OpenAI::Responses::Tool::LocalShell::OrHash,
+                      OpenAI::Responses::FunctionShellTool::OrHash,
+                      OpenAI::Responses::CustomTool::OrHash,
+                      OpenAI::Responses::NamespaceTool::OrHash,
+                      OpenAI::Responses::ToolSearchTool::OrHash,
+                      OpenAI::Responses::ApplyPatchTool::OrHash,
+                      OpenAI::Responses::WebSearchTool::OrHash,
+                      OpenAI::Responses::WebSearchPreviewTool::OrHash
+                    )
+                  ]
+                )
+                  .void
+              }
               attr_writer :tools
 
               # An alternative to temperature for nucleus sampling; 1.0 includes all tokens.
@@ -1220,40 +1279,47 @@ module OpenAI
 
               sig do
                 params(
+
                   max_completion_tokens: Integer,
-                  reasoning_effort:
-                    T.nilable(OpenAI::ReasoningEffort::OrSymbol),
+
+                  reasoning_effort: T.nilable(OpenAI::ReasoningEffort::OrSymbol),
+
                   seed: Integer,
+
                   temperature: Float,
-                  text:
-                    OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::SamplingParams::Text::OrHash,
-                  tools:
-                    T::Array[
-                      T.any(
-                        OpenAI::Responses::FunctionTool::OrHash,
-                        OpenAI::Responses::FileSearchTool::OrHash,
-                        OpenAI::Responses::ComputerTool::OrHash,
-                        OpenAI::Responses::ComputerUsePreviewTool::OrHash,
-                        OpenAI::Responses::Tool::Mcp::OrHash,
-                        OpenAI::Responses::Tool::CodeInterpreter::OrHash,
-                        OpenAI::Responses::Tool::ProgrammaticToolCalling::OrHash,
-                        OpenAI::Responses::Tool::ImageGeneration::OrHash,
-                        OpenAI::Responses::Tool::LocalShell::OrHash,
-                        OpenAI::Responses::FunctionShellTool::OrHash,
-                        OpenAI::Responses::CustomTool::OrHash,
-                        OpenAI::Responses::NamespaceTool::OrHash,
-                        OpenAI::Responses::ToolSearchTool::OrHash,
-                        OpenAI::Responses::ApplyPatchTool::OrHash,
-                        OpenAI::Responses::WebSearchTool::OrHash,
-                        OpenAI::Responses::WebSearchPreviewTool::OrHash
-                      )
-                    ],
+
+                  text: OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::SamplingParams::Text::OrHash,
+
+                  tools: T::Array[
+                    T.any(
+                      OpenAI::Responses::FunctionTool::OrHash,
+                      OpenAI::Responses::FileSearchTool::OrHash,
+                      OpenAI::Responses::ComputerTool::OrHash,
+                      OpenAI::Responses::ComputerUsePreviewTool::OrHash,
+                      OpenAI::Responses::Tool::Mcp::OrHash,
+                      OpenAI::Responses::Tool::CodeInterpreter::OrHash,
+                      OpenAI::Responses::Tool::ProgrammaticToolCalling::OrHash,
+                      OpenAI::Responses::Tool::ImageGeneration::OrHash,
+                      OpenAI::Responses::Tool::LocalShell::OrHash,
+                      OpenAI::Responses::FunctionShellTool::OrHash,
+                      OpenAI::Responses::CustomTool::OrHash,
+                      OpenAI::Responses::NamespaceTool::OrHash,
+                      OpenAI::Responses::ToolSearchTool::OrHash,
+                      OpenAI::Responses::ApplyPatchTool::OrHash,
+                      OpenAI::Responses::WebSearchTool::OrHash,
+                      OpenAI::Responses::WebSearchPreviewTool::OrHash
+                    )
+                  ],
+
                   top_p: Float
-                ).returns(T.attached_class)
+                )
+                  .returns(T.attached_class)
               end
               def self.new(
+
                 # The maximum number of tokens in the generated output.
                 max_completion_tokens: nil,
+
                 # Constrains effort on reasoning for reasoning models. Currently supported values
                 # are `none`, `minimal`, `low`, `medium`, `high`, `xhigh`, and `max`. Reducing
                 # reasoning effort can result in faster responses and fewer tokens used on
@@ -1261,16 +1327,20 @@ module OpenAI
                 # [reasoning guide](https://platform.openai.com/docs/guides/reasoning) for
                 # model-specific support.
                 reasoning_effort: nil,
+
                 # A seed value to initialize the randomness, during sampling.
                 seed: nil,
+
                 # A higher temperature increases randomness in the outputs.
                 temperature: nil,
+
                 # Configuration options for a text response from the model. Can be plain text or
                 # structured JSON data. Learn more:
                 #
                 # - [Text inputs and outputs](https://platform.openai.com/docs/guides/text)
                 # - [Structured Outputs](https://platform.openai.com/docs/guides/structured-outputs)
                 text: nil,
+
                 # An array of tools the model may call while generating a response. You can
                 # specify which tool to use by setting the `tool_choice` parameter.
                 #
@@ -1286,7 +1356,9 @@ module OpenAI
                 #   the model to call your own code. Learn more about
                 #   [function calling](https://platform.openai.com/docs/guides/function-calling).
                 tools: nil,
+
                 # An alternative to temperature for nucleus sampling; 1.0 includes all tokens.
+
                 top_p: nil
               )
               end
@@ -1295,12 +1367,10 @@ module OpenAI
                 override.returns(
                   {
                     max_completion_tokens: Integer,
-                    reasoning_effort:
-                      T.nilable(OpenAI::ReasoningEffort::TaggedSymbol),
+                    reasoning_effort: T.nilable(OpenAI::ReasoningEffort::TaggedSymbol),
                     seed: Integer,
                     temperature: Float,
-                    text:
-                      OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::SamplingParams::Text,
+                    text: OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::SamplingParams::Text,
                     tools: T::Array[OpenAI::Responses::Tool::Variants],
                     top_p: Float
                   }
@@ -1310,13 +1380,12 @@ module OpenAI
               end
 
               class Text < OpenAI::Internal::Type::BaseModel
-                OrHash =
-                  T.type_alias do
-                    T.any(
-                      OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::SamplingParams::Text,
-                      OpenAI::Internal::AnyHash
-                    )
-                  end
+                OrHash = T.type_alias do
+                  T.any(
+                    OpenAI::Models::Evals::RunCreateResponse::DataSource::Responses::SamplingParams::Text,
+                    OpenAI::Internal::AnyHash
+                  )
+                end
 
                 # An object specifying the format that the model must output.
                 #
@@ -1331,25 +1400,19 @@ module OpenAI
                 # Setting to `{ "type": "json_object" }` enables the older JSON mode, which
                 # ensures the message the model generates is valid JSON. Using `json_schema` is
                 # preferred for models that support it.
-                sig do
-                  returns(
-                    T.nilable(
-                      OpenAI::Responses::ResponseFormatTextConfig::Variants
-                    )
-                  )
-                end
+                sig { returns(T.nilable(OpenAI::Responses::ResponseFormatTextConfig::Variants)) }
                 attr_reader :format_
 
-                sig do
+                sig {
                   params(
-                    format_:
-                      T.any(
-                        OpenAI::ResponseFormatText::OrHash,
-                        OpenAI::Responses::ResponseFormatTextJSONSchemaConfig::OrHash,
-                        OpenAI::ResponseFormatJSONObject::OrHash
-                      )
-                  ).void
-                end
+                    format_: T.any(
+                      OpenAI::ResponseFormatText::OrHash,
+                      OpenAI::Responses::ResponseFormatTextJSONSchemaConfig::OrHash,
+                      OpenAI::ResponseFormatJSONObject::OrHash
+                    )
+                  )
+                    .void
+                }
                 attr_writer :format_
 
                 # Configuration options for a text response from the model. Can be plain text or
@@ -1359,15 +1422,17 @@ module OpenAI
                 # - [Structured Outputs](https://platform.openai.com/docs/guides/structured-outputs)
                 sig do
                   params(
-                    format_:
-                      T.any(
-                        OpenAI::ResponseFormatText::OrHash,
-                        OpenAI::Responses::ResponseFormatTextJSONSchemaConfig::OrHash,
-                        OpenAI::ResponseFormatJSONObject::OrHash
-                      )
-                  ).returns(T.attached_class)
+
+                    format_: T.any(
+                      OpenAI::ResponseFormatText::OrHash,
+                      OpenAI::Responses::ResponseFormatTextJSONSchemaConfig::OrHash,
+                      OpenAI::ResponseFormatJSONObject::OrHash
+                    )
+                  )
+                    .returns(T.attached_class)
                 end
                 def self.new(
+
                   # An object specifying the format that the model must output.
                   #
                   # Configuring `{ "type": "json_schema" }` enables Structured Outputs, which
@@ -1381,43 +1446,36 @@ module OpenAI
                   # Setting to `{ "type": "json_object" }` enables the older JSON mode, which
                   # ensures the message the model generates is valid JSON. Using `json_schema` is
                   # preferred for models that support it.
+
                   format_: nil
                 )
                 end
 
                 sig do
                   override.returns(
-                    {
-                      format_:
-                        OpenAI::Responses::ResponseFormatTextConfig::Variants
-                    }
+                    {format_: OpenAI::Responses::ResponseFormatTextConfig::Variants}
                   )
                 end
                 def to_hash
                 end
+
               end
             end
           end
 
-          sig do
-            override.returns(
-              T::Array[
-                OpenAI::Models::Evals::RunCreateResponse::DataSource::Variants
-              ]
-            )
-          end
+          sig { override.returns(T::Array[OpenAI::Models::Evals::RunCreateResponse::DataSource::Variants]) }
           def self.variants
           end
+
         end
 
         class PerModelUsage < OpenAI::Internal::Type::BaseModel
-          OrHash =
-            T.type_alias do
-              T.any(
-                OpenAI::Models::Evals::RunCreateResponse::PerModelUsage,
-                OpenAI::Internal::AnyHash
-              )
-            end
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Models::Evals::RunCreateResponse::PerModelUsage,
+              OpenAI::Internal::AnyHash
+            )
+          end
 
           # The number of tokens retrieved from cache.
           sig { returns(Integer) }
@@ -1445,26 +1503,40 @@ module OpenAI
 
           sig do
             params(
+
               cached_tokens: Integer,
+
               completion_tokens: Integer,
+
               invocation_count: Integer,
+
               model_name: String,
+
               prompt_tokens: Integer,
+
               total_tokens: Integer
-            ).returns(T.attached_class)
+            )
+              .returns(T.attached_class)
           end
           def self.new(
+
             # The number of tokens retrieved from cache.
             cached_tokens:,
+
             # The number of completion tokens generated.
             completion_tokens:,
+
             # The number of invocations.
             invocation_count:,
+
             # The name of the model.
             model_name:,
+
             # The number of prompt tokens used.
             prompt_tokens:,
+
             # The total number of tokens used.
+
             total_tokens:
           )
           end
@@ -1483,16 +1555,16 @@ module OpenAI
           end
           def to_hash
           end
+
         end
 
         class PerTestingCriteriaResult < OpenAI::Internal::Type::BaseModel
-          OrHash =
-            T.type_alias do
-              T.any(
-                OpenAI::Models::Evals::RunCreateResponse::PerTestingCriteriaResult,
-                OpenAI::Internal::AnyHash
-              )
-            end
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Models::Evals::RunCreateResponse::PerTestingCriteriaResult,
+              OpenAI::Internal::AnyHash
+            )
+          end
 
           # Number of tests failed for this criteria.
           sig { returns(Integer) }
@@ -1508,38 +1580,46 @@ module OpenAI
 
           sig do
             params(
+
               failed: Integer,
+
               passed: Integer,
+
               testing_criteria: String
-            ).returns(T.attached_class)
+            )
+              .returns(T.attached_class)
           end
           def self.new(
+
             # Number of tests failed for this criteria.
             failed:,
+
             # Number of tests passed for this criteria.
             passed:,
+
             # A description of the testing criteria.
+
             testing_criteria:
           )
           end
 
           sig do
             override.returns(
-              { failed: Integer, passed: Integer, testing_criteria: String }
+              {failed: Integer, passed: Integer, testing_criteria: String}
             )
           end
           def to_hash
           end
+
         end
 
         class ResultCounts < OpenAI::Internal::Type::BaseModel
-          OrHash =
-            T.type_alias do
-              T.any(
-                OpenAI::Models::Evals::RunCreateResponse::ResultCounts,
-                OpenAI::Internal::AnyHash
-              )
-            end
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Models::Evals::RunCreateResponse::ResultCounts,
+              OpenAI::Internal::AnyHash
+            )
+          end
 
           # Number of output items that resulted in an error.
           sig { returns(Integer) }
@@ -1560,38 +1640,47 @@ module OpenAI
           # Counters summarizing the outcomes of the evaluation run.
           sig do
             params(
+
               errored: Integer,
+
               failed: Integer,
+
               passed: Integer,
+
               total: Integer
-            ).returns(T.attached_class)
+            )
+              .returns(T.attached_class)
           end
           def self.new(
+
             # Number of output items that resulted in an error.
             errored:,
+
             # Number of output items that failed to pass the evaluation.
             failed:,
+
             # Number of output items that passed the evaluation.
             passed:,
+
             # Total number of executed output items.
+
             total:
           )
           end
 
           sig do
             override.returns(
-              {
-                errored: Integer,
-                failed: Integer,
-                passed: Integer,
-                total: Integer
-              }
+              {errored: Integer, failed: Integer, passed: Integer, total: Integer}
             )
           end
           def to_hash
           end
+
         end
+
       end
+
     end
+
   end
 end