openai 0.83.0 → 0.85.0

data/rbi/openai/models/responses/response_configuration_update_item_param.rbi

@@ -0,0 +1,117 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Responses
+
+      class ResponseConfigurationUpdateItemParam < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Responses::ResponseConfigurationUpdateItemParam,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # The item type. Always `configuration_update`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # The unique ID of the configuration update item.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :id
+
+        # Updates to reasoning configuration. Only effort is supported.
+        sig { returns(T.nilable(OpenAI::Responses::ResponseConfigurationUpdateItemParam::Reasoning)) }
+        attr_reader :reasoning
+
+        sig { params(reasoning: OpenAI::Responses::ResponseConfigurationUpdateItemParam::Reasoning::OrHash).void }
+        attr_writer :reasoning
+
+        # An update to the conversation's response configuration. The configuration
+        # remains in effect for subsequent responses until it is replaced by another
+        # configuration update.
+        sig do
+          params(
+
+            id: T.nilable(String),
+
+            reasoning: OpenAI::Responses::ResponseConfigurationUpdateItemParam::Reasoning::OrHash,
+
+            type: Symbol
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # The unique ID of the configuration update item.
+          id: nil,
+
+          # Updates to reasoning configuration. Only effort is supported.
+          reasoning: nil,
+
+          # The item type. Always `configuration_update`.
+
+          type: :configuration_update
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              type: Symbol,
+              id: T.nilable(String),
+              reasoning: OpenAI::Responses::ResponseConfigurationUpdateItemParam::Reasoning
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class Reasoning < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Responses::ResponseConfigurationUpdateItemParam::Reasoning,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          # The reasoning effort to use for subsequent responses until another configuration
+          # update replaces it.
+          sig { returns(T.nilable(OpenAI::ReasoningEffort::OrSymbol)) }
+          attr_accessor :effort
+
+          # Updates to reasoning configuration. Only effort is supported.
+          sig do
+            params(
+
+              effort: T.nilable(OpenAI::ReasoningEffort::OrSymbol)
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            # The reasoning effort to use 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

data/rbi/openai/models/responses/response_create_params.rbi

@@ -99,9 +99,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 {
@@ -186,8 +186,6 @@ module OpenAI
         sig { returns(T.nilable(OpenAI::Responses::ResponseCreateParams::PromptCacheRetention::OrSymbol)) }
         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)) }
@@ -587,9 +585,9 @@ module OpenAI
           # a maximum length of 512 characters.
           metadata: nil,
 
-          # 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: nil,
@@ -645,8 +643,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,

data/rbi/openai/models/responses/response_custom_tool_call.rbi

@@ -37,6 +37,13 @@ module OpenAI
         sig { params(id: String).void }
         attr_writer :id
 
+        # Whether the custom tool call runs asynchronously.
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :async
+
+        sig { params(async: T::Boolean).void }
+        attr_writer :async
+
         # The execution context that produced this tool call.
         sig {
           returns(
@@ -69,6 +76,8 @@ module OpenAI
 
             id: String,
 
+            async: T::Boolean,
+
             caller_: T.nilable(
               T.any(
                 OpenAI::Responses::ResponseCustomToolCall::Caller::Direct::OrHash,
@@ -96,6 +105,9 @@ module OpenAI
           # The unique ID of the custom tool call in the OpenAI platform.
           id: nil,
 
+          # Whether the custom tool call runs asynchronously.
+          async: nil,
+
           # The execution context that produced this tool call.
           caller_: nil,
 
@@ -116,6 +128,7 @@ module OpenAI
               name: String,
               type: Symbol,
               id: String,
+              async: T::Boolean,
               caller_: T.nilable(
                 T.any(
                   OpenAI::Responses::ResponseCustomToolCall::Caller::Direct,

data/rbi/openai/models/responses/response_custom_tool_call_item.rbi

@@ -44,6 +44,8 @@ module OpenAI
 
             status: OpenAI::Responses::ResponseCustomToolCallItem::Status::OrSymbol,
 
+            async: T::Boolean,
+
             caller_: T.nilable(
               T.any(
                 OpenAI::Responses::ResponseCustomToolCall::Caller::Direct::OrHash,
@@ -77,6 +79,9 @@ module OpenAI
           # Populated when items are returned via API.
           status:,
 
+          # Whether the custom tool call runs asynchronously.
+          async: nil,
+
           # The execution context that produced this tool call.
           caller_: nil,
 
@@ -101,6 +106,7 @@ module OpenAI
               id: String,
               status: OpenAI::Responses::ResponseCustomToolCallItem::Status::TaggedSymbol,
               type: Symbol,
+              async: T::Boolean,
               caller_: T.nilable(
                 T.any(
                   OpenAI::Responses::ResponseCustomToolCall::Caller::Direct,

data/rbi/openai/models/responses/response_error.rbi

@@ -22,13 +22,21 @@ module OpenAI
         sig { returns(String) }
         attr_accessor :message
 
+        sig { returns(T.nilable(OpenAI::Responses::ResponseError::Misalignment)) }
+        attr_reader :misalignment
+
+        sig { params(misalignment: OpenAI::Responses::ResponseError::Misalignment::OrHash).void }
+        attr_writer :misalignment
+
         # An error object returned when the model fails to generate a Response.
         sig do
           params(
 
             code: OpenAI::Responses::ResponseError::Code::OrSymbol,
 
-            message: String
+            message: String,
+
+            misalignment: OpenAI::Responses::ResponseError::Misalignment::OrHash
           )
             .returns(T.attached_class)
         end
@@ -38,14 +46,19 @@ module OpenAI
           code:,
 
           # A human-readable description of the error.
+          message:,
 
-          message:
+          misalignment: nil
         )
         end
 
         sig do
           override.returns(
-            {code: OpenAI::Responses::ResponseError::Code::TaggedSymbol, message: String}
+            {
+              code: OpenAI::Responses::ResponseError::Code::TaggedSymbol,
+              message: String,
+              misalignment: OpenAI::Responses::ResponseError::Misalignment
+            }
           )
         end
         def to_hash
@@ -66,6 +79,10 @@ module OpenAI
             OpenAI::Responses::ResponseError::Code::TaggedSymbol
           )
           BIO_POLICY = T.let(:bio_policy, OpenAI::Responses::ResponseError::Code::TaggedSymbol)
+          MISALIGNMENT_POLICY_VIOLATION = T.let(
+            :misalignment_policy_violation,
+            OpenAI::Responses::ResponseError::Code::TaggedSymbol
+          )
           VECTOR_STORE_TIMEOUT = T.let(:vector_store_timeout, OpenAI::Responses::ResponseError::Code::TaggedSymbol)
           INVALID_IMAGE = T.let(:invalid_image, OpenAI::Responses::ResponseError::Code::TaggedSymbol)
           INVALID_IMAGE_FORMAT = T.let(:invalid_image_format, OpenAI::Responses::ResponseError::Code::TaggedSymbol)
@@ -96,6 +113,147 @@ module OpenAI
           end
         end
 
+        class Misalignment < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Responses::ResponseError::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(OpenAI::Responses::ResponseError::Misalignment::ErrorType::Variants)) }
+          attr_reader :error_type
+
+          sig {
+            params(error_type: T.any(String, OpenAI::Responses::ResponseError::Misalignment::ErrorType::OrSymbol)).void
+          }
+          attr_writer :error_type
+
+          # An optional public continuation instruction.
+          sig { returns(T.nilable(OpenAI::Responses::ResponseError::Misalignment::Steer)) }
+          attr_reader :steer
+
+          sig { params(steer: OpenAI::Responses::ResponseError::Misalignment::Steer::OrHash).void }
+          attr_writer :steer
+
+          sig do
+            params(
+
+              detailed_explanation: String,
+
+              error_type: T.any(String, OpenAI::Responses::ResponseError::Misalignment::ErrorType::OrSymbol),
+
+              steer: OpenAI::Responses::ResponseError::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: OpenAI::Responses::ResponseError::Misalignment::ErrorType::Variants,
+                steer: OpenAI::Responses::ResponseError::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::Responses::ResponseError::Misalignment::ErrorType::TaggedSymbol)
+            }
+
+            sig { override.returns(T::Array[OpenAI::Responses::ResponseError::Misalignment::ErrorType::Variants]) }
+            def self.variants
+            end
+
+            TaggedSymbol = T.type_alias do
+              T.all(Symbol, OpenAI::Responses::ResponseError::Misalignment::ErrorType)
+            end
+
+            OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+            POTENTIALLY_UNINTENDED_DATA_TRANSFER = T.let(
+              :potentially_unintended_data_transfer,
+              OpenAI::Responses::ResponseError::Misalignment::ErrorType::TaggedSymbol
+            )
+            POTENTIALLY_UNINTENDED_DATA_ACCESS = T.let(
+              :potentially_unintended_data_access,
+              OpenAI::Responses::ResponseError::Misalignment::ErrorType::TaggedSymbol
+            )
+            POTENTIALLY_UNINTENDED_DESTRUCTIVE_ACTIVITY = T.let(
+              :potentially_unintended_destructive_activity,
+              OpenAI::Responses::ResponseError::Misalignment::ErrorType::TaggedSymbol
+            )
+            OTHER = T.let(:other, OpenAI::Responses::ResponseError::Misalignment::ErrorType::TaggedSymbol)
+
+          end
+
+          class Steer < OpenAI::Internal::Type::BaseModel
+            OrHash = T.type_alias do
+              T.any(
+                OpenAI::Responses::ResponseError::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/responses/response_function_tool_call.rbi

@@ -41,6 +41,13 @@ module OpenAI
         sig { params(id: String).void }
         attr_writer :id
 
+        # Whether the function tool call runs asynchronously.
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :async
+
+        sig { params(async: T::Boolean).void }
+        attr_writer :async
+
         # The execution context that produced this tool call.
         sig {
           returns(
@@ -83,6 +90,8 @@ module OpenAI
 
             id: String,
 
+            async: T::Boolean,
+
             caller_: T.nilable(
               T.any(
                 OpenAI::Responses::ResponseFunctionToolCall::Caller::Direct::OrHash,
@@ -112,6 +121,9 @@ module OpenAI
           # The unique ID of the function tool call.
           id: nil,
 
+          # Whether the function tool call runs asynchronously.
+          async: nil,
+
           # The execution context that produced this tool call.
           caller_: nil,
 
@@ -136,6 +148,7 @@ module OpenAI
               name: String,
               type: Symbol,
               id: String,
+              async: T::Boolean,
               caller_: T.nilable(
                 T.any(
                   OpenAI::Responses::ResponseFunctionToolCall::Caller::Direct,

data/rbi/openai/models/responses/response_function_tool_call_item.rbi

@@ -46,6 +46,8 @@ module OpenAI
 
             status: OpenAI::Responses::ResponseFunctionToolCallItem::Status::OrSymbol,
 
+            async: T::Boolean,
+
             caller_: T.nilable(
               T.any(
                 OpenAI::Responses::ResponseFunctionToolCall::Caller::Direct::OrHash,
@@ -79,6 +81,9 @@ module OpenAI
           # Populated when items are returned via API.
           status:,
 
+          # Whether the function tool call runs asynchronously.
+          async: nil,
+
           # The execution context that produced this tool call.
           caller_: nil,
 
@@ -103,6 +108,7 @@ module OpenAI
               id: String,
               status: OpenAI::Responses::ResponseFunctionToolCallItem::Status::TaggedSymbol,
               type: Symbol,
+              async: T::Boolean,
               caller_: T.nilable(
                 T.any(
                   OpenAI::Responses::ResponseFunctionToolCall::Caller::Direct,

data/rbi/openai/models/responses/response_incomplete_event.rbi

@@ -30,6 +30,10 @@ module OpenAI
         attr_accessor :type
 
         # An event that is emitted when a response finishes as incomplete.
+        #
+        # Over WebSocket, steering can finish a response with
+        # `response.incomplete_details.reason` set to `steered`, followed automatically by
+        # a successor `response.created` that commits the queued steering input.
         sig do
           params(
 

data/rbi/openai/models/responses/response_input_item.rbi

@@ -27,6 +27,7 @@ module OpenAI
             OpenAI::Responses::ResponseInputItem::ToolSearchCall,
             OpenAI::Responses::ResponseToolSearchOutputItemParam,
             OpenAI::Responses::ResponseInputItem::AdditionalTools,
+            OpenAI::Responses::ResponseConfigurationUpdateItemParam,
             OpenAI::Responses::ResponseReasoningItem,
             OpenAI::Responses::ResponseCompactionItemParam,
             OpenAI::Responses::ResponseInputItem::ImageGenerationCall,

data/rbi/openai/models/responses/response_item.rbi

@@ -22,6 +22,7 @@ module OpenAI
             OpenAI::Responses::ResponseToolSearchCall,
             OpenAI::Responses::ResponseToolSearchOutputItem,
             OpenAI::Responses::ResponseItem::AdditionalTools,
+            OpenAI::Responses::ResponseConfigurationUpdateItem,
             OpenAI::Responses::ResponseReasoningItem,
             OpenAI::Responses::ResponseItem::Program,
             OpenAI::Responses::ResponseItem::ProgramOutput,

data/rbi/openai/models/responses/response_item_list.rbi

@@ -53,6 +53,7 @@ module OpenAI
                 OpenAI::Responses::ResponseToolSearchCall::OrHash,
                 OpenAI::Responses::ResponseToolSearchOutputItem::OrHash,
                 OpenAI::Responses::ResponseItem::AdditionalTools::OrHash,
+                OpenAI::Responses::ResponseConfigurationUpdateItem::OrHash,
                 OpenAI::Responses::ResponseReasoningItem::OrHash,
                 OpenAI::Responses::ResponseItem::Program::OrHash,
                 OpenAI::Responses::ResponseItem::ProgramOutput::OrHash,

data/rbi/openai/models/responses/response_steer_accepted_event.rbi

@@ -0,0 +1,146 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Responses
+
+      class ResponseSteerAcceptedEvent < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Responses::ResponseSteerAcceptedEvent,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # The sequence number for this event.
+        sig { returns(Integer) }
+        attr_accessor :sequence_number
+
+        # The accepted steering submission.
+        sig { returns(OpenAI::Responses::ResponseSteerAcceptedEvent::Steer) }
+        attr_reader :steer
+
+        sig { params(steer: OpenAI::Responses::ResponseSteerAcceptedEvent::Steer::OrHash).void }
+        attr_writer :steer
+
+        # The event discriminator. Always `response.steer.accepted`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # The WebSocket lane that emitted this event. This field is present when the
+        # target response's `response.create` event supplied a `stream_id`.
+        sig { returns(T.nilable(String)) }
+        attr_reader :stream_id
+
+        sig { params(stream_id: String).void }
+        attr_writer :stream_id
+
+        # Emitted when steering input has been validated and queued. Acceptance means the
+        # server owns the input, not that it has been applied. The successor's
+        # `response.created` event is the commit point. If accepted input cannot be
+        # committed, `response.steer.failed` returns it with the same steering ID.
+        #
+        # When the response stops for client-owned tool output or approval, the input
+        # remains queued and `response.steer.pending` is emitted after
+        # `response.completed`. Fill the pending event's `required_input` stubs with saved
+        # results and send one matching explicit `response.create` per parent. Do not
+        # resend accepted input while it is still queued.
+        sig do
+          params(
+
+            sequence_number: Integer,
+
+            steer: OpenAI::Responses::ResponseSteerAcceptedEvent::Steer::OrHash,
+
+            stream_id: String,
+
+            type: Symbol
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # The sequence number for this event.
+          sequence_number:,
+
+          # The accepted steering submission.
+          steer:,
+
+          # The WebSocket lane that emitted this event. This field is present when the
+          # target response's `response.create` event supplied a `stream_id`.
+          stream_id: nil,
+
+          # The event discriminator. Always `response.steer.accepted`.
+
+          type: :"response.steer.accepted"
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              sequence_number: Integer,
+              steer: OpenAI::Responses::ResponseSteerAcceptedEvent::Steer,
+              type: Symbol,
+              stream_id: String
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class Steer < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Responses::ResponseSteerAcceptedEvent::Steer,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          # The ID assigned to the steering submission.
+          sig { returns(String) }
+          attr_accessor :id
+
+          # The ID of the response being steered.
+          sig { returns(String) }
+          attr_accessor :previous_response_id
+
+          # The accepted steering submission.
+          sig do
+            params(
+
+              id: String,
+
+              previous_response_id: String
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            # The ID assigned to the steering submission.
+            id:,
+
+            # The ID of the response being steered.
+
+            previous_response_id:
+          )
+          end
+
+          sig do
+            override.returns(
+              {id: String, previous_response_id: String}
+            )
+          end
+          def to_hash
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+end