openai 0.83.0 → 0.85.0

data/rbi/openai/models/error_object.rbi

@@ -24,6 +24,12 @@ module OpenAI
       sig { returns(String) }
       attr_accessor :type
 
+      sig { returns(T.nilable(OpenAI::ErrorObject::Misalignment)) }
+      attr_reader :misalignment
+
+      sig { params(misalignment: OpenAI::ErrorObject::Misalignment::OrHash).void }
+      attr_writer :misalignment
+
       sig do
         params(
 
@@ -33,7 +39,9 @@ module OpenAI
 
           param: T.nilable(String),
 
-          type: String
+          type: String,
+
+          misalignment: OpenAI::ErrorObject::Misalignment::OrHash
         )
           .returns(T.attached_class)
       end
@@ -45,18 +53,163 @@ module OpenAI
 
         param:,
 
-        type:
+        type:,
+
+        misalignment: nil
       )
       end
 
       sig do
         override.returns(
-          {code: T.nilable(String), message: String, param: T.nilable(String), type: String}
+          {
+            code: T.nilable(String),
+            message: String,
+            param: T.nilable(String),
+            type: String,
+            misalignment: OpenAI::ErrorObject::Misalignment
+          }
         )
       end
       def to_hash
       end
 
+      class Misalignment < OpenAI::Internal::Type::BaseModel
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::ErrorObject::Misalignment,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # The public explanation for this block.
+        sig { returns(T.nilable(String)) }
+        attr_reader :detailed_explanation
+
+        sig { params(detailed_explanation: String).void }
+        attr_writer :detailed_explanation
+
+        # An optional classification; clients must accept additional values.
+        sig { returns(T.nilable(T.any(String, OpenAI::ErrorObject::Misalignment::ErrorType::OrSymbol))) }
+        attr_reader :error_type
+
+        sig { params(error_type: T.any(String, OpenAI::ErrorObject::Misalignment::ErrorType::OrSymbol)).void }
+        attr_writer :error_type
+
+        # An optional public continuation instruction.
+        sig { returns(T.nilable(OpenAI::ErrorObject::Misalignment::Steer)) }
+        attr_reader :steer
+
+        sig { params(steer: OpenAI::ErrorObject::Misalignment::Steer::OrHash).void }
+        attr_writer :steer
+
+        sig do
+          params(
+
+            detailed_explanation: String,
+
+            error_type: T.any(String, OpenAI::ErrorObject::Misalignment::ErrorType::OrSymbol),
+
+            steer: OpenAI::ErrorObject::Misalignment::Steer::OrHash
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # The public explanation for this block.
+          detailed_explanation: nil,
+
+          # An optional classification; clients must accept additional values.
+          error_type: nil,
+
+          # An optional public continuation instruction.
+
+          steer: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              detailed_explanation: String,
+              error_type: T.any(String, OpenAI::ErrorObject::Misalignment::ErrorType::OrSymbol),
+              steer: OpenAI::ErrorObject::Misalignment::Steer
+            }
+          )
+        end
+        def to_hash
+        end
+
+        # An optional classification; clients must accept additional values.
+        module ErrorType
+          extend OpenAI::Internal::Type::Union
+
+          Variants = T.type_alias { T.any(String, OpenAI::ErrorObject::Misalignment::ErrorType::TaggedSymbol) }
+
+          sig { override.returns(T::Array[OpenAI::ErrorObject::Misalignment::ErrorType::Variants]) }
+          def self.variants
+          end
+
+          TaggedSymbol = T.type_alias do
+            T.all(Symbol, OpenAI::ErrorObject::Misalignment::ErrorType)
+          end
+
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          POTENTIALLY_UNINTENDED_DATA_TRANSFER = T.let(
+            :potentially_unintended_data_transfer,
+            OpenAI::ErrorObject::Misalignment::ErrorType::TaggedSymbol
+          )
+          POTENTIALLY_UNINTENDED_DATA_ACCESS = T.let(
+            :potentially_unintended_data_access,
+            OpenAI::ErrorObject::Misalignment::ErrorType::TaggedSymbol
+          )
+          POTENTIALLY_UNINTENDED_DESTRUCTIVE_ACTIVITY = T.let(
+            :potentially_unintended_destructive_activity,
+            OpenAI::ErrorObject::Misalignment::ErrorType::TaggedSymbol
+          )
+          OTHER = T.let(:other, OpenAI::ErrorObject::Misalignment::ErrorType::TaggedSymbol)
+
+        end
+
+        class Steer < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::ErrorObject::Misalignment::Steer,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          # The public continuation instruction.
+          sig { returns(String) }
+          attr_accessor :message
+
+          # An optional public continuation instruction.
+          sig do
+            params(
+
+              message: String
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            # The public continuation instruction.
+
+            message:
+          )
+          end
+
+          sig do
+            override.returns(
+              {message: String}
+            )
+          end
+          def to_hash
+          end
+
+        end
+      end
+
     end
 
   end

