openai 0.23.3 → 0.24.0

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

data/rbi/openai/models/graders/score_model_grader.rbi

@@ -35,10 +35,17 @@ module OpenAI
         attr_writer :range
 
         # The sampling parameters for the model.
-        sig { returns(T.nilable(T.anything)) }
+        sig do
+          returns(T.nilable(OpenAI::Graders::ScoreModelGrader::SamplingParams))
+        end
         attr_reader :sampling_params
 
-        sig { params(sampling_params: T.anything).void }
+        sig do
+          params(
+            sampling_params:
+              OpenAI::Graders::ScoreModelGrader::SamplingParams::OrHash
+          ).void
+        end
         attr_writer :sampling_params
 
         # A ScoreModelGrader object that uses a model to assign a score to the input.
@@ -48,7 +55,8 @@ module OpenAI
             model: String,
             name: String,
             range: T::Array[Float],
-            sampling_params: T.anything,
+            sampling_params:
+              OpenAI::Graders::ScoreModelGrader::SamplingParams::OrHash,
             type: Symbol
           ).returns(T.attached_class)
         end
@@ -76,7 +84,7 @@ module OpenAI
               name: String,
               type: Symbol,
               range: T::Array[Float],
-              sampling_params: T.anything
+              sampling_params: OpenAI::Graders::ScoreModelGrader::SamplingParams
             }
           )
         end
@@ -372,6 +380,82 @@ module OpenAI
             end
           end
         end
+
+        class SamplingParams < OpenAI::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                OpenAI::Graders::ScoreModelGrader::SamplingParams,
+                OpenAI::Internal::AnyHash
+              )
+            end
+
+          # The maximum number of tokens the grader model may generate in its response.
+          sig { returns(T.nilable(Integer)) }
+          attr_accessor :max_completions_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_accessor :seed
+
+          # A higher temperature increases randomness in the outputs.
+          sig { returns(T.nilable(Float)) }
+          attr_accessor :temperature
+
+          # An alternative to temperature for nucleus sampling; 1.0 includes all tokens.
+          sig { returns(T.nilable(Float)) }
+          attr_accessor :top_p
+
+          # The sampling parameters for the model.
+          sig do
+            params(
+              max_completions_tokens: T.nilable(Integer),
+              reasoning_effort: T.nilable(OpenAI::ReasoningEffort::OrSymbol),
+              seed: T.nilable(Integer),
+              temperature: T.nilable(Float),
+              top_p: T.nilable(Float)
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # The maximum number of tokens the grader model may generate in its response.
+            max_completions_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.
+            temperature: nil,
+            # An alternative to temperature for nucleus sampling; 1.0 includes all tokens.
+            top_p: nil
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                max_completions_tokens: T.nilable(Integer),
+                reasoning_effort: T.nilable(OpenAI::ReasoningEffort::OrSymbol),
+                seed: T.nilable(Integer),
+                temperature: T.nilable(Float),
+                top_p: T.nilable(Float)
+              }
+            )
+          end
+          def to_hash
+          end
+        end
       end
     end
   end

data/sig/openai/errors.rbs

@@ -21,6 +21,8 @@ module OpenAI
 
       attr_accessor status: Integer?
 
+      attr_accessor headers: ::Hash[String, String]?
+
       attr_accessor body: top?
 
       attr_accessor code: String?
