openai 0.29.0 → 0.31.0

data/rbi/openai/models/responses_model.rbi

@@ -78,6 +78,16 @@ module OpenAI
             :"gpt-5-codex",
             OpenAI::ResponsesModel::ResponsesOnlyModel::TaggedSymbol
           )
+        GPT_5_PRO =
+          T.let(
+            :"gpt-5-pro",
+            OpenAI::ResponsesModel::ResponsesOnlyModel::TaggedSymbol
+          )
+        GPT_5_PRO_2025_10_06 =
+          T.let(
+            :"gpt-5-pro-2025-10-06",
+            OpenAI::ResponsesModel::ResponsesOnlyModel::TaggedSymbol
+          )
 
         sig do
           override.returns(

data/rbi/openai/models/vector_stores/vector_store_file.rbi

@@ -190,7 +190,7 @@ module OpenAI
               )
             end
 
-          # One of `server_error` or `rate_limit_exceeded`.
+          # One of `server_error`, `unsupported_file`, or `invalid_file`.
           sig do
             returns(
               OpenAI::VectorStores::VectorStoreFile::LastError::Code::TaggedSymbol
@@ -212,7 +212,7 @@ module OpenAI
             ).returns(T.attached_class)
           end
           def self.new(
-            # One of `server_error` or `rate_limit_exceeded`.
+            # One of `server_error`, `unsupported_file`, or `invalid_file`.
             code:,
             # A human-readable description of the error.
             message:
@@ -231,7 +231,7 @@ module OpenAI
           def to_hash
           end
 
-          # One of `server_error` or `rate_limit_exceeded`.
+          # One of `server_error`, `unsupported_file`, or `invalid_file`.
           module Code
             extend OpenAI::Internal::Type::Enum
 

data/rbi/openai/models/video.rbi

@@ -0,0 +1,143 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    class Video < OpenAI::Internal::Type::BaseModel
+      OrHash = T.type_alias { T.any(OpenAI::Video, OpenAI::Internal::AnyHash) }
+
+      # Unique identifier for the video job.
+      sig { returns(String) }
+      attr_accessor :id
+
+      # Unix timestamp (seconds) for when the job completed, if finished.
+      sig { returns(T.nilable(Integer)) }
+      attr_accessor :completed_at
+
+      # Unix timestamp (seconds) for when the job was created.
+      sig { returns(Integer) }
+      attr_accessor :created_at
+
+      # Error payload that explains why generation failed, if applicable.
+      sig { returns(T.nilable(OpenAI::VideoCreateError)) }
+      attr_reader :error
+
+      sig { params(error: T.nilable(OpenAI::VideoCreateError::OrHash)).void }
+      attr_writer :error
+
+      # Unix timestamp (seconds) for when the downloadable assets expire, if set.
+      sig { returns(T.nilable(Integer)) }
+      attr_accessor :expires_at
+
+      # The video generation model that produced the job.
+      sig { returns(OpenAI::VideoModel::TaggedSymbol) }
+      attr_accessor :model
+
+      # The object type, which is always `video`.
+      sig { returns(Symbol) }
+      attr_accessor :object
+
+      # Approximate completion percentage for the generation task.
+      sig { returns(Integer) }
+      attr_accessor :progress
+
+      # Identifier of the source video if this video is a remix.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :remixed_from_video_id
+
+      # Duration of the generated clip in seconds.
+      sig { returns(OpenAI::VideoSeconds::TaggedSymbol) }
+      attr_accessor :seconds
+
+      # The resolution of the generated video.
+      sig { returns(OpenAI::VideoSize::TaggedSymbol) }
+      attr_accessor :size
+
+      # Current lifecycle status of the video job.
+      sig { returns(OpenAI::Video::Status::TaggedSymbol) }
+      attr_accessor :status
+
+      # Structured information describing a generated video job.
+      sig do
+        params(
+          id: String,
+          completed_at: T.nilable(Integer),
+          created_at: Integer,
+          error: T.nilable(OpenAI::VideoCreateError::OrHash),
+          expires_at: T.nilable(Integer),
+          model: OpenAI::VideoModel::OrSymbol,
+          progress: Integer,
+          remixed_from_video_id: T.nilable(String),
+          seconds: OpenAI::VideoSeconds::OrSymbol,
+          size: OpenAI::VideoSize::OrSymbol,
+          status: OpenAI::Video::Status::OrSymbol,
+          object: Symbol
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Unique identifier for the video job.
+        id:,
+        # Unix timestamp (seconds) for when the job completed, if finished.
+        completed_at:,
+        # Unix timestamp (seconds) for when the job was created.
+        created_at:,
+        # Error payload that explains why generation failed, if applicable.
+        error:,
+        # Unix timestamp (seconds) for when the downloadable assets expire, if set.
+        expires_at:,
+        # The video generation model that produced the job.
+        model:,
+        # Approximate completion percentage for the generation task.
+        progress:,
+        # Identifier of the source video if this video is a remix.
+        remixed_from_video_id:,
+        # Duration of the generated clip in seconds.
+        seconds:,
+        # The resolution of the generated video.
+        size:,
+        # Current lifecycle status of the video job.
+        status:,
+        # The object type, which is always `video`.
+        object: :video
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            completed_at: T.nilable(Integer),
+            created_at: Integer,
+            error: T.nilable(OpenAI::VideoCreateError),
+            expires_at: T.nilable(Integer),
+            model: OpenAI::VideoModel::TaggedSymbol,
+            object: Symbol,
+            progress: Integer,
+            remixed_from_video_id: T.nilable(String),
+            seconds: OpenAI::VideoSeconds::TaggedSymbol,
+            size: OpenAI::VideoSize::TaggedSymbol,
+            status: OpenAI::Video::Status::TaggedSymbol
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # Current lifecycle status of the video job.
+      module Status
+        extend OpenAI::Internal::Type::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, OpenAI::Video::Status) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        QUEUED = T.let(:queued, OpenAI::Video::Status::TaggedSymbol)
+        IN_PROGRESS = T.let(:in_progress, OpenAI::Video::Status::TaggedSymbol)
+        COMPLETED = T.let(:completed, OpenAI::Video::Status::TaggedSymbol)
+        FAILED = T.let(:failed, OpenAI::Video::Status::TaggedSymbol)
+
+        sig { override.returns(T::Array[OpenAI::Video::Status::TaggedSymbol]) }
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/openai/models/video_create_error.rbi

@@ -0,0 +1,26 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    class VideoCreateError < OpenAI::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(OpenAI::VideoCreateError, OpenAI::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :code
+
+      sig { returns(String) }
+      attr_accessor :message
+
+      sig { params(code: String, message: String).returns(T.attached_class) }
+      def self.new(code:, message:)
+      end
+
+      sig { override.returns({ code: String, message: String }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/openai/models/video_create_params.rbi

@@ -0,0 +1,87 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    class VideoCreateParams < OpenAI::Internal::Type::BaseModel
+      extend OpenAI::Internal::Type::RequestParameters::Converter
+      include OpenAI::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(OpenAI::VideoCreateParams, OpenAI::Internal::AnyHash)
+        end
+
+      # Text prompt that describes the video to generate.
+      sig { returns(String) }
+      attr_accessor :prompt
+
+      # Optional image reference that guides generation.
+      sig { returns(T.nilable(OpenAI::Internal::FileInput)) }
+      attr_reader :input_reference
+
+      sig { params(input_reference: OpenAI::Internal::FileInput).void }
+      attr_writer :input_reference
+
+      # The video generation model to use. Defaults to `sora-2`.
+      sig { returns(T.nilable(OpenAI::VideoModel::OrSymbol)) }
+      attr_reader :model
+
+      sig { params(model: OpenAI::VideoModel::OrSymbol).void }
+      attr_writer :model
+
+      # Clip duration in seconds. Defaults to 4 seconds.
+      sig { returns(T.nilable(OpenAI::VideoSeconds::OrSymbol)) }
+      attr_reader :seconds
+
+      sig { params(seconds: OpenAI::VideoSeconds::OrSymbol).void }
+      attr_writer :seconds
+
+      # Output resolution formatted as width x height. Defaults to 720x1280.
+      sig { returns(T.nilable(OpenAI::VideoSize::OrSymbol)) }
+      attr_reader :size
+
+      sig { params(size: OpenAI::VideoSize::OrSymbol).void }
+      attr_writer :size
+
+      sig do
+        params(
+          prompt: String,
+          input_reference: OpenAI::Internal::FileInput,
+          model: OpenAI::VideoModel::OrSymbol,
+          seconds: OpenAI::VideoSeconds::OrSymbol,
+          size: OpenAI::VideoSize::OrSymbol,
+          request_options: OpenAI::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Text prompt that describes the video to generate.
+        prompt:,
+        # Optional image reference that guides generation.
+        input_reference: nil,
+        # The video generation model to use. Defaults to `sora-2`.
+        model: nil,
+        # Clip duration in seconds. Defaults to 4 seconds.
+        seconds: nil,
+        # Output resolution formatted as width x height. Defaults to 720x1280.
+        size: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            prompt: String,
+            input_reference: OpenAI::Internal::FileInput,
+            model: OpenAI::VideoModel::OrSymbol,
+            seconds: OpenAI::VideoSeconds::OrSymbol,
+            size: OpenAI::VideoSize::OrSymbol,
+            request_options: OpenAI::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/openai/models/video_delete_params.rbi

@@ -0,0 +1,27 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    class VideoDeleteParams < OpenAI::Internal::Type::BaseModel
+      extend OpenAI::Internal::Type::RequestParameters::Converter
+      include OpenAI::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(OpenAI::VideoDeleteParams, OpenAI::Internal::AnyHash)
+        end
+
+      sig do
+        params(request_options: OpenAI::RequestOptions::OrHash).returns(
+          T.attached_class
+        )
+      end
+      def self.new(request_options: {})
+      end
+
+      sig { override.returns({ request_options: OpenAI::RequestOptions }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/openai/models/video_delete_response.rbi

@@ -0,0 +1,46 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    class VideoDeleteResponse < OpenAI::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(OpenAI::Models::VideoDeleteResponse, OpenAI::Internal::AnyHash)
+        end
+
+      # Identifier of the deleted video.
+      sig { returns(String) }
+      attr_accessor :id
+
+      # Indicates that the video resource was deleted.
+      sig { returns(T::Boolean) }
+      attr_accessor :deleted
+
+      # The object type that signals the deletion response.
+      sig { returns(Symbol) }
+      attr_accessor :object
+
+      # Confirmation payload returned after deleting a video.
+      sig do
+        params(id: String, deleted: T::Boolean, object: Symbol).returns(
+          T.attached_class
+        )
+      end
+      def self.new(
+        # Identifier of the deleted video.
+        id:,
+        # Indicates that the video resource was deleted.
+        deleted:,
+        # The object type that signals the deletion response.
+        object: :"video.deleted"
+      )
+      end
+
+      sig do
+        override.returns({ id: String, deleted: T::Boolean, object: Symbol })
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/openai/models/video_download_content_params.rbi

@@ -0,0 +1,89 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    class VideoDownloadContentParams < OpenAI::Internal::Type::BaseModel
+      extend OpenAI::Internal::Type::RequestParameters::Converter
+      include OpenAI::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(OpenAI::VideoDownloadContentParams, OpenAI::Internal::AnyHash)
+        end
+
+      # Which downloadable asset to return. Defaults to the MP4 video.
+      sig do
+        returns(
+          T.nilable(OpenAI::VideoDownloadContentParams::Variant::OrSymbol)
+        )
+      end
+      attr_reader :variant
+
+      sig do
+        params(
+          variant: OpenAI::VideoDownloadContentParams::Variant::OrSymbol
+        ).void
+      end
+      attr_writer :variant
+
+      sig do
+        params(
+          variant: OpenAI::VideoDownloadContentParams::Variant::OrSymbol,
+          request_options: OpenAI::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Which downloadable asset to return. Defaults to the MP4 video.
+        variant: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            variant: OpenAI::VideoDownloadContentParams::Variant::OrSymbol,
+            request_options: OpenAI::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # Which downloadable asset to return. Defaults to the MP4 video.
+      module Variant
+        extend OpenAI::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, OpenAI::VideoDownloadContentParams::Variant)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        VIDEO =
+          T.let(
+            :video,
+            OpenAI::VideoDownloadContentParams::Variant::TaggedSymbol
+          )
+        THUMBNAIL =
+          T.let(
+            :thumbnail,
+            OpenAI::VideoDownloadContentParams::Variant::TaggedSymbol
+          )
+        SPRITESHEET =
+          T.let(
+            :spritesheet,
+            OpenAI::VideoDownloadContentParams::Variant::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[OpenAI::VideoDownloadContentParams::Variant::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/openai/models/video_list_params.rbi

@@ -0,0 +1,91 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    class VideoListParams < OpenAI::Internal::Type::BaseModel
+      extend OpenAI::Internal::Type::RequestParameters::Converter
+      include OpenAI::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(OpenAI::VideoListParams, OpenAI::Internal::AnyHash)
+        end
+
+      # Identifier for the last item from the previous pagination request
+      sig { returns(T.nilable(String)) }
+      attr_reader :after
+
+      sig { params(after: String).void }
+      attr_writer :after
+
+      # Number of items to retrieve
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :limit
+
+      sig { params(limit: Integer).void }
+      attr_writer :limit
+
+      # Sort order of results by timestamp. Use `asc` for ascending order or `desc` for
+      # descending order.
+      sig { returns(T.nilable(OpenAI::VideoListParams::Order::OrSymbol)) }
+      attr_reader :order
+
+      sig { params(order: OpenAI::VideoListParams::Order::OrSymbol).void }
+      attr_writer :order
+
+      sig do
+        params(
+          after: String,
+          limit: Integer,
+          order: OpenAI::VideoListParams::Order::OrSymbol,
+          request_options: OpenAI::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Identifier for the last item from the previous pagination request
+        after: nil,
+        # Number of items to retrieve
+        limit: nil,
+        # Sort order of results by timestamp. Use `asc` for ascending order or `desc` for
+        # descending order.
+        order: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            after: String,
+            limit: Integer,
+            order: OpenAI::VideoListParams::Order::OrSymbol,
+            request_options: OpenAI::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # Sort order of results by timestamp. Use `asc` for ascending order or `desc` for
+      # descending order.
+      module Order
+        extend OpenAI::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, OpenAI::VideoListParams::Order) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        ASC = T.let(:asc, OpenAI::VideoListParams::Order::TaggedSymbol)
+        DESC = T.let(:desc, OpenAI::VideoListParams::Order::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[OpenAI::VideoListParams::Order::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/openai/models/video_model.rbi

@@ -0,0 +1,19 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    module VideoModel
+      extend OpenAI::Internal::Type::Enum
+
+      TaggedSymbol = T.type_alias { T.all(Symbol, OpenAI::VideoModel) }
+      OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+      SORA_2 = T.let(:"sora-2", OpenAI::VideoModel::TaggedSymbol)
+      SORA_2_PRO = T.let(:"sora-2-pro", OpenAI::VideoModel::TaggedSymbol)
+
+      sig { override.returns(T::Array[OpenAI::VideoModel::TaggedSymbol]) }
+      def self.values
+      end
+    end
+  end
+end

data/rbi/openai/models/video_remix_params.rbi

@@ -0,0 +1,40 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    class VideoRemixParams < OpenAI::Internal::Type::BaseModel
+      extend OpenAI::Internal::Type::RequestParameters::Converter
+      include OpenAI::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(OpenAI::VideoRemixParams, OpenAI::Internal::AnyHash)
+        end
+
+      # Updated text prompt that directs the remix generation.
+      sig { returns(String) }
+      attr_accessor :prompt
+
+      sig do
+        params(
+          prompt: String,
+          request_options: OpenAI::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Updated text prompt that directs the remix generation.
+        prompt:,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          { prompt: String, request_options: OpenAI::RequestOptions }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/openai/models/video_retrieve_params.rbi

@@ -0,0 +1,27 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    class VideoRetrieveParams < OpenAI::Internal::Type::BaseModel
+      extend OpenAI::Internal::Type::RequestParameters::Converter
+      include OpenAI::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(OpenAI::VideoRetrieveParams, OpenAI::Internal::AnyHash)
+        end
+
+      sig do
+        params(request_options: OpenAI::RequestOptions::OrHash).returns(
+          T.attached_class
+        )
+      end
+      def self.new(request_options: {})
+      end
+
+      sig { override.returns({ request_options: OpenAI::RequestOptions }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/openai/models/video_seconds.rbi

@@ -0,0 +1,20 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    module VideoSeconds
+      extend OpenAI::Internal::Type::Enum
+
+      TaggedSymbol = T.type_alias { T.all(Symbol, OpenAI::VideoSeconds) }
+      OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+      VIDEO_SECONDS_4 = T.let(:"4", OpenAI::VideoSeconds::TaggedSymbol)
+      VIDEO_SECONDS_8 = T.let(:"8", OpenAI::VideoSeconds::TaggedSymbol)
+      VIDEO_SECONDS_12 = T.let(:"12", OpenAI::VideoSeconds::TaggedSymbol)
+
+      sig { override.returns(T::Array[OpenAI::VideoSeconds::TaggedSymbol]) }
+      def self.values
+      end
+    end
+  end
+end

data/rbi/openai/models/video_size.rbi

@@ -0,0 +1,23 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    module VideoSize
+      extend OpenAI::Internal::Type::Enum
+
+      TaggedSymbol = T.type_alias { T.all(Symbol, OpenAI::VideoSize) }
+      OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+      VIDEO_SIZE_720X1280 = T.let(:"720x1280", OpenAI::VideoSize::TaggedSymbol)
+      VIDEO_SIZE_1280X720 = T.let(:"1280x720", OpenAI::VideoSize::TaggedSymbol)
+      VIDEO_SIZE_1024X1792 =
+        T.let(:"1024x1792", OpenAI::VideoSize::TaggedSymbol)
+      VIDEO_SIZE_1792X1024 =
+        T.let(:"1792x1024", OpenAI::VideoSize::TaggedSymbol)
+
+      sig { override.returns(T::Array[OpenAI::VideoSize::TaggedSymbol]) }
+      def self.values
+      end
+    end
+  end
+end