data/rbi/openai/models/eval_create_response.rbi

@@ -50,7 +50,7 @@ module OpenAI
       #
       # - Improve the quality of my chatbot
       # - See how well my chatbot handles customer support
-      # - Check if o4-mini is better at my usecase than gpt-4o
+      # - Check if o4-mini is better at my usecase than gpt-6-astra
       sig do
         params(
 

data/rbi/openai/models/eval_list_response.rbi

@@ -50,7 +50,7 @@ module OpenAI
       #
       # - Improve the quality of my chatbot
       # - See how well my chatbot handles customer support
-      # - Check if o4-mini is better at my usecase than gpt-4o
+      # - Check if o4-mini is better at my usecase than gpt-6-astra
       sig do
         params(
 

data/rbi/openai/models/eval_retrieve_response.rbi

@@ -50,7 +50,7 @@ module OpenAI
       #
       # - Improve the quality of my chatbot
       # - See how well my chatbot handles customer support
-      # - Check if o4-mini is better at my usecase than gpt-4o
+      # - Check if o4-mini is better at my usecase than gpt-6-astra
       sig do
         params(
 

data/rbi/openai/models/eval_update_response.rbi

@@ -50,7 +50,7 @@ module OpenAI
       #
       # - Improve the quality of my chatbot
       # - See how well my chatbot handles customer support
-      # - Check if o4-mini is better at my usecase than gpt-4o
+      # - Check if o4-mini is better at my usecase than gpt-6-astra
       sig do
         params(
 

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

@@ -320,7 +320,7 @@ module OpenAI
             sig { returns(T.nilable(T::Hash[Symbol, String])) }
             attr_accessor :metadata
 
-            # An optional model to filter by (e.g., 'gpt-4o').
+            # An optional model to filter by (e.g., 'gpt-6-astra').
             sig { returns(T.nilable(String)) }
             attr_accessor :model
 
@@ -361,7 +361,7 @@ module OpenAI
               # a maximum length of 512 characters.
               metadata: nil,
 
-              # An optional model to filter by (e.g., 'gpt-4o').
+              # An optional model to filter by (e.g., 'gpt-6-astra').
               model: nil,
 
               # The type of source. Always `stored_completions`.

data/rbi/openai/models/reasoning.rbi

@@ -56,8 +56,6 @@ module OpenAI
       sig { returns(T.nilable(OpenAI::Reasoning::Summary::OrSymbol)) }
       attr_accessor :summary
 
-      # **gpt-5 and o-series models only**
-      #
       # Configuration options for
       # [reasoning models](https://platform.openai.com/docs/guides/reasoning).
       sig do

data/rbi/openai/models/responses/custom_tool.rbi

@@ -26,6 +26,14 @@ module OpenAI
         sig { returns(T.nilable(T::Array[OpenAI::Responses::CustomTool::AllowedCaller::OrSymbol])) }
         attr_accessor :allowed_callers
 
+        # Whether the tool response can be returned asynchronously versus immediately
+        # returned on next response creation.
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :async
+
+        sig { params(async: T::Boolean).void }
+        attr_writer :async
+
         # Whether this tool should be deferred and discovered via tool search.
         sig { returns(T.nilable(T::Boolean)) }
         attr_reader :defer_loading
@@ -61,6 +69,8 @@ module OpenAI
 
             allowed_callers: T.nilable(T::Array[OpenAI::Responses::CustomTool::AllowedCaller::OrSymbol]),
 
+            async: T::Boolean,
+
             defer_loading: T::Boolean,
 
             description: String,
@@ -79,6 +89,10 @@ module OpenAI
           # The tool invocation context(s).
           allowed_callers: nil,
 
+          # Whether the tool response can be returned asynchronously versus immediately
+          # returned on next response creation.
+          async: nil,
+
           # Whether this tool should be deferred and discovered via tool search.
           defer_loading: nil,
 
@@ -100,6 +114,7 @@ module OpenAI
               name: String,
               type: Symbol,
               allowed_callers: T.nilable(T::Array[OpenAI::Responses::CustomTool::AllowedCaller::OrSymbol]),
+              async: T::Boolean,
               defer_loading: T::Boolean,
               description: String,
               format_: T.any(OpenAI::CustomToolInputFormat::Text, OpenAI::CustomToolInputFormat::Grammar)

data/rbi/openai/models/responses/function_tool.rbi

@@ -34,6 +34,12 @@ module OpenAI
         sig { returns(T.nilable(T::Array[OpenAI::Responses::FunctionTool::AllowedCaller::OrSymbol])) }
         attr_accessor :allowed_callers
 
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :async
+
+        sig { params(async: T::Boolean).void }
+        attr_writer :async
+
         # Whether this function is deferred and loaded via tool search.
         sig { returns(T.nilable(T::Boolean)) }
         attr_reader :defer_loading
@@ -65,6 +71,8 @@ module OpenAI
 
             allowed_callers: T.nilable(T::Array[OpenAI::Responses::FunctionTool::AllowedCaller::OrSymbol]),
 
+            async: T::Boolean,
+
             defer_loading: T::Boolean,
 
             description: T.nilable(String),
@@ -89,6 +97,8 @@ module OpenAI
           # The tool invocation context(s).
           allowed_callers: nil,
 
+          async: nil,
+
           # Whether this function is deferred and loaded via tool search.
           defer_loading: nil,
 
@@ -114,6 +124,7 @@ module OpenAI
               strict: T.nilable(T::Boolean),
               type: Symbol,
               allowed_callers: T.nilable(T::Array[OpenAI::Responses::FunctionTool::AllowedCaller::OrSymbol]),
+              async: T::Boolean,
               defer_loading: T::Boolean,
               description: T.nilable(String),
               output_schema: T.nilable(T::Hash[Symbol, T.anything])

data/rbi/openai/models/responses/namespace_tool.rbi

@@ -106,6 +106,14 @@ module OpenAI
             }
             attr_accessor :allowed_callers
 
+            # Whether the tool response can be returned asynchronously versus immediately
+            # returned on next response creation.
+            sig { returns(T.nilable(T::Boolean)) }
+            attr_reader :async
+
+            sig { params(async: T::Boolean).void }
+            attr_writer :async
+
             # Whether this function should be deferred and discovered via tool search.
             sig { returns(T.nilable(T::Boolean)) }
             attr_reader :defer_loading
@@ -139,6 +147,8 @@ module OpenAI
                   T::Array[OpenAI::Responses::NamespaceTool::Tool::Function::AllowedCaller::OrSymbol]
                 ),
 
+                async: T::Boolean,
+
                 defer_loading: T::Boolean,
 
                 description: T.nilable(String),
@@ -160,6 +170,10 @@ module OpenAI
               # The tool invocation context(s).
               allowed_callers: nil,
 
+              # Whether the tool response can be returned asynchronously versus immediately
+              # returned on next response creation.
+              async: nil,
+
               # Whether this function should be deferred and discovered via tool search.
               defer_loading: nil,
 
@@ -188,6 +202,7 @@ module OpenAI
                   allowed_callers: T.nilable(
                     T::Array[OpenAI::Responses::NamespaceTool::Tool::Function::AllowedCaller::OrSymbol]
                   ),
+                  async: T::Boolean,
                   defer_loading: T::Boolean,
                   description: T.nilable(String),
                   output_schema: T.nilable(T::Hash[Symbol, T.anything]),

data/rbi/openai/models/responses/response.rbi

@@ -53,9 +53,9 @@ module OpenAI
         sig { returns(T.nilable(T::Hash[Symbol, String])) }
         attr_accessor :metadata
 
-        # Model ID used to generate the response, like `gpt-4o` or `o3`. OpenAI offers a
-        # wide range of models with different capabilities, performance characteristics,
-        # and price points. Refer to the
+        # Model ID used to generate the response, like `gpt-6-astra`. OpenAI offers a wide
+        # range of models with different capabilities, performance characteristics, and
+        # price points. Refer to the
         # [model guide](https://platform.openai.com/docs/models) to browse and compare
         # available models.
         sig { returns(OpenAI::ResponsesModel::Variants) }
@@ -215,8 +215,6 @@ module OpenAI
         sig { returns(T.nilable(OpenAI::Responses::Response::PromptCacheRetention::TaggedSymbol)) }
         attr_accessor :prompt_cache_retention
 
-        # **gpt-5 and o-series models only**
-        #
         # Configuration options for
         # [reasoning models](https://platform.openai.com/docs/guides/reasoning).
         sig { returns(T.nilable(OpenAI::Reasoning)) }
@@ -477,9 +475,9 @@ module OpenAI
           # a maximum length of 512 characters.
           metadata:,
 
-          # Model ID used to generate the response, like `gpt-4o` or `o3`. OpenAI offers a
-          # wide range of models with different capabilities, performance characteristics,
-          # and price points. Refer to the
+          # Model ID used to generate the response, like `gpt-6-astra`. OpenAI offers a wide
+          # range of models with different capabilities, performance characteristics, and
+          # price points. Refer to the
           # [model guide](https://platform.openai.com/docs/models) to browse and compare
           # available models.
           model:,
@@ -600,8 +598,6 @@ module OpenAI
           #   `prompt_cache_retention` is not specified.
           prompt_cache_retention: nil,
 
-          # **gpt-5 and o-series models only**
-          #
           # Configuration options for
           # [reasoning models](https://platform.openai.com/docs/guides/reasoning).
           reasoning: nil,
@@ -733,7 +729,9 @@ module OpenAI
             )
           end
 
-          # The reason why the response is incomplete.
+          # The reason why the response is incomplete. `steered` means the response stopped
+          # at a safe output boundary after a WebSocket `response.steer` event. The server
+          # can then create a successor response automatically with the queued input.
           sig { returns(T.nilable(OpenAI::Responses::Response::IncompleteDetails::Reason::TaggedSymbol)) }
           attr_reader :reason
 
@@ -750,7 +748,9 @@ module OpenAI
           end
           def self.new(
 
-            # The reason why the response is incomplete.
+            # The reason why the response is incomplete. `steered` means the response stopped
+            # at a safe output boundary after a WebSocket `response.steer` event. The server
+            # can then create a successor response automatically with the queued input.
 
             reason: nil
           )
@@ -764,7 +764,9 @@ module OpenAI
           def to_hash
           end
 
-          # The reason why the response is incomplete.
+          # The reason why the response is incomplete. `steered` means the response stopped
+          # at a safe output boundary after a WebSocket `response.steer` event. The server
+          # can then create a successor response automatically with the queued input.
           module Reason
             extend OpenAI::Internal::Type::Enum
 
@@ -775,10 +777,12 @@ module OpenAI
               :max_output_tokens,
               OpenAI::Responses::Response::IncompleteDetails::Reason::TaggedSymbol
             )