@@ -32,6 +34,7 @@ module OpenAI
       def initialize: (
         url: URI::Generic,
         ?status: Integer?,
+        ?headers: ::Hash[String, String]?,
         ?body: Object?,
         ?request: nil,
         ?response: nil,
@@ -43,6 +46,7 @@ module OpenAI
       def initialize: (
         url: URI::Generic,
         ?status: nil,
+        ?headers: ::Hash[String, String]?,
         ?body: nil,
         ?request: nil,
         ?response: nil,
@@ -54,6 +58,7 @@ module OpenAI
       def initialize: (
         url: URI::Generic,
         ?status: nil,
+        ?headers: ::Hash[String, String]?,
         ?body: nil,
         ?request: nil,
         ?response: nil,
@@ -65,6 +70,7 @@ module OpenAI
       def self.for: (
         url: URI::Generic,
         status: Integer,
+        headers: ::Hash[String, String]?,
         body: Object?,
         request: nil,
         response: nil,
@@ -74,6 +80,7 @@ module OpenAI
       def initialize: (
         url: URI::Generic,
         status: Integer,
+        headers: ::Hash[String, String]?,
         body: Object?,
         request: nil,
         response: nil,

data/sig/openai/internal/type/base_stream.rbs

@@ -8,6 +8,10 @@ module OpenAI
           Enumerable[top] stream
         ) -> (^(Integer arg0) -> void)
 
+        attr_reader status: Integer
+
+        attr_reader headers: ::Hash[String, String]
+
         def close: -> void
 
         private def iterator: -> Enumerable[Elem]
@@ -22,6 +26,7 @@ module OpenAI
           model: Class | OpenAI::Internal::Type::Converter,
           url: URI::Generic,
           status: Integer,
+          headers: ::Hash[String, String],
           response: top,
           unwrap: Symbol
           | Integer

data/sig/openai/models/conversations/input_file_content.rbs

@@ -1,41 +1,7 @@
 module OpenAI
   module Models
     module Conversations
-      type input_file_content =
-        {
-          file_id: String?,
-          type: :input_file,
-          file_url: String,
-          filename: String
-        }
-
-      class InputFileContent < OpenAI::Internal::Type::BaseModel
-        attr_accessor file_id: String?
-
-        attr_accessor type: :input_file
-
-        attr_reader file_url: String?
-
-        def file_url=: (String) -> String
-
-        attr_reader filename: String?
-
-        def filename=: (String) -> String
-
-        def initialize: (
-          file_id: String?,
-          ?file_url: String,
-          ?filename: String,
-          ?type: :input_file
-        ) -> void
-
-        def to_hash: -> {
-          file_id: String?,
-          type: :input_file,
-          file_url: String,
-          filename: String
-        }
-      end
+      class InputFileContent = OpenAI::Models::Responses::ResponseInputFile
     end
   end
 end

data/sig/openai/models/conversations/input_image_content.rbs

@@ -1,49 +1,7 @@
 module OpenAI
   module Models
     module Conversations
-      type input_image_content =
-        {
-          detail: OpenAI::Models::Conversations::InputImageContent::detail,
-          file_id: String?,
-          image_url: String?,
-          type: :input_image
-        }
-
-      class InputImageContent < OpenAI::Internal::Type::BaseModel
-        attr_accessor detail: OpenAI::Models::Conversations::InputImageContent::detail
-
-        attr_accessor file_id: String?
-
-        attr_accessor image_url: String?
-
-        attr_accessor type: :input_image
-
-        def initialize: (
-          detail: OpenAI::Models::Conversations::InputImageContent::detail,
-          file_id: String?,
-          image_url: String?,
-          ?type: :input_image
-        ) -> void
-
-        def to_hash: -> {
-          detail: OpenAI::Models::Conversations::InputImageContent::detail,
-          file_id: String?,
-          image_url: String?,
-          type: :input_image
-        }
-
-        type detail = :low | :high | :auto
-
-        module Detail
-          extend OpenAI::Internal::Type::Enum
-
-          LOW: :low
-          HIGH: :high
-          AUTO: :auto
-
-          def self?.values: -> ::Array[OpenAI::Models::Conversations::InputImageContent::detail]
-        end
-      end
+      class InputImageContent = OpenAI::Models::Responses::ResponseInputImage
     end
   end
 end

data/sig/openai/models/conversations/input_text_content.rbs

@@ -1,17 +1,7 @@
 module OpenAI
   module Models
     module Conversations
-      type input_text_content = { text: String, type: :input_text }
-
-      class InputTextContent < OpenAI::Internal::Type::BaseModel
-        attr_accessor text: String
-
-        attr_accessor type: :input_text
-
-        def initialize: (text: String, ?type: :input_text) -> void
-
-        def to_hash: -> { text: String, type: :input_text }
-      end
+      class InputTextContent = OpenAI::Models::Responses::ResponseInputText
     end
   end
 end

data/sig/openai/models/conversations/message.rbs

@@ -38,14 +38,14 @@ module OpenAI
         }
 
         type content =
-          OpenAI::Conversations::InputTextContent
-          | OpenAI::Conversations::OutputTextContent
+          OpenAI::Responses::ResponseInputText
+          | OpenAI::Responses::ResponseOutputText
           | OpenAI::Conversations::TextContent
           | OpenAI::Conversations::SummaryTextContent
-          | OpenAI::Conversations::RefusalContent
-          | OpenAI::Conversations::InputImageContent
+          | OpenAI::Responses::ResponseOutputRefusal
+          | OpenAI::Responses::ResponseInputImage
           | OpenAI::Conversations::ComputerScreenshotContent
-          | OpenAI::Conversations::InputFileContent
+          | OpenAI::Responses::ResponseInputFile
 
         module Content
           extend OpenAI::Internal::Type::Union