openai 0.23.3 → 0.25.0

data/rbi/openai/models/conversations/refusal_content.rbi

@@ -3,36 +3,7 @@
 module OpenAI
   module Models
     module Conversations
-      class RefusalContent < OpenAI::Internal::Type::BaseModel
-        OrHash =
-          T.type_alias do
-            T.any(
-              OpenAI::Conversations::RefusalContent,
-              OpenAI::Internal::AnyHash
-            )
-          end
-
-        # The refusal explanation from the model.
-        sig { returns(String) }
-        attr_accessor :refusal
-
-        # The type of the refusal. Always `refusal`.
-        sig { returns(Symbol) }
-        attr_accessor :type
-
-        sig { params(refusal: String, type: Symbol).returns(T.attached_class) }
-        def self.new(
-          # The refusal explanation from the model.
-          refusal:,
-          # The type of the refusal. Always `refusal`.
-          type: :refusal
-        )
-        end
-
-        sig { override.returns({ refusal: String, type: Symbol }) }
-        def to_hash
-        end
-      end
+      RefusalContent = OpenAI::Models::Responses::ResponseOutputRefusal
     end
   end
 end

data/rbi/openai/models/conversations/summary_text_content.rbi

@@ -12,14 +12,22 @@ module OpenAI
             )
           end
 
+        # A summary of the reasoning output from the model so far.
         sig { returns(String) }
         attr_accessor :text
 
+        # The type of the object. Always `summary_text`.
         sig { returns(Symbol) }
         attr_accessor :type
 
+        # A summary text from the model.
         sig { params(text: String, type: Symbol).returns(T.attached_class) }
-        def self.new(text:, type: :summary_text)
+        def self.new(
+          # A summary of the reasoning output from the model so far.
+          text:,
+          # The type of the object. Always `summary_text`.
+          type: :summary_text
+        )
         end
 
         sig { override.returns({ text: String, type: Symbol }) }

data/rbi/openai/models/conversations/text_content.rbi

@@ -15,6 +15,7 @@ module OpenAI
         sig { returns(Symbol) }
         attr_accessor :type
 
+        # A text content.
         sig { params(text: String, type: Symbol).returns(T.attached_class) }
         def self.new(text:, type: :text)
         end

data/rbi/openai/models/evals/create_eval_completions_run_data_source.rbi

@@ -887,6 +887,14 @@ module OpenAI
           sig { params(max_completion_tokens: Integer).void }
           attr_writer :max_completion_tokens
 
+          # Constrains effort on reasoning for
+          # [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently
+          # supported values are `minimal`, `low`, `medium`, and `high`. Reducing reasoning
+          # effort can result in faster responses and fewer tokens used on reasoning in a
+          # response.
+          sig { returns(T.nilable(OpenAI::ReasoningEffort::OrSymbol)) }
+          attr_accessor :reasoning_effort
+
           # An object specifying the format that the model must output.
           #
           # Setting to `{ "type": "json_schema", "json_schema": {...} }` enables Structured
