openai 0.23.3 → 0.24.0

data/rbi/openai/internal/type/base_stream.rbi

@@ -27,6 +27,12 @@ module OpenAI
           end
         end
 
+        sig { returns(Integer) }
+        attr_reader :status
+
+        sig { returns(T::Hash[String, String]) }
+        attr_reader :headers
+
         sig { void }
         def close
         end
@@ -51,6 +57,7 @@ module OpenAI
               T.any(T::Class[T.anything], OpenAI::Internal::Type::Converter),
             url: URI::Generic,
             status: Integer,
+            headers: T::Hash[String, String],
             response: Net::HTTPResponse,
             unwrap:
               T.any(
@@ -62,7 +69,15 @@ module OpenAI
             stream: T::Enumerable[Message]
           ).void
         end
-        def initialize(model:, url:, status:, response:, unwrap:, stream:)
+        def initialize(
+          model:,
+          url:,
+          status:,
+          headers:,
+          response:,
+          unwrap:,
+          stream:
+        )
         end
 
         # @api private

data/rbi/openai/internal/util.rbi

@@ -361,7 +361,7 @@ module OpenAI
         # Assumes each chunk in stream has `Encoding::BINARY`.
         sig do
           params(
-            headers: T.any(T::Hash[String, String], Net::HTTPHeader),
+            headers: T::Hash[String, String],
             stream: T::Enumerable[String],
             suppress_error: T::Boolean
           ).returns(T.anything)

data/rbi/openai/models/conversations/computer_screenshot_content.rbi

@@ -25,6 +25,7 @@ module OpenAI
         sig { returns(Symbol) }
         attr_accessor :type
 
