openai 0.83.0 → 0.85.0

data/rbi/openai/models/responses/responses_server_event.rbi

@@ -12,6 +12,9 @@ module OpenAI
         Variants = T.type_alias do
           T.any(
             OpenAI::Responses::ResponsesServerEvent::ResponseWsError,
+            OpenAI::Responses::ResponseSteerAcceptedEvent,
+            OpenAI::Responses::ResponseSteerPendingEvent,
+            OpenAI::Responses::ResponseSteerFailedEvent,
             OpenAI::Responses::ResponsesServerEvent::ResponseAudioWsDelta,
             OpenAI::Responses::ResponsesServerEvent::ResponseAudioWsDone,
             OpenAI::Responses::ResponsesServerEvent::ResponseAudioTranscriptWsDelta,
@@ -1792,6 +1795,10 @@ module OpenAI
           attr_writer :stream_id
 
           # 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(
 
@@ -4303,6 +4310,17 @@ module OpenAI
             sig { params(headers: T::Hash[Symbol, String]).void }
             attr_writer :headers
 
+            sig { returns(T.nilable(OpenAI::Responses::ResponsesServerEvent::ResponseWsError::Error::Misalignment)) }
+            attr_reader :misalignment
+
+            sig {
+              params(
+                misalignment: OpenAI::Responses::ResponsesServerEvent::ResponseWsError::Error::Misalignment::OrHash
+              )
+                .void
+            }
+            attr_writer :misalignment
+
             # Details about the error.
             sig do
               params(
@@ -4315,7 +4333,9 @@ module OpenAI
 
                 type: String,
 
-                headers: T::Hash[Symbol, String]
+                headers: T::Hash[Symbol, String],
+
+                misalignment: OpenAI::Responses::ResponsesServerEvent::ResponseWsError::Error::Misalignment::OrHash
               )
                 .returns(T.attached_class)
             end
@@ -4334,8 +4354,9 @@ module OpenAI
               type:,
 
               # The response headers that were emitted with the error, if any.
+              headers: nil,
 
-              headers: nil
+              misalignment: nil
             )
             end
 
@@ -4346,13 +4367,191 @@ module OpenAI
                   message: String,
                   param: T.nilable(String),
                   type: String,
-                  headers: T::Hash[Symbol, String]
+                  headers: T::Hash[Symbol, String],
+                  misalignment: OpenAI::Responses::ResponsesServerEvent::ResponseWsError::Error::Misalignment
                 }
               )
             end
             def to_hash
             end
 
