openai 0.13.0 → 0.14.0

data/rbi/openai/models/image_gen_partial_image_event.rbi

@@ -0,0 +1,243 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    class ImageGenPartialImageEvent < OpenAI::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(OpenAI::ImageGenPartialImageEvent, OpenAI::Internal::AnyHash)
+        end
+
+      # Base64-encoded partial image data, suitable for rendering as an image.
+      sig { returns(String) }
+      attr_accessor :b64_json
+
+      # The background setting for the requested image.
+      sig do
+        returns(OpenAI::ImageGenPartialImageEvent::Background::TaggedSymbol)
+      end
+      attr_accessor :background
+
+      # The Unix timestamp when the event was created.
+      sig { returns(Integer) }
+      attr_accessor :created_at
+
+      # The output format for the requested image.
+      sig do
+        returns(OpenAI::ImageGenPartialImageEvent::OutputFormat::TaggedSymbol)
+      end
+      attr_accessor :output_format
+
+      # 0-based index for the partial image (streaming).
+      sig { returns(Integer) }
+      attr_accessor :partial_image_index
+
+      # The quality setting for the requested image.
+      sig { returns(OpenAI::ImageGenPartialImageEvent::Quality::TaggedSymbol) }
+      attr_accessor :quality
+
+      # The size of the requested image.
+      sig { returns(OpenAI::ImageGenPartialImageEvent::Size::TaggedSymbol) }
+      attr_accessor :size
+
+      # The type of the event. Always `image_generation.partial_image`.
+      sig { returns(Symbol) }
+      attr_accessor :type
+
+      # Emitted when a partial image is available during image generation streaming.
+      sig do
+        params(
+          b64_json: String,
+          background: OpenAI::ImageGenPartialImageEvent::Background::OrSymbol,
+          created_at: Integer,
+          output_format:
+            OpenAI::ImageGenPartialImageEvent::OutputFormat::OrSymbol,
+          partial_image_index: Integer,
+          quality: OpenAI::ImageGenPartialImageEvent::Quality::OrSymbol,
+          size: OpenAI::ImageGenPartialImageEvent::Size::OrSymbol,
+          type: Symbol
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Base64-encoded partial image data, suitable for rendering as an image.
+        b64_json:,
+        # The background setting for the requested image.
+        background:,
+        # The Unix timestamp when the event was created.
+        created_at:,
+        # The output format for the requested image.
+        output_format:,
+        # 0-based index for the partial image (streaming).
+        partial_image_index:,
+        # The quality setting for the requested image.
+        quality:,
+        # The size of the requested image.
+        size:,
+        # The type of the event. Always `image_generation.partial_image`.
+        type: :"image_generation.partial_image"
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            b64_json: String,
+            background:
+              OpenAI::ImageGenPartialImageEvent::Background::TaggedSymbol,
+            created_at: Integer,
+            output_format:
+              OpenAI::ImageGenPartialImageEvent::OutputFormat::TaggedSymbol,
+            partial_image_index: Integer,
+            quality: OpenAI::ImageGenPartialImageEvent::Quality::TaggedSymbol,
+            size: OpenAI::ImageGenPartialImageEvent::Size::TaggedSymbol,
+            type: Symbol
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # The background setting for the requested image.
+      module Background
+        extend OpenAI::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, OpenAI::ImageGenPartialImageEvent::Background)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        TRANSPARENT =
+          T.let(
+            :transparent,
+            OpenAI::ImageGenPartialImageEvent::Background::TaggedSymbol
+          )
+        OPAQUE =
+          T.let(
+            :opaque,
+            OpenAI::ImageGenPartialImageEvent::Background::TaggedSymbol
+          )
+        AUTO =
+          T.let(
+            :auto,
+            OpenAI::ImageGenPartialImageEvent::Background::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[
+              OpenAI::ImageGenPartialImageEvent::Background::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
+      end
+
+      # The output format for the requested image.
+      module OutputFormat
+        extend OpenAI::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, OpenAI::ImageGenPartialImageEvent::OutputFormat)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        PNG =
+          T.let(
+            :png,
+            OpenAI::ImageGenPartialImageEvent::OutputFormat::TaggedSymbol
+          )
+        WEBP =
+          T.let(
+            :webp,
+            OpenAI::ImageGenPartialImageEvent::OutputFormat::TaggedSymbol
+          )
+        JPEG =
+          T.let(
+            :jpeg,
+            OpenAI::ImageGenPartialImageEvent::OutputFormat::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[
+              OpenAI::ImageGenPartialImageEvent::OutputFormat::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
+      end
+
+      # The quality setting for the requested image.
+      module Quality
+        extend OpenAI::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, OpenAI::ImageGenPartialImageEvent::Quality)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        LOW =
+          T.let(:low, OpenAI::ImageGenPartialImageEvent::Quality::TaggedSymbol)
+        MEDIUM =
+          T.let(
+            :medium,
+            OpenAI::ImageGenPartialImageEvent::Quality::TaggedSymbol
+          )
+        HIGH =
+          T.let(:high, OpenAI::ImageGenPartialImageEvent::Quality::TaggedSymbol)
+        AUTO =
+          T.let(:auto, OpenAI::ImageGenPartialImageEvent::Quality::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[OpenAI::ImageGenPartialImageEvent::Quality::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+
+      # The size of the requested image.
+      module Size
+        extend OpenAI::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, OpenAI::ImageGenPartialImageEvent::Size)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        SIZE_1024X1024 =
+          T.let(
+            :"1024x1024",
+            OpenAI::ImageGenPartialImageEvent::Size::TaggedSymbol
+          )
+        SIZE_1024X1536 =
+          T.let(
+            :"1024x1536",
+            OpenAI::ImageGenPartialImageEvent::Size::TaggedSymbol
+          )
+        SIZE_1536X1024 =
+          T.let(
+            :"1536x1024",
+            OpenAI::ImageGenPartialImageEvent::Size::TaggedSymbol
+          )
+        AUTO =
+          T.let(:auto, OpenAI::ImageGenPartialImageEvent::Size::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[OpenAI::ImageGenPartialImageEvent::Size::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/openai/models/image_gen_stream_event.rbi

@@ -0,0 +1,22 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    # Emitted when a partial image is available during image generation streaming.
+    module ImageGenStreamEvent
+      extend OpenAI::Internal::Type::Union
+
+      Variants =
+        T.type_alias do
+          T.any(
+            OpenAI::ImageGenPartialImageEvent,
+            OpenAI::ImageGenCompletedEvent
+          )
+        end
+
+      sig { override.returns(T::Array[OpenAI::ImageGenStreamEvent::Variants]) }
+      def self.variants
+      end
+    end
+  end
+end

data/rbi/openai/models/image_generate_params.rbi

@@ -60,6 +60,12 @@ module OpenAI
       end
       attr_accessor :output_format
 
+      # The number of partial images to generate. This parameter is used for streaming
+      # responses that return partial images. Value must be between 0 and 3. When set to
+      # 0, the response will be a single image sent in one streaming event.
+      sig { returns(T.nilable(Integer)) }
+      attr_accessor :partial_images
+
       # The quality of the image that will be generated.
       #
       # - `auto` (default value) will automatically select the best quality for the
@@ -116,6 +122,7 @@ module OpenAI
           output_compression: T.nilable(Integer),
           output_format:
             T.nilable(OpenAI::ImageGenerateParams::OutputFormat::OrSymbol),
+          partial_images: T.nilable(Integer),
           quality: T.nilable(OpenAI::ImageGenerateParams::Quality::OrSymbol),
           response_format:
             T.nilable(OpenAI::ImageGenerateParams::ResponseFormat::OrSymbol),
@@ -155,6 +162,10 @@ module OpenAI
         # The format in which the generated images are returned. This parameter is only
         # supported for `gpt-image-1`. Must be one of `png`, `jpeg`, or `webp`.
         output_format: nil,
+        # The number of partial images to generate. This parameter is used for streaming
+        # responses that return partial images. Value must be between 0 and 3. When set to
+        # 0, the response will be a single image sent in one streaming event.
+        partial_images: nil,
         # The quality of the image that will be generated.
         #
         # - `auto` (default value) will automatically select the best quality for the
@@ -199,6 +210,7 @@ module OpenAI
             output_compression: T.nilable(Integer),
             output_format:
               T.nilable(OpenAI::ImageGenerateParams::OutputFormat::OrSymbol),
+            partial_images: T.nilable(Integer),
             quality: T.nilable(OpenAI::ImageGenerateParams::Quality::OrSymbol),
             response_format:
               T.nilable(OpenAI::ImageGenerateParams::ResponseFormat::OrSymbol),

data/rbi/openai/models/responses/response_output_refusal.rbi

@@ -12,7 +12,7 @@ module OpenAI
             )
           end
 
-        # The refusal explanationfrom the model.
+        # The refusal explanation from the model.
         sig { returns(String) }
         attr_accessor :refusal
 
@@ -23,7 +23,7 @@ module OpenAI
         # A refusal from the model.
         sig { params(refusal: String, type: Symbol).returns(T.attached_class) }
         def self.new(
-          # The refusal explanationfrom the model.
+          # The refusal explanation from the model.
           refusal:,
           # The type of the refusal. Always `refusal`.
           type: :refusal

data/rbi/openai/models/responses/tool.rbi

@@ -565,6 +565,18 @@ module OpenAI
           end
           attr_writer :background
 
+          # Control how much effort the model will exert to match the style and features,
+          # especially facial features, of input images. This parameter is only supported
+          # for `gpt-image-1`. Supports `high` and `low`. Defaults to `low`.
+          sig do
+            returns(
+              T.nilable(
+                OpenAI::Responses::Tool::ImageGeneration::InputFidelity::OrSymbol
+              )
+            )
+          end
+          attr_accessor :input_fidelity
+
           # Optional mask for inpainting. Contains `image_url` (string, optional) and
           # `file_id` (string, optional).
           sig do
@@ -695,6 +707,10 @@ module OpenAI
             params(
               background:
                 OpenAI::Responses::Tool::ImageGeneration::Background::OrSymbol,
+              input_fidelity:
+                T.nilable(
+                  OpenAI::Responses::Tool::ImageGeneration::InputFidelity::OrSymbol
+                ),
               input_image_mask:
                 OpenAI::Responses::Tool::ImageGeneration::InputImageMask::OrHash,
               model: OpenAI::Responses::Tool::ImageGeneration::Model::OrSymbol,
@@ -714,6 +730,10 @@ module OpenAI
             # Background type for the generated image. One of `transparent`, `opaque`, or
             # `auto`. Default: `auto`.
             background: nil,
+            # Control how much effort the model will exert to match the style and features,
+            # especially facial features, of input images. This parameter is only supported
+            # for `gpt-image-1`. Supports `high` and `low`. Defaults to `low`.
+            input_fidelity: nil,
             # Optional mask for inpainting. Contains `image_url` (string, optional) and
             # `file_id` (string, optional).
             input_image_mask: nil,
@@ -746,6 +766,10 @@ module OpenAI
                 type: Symbol,
                 background:
                   OpenAI::Responses::Tool::ImageGeneration::Background::OrSymbol,
+                input_fidelity:
+                  T.nilable(
+                    OpenAI::Responses::Tool::ImageGeneration::InputFidelity::OrSymbol
+                  ),
                 input_image_mask:
                   OpenAI::Responses::Tool::ImageGeneration::InputImageMask,
                 model:
@@ -806,6 +830,43 @@ module OpenAI
             end
           end
 
+          # Control how much effort the model will exert to match the style and features,
+          # especially facial features, of input images. This parameter is only supported
+          # for `gpt-image-1`. Supports `high` and `low`. Defaults to `low`.
+          module InputFidelity
+            extend OpenAI::Internal::Type::Enum
+
+            TaggedSymbol =
+              T.type_alias do
+                T.all(
+                  Symbol,
+                  OpenAI::Responses::Tool::ImageGeneration::InputFidelity
+                )
+              end
+            OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+            HIGH =
+              T.let(
+                :high,
+                OpenAI::Responses::Tool::ImageGeneration::InputFidelity::TaggedSymbol
+              )
+            LOW =
+              T.let(
+                :low,
+                OpenAI::Responses::Tool::ImageGeneration::InputFidelity::TaggedSymbol
+              )
+
+            sig do
+              override.returns(
+                T::Array[
+                  OpenAI::Responses::Tool::ImageGeneration::InputFidelity::TaggedSymbol
+                ]
+              )
+            end
+            def self.values
+            end
+          end
+
           class InputImageMask < OpenAI::Internal::Type::BaseModel
             OrHash =
               T.type_alias do

data/rbi/openai/models.rbi

@@ -115,10 +115,22 @@ module OpenAI
 
   ImageCreateVariationParams = OpenAI::Models::ImageCreateVariationParams
 
+  ImageEditCompletedEvent = OpenAI::Models::ImageEditCompletedEvent
+
   ImageEditParams = OpenAI::Models::ImageEditParams
 
+  ImageEditPartialImageEvent = OpenAI::Models::ImageEditPartialImageEvent
+
+  ImageEditStreamEvent = OpenAI::Models::ImageEditStreamEvent
+
+  ImageGenCompletedEvent = OpenAI::Models::ImageGenCompletedEvent
+
   ImageGenerateParams = OpenAI::Models::ImageGenerateParams
 
+  ImageGenPartialImageEvent = OpenAI::Models::ImageGenPartialImageEvent
+
+  ImageGenStreamEvent = OpenAI::Models::ImageGenStreamEvent
+
   ImageModel = OpenAI::Models::ImageModel
 
   ImagesResponse = OpenAI::Models::ImagesResponse