+        # A screenshot of a computer.
         sig do
           params(
             file_id: T.nilable(String),

data/rbi/openai/models/conversations/input_file_content.rbi

@@ -3,70 +3,7 @@
 module OpenAI
   module Models
     module Conversations
-      class InputFileContent < OpenAI::Internal::Type::BaseModel
-        OrHash =
-          T.type_alias do
-            T.any(
-              OpenAI::Conversations::InputFileContent,
-              OpenAI::Internal::AnyHash
-            )
-          end
-
-        # The ID of the file to be sent to the model.
-        sig { returns(T.nilable(String)) }
-        attr_accessor :file_id
-
-        # The type of the input item. Always `input_file`.
-        sig { returns(Symbol) }
-        attr_accessor :type
-
-        # The URL of the file to be sent to the model.
-        sig { returns(T.nilable(String)) }
-        attr_reader :file_url
-
-        sig { params(file_url: String).void }
-        attr_writer :file_url
-
-        # The name of the file to be sent to the model.
-        sig { returns(T.nilable(String)) }
-        attr_reader :filename
-
-        sig { params(filename: String).void }
-        attr_writer :filename
-
-        sig do
-          params(
-            file_id: T.nilable(String),
-            file_url: String,
-            filename: String,
-            type: Symbol
-          ).returns(T.attached_class)
-        end
-        def self.new(
-          # The ID of the file to be sent to the model.
-          file_id:,
-          # The URL of the file to be sent to the model.
-          file_url: nil,
-          # The name of the file to be sent to the model.
-          filename: nil,
-          # The type of the input item. Always `input_file`.
-          type: :input_file
-        )
-        end
-
-        sig do
-          override.returns(
-            {
-              file_id: T.nilable(String),
-              type: Symbol,
-              file_url: String,
-              filename: String
-            }
-          )
-        end
-        def to_hash
-        end
-      end
+      InputFileContent = OpenAI::Models::Responses::ResponseInputFile
     end
   end
 end

data/rbi/openai/models/conversations/input_image_content.rbi

@@ -3,111 +3,7 @@
 module OpenAI
   module Models
     module Conversations
-      class InputImageContent < OpenAI::Internal::Type::BaseModel
-        OrHash =
-          T.type_alias do
-            T.any(
-              OpenAI::Conversations::InputImageContent,
-              OpenAI::Internal::AnyHash
-            )
-          end
-
-        # The detail level of the image to be sent to the model. One of `high`, `low`, or
-        # `auto`. Defaults to `auto`.
-        sig do
-          returns(
-            OpenAI::Conversations::InputImageContent::Detail::TaggedSymbol
-          )
-        end
-        attr_accessor :detail
-
-        # The ID of the file to be sent to the model.
-        sig { returns(T.nilable(String)) }
-        attr_accessor :file_id
-
-        # The URL of the image to be sent to the model. A fully qualified URL or base64
-        # encoded image in a data URL.
-        sig { returns(T.nilable(String)) }
-        attr_accessor :image_url
-
-        # The type of the input item. Always `input_image`.
-        sig { returns(Symbol) }
-        attr_accessor :type
-
-        sig do
-          params(
-            detail: OpenAI::Conversations::InputImageContent::Detail::OrSymbol,
-            file_id: T.nilable(String),
-            image_url: T.nilable(String),
-            type: Symbol
-          ).returns(T.attached_class)
-        end
-        def self.new(
-          # The detail level of the image to be sent to the model. One of `high`, `low`, or
-          # `auto`. Defaults to `auto`.
-          detail:,
-          # The ID of the file to be sent to the model.
-          file_id:,
-          # The URL of the image to be sent to the model. A fully qualified URL or base64
-          # encoded image in a data URL.
-          image_url:,
-          # The type of the input item. Always `input_image`.
-          type: :input_image
-        )
-        end
-
-        sig do
-          override.returns(
-            {
-              detail:
-                OpenAI::Conversations::InputImageContent::Detail::TaggedSymbol,
-              file_id: T.nilable(String),
-              image_url: T.nilable(String),
-              type: Symbol
-            }
-          )
-        end
-        def to_hash
-        end
-
-        # The detail level of the image to be sent to the model. One of `high`, `low`, or
-        # `auto`. Defaults to `auto`.
-        module Detail
-          extend OpenAI::Internal::Type::Enum
-
-          TaggedSymbol =
-            T.type_alias do
-              T.all(Symbol, OpenAI::Conversations::InputImageContent::Detail)
-            end
-          OrSymbol = T.type_alias { T.any(Symbol, String) }
-
-          LOW =
-            T.let(
-              :low,
-              OpenAI::Conversations::InputImageContent::Detail::TaggedSymbol
-            )
-          HIGH =
-            T.let(
-              :high,
-              OpenAI::Conversations::InputImageContent::Detail::TaggedSymbol
-            )
-          AUTO =
-            T.let(
-              :auto,
-              OpenAI::Conversations::InputImageContent::Detail::TaggedSymbol
-            )
-
-          sig do
-            override.returns(
-              T::Array[
-                OpenAI::Conversations::InputImageContent::Detail::TaggedSymbol
-              ]
-            )
-          end
-          def self.values
-          end
-        end
-      end
+      InputImageContent = OpenAI::Models::Responses::ResponseInputImage
     end
   end
 end

data/rbi/openai/models/conversations/input_text_content.rbi

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

data/rbi/openai/models/conversations/message.rbi

@@ -33,20 +33,21 @@ module OpenAI
         sig { returns(Symbol) }
         attr_accessor :type
 
+        # A message to or from the model.
         sig do
           params(
             id: String,
             content:
               T::Array[
                 T.any(
-                  OpenAI::Conversations::InputTextContent::OrHash,
-                  OpenAI::Conversations::OutputTextContent::OrHash,
+                  OpenAI::Responses::ResponseInputText::OrHash,
+                  OpenAI::Responses::ResponseOutputText::OrHash,
                   OpenAI::Conversations::TextContent::OrHash,
                   OpenAI::Conversations::SummaryTextContent::OrHash,
-                  OpenAI::Conversations::RefusalContent::OrHash,
-                  OpenAI::Conversations::InputImageContent::OrHash,
+                  OpenAI::Responses::ResponseOutputRefusal::OrHash,
+                  OpenAI::Responses::ResponseInputImage::OrHash,
                   OpenAI::Conversations::ComputerScreenshotContent::OrHash,
-                  OpenAI::Conversations::InputFileContent::OrHash
+                  OpenAI::Responses::ResponseInputFile::OrHash
                 )
               ],
             role: OpenAI::Conversations::Message::Role::OrSymbol,
@@ -85,20 +86,21 @@ module OpenAI
         def to_hash
         end
 
+        # A text input to the model.
         module Content
           extend OpenAI::Internal::Type::Union
 
           Variants =
             T.type_alias do
               T.any(
-                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
               )
             end
 

data/rbi/openai/models/conversations/output_text_content.rbi

@@ -3,108 +3,7 @@
 module OpenAI
   module Models
     module Conversations
-      class OutputTextContent < OpenAI::Internal::Type::BaseModel
-        OrHash =
-          T.type_alias do
-            T.any(
-              OpenAI::Conversations::OutputTextContent,
-              OpenAI::Internal::AnyHash
-            )
-          end
-
-        # The annotations of the text output.
-        sig do
-          returns(
-            T::Array[
-              OpenAI::Conversations::OutputTextContent::Annotation::Variants
-            ]
-          )
-        end
-        attr_accessor :annotations
-
-        # The text output from the model.
-        sig { returns(String) }
-        attr_accessor :text
-
-        # The type of the output text. Always `output_text`.
-        sig { returns(Symbol) }
-        attr_accessor :type
-
-        sig { returns(T.nilable(T::Array[OpenAI::Conversations::LobProb])) }
-        attr_reader :logprobs
-
-        sig do
-          params(
-            logprobs: T::Array[OpenAI::Conversations::LobProb::OrHash]
-          ).void
-        end
-        attr_writer :logprobs
-
-        sig do
-          params(
-            annotations:
-              T::Array[
-                T.any(
-                  OpenAI::Conversations::FileCitationBody::OrHash,
-                  OpenAI::Conversations::URLCitationBody::OrHash,
-                  OpenAI::Conversations::ContainerFileCitationBody::OrHash
-                )
-              ],
-            text: String,
-            logprobs: T::Array[OpenAI::Conversations::LobProb::OrHash],
-            type: Symbol
-          ).returns(T.attached_class)
-        end
-        def self.new(
-          # The annotations of the text output.
-          annotations:,
-          # The text output from the model.
-          text:,
-          logprobs: nil,
-          # The type of the output text. Always `output_text`.
-          type: :output_text
-        )
-        end
-
-        sig do
-          override.returns(
-            {
-              annotations:
-                T::Array[
-                  OpenAI::Conversations::OutputTextContent::Annotation::Variants
-                ],
-              text: String,
-              type: Symbol,
-              logprobs: T::Array[OpenAI::Conversations::LobProb]
-            }
-          )
-        end
-        def to_hash
-        end
-
-        module Annotation
-          extend OpenAI::Internal::Type::Union
-
-          Variants =
-            T.type_alias do
-              T.any(
-                OpenAI::Conversations::FileCitationBody,
-                OpenAI::Conversations::URLCitationBody,
-                OpenAI::Conversations::ContainerFileCitationBody
-              )
-            end
-
-          sig do
-            override.returns(
-              T::Array[
-                OpenAI::Conversations::OutputTextContent::Annotation::Variants
-              ]
-            )
-          end
-          def self.variants
-          end
-        end
-      end
+      OutputTextContent = OpenAI::Models::Responses::ResponseOutputText
     end
   end
 end

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

@@ -18,6 +18,7 @@ module OpenAI
         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)
         end

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: