openai 0.84.0 → 0.85.0

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

data/rbi/openai/models/responses/response_steer_error_code.rbi

@@ -0,0 +1,63 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Responses
+
+      # A machine-readable steering error code. Clients should handle unknown values
+      # because additional codes may be introduced. Known values include:
+      #
+      # - `response_not_found`: The target response is not available on this connection.
+      # - `invalid_input`: The event or input failed validation.
+      # - `steering_not_supported`: The model or response execution mode does not
+      #   support steering.
+      # - `too_many_pending_steers`: Too much steering input is pending for the
+      #   response.
+      # - `response_already_completed`: The response completed and is no longer
+      #   accepting steering input.
+      # - `response_not_active`: The response is no longer accepting steering input.
+      # - `successor_creation_failed`: The successor response could not be created.
+      module ResponseSteerErrorCode
+        extend OpenAI::Internal::Type::Union
+
+        Variants = T.type_alias do
+          T.any(
+            OpenAI::Responses::ResponseSteerErrorCode::TaggedSymbol,
+            String
+          )
+        end
+
+        sig { override.returns(T::Array[OpenAI::Responses::ResponseSteerErrorCode::Variants]) }
+        def self.variants
+        end
+
+        TaggedSymbol = T.type_alias do
+          T.all(Symbol, OpenAI::Responses::ResponseSteerErrorCode)
+        end
+
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        RESPONSE_NOT_FOUND = T.let(:response_not_found, OpenAI::Responses::ResponseSteerErrorCode::TaggedSymbol)
+        INVALID_INPUT = T.let(:invalid_input, OpenAI::Responses::ResponseSteerErrorCode::TaggedSymbol)
+        STEERING_NOT_SUPPORTED = T.let(:steering_not_supported, OpenAI::Responses::ResponseSteerErrorCode::TaggedSymbol)
+        TOO_MANY_PENDING_STEERS = T.let(
+          :too_many_pending_steers,
+          OpenAI::Responses::ResponseSteerErrorCode::TaggedSymbol
+        )
+        RESPONSE_ALREADY_COMPLETED = T.let(
+          :response_already_completed,
+          OpenAI::Responses::ResponseSteerErrorCode::TaggedSymbol
+        )
+        RESPONSE_NOT_ACTIVE = T.let(:response_not_active, OpenAI::Responses::ResponseSteerErrorCode::TaggedSymbol)
+        SUCCESSOR_CREATION_FAILED = T.let(
+          :successor_creation_failed,
+          OpenAI::Responses::ResponseSteerErrorCode::TaggedSymbol
+        )
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/responses/response_steer_event.rbi

@@ -0,0 +1,119 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Responses
+
+      class ResponseSteerEvent < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Responses::ResponseSteerEvent,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # Input to queue for a continuation of the response. Uses the same string or
+        # input-item shape as `response.create.input`, with a non-empty array when
+        # supplying input items.
+        #
+        # Steering accepts only messages with the `user` role. Each message may contain
+        # only `type`, `role`, and `content`, with `content` as a string or an array of
+        # `input_text`, `input_image`, and `input_file` parts. The optional `type` must be
+        # `message`. Other roles, tool outputs, and item types are not supported for
+        # steering.
+        sig {
+          returns(T.any(String, T::Array[OpenAI::Responses::ResponseSteerInput::ResponseSteerInputItemList::Variants]))
+        }
+        attr_accessor :input
+
+        # The ID of the response to steer on this WebSocket connection.
+        sig { returns(String) }
+        attr_accessor :previous_response_id
+
+        # The event discriminator. Always `response.steer`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # Queues user input to steer a response on this WebSocket connection. Input can
+        # contain text, images, and files. Steering is supported only for single-agent
+        # responses on models and execution modes that support steering. Responses bound
+        # to a conversation or using automatic compaction do not support steering.
+        #
+        # A `response.steer.accepted` event acknowledges that the server owns the queued
+        # input, not that it has been applied. The successor's `response.created` event is
+        # the commit point. Input that cannot be committed is returned in
+        # `response.steer.failed`.
+        #
+        # Steering may cause the active response to finish at a safe output boundary with
+        # `response.incomplete` and `incomplete_details.reason` set to `steered`, followed
+        # automatically by a successor `response.created`. Normal completion can also be
+        # followed by an automatic successor. Automatic successors inherit the previous
+        # response's settings and continue from it with the queued input.
+        #
+        # If the response stops for client-owned tool output or approval, accepted
+        # steering input remains queued and `response.steer.pending` is emitted after
+        # `response.completed`. Fill the `required_input` stubs from that event with saved
+        # tool results or approval decisions, and send one explicit `response.create` per
+        # parent with the same `previous_response_id` and WebSocket lane. Do not rerun
+        # tools or resend accepted steering input. The queued input is prepended in
+        # submission order to that request's input, and the explicit request retains its
+        # own settings.
+        #
+        # This event accepts only `type`, `previous_response_id`, and `input`. Do not send
+        # `stream_id`; the target response determines the WebSocket lane.
+        sig do
+          params(
+
+            input: T.any(String, T::Array[OpenAI::Responses::ResponseSteerInput::ResponseSteerInputItemList::Variants]),
+
+            previous_response_id: String,
+
+            type: Symbol
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # Input to queue for a continuation of the response. Uses the same string or
+          # input-item shape as `response.create.input`, with a non-empty array when
+          # supplying input items.
+          #
+          # Steering accepts only messages with the `user` role. Each message may contain
+          # only `type`, `role`, and `content`, with `content` as a string or an array of
+          # `input_text`, `input_image`, and `input_file` parts. The optional `type` must be
+          # `message`. Other roles, tool outputs, and item types are not supported for
+          # steering.
+          input:,
+
+          # The ID of the response to steer on this WebSocket connection.
+          previous_response_id:,
+
+          # The event discriminator. Always `response.steer`.
+
+          type: :"response.steer"
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              input: T.any(
+                String,
+                T::Array[OpenAI::Responses::ResponseSteerInput::ResponseSteerInputItemList::Variants]
+              ),
+              previous_response_id: String,
+              type: Symbol
+            }
+          )
+        end
+        def to_hash
+        end
+
+      end
+
+    end
+
+  end
+end