+            MAX_MESSAGES = T.let(:max_messages, OpenAI::Responses::Response::IncompleteDetails::Reason::TaggedSymbol)
             CONTENT_FILTER = T.let(
               :content_filter,
               OpenAI::Responses::Response::IncompleteDetails::Reason::TaggedSymbol
             )
+            STEERED = T.let(:steered, OpenAI::Responses::Response::IncompleteDetails::Reason::TaggedSymbol)
 
             sig { override.returns(T::Array[OpenAI::Responses::Response::IncompleteDetails::Reason::TaggedSymbol]) }
             def self.values

data/rbi/openai/models/responses/response_compact_params.rbi

@@ -17,9 +17,9 @@ module OpenAI
           )
         end
 
-        # Model ID used to generate the response, like `gpt-5` or `o3`. OpenAI offers a
-        # wide range of models with different capabilities, performance characteristics,
-        # and price points. Refer to the
+        # Model ID used to generate the response, like `gpt-6-astra`. OpenAI offers a wide
+        # range of models with different capabilities, performance characteristics, and
+        # price points. Refer to the
         # [model guide](https://platform.openai.com/docs/models) to browse and compare
         # available models.
         sig { returns(T.nilable(T.any(OpenAI::Responses::ResponseCompactParams::Model::OrSymbol, String))) }