@@ -963,6 +971,7 @@ module OpenAI
           sig do
             params(
               max_completion_tokens: Integer,
+              reasoning_effort: T.nilable(OpenAI::ReasoningEffort::OrSymbol),
               response_format:
                 T.any(
                   OpenAI::ResponseFormatText::OrHash,
@@ -978,6 +987,12 @@ module OpenAI
           def self.new(
             # The maximum number of tokens in the generated output.
             max_completion_tokens: nil,
+            # Constrains effort on reasoning for
+            # [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently
+            # supported values are `minimal`, `low`, `medium`, and `high`. Reducing reasoning
+            # effort can result in faster responses and fewer tokens used on reasoning in a
+            # response.
+            reasoning_effort: nil,
             # An object specifying the format that the model must output.
             #
             # Setting to `{ "type": "json_schema", "json_schema": {...} }` enables Structured
@@ -1006,6 +1021,7 @@ module OpenAI
             override.returns(
               {
                 max_completion_tokens: Integer,
+                reasoning_effort: T.nilable(OpenAI::ReasoningEffort::OrSymbol),
                 response_format:
                   T.any(
                     OpenAI::ResponseFormatText,

data/rbi/openai/models/evals/run_cancel_response.rbi

@@ -1115,6 +1115,14 @@ module OpenAI
               sig { params(max_completion_tokens: Integer).void }
               attr_writer :max_completion_tokens
 
+              # Constrains effort on reasoning for
+              # [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently
+              # supported values are `minimal`, `low`, `medium`, and `high`. Reducing reasoning
+              # effort can result in faster responses and fewer tokens used on reasoning in a
+              # response.
+              sig { returns(T.nilable(OpenAI::ReasoningEffort::TaggedSymbol)) }
+              attr_accessor :reasoning_effort
+
               # A seed value to initialize the randomness, during sampling.
               sig { returns(T.nilable(Integer)) }
               attr_reader :seed
@@ -1201,6 +1209,8 @@ module OpenAI
               sig do
                 params(
                   max_completion_tokens: Integer,
+                  reasoning_effort:
+                    T.nilable(OpenAI::ReasoningEffort::OrSymbol),
                   seed: Integer,
                   temperature: Float,
                   text:
@@ -1226,6 +1236,12 @@ module OpenAI
               def self.new(
                 # The maximum number of tokens in the generated output.
                 max_completion_tokens: nil,
+                # Constrains effort on reasoning for
+                # [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently
+                # supported values are `minimal`, `low`, `medium`, and `high`. Reducing reasoning
+                # effort can result in faster responses and fewer tokens used on reasoning in a
+                # response.
+                reasoning_effort: nil,
                 # A seed value to initialize the randomness, during sampling.
                 seed: nil,
                 # A higher temperature increases randomness in the outputs.
@@ -1260,6 +1276,8 @@ module OpenAI
                 override.returns(
                   {
                     max_completion_tokens: Integer,
+                    reasoning_effort:
+                      T.nilable(OpenAI::ReasoningEffort::TaggedSymbol),
                     seed: Integer,
                     temperature: Float,
                     text:

data/rbi/openai/models/evals/run_create_params.rbi

@@ -1073,6 +1073,14 @@ module OpenAI
               sig { params(max_completion_tokens: Integer).void }
               attr_writer :max_completion_tokens
 
+              # Constrains effort on reasoning for
+              # [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently
+              # supported values are `minimal`, `low`, `medium`, and `high`. Reducing reasoning
+              # effort can result in faster responses and fewer tokens used on reasoning in a
+              # response.
+              sig { returns(T.nilable(OpenAI::ReasoningEffort::OrSymbol)) }
+              attr_accessor :reasoning_effort
+
               # A seed value to initialize the randomness, during sampling.
               sig { returns(T.nilable(Integer)) }
               attr_reader :seed
@@ -1176,6 +1184,8 @@ module OpenAI
               sig do
                 params(
                   max_completion_tokens: Integer,
+                  reasoning_effort:
+                    T.nilable(OpenAI::ReasoningEffort::OrSymbol),
                   seed: Integer,
                   temperature: Float,
                   text:
@@ -1201,6 +1211,12 @@ module OpenAI
               def self.new(
                 # The maximum number of tokens in the generated output.
                 max_completion_tokens: nil,
+                # Constrains effort on reasoning for
+                # [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently
+                # supported values are `minimal`, `low`, `medium`, and `high`. Reducing reasoning
+                # effort can result in faster responses and fewer tokens used on reasoning in a
+                # response.
+                reasoning_effort: nil,
                 # A seed value to initialize the randomness, during sampling.
                 seed: nil,
                 # A higher temperature increases randomness in the outputs.
@@ -1235,6 +1251,8 @@ module OpenAI
                 override.returns(
                   {
                     max_completion_tokens: Integer,
+                    reasoning_effort:
+                      T.nilable(OpenAI::ReasoningEffort::OrSymbol),
                     seed: Integer,
                     temperature: Float,
                     text:

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

@@ -1115,6 +1115,14 @@ module OpenAI
               sig { params(max_completion_tokens: Integer).void }
               attr_writer :max_completion_tokens
 
+              # Constrains effort on reasoning for
+              # [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently
+              # supported values are `minimal`, `low`, `medium`, and `high`. Reducing reasoning
+              # effort can result in faster responses and fewer tokens used on reasoning in a
+              # response.
+              sig { returns(T.nilable(OpenAI::ReasoningEffort::TaggedSymbol)) }
+              attr_accessor :reasoning_effort
+
               # A seed value to initialize the randomness, during sampling.
               sig { returns(T.nilable(Integer)) }
               attr_reader :seed
@@ -1201,6 +1209,8 @@ module OpenAI
               sig do
                 params(
                   max_completion_tokens: Integer,
+                  reasoning_effort:
+                    T.nilable(OpenAI::ReasoningEffort::OrSymbol),
                   seed: Integer,
                   temperature: Float,
                   text:
@@ -1226,6 +1236,12 @@ module OpenAI
               def self.new(
                 # The maximum number of tokens in the generated output.
                 max_completion_tokens: nil,
+                # Constrains effort on reasoning for
+                # [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently
+                # supported values are `minimal`, `low`, `medium`, and `high`. Reducing reasoning
+                # effort can result in faster responses and fewer tokens used on reasoning in a
+                # response.
+                reasoning_effort: nil,
                 # A seed value to initialize the randomness, during sampling.
                 seed: nil,
                 # A higher temperature increases randomness in the outputs.
@@ -1260,6 +1276,8 @@ module OpenAI
                 override.returns(
                   {
                     max_completion_tokens: Integer,
+                    reasoning_effort:
+                      T.nilable(OpenAI::ReasoningEffort::TaggedSymbol),
                     seed: Integer,
                     temperature: Float,
                     text:

data/rbi/openai/models/evals/run_list_response.rbi

@@ -1111,6 +1111,14 @@ module OpenAI
               sig { params(max_completion_tokens: Integer).void }
               attr_writer :max_completion_tokens
 
+              # Constrains effort on reasoning for
+              # [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently
+              # supported values are `minimal`, `low`, `medium`, and `high`. Reducing reasoning
+              # effort can result in faster responses and fewer tokens used on reasoning in a
+              # response.
+              sig { returns(T.nilable(OpenAI::ReasoningEffort::TaggedSymbol)) }
+              attr_accessor :reasoning_effort
+
               # A seed value to initialize the randomness, during sampling.
               sig { returns(T.nilable(Integer)) }
               attr_reader :seed
@@ -1197,6 +1205,8 @@ module OpenAI
               sig do
                 params(
                   max_completion_tokens: Integer,
+                  reasoning_effort:
+                    T.nilable(OpenAI::ReasoningEffort::OrSymbol),
                   seed: Integer,
                   temperature: Float,
                   text:
@@ -1222,6 +1232,12 @@ module OpenAI
               def self.new(
                 # The maximum number of tokens in the generated output.
                 max_completion_tokens: nil,
+                # Constrains effort on reasoning for
+                # [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently
+                # supported values are `minimal`, `low`, `medium`, and `high`. Reducing reasoning
+                # effort can result in faster responses and fewer tokens used on reasoning in a
+                # response.
+                reasoning_effort: nil,
                 # A seed value to initialize the randomness, during sampling.
                 seed: nil,
                 # A higher temperature increases randomness in the outputs.
@@ -1256,6 +1272,8 @@ module OpenAI
                 override.returns(
                   {
                     max_completion_tokens: Integer,
+                    reasoning_effort:
+                      T.nilable(OpenAI::ReasoningEffort::TaggedSymbol),
                     seed: Integer,
                     temperature: Float,
                     text:

data/rbi/openai/models/evals/run_retrieve_response.rbi

@@ -1117,6 +1117,14 @@ module OpenAI
               sig { params(max_completion_tokens: Integer).void }
               attr_writer :max_completion_tokens
 
+              # Constrains effort on reasoning for
+              # [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently
+              # supported values are `minimal`, `low`, `medium`, and `high`. Reducing reasoning
+              # effort can result in faster responses and fewer tokens used on reasoning in a
+              # response.
+              sig { returns(T.nilable(OpenAI::ReasoningEffort::TaggedSymbol)) }
+              attr_accessor :reasoning_effort
+
               # A seed value to initialize the randomness, during sampling.
               sig { returns(T.nilable(Integer)) }
               attr_reader :seed
@@ -1203,6 +1211,8 @@ module OpenAI
               sig do
                 params(
                   max_completion_tokens: Integer,
+                  reasoning_effort:
+                    T.nilable(OpenAI::ReasoningEffort::OrSymbol),
                   seed: Integer,
                   temperature: Float,
                   text:
@@ -1228,6 +1238,12 @@ module OpenAI
               def self.new(
                 # The maximum number of tokens in the generated output.
                 max_completion_tokens: nil,
+                # Constrains effort on reasoning for
+                # [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently
+                # supported values are `minimal`, `low`, `medium`, and `high`. Reducing reasoning
+                # effort can result in faster responses and fewer tokens used on reasoning in a
+                # response.
+                reasoning_effort: nil,
                 # A seed value to initialize the randomness, during sampling.
                 seed: nil,
                 # A higher temperature increases randomness in the outputs.
@@ -1262,6 +1278,8 @@ module OpenAI
                 override.returns(
                   {
                     max_completion_tokens: Integer,
+                    reasoning_effort:
+                      T.nilable(OpenAI::ReasoningEffort::TaggedSymbol),
                     seed: Integer,
                     temperature: Float,
                     text:

data/rbi/openai/models/evals/runs/output_item_list_response.rbi

@@ -37,8 +37,14 @@ module OpenAI
           sig { returns(Symbol) }
           attr_accessor :object
 
-          # A list of results from the evaluation run.
-          sig { returns(T::Array[T::Hash[Symbol, T.anything]]) }
+          # A list of grader results for this output item.
+          sig do
+            returns(
+              T::Array[
+                OpenAI::Models::Evals::Runs::OutputItemListResponse::Result
+              ]
+            )
+          end
           attr_accessor :results
 
           # The identifier of the evaluation run associated with this output item.
@@ -71,7 +77,10 @@ module OpenAI
               datasource_item: T::Hash[Symbol, T.anything],
               datasource_item_id: Integer,
               eval_id: String,
-              results: T::Array[T::Hash[Symbol, T.anything]],
+              results:
+                T::Array[
+                  OpenAI::Models::Evals::Runs::OutputItemListResponse::Result::OrHash
+                ],
               run_id: String,
               sample:
                 OpenAI::Models::Evals::Runs::OutputItemListResponse::Sample::OrHash,
@@ -90,7 +99,7 @@ module OpenAI
             datasource_item_id:,
             # The identifier of the evaluation group.
             eval_id:,
-            # A list of results from the evaluation run.
+            # A list of grader results for this output item.
             results:,
             # The identifier of the evaluation run associated with this output item.
             run_id:,
@@ -112,7 +121,10 @@ module OpenAI
                 datasource_item_id: Integer,
                 eval_id: String,
                 object: Symbol,
-                results: T::Array[T::Hash[Symbol, T.anything]],
+                results:
+                  T::Array[
+                    OpenAI::Models::Evals::Runs::OutputItemListResponse::Result
+                  ],
                 run_id: String,
                 sample:
                   OpenAI::Models::Evals::Runs::OutputItemListResponse::Sample,
@@ -123,6 +135,77 @@ module OpenAI
           def to_hash
           end
 
+          class Result < OpenAI::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  OpenAI::Models::Evals::Runs::OutputItemListResponse::Result,
+                  OpenAI::Internal::AnyHash
+                )
+              end
+
+            # The name of the grader.
+            sig { returns(String) }
+            attr_accessor :name
+
+            # Whether the grader considered the output a pass.
+            sig { returns(T::Boolean) }
+            attr_accessor :passed
+
+            # The numeric score produced by the grader.
+            sig { returns(Float) }
+            attr_accessor :score
+
+            # Optional sample or intermediate data produced by the grader.
+            sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
+            attr_accessor :sample
+
+            # The grader type (for example, "string-check-grader").
+            sig { returns(T.nilable(String)) }
+            attr_reader :type
+
+            sig { params(type: String).void }
+            attr_writer :type
+
+            # A single grader result for an evaluation run output item.
+            sig do
+              params(
+                name: String,
+                passed: T::Boolean,
+                score: Float,
+                sample: T.nilable(T::Hash[Symbol, T.anything]),
+                type: String
+              ).returns(T.attached_class)
+            end
+            def self.new(
+              # The name of the grader.
+              name:,
+              # Whether the grader considered the output a pass.
+              passed:,
+              # The numeric score produced by the grader.
+              score:,
+              # Optional sample or intermediate data produced by the grader.
+              sample: nil,
+              # The grader type (for example, "string-check-grader").
+              type: nil
+            )
+            end
+
+            sig do
+              override.returns(
+                {
+                  name: String,
+                  passed: T::Boolean,
+                  score: Float,
+                  sample: T.nilable(T::Hash[Symbol, T.anything]),
+                  type: String
+                }
+              )
+            end
+            def to_hash
+            end
+          end
+
           class Sample < OpenAI::Internal::Type::BaseModel
             OrHash =
               T.type_alias do

data/rbi/openai/models/evals/runs/output_item_retrieve_response.rbi

@@ -37,8 +37,14 @@ module OpenAI
           sig { returns(Symbol) }
           attr_accessor :object
 
-          # A list of results from the evaluation run.
-          sig { returns(T::Array[T::Hash[Symbol, T.anything]]) }
+          # A list of grader results for this output item.
+          sig do
+            returns(
+              T::Array[
+                OpenAI::Models::Evals::Runs::OutputItemRetrieveResponse::Result
+              ]
+            )
+          end
           attr_accessor :results
 
           # The identifier of the evaluation run associated with this output item.
@@ -73,7 +79,10 @@ module OpenAI
               datasource_item: T::Hash[Symbol, T.anything],
               datasource_item_id: Integer,
               eval_id: String,
-              results: T::Array[T::Hash[Symbol, T.anything]],
+              results:
+                T::Array[
+                  OpenAI::Models::Evals::Runs::OutputItemRetrieveResponse::Result::OrHash
+                ],
               run_id: String,
               sample:
                 OpenAI::Models::Evals::Runs::OutputItemRetrieveResponse::Sample::OrHash,
@@ -92,7 +101,7 @@ module OpenAI
             datasource_item_id:,
             # The identifier of the evaluation group.
             eval_id:,
-            # A list of results from the evaluation run.
+            # A list of grader results for this output item.
             results:,
             # The identifier of the evaluation run associated with this output item.
             run_id:,
@@ -114,7 +123,10 @@ module OpenAI
                 datasource_item_id: Integer,
                 eval_id: String,
                 object: Symbol,
-                results: T::Array[T::Hash[Symbol, T.anything]],
+                results:
+                  T::Array[
+                    OpenAI::Models::Evals::Runs::OutputItemRetrieveResponse::Result
+                  ],
                 run_id: String,
                 sample:
                   OpenAI::Models::Evals::Runs::OutputItemRetrieveResponse::Sample,
@@ -125,6 +137,77 @@ module OpenAI
           def to_hash
           end
 
+          class Result < OpenAI::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  OpenAI::Models::Evals::Runs::OutputItemRetrieveResponse::Result,
+                  OpenAI::Internal::AnyHash
+                )
+              end
+
+            # The name of the grader.
+            sig { returns(String) }
+            attr_accessor :name
+
+            # Whether the grader considered the output a pass.
+            sig { returns(T::Boolean) }
+            attr_accessor :passed
+
+            # The numeric score produced by the grader.
+            sig { returns(Float) }
+            attr_accessor :score
+
+            # Optional sample or intermediate data produced by the grader.
+            sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
+            attr_accessor :sample
+
+            # The grader type (for example, "string-check-grader").
+            sig { returns(T.nilable(String)) }
+            attr_reader :type
+
+            sig { params(type: String).void }
+            attr_writer :type
+
+            # A single grader result for an evaluation run output item.
+            sig do
+              params(
+                name: String,
+                passed: T::Boolean,
+                score: Float,
+                sample: T.nilable(T::Hash[Symbol, T.anything]),
+                type: String
+              ).returns(T.attached_class)
+            end
+            def self.new(
+              # The name of the grader.
+              name:,
+              # Whether the grader considered the output a pass.
+              passed:,
+              # The numeric score produced by the grader.
+              score:,
+              # Optional sample or intermediate data produced by the grader.
+              sample: nil,
+              # The grader type (for example, "string-check-grader").
+              type: nil
+            )
+            end
+
+            sig do
+              override.returns(
+                {
+                  name: String,
+                  passed: T::Boolean,
+                  score: Float,
+                  sample: T.nilable(T::Hash[Symbol, T.anything]),
+                  type: String
+                }
+              )
+            end
+            def to_hash
+            end
+          end
+
           class Sample < OpenAI::Internal::Type::BaseModel
             OrHash =
               T.type_alias do