+            class Misalignment < OpenAI::Internal::Type::BaseModel
+              OrHash = T.type_alias do
+                T.any(
+                  OpenAI::Responses::ResponsesServerEvent::ResponseWsError::Error::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::ResponsesServerEvent::ResponseWsError::Error::Misalignment::ErrorType::Variants
+                  )
+                )
+              }
+              attr_reader :error_type
+
+              sig {
+                params(
+                  error_type: T.any(
+                    String,
+                    OpenAI::Responses::ResponsesServerEvent::ResponseWsError::Error::Misalignment::ErrorType::OrSymbol
+                  )
+                )
+                  .void
+              }
+              attr_writer :error_type
+
+              # An optional public continuation instruction.
+              sig {
+                returns(T.nilable(OpenAI::Responses::ResponsesServerEvent::ResponseWsError::Error::Misalignment::Steer))
+              }
+              attr_reader :steer
+
+              sig {
+                params(
+                  steer: OpenAI::Responses::ResponsesServerEvent::ResponseWsError::Error::Misalignment::Steer::OrHash
+                )
+                  .void
+              }
+              attr_writer :steer
+
+              sig do
+                params(
+
+                  detailed_explanation: String,
+
+                  error_type: T.any(
+                    String,
+                    OpenAI::Responses::ResponsesServerEvent::ResponseWsError::Error::Misalignment::ErrorType::OrSymbol
+                  ),
+
+                  steer: OpenAI::Responses::ResponsesServerEvent::ResponseWsError::Error::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::ResponsesServerEvent::ResponseWsError::Error::Misalignment::ErrorType::Variants,
+                    steer: OpenAI::Responses::ResponsesServerEvent::ResponseWsError::Error::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::ResponsesServerEvent::ResponseWsError::Error::Misalignment::ErrorType::TaggedSymbol
+                  )
+                }
+
+                sig {
+                  override.returns(
+                    T::Array[
+                      OpenAI::Responses::ResponsesServerEvent::ResponseWsError::Error::Misalignment::ErrorType::Variants
+                    ]
+                  )
+                }
+                def self.variants
+                end
+
+                TaggedSymbol = T.type_alias do
+                  T.all(
+                    Symbol,
+                    OpenAI::Responses::ResponsesServerEvent::ResponseWsError::Error::Misalignment::ErrorType
+                  )
+                end
+
+                OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+                POTENTIALLY_UNINTENDED_DATA_TRANSFER = T.let(
+                  :potentially_unintended_data_transfer,
+                  OpenAI::Responses::ResponsesServerEvent::ResponseWsError::Error::Misalignment::ErrorType::TaggedSymbol
+                )
+                POTENTIALLY_UNINTENDED_DATA_ACCESS = T.let(
+                  :potentially_unintended_data_access,
+                  OpenAI::Responses::ResponsesServerEvent::ResponseWsError::Error::Misalignment::ErrorType::TaggedSymbol
+                )
+                POTENTIALLY_UNINTENDED_DESTRUCTIVE_ACTIVITY = T.let(
+                  :potentially_unintended_destructive_activity,
+                  OpenAI::Responses::ResponsesServerEvent::ResponseWsError::Error::Misalignment::ErrorType::TaggedSymbol
+                )
+                OTHER = T.let(
+                  :other,
+                  OpenAI::Responses::ResponsesServerEvent::ResponseWsError::Error::Misalignment::ErrorType::TaggedSymbol
+                )
+
+              end
+
+              class Steer < OpenAI::Internal::Type::BaseModel
+                OrHash = T.type_alias do
+                  T.any(
+                    OpenAI::Responses::ResponsesServerEvent::ResponseWsError::Error::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/safety/alert_retrieve_params.rbi

@@ -0,0 +1,55 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Safety
+
+      class AlertRetrieveParams < OpenAI::Internal::Type::BaseModel
+
+        extend OpenAI::Internal::Type::RequestParameters::Converter
+        include OpenAI::Internal::Type::RequestParameters
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Safety::AlertRetrieveParams,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # Project safety alert ID
+        sig { returns(String) }
+        attr_accessor :id
+
+        sig do
+          params(
+
+            id: String,
+
+            request_options: OpenAI::RequestOptions::OrHash
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # Project safety alert ID
+          id:,
+
+          request_options: {}
+        )
+        end
+
+        sig do
+          override.returns(
+            {id: String, request_options: OpenAI::RequestOptions}
+          )
+        end
+        def to_hash
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/safety/safety_alert.rbi

@@ -0,0 +1,147 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    SafetyAlert = Safety::SafetyAlert
+
+    module Safety
+
+      class SafetyAlert < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Safety::SafetyAlert,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        sig { returns(String) }
+        attr_accessor :id
+
+        sig { returns(Integer) }
+        attr_accessor :created_at
+
+        sig { returns(OpenAI::Safety::SafetyAlert::ErrorType::TaggedSymbol) }
+        attr_accessor :error_type
+
+        sig { returns(String) }
+        attr_accessor :model
+
+        sig { returns(Symbol) }
+        attr_accessor :object
+
+        # A customer-safe description derived from error_type, or null for zero data
+        # retention requests.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :reason
+
+        sig { returns(String) }
+        attr_accessor :request_id
+
+        # Whether block registration succeeded for this request. This does not confirm
+        # that response execution stopped.
+        sig { returns(T::Boolean) }
+        attr_accessor :request_paused
+
+        sig { returns(String) }
+        attr_accessor :response_id
+
+        sig do
+          params(
+
+            id: String,
+
+            created_at: Integer,
+
+            error_type: OpenAI::Safety::SafetyAlert::ErrorType::OrSymbol,
+
+            model: String,
+
+            reason: T.nilable(String),
+
+            request_id: String,
+
+            request_paused: T::Boolean,
+
+            response_id: String,
+
+            object: Symbol
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          id:,
+
+          created_at:,
+
+          error_type:,
+
+          model:,
+
+          # A customer-safe description derived from error_type, or null for zero data
+          # retention requests.
+          reason:,
+
+          request_id:,
+
+          # Whether block registration succeeded for this request. This does not confirm
+          # that response execution stopped.
+          request_paused:,
+
+          response_id:,
+
+          object: :"safety.alert"
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              id: String,
+              created_at: Integer,
+              error_type: OpenAI::Safety::SafetyAlert::ErrorType::TaggedSymbol,
+              model: String,
+              object: Symbol,
+              reason: T.nilable(String),
+              request_id: String,
+              request_paused: T::Boolean,
+              response_id: String
+            }
+          )
+        end
+        def to_hash
+        end
+
+        module ErrorType
+          extend OpenAI::Internal::Type::Enum
+
+          TaggedSymbol = T.type_alias { T.all(Symbol, OpenAI::Safety::SafetyAlert::ErrorType) }
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          POTENTIALLY_UNINTENDED_DATA_TRANSFER = T.let(
+            :potentially_unintended_data_transfer,
+            OpenAI::Safety::SafetyAlert::ErrorType::TaggedSymbol
+          )
+          POTENTIALLY_UNINTENDED_DATA_ACCESS = T.let(
+            :potentially_unintended_data_access,
+            OpenAI::Safety::SafetyAlert::ErrorType::TaggedSymbol
+          )
+          POTENTIALLY_UNINTENDED_DESTRUCTIVE_ACTIVITY = T.let(
+            :potentially_unintended_destructive_activity,
+            OpenAI::Safety::SafetyAlert::ErrorType::TaggedSymbol
+          )
+          OTHER = T.let(:other, OpenAI::Safety::SafetyAlert::ErrorType::TaggedSymbol)
+
+          sig { override.returns(T::Array[OpenAI::Safety::SafetyAlert::ErrorType::TaggedSymbol]) }
+          def self.values
+          end
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/video_create_error.rbi