@@ -112,9 +112,9 @@ module OpenAI
         end
         def self.new(
 
-          # Model ID used to generate the response, like `gpt-5` or `o3`. OpenAI offers a
-          # wide range of models with different capabilities, performance characteristics,
-          # and price points. Refer to the
+          # Model ID used to generate the response, like `gpt-6-astra`. OpenAI offers a wide
+          # range of models with different capabilities, performance characteristics, and
+          # price points. Refer to the
           # [model guide](https://platform.openai.com/docs/models) to browse and compare
           # available models.
           model:,
@@ -192,9 +192,9 @@ module OpenAI
         def to_hash
         end
 
-        # Model ID used to generate the response, like `gpt-5` or `o3`. OpenAI offers a
-        # wide range of models with different capabilities, performance characteristics,
-        # and price points. Refer to the
+        # Model ID used to generate the response, like `gpt-6-astra`. OpenAI offers a wide
+        # range of models with different capabilities, performance characteristics, and
+        # price points. Refer to the
         # [model guide](https://platform.openai.com/docs/models) to browse and compare
         # available models.
         module Model
@@ -212,6 +212,7 @@ module OpenAI
 
           OrSymbol = T.type_alias { T.any(Symbol, String) }
 
+          GPT_6_ASTRA = T.let(:"gpt-6-astra", OpenAI::Responses::ResponseCompactParams::Model::TaggedSymbol)
           GPT_5_6_SOL = T.let(:"gpt-5.6-sol", OpenAI::Responses::ResponseCompactParams::Model::TaggedSymbol)
           GPT_5_6_TERRA = T.let(:"gpt-5.6-terra", OpenAI::Responses::ResponseCompactParams::Model::TaggedSymbol)
           GPT_5_6_LUNA = T.let(:"gpt-5.6-luna", OpenAI::Responses::ResponseCompactParams::Model::TaggedSymbol)

data/rbi/openai/models/responses/response_configuration_update_item.rbi

@@ -0,0 +1,112 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Responses
+
+      class ResponseConfigurationUpdateItem < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Responses::ResponseConfigurationUpdateItem,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # The unique ID of the configuration update item.
+        sig { returns(String) }
+        attr_accessor :id
+
+        # The item type. Always `configuration_update`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # The reasoning configuration applied by this update.
+        sig { returns(T.nilable(OpenAI::Responses::ResponseConfigurationUpdateItem::Reasoning)) }
+        attr_reader :reasoning
+
+        sig { params(reasoning: OpenAI::Responses::ResponseConfigurationUpdateItem::Reasoning::OrHash).void }
+        attr_writer :reasoning
+
+        # A configuration update that applies to subsequent responses until it is replaced
+        # by another configuration update.
+        sig do
+          params(
+
+            id: String,
+
+            reasoning: OpenAI::Responses::ResponseConfigurationUpdateItem::Reasoning::OrHash,
+
+            type: Symbol
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # The unique ID of the configuration update item.
+          id:,
+
+          # The reasoning configuration applied by this update.
+          reasoning: nil,
+
+          # The item type. Always `configuration_update`.
+
+          type: :configuration_update
+        )
+        end
+
+        sig do
+          override.returns(
+            {id: String, type: Symbol, reasoning: OpenAI::Responses::ResponseConfigurationUpdateItem::Reasoning}
+          )
+        end
+        def to_hash
+        end
+
+        class Reasoning < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Responses::ResponseConfigurationUpdateItem::Reasoning,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          # The reasoning effort used for subsequent responses until another configuration
+          # update replaces it.
+          sig { returns(T.nilable(OpenAI::ReasoningEffort::OrSymbol)) }
+          attr_accessor :effort
+
+          # The reasoning configuration applied by this update.
+          sig do
+            params(
+
+              effort: T.nilable(OpenAI::ReasoningEffort::OrSymbol)
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            # The reasoning effort used for subsequent responses until another configuration
+            # update replaces it.
+
+            effort: nil
+          )
+          end
+
+          sig do
+            override.returns(
+              {effort: T.nilable(OpenAI::ReasoningEffort::OrSymbol)}
+            )
+          end
+          def to_hash
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+end