@@ -20,13 +20,21 @@ module OpenAI
       sig { returns(String) }
       attr_accessor :message
 
+      sig { returns(T.nilable(OpenAI::VideoCreateError::Misalignment)) }
+      attr_reader :misalignment
+
+      sig { params(misalignment: OpenAI::VideoCreateError::Misalignment::OrHash).void }
+      attr_writer :misalignment
+
       # An error that occurred while generating the response.
       sig do
         params(
 
           code: String,
 
-          message: String
+          message: String,
+
+          misalignment: OpenAI::VideoCreateError::Misalignment::OrHash
         )
           .returns(T.attached_class)
       end
@@ -36,19 +44,157 @@ module OpenAI
         code:,
 
         # A human-readable description of the error that was returned.
+        message:,
 
-        message:
+        misalignment: nil
       )
       end
 
       sig do
         override.returns(
-          {code: String, message: String}
+          {code: String, message: String, misalignment: OpenAI::VideoCreateError::Misalignment}
         )
       end
       def to_hash
       end
 
+      class Misalignment < OpenAI::Internal::Type::BaseModel
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::VideoCreateError::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::VideoCreateError::Misalignment::ErrorType::Variants)) }
+        attr_reader :error_type
+
+        sig { params(error_type: T.any(String, OpenAI::VideoCreateError::Misalignment::ErrorType::OrSymbol)).void }
+        attr_writer :error_type
+
+        # An optional public continuation instruction.
+        sig { returns(T.nilable(OpenAI::VideoCreateError::Misalignment::Steer)) }
+        attr_reader :steer
+
+        sig { params(steer: OpenAI::VideoCreateError::Misalignment::Steer::OrHash).void }
+        attr_writer :steer
+
+        sig do
+          params(
+
+            detailed_explanation: String,
+
+            error_type: T.any(String, OpenAI::VideoCreateError::Misalignment::ErrorType::OrSymbol),
+
+            steer: OpenAI::VideoCreateError::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::VideoCreateError::Misalignment::ErrorType::Variants,
+              steer: OpenAI::VideoCreateError::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::VideoCreateError::Misalignment::ErrorType::TaggedSymbol) }
+
+          sig { override.returns(T::Array[OpenAI::VideoCreateError::Misalignment::ErrorType::Variants]) }
+          def self.variants
+          end
+
+          TaggedSymbol = T.type_alias do
+            T.all(Symbol, OpenAI::VideoCreateError::Misalignment::ErrorType)
+          end
+
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          POTENTIALLY_UNINTENDED_DATA_TRANSFER = T.let(
+            :potentially_unintended_data_transfer,
+            OpenAI::VideoCreateError::Misalignment::ErrorType::TaggedSymbol
+          )
+          POTENTIALLY_UNINTENDED_DATA_ACCESS = T.let(
+            :potentially_unintended_data_access,
+            OpenAI::VideoCreateError::Misalignment::ErrorType::TaggedSymbol
+          )
+          POTENTIALLY_UNINTENDED_DESTRUCTIVE_ACTIVITY = T.let(
+            :potentially_unintended_destructive_activity,
+            OpenAI::VideoCreateError::Misalignment::ErrorType::TaggedSymbol
+          )
+          OTHER = T.let(:other, OpenAI::VideoCreateError::Misalignment::ErrorType::TaggedSymbol)
+
+        end
+
+        class Steer < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::VideoCreateError::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