openai 0.86.0 → 0.87.0

data/lib/openai/models/webhooks/realtime_call_incoming_webhook_event.rb

@@ -55,8 +55,10 @@ module OpenAI
         # @see OpenAI::Models::Webhooks::RealtimeCallIncomingWebhookEvent#data
         class Data < OpenAI::Internal::Type::BaseModel
           # @!attribute call_id
-          #   The Transceiver `rtc_...` ID of the pending SIP session. The same value appears
-          #   as `session_id` in `live.call.incoming`.
+          #   The Transceiver `rtc_...` ID of the pending SIP session. The paired
+          #   `live.call.incoming` event derives its `session_id` by replacing the `rtc_`
+          #   prefix with `live_`. Use the ID returned by the event with the corresponding
+          #   Realtime or Live API.
           #
           #   @return [String]
           required :call_id, String
@@ -77,7 +79,7 @@ module OpenAI
           #
           #   Event data payload.
           #
-          #   @param call_id [String] The Transceiver `rtc_...` ID of the pending SIP session. The same
+          #   @param call_id [String] The Transceiver `rtc_...` ID of the pending SIP session. The paired
           #
           #   @param sip_headers [Array<OpenAI::Models::Webhooks::RealtimeCallIncomingWebhookEvent::Data::SipHeader>] Headers from the SIP Invite.
 

data/lib/openai/resources/images.rb

@@ -51,8 +51,7 @@ module OpenAI
       # {OpenAI::Models::ImageEditParams} for more details.
       #
       # Creates an edited or extended image given one or more source images and a
-      # prompt. This endpoint supports GPT Image models (`gpt-image-1.5`, `gpt-image-1`,
-      # `gpt-image-1-mini`, and `chatgpt-image-latest`) and `dall-e-2`.
+      # prompt. This endpoint supports GPT Image models and `dall-e-2`.
       #
       # `String`, `StringIO`, and pathless `IO` inputs are sent with generic upload
       # metadata. Use `OpenAI::FilePart` when you need to override the filename or
@@ -64,7 +63,7 @@ module OpenAI
       #
       # @param prompt [String] A text description of the desired image(s). The maximum length is 1000 character
       #
-      # @param background [Symbol, OpenAI::Models::ImageEditParams::Background, nil] Allows to set transparency for the background of the generated image(s).
+      # @param background [Symbol, OpenAI::Models::ImageEditParams::Background, nil] Allows to set transparency for the background of the generated image(s). Must
       #
       # @param input_fidelity [Symbol, OpenAI::Models::ImageEditParams::InputFidelity, nil] Control how much effort the model will exert to match the style and features, es
       #
@@ -80,11 +79,11 @@ module OpenAI
       #
       # @param partial_images [Integer, nil] The number of partial images to generate. This parameter is used for
       #
-      # @param quality [Symbol, OpenAI::Models::ImageEditParams::Quality, nil] The quality of the image that will be generated for GPT image models. Defaults t
+      # @param quality [Symbol, OpenAI::Models::ImageEditParams::Quality, nil] The quality of the image that will be generated for GPT image models. The GPT im
       #
       # @param response_format [Symbol, OpenAI::Models::ImageEditParams::ResponseFormat, nil] The format in which the generated images are returned. Must be one of `url` or `
       #
-      # @param size [String, Symbol, OpenAI::Models::ImageEditParams::Size, nil] The size of the generated images. For `gpt-image-2` and `gpt-image-2-2026-04-21`
+      # @param size [String, Symbol, OpenAI::Models::ImageEditParams::Size, nil] The size of the generated images. For `gpt-image-2`, `gpt-image-2-2026-04-21`, `
       #
       # @param user [String] A unique identifier representing your end-user, which can help OpenAI to monitor
       #
@@ -117,8 +116,7 @@ module OpenAI
       # {OpenAI::Models::ImageEditParams} for more details.
       #
       # Creates an edited or extended image given one or more source images and a
-      # prompt. This endpoint supports GPT Image models (`gpt-image-1.5`, `gpt-image-1`,
-      # `gpt-image-1-mini`, and `chatgpt-image-latest`) and `dall-e-2`.
+      # prompt. This endpoint supports GPT Image models and `dall-e-2`.
       #
       # `String`, `StringIO`, and pathless `IO` inputs are sent with generic upload
       # metadata. Use `OpenAI::FilePart` when you need to override the filename or
@@ -130,7 +128,7 @@ module OpenAI
       #
       # @param prompt [String] A text description of the desired image(s). The maximum length is 1000 character
       #
-      # @param background [Symbol, OpenAI::Models::ImageEditParams::Background, nil] Allows to set transparency for the background of the generated image(s).
+      # @param background [Symbol, OpenAI::Models::ImageEditParams::Background, nil] Allows to set transparency for the background of the generated image(s). Must
       #
       # @param input_fidelity [Symbol, OpenAI::Models::ImageEditParams::InputFidelity, nil] Control how much effort the model will exert to match the style and features, es
       #
@@ -146,11 +144,11 @@ module OpenAI
       #
       # @param partial_images [Integer, nil] The number of partial images to generate. This parameter is used for
       #
-      # @param quality [Symbol, OpenAI::Models::ImageEditParams::Quality, nil] The quality of the image that will be generated for GPT image models. Defaults t
+      # @param quality [Symbol, OpenAI::Models::ImageEditParams::Quality, nil] The quality of the image that will be generated for GPT image models. The GPT im
       #
       # @param response_format [Symbol, OpenAI::Models::ImageEditParams::ResponseFormat, nil] The format in which the generated images are returned. Must be one of `url` or `
       #
-      # @param size [String, Symbol, OpenAI::Models::ImageEditParams::Size, nil] The size of the generated images. For `gpt-image-2` and `gpt-image-2-2026-04-21`
+      # @param size [String, Symbol, OpenAI::Models::ImageEditParams::Size, nil] The size of the generated images. For `gpt-image-2`, `gpt-image-2-2026-04-21`, `
       #
       # @param user [String] A unique identifier representing your end-user, which can help OpenAI to monitor
       #
@@ -195,7 +193,7 @@ module OpenAI
       #
       # @param prompt [String] A text description of the desired image(s). The maximum length is 32000 characte
       #
-      # @param background [Symbol, OpenAI::Models::ImageGenerateParams::Background, nil] Allows to set transparency for the background of the generated image(s).
+      # @param background [Symbol, OpenAI::Models::ImageGenerateParams::Background, nil] Allows to set transparency for the background of the generated image(s). Must
       #
       # @param model [String, Symbol, OpenAI::Models::ImageModel, nil] The model to use for image generation. One of `dall-e-2`, `dall-e-3`, or a GPT i
       #
@@ -213,7 +211,7 @@ module OpenAI
       #
       # @param response_format [Symbol, OpenAI::Models::ImageGenerateParams::ResponseFormat, nil] The format in which generated images with `dall-e-2` and `dall-e-3` are returned
       #
-      # @param size [String, Symbol, OpenAI::Models::ImageGenerateParams::Size, nil] The size of the generated images. For `gpt-image-2` and `gpt-image-2-2026-04-21`
+      # @param size [String, Symbol, OpenAI::Models::ImageGenerateParams::Size, nil] The size of the generated images. For `gpt-image-2`, `gpt-image-2-2026-04-21`, `
       #
       # @param style [Symbol, OpenAI::Models::ImageGenerateParams::Style, nil] The style of the generated images. This parameter is only supported for `dall-e-
       #
@@ -253,7 +251,7 @@ module OpenAI
       #
       # @param prompt [String] A text description of the desired image(s). The maximum length is 32000 characte
       #
-      # @param background [Symbol, OpenAI::Models::ImageGenerateParams::Background, nil] Allows to set transparency for the background of the generated image(s).
+      # @param background [Symbol, OpenAI::Models::ImageGenerateParams::Background, nil] Allows to set transparency for the background of the generated image(s). Must
       #
       # @param model [String, Symbol, OpenAI::Models::ImageModel, nil] The model to use for image generation. One of `dall-e-2`, `dall-e-3`, or a GPT i
       #
@@ -271,7 +269,7 @@ module OpenAI
       #
       # @param response_format [Symbol, OpenAI::Models::ImageGenerateParams::ResponseFormat, nil] The format in which generated images with `dall-e-2` and `dall-e-3` are returned
       #
-      # @param size [String, Symbol, OpenAI::Models::ImageGenerateParams::Size, nil] The size of the generated images. For `gpt-image-2` and `gpt-image-2-2026-04-21`
+      # @param size [String, Symbol, OpenAI::Models::ImageGenerateParams::Size, nil] The size of the generated images. For `gpt-image-2`, `gpt-image-2-2026-04-21`, `
       #
       # @param style [Symbol, OpenAI::Models::ImageGenerateParams::Style, nil] The style of the generated images. This parameter is only supported for `dall-e-
       #

data/lib/openai/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module OpenAI
-  VERSION = "0.86.0"
+  VERSION = "0.87.0"
 end

data/local-audio.md

@@ -0,0 +1,146 @@
+# Local recording and playback
+
+Use `OpenAI::LocalAudio` to record a finite microphone clip or play generated
+speech. These helpers run separately installed FFmpeg and FFplay executables.
+They do not add native gem dependencies. Loading `openai` or the helper does not
+open a device; calling `record` or `play` starts the corresponding operation.
+
+## Setup
+
+Install FFmpeg and FFplay and make both executables available on `PATH`. Your
+FFmpeg build must include the capture backend for your operating system. Allow
+microphone access in your operating system when recording.
+
+With `OPENAI_API_KEY` configured, run:
+
+```sh
+bundle exec ruby examples/audio/record_and_play.rb
+```
+
+The example records five seconds, uploads the clip for transcription, prints the
+transcript, and plays generated speech. Models and voice are constants at the top
+of the example so they are easy to change.
+
+## Record a clip
+
+```ruby
+require "openai"
+require "openai/helpers/local_audio"
+
+client = OpenAI::Client.new
+clip = OpenAI::LocalAudio.record(duration: 5, timeout: 10)
+transcript = client.audio.transcriptions.create(model: "gpt-transcribe", file: clip)
+puts(transcript.text)
+```
+
+`record(duration:, device: nil, timeout: nil)` returns an `OpenAI::FilePart`
+containing a rewound `StringIO`, named `audio.wav` with content type `audio/wav`.
+The audio is mono, 24 kHz, signed 16-bit PCM. The helper buffers the recording in
+memory, so memory use grows with recording duration.
+
+`duration` is required and must be positive and finite. `timeout` is an optional
+positive, finite wall-clock deadline in seconds. An expired deadline raises an
+error rather than returning a partial recording.
+
+### Choose a microphone
+
+On macOS and Linux, omitting `device:` uses the capture backend's default device.
+To select another microphone, pass `device:` directly:
+
+```ruby
+# macOS: AVFoundation audio device index (or its device name).
+clip = OpenAI::LocalAudio.record(duration: 5, device: 0)
+
+# Linux: ALSA device name; integer 0 is shorthand for "hw:0".
+clip = OpenAI::LocalAudio.record(duration: 5, device: "hw:0")
+
+# Windows: DirectShow requires an explicit audio device name.
+clip = OpenAI::LocalAudio.record(duration: 5, device: "Microphone (USB Audio)")
+```
+
+For Windows, add the appropriate `device:` argument to the example's `record`
+call. There is no device environment variable to configure. Device names and
+indices are local to your machine and may change when hardware is reconnected.
+
+List capture devices using your platform's tools:
+
+```sh
+# macOS (FFmpeg prints the list and exits without recording)
+ffmpeg -f avfoundation -list_devices true -i ""
+
+# Linux
+arecord -L
+
+# Windows (FFmpeg prints the list and exits without recording)
+ffmpeg -list_devices true -f dshow -i dummy
+```
+
+## Play speech
+
+```ruby
+speech = client.audio.speech.create(
+  model: "gpt-4o-mini-tts",
+  voice: "marin",
+  input: "Recording complete."
+)
+OpenAI::LocalAudio.play(speech, timeout: 30)
+```
+
+`play(source, format: :auto, timeout: nil)` waits for FFplay to finish and returns
+`nil`. It accepts `IO`, `StringIO`, or a `FilePart` containing IO or binary bytes.
+It reads from the source's current position and leaves caller-owned IO open. Bare
+strings are not interpreted as file paths or URLs.
+
+The default `format: :auto` supports self-contained WAV, MP3, Ogg, AAC and FLAC
+streams. For headerless mono 24 kHz signed little-endian PCM16, pass
+`format: :pcm`. PCM must end on a complete two-byte sample. Playback uses FFplay's
+configured output device; this helper has no output-device selector.
+
+Both methods close their pipes and terminate/reap owned subprocesses on errors
+or interruption. Errors are under `OpenAI::LocalAudio::Error`:
+`DependencyError`, `UnsupportedPlatformError`, `DeviceError`, `PlaybackError`,
+`FormatError`, and `TimeoutError`. Media subprocesses receive a restricted
+environment without the API key, and their diagnostics are not included in
+exceptions. FFplay can exit successfully despite a decoder or device error, so
+the helper drains error-level diagnostics through a pipe, retaining only whether
+an error occurred. Diagnostic contents are discarded and never written to disk.
+
+## Model choices
+
+Checked against OpenAI documentation on September 8, 2026:
+
+- [`gpt-transcribe`](https://developers.openai.com/api/docs/guides/speech-to-text) is the recommended model for general-purpose file transcription.
+- [`gpt-4o-mini-tts`](https://developers.openai.com/api/docs/guides/text-to-speech) is the current recommended speech-generation model; `marin` is one of the recommended voices for quality.
+
+## Realtime applications
+
+For streaming audio and conversation events, use the existing
+[Realtime API helpers](realtime.md) and [Realtime examples](examples/realtime/README.md).
+The finite helpers here do not manage a continuous microphone stream,
+interruptible voice conversation, echo cancellation, or playback-position tracking.
+
+## End-to-end verification
+
+Run the actual recording example against the live API without opening physical
+devices:
+
+```sh
+bundle exec ruby scripts/test-local-audio-examples.rb
+```
+
+To also run the invalid-audio regression against installed FFplay:
+
+```sh
+OPENAI_AUDIO_FFPLAY_TEST=1 bundle exec ruby test/openai/helpers/local_audio_test.rb
+```
+
+This opt-in test requires `OPENAI_API_KEY`, FFmpeg and FFplay and makes paid API
+calls. It generates synthetic speech, substitutes that file for microphone input,
+runs real FFmpeg capture and transcription, generates speech, and plays it through
+FFplay's dummy output driver. It checks the transcription and successful example
+completion with a 90-second example deadline. Captured API output is not logged;
+temporary synthetic media is removed on normal exit or exceptions.
+
+This verifies the software flow, not physical microphone permissions, speaker
+output, or device compatibility. Physical hardware and platform behavior must be
+checked on the intended host.

data/rbi/openai/helpers/local_audio/interface.rbi

@@ -0,0 +1,110 @@
+# typed: strong
+
+module OpenAI
+  module LocalAudio
+    sig {
+      params(duration: Numeric, device: T.nilable(T.any(String, Integer)), timeout: T.nilable(Numeric)).returns(
+        OpenAI::FilePart
+      )
+    }
+    def self.record(duration:, device: nil, timeout: nil)
+    end
+
+    sig {
+      params(source: T.any(IO, StringIO, OpenAI::FilePart), format: Symbol, timeout: T.nilable(Numeric)).returns(
+        NilClass
+      )
+    }
+    def self.play(source, format: :auto, timeout: nil)
+    end
+
+    # @api private
+    sig { params(source: T.any(IO, StringIO, OpenAI::FilePart)).returns(T.any(IO, StringIO)) }
+    def self.playback_source(source)
+    end
+
+    # @api private
+    sig { params(device: T.nilable(T.any(String, Integer)), platform: String).returns([String, String]) }
+    def self.capture_device(device, platform: RUBY_PLATFORM)
+    end
+
+    # @api private
+    sig { params(bytes: Integer).returns(String) }
+    def self.wav_header(bytes)
+    end
+
+    # @api private
+    class MediaProcess
+      sig { returns(T::Hash[String, String]) }
+      def self.environment
+      end
+
+      sig { returns(Float) }
+      def self.clock
+      end
+
+      sig { params(value: Numeric, name: T.any(String, Symbol)).returns(Float) }
+      def self.duration(value, name:)
+      end
+
+      sig {
+        params(
+          argv: T::Array[String],
+          input: T.any(IO, String),
+          output: T.any(IO, String),
+          timeout: T.nilable(Numeric),
+          capture_errors: T::Boolean
+        )
+          .void
+      }
+      def initialize(argv, input:, output:, timeout:, capture_errors: false)
+      end
+
+      sig { void }
+      def check_deadline
+      end
+
+      sig { returns(T::Boolean) }
+      def errors?
+      end
+
+      sig { params(io: T.any(IO, StringIO), stop_on_exit: T::Boolean).returns(T.nilable(String)) }
+      def read(io, stop_on_exit: false)
+      end
+
+      sig { params(io: IO, bytes: String).void }
+      def write(io, bytes)
+      end
+
+      sig { returns(Process::Status) }
+      def wait
+      end
+
+      sig { void }
+      def close
+      end
+    end
+
+    class Error < OpenAI::Errors::Error
+    end
+
+    class DependencyError < OpenAI::LocalAudio::Error
+    end
+
+    class UnsupportedPlatformError < OpenAI::LocalAudio::Error
+    end
+
+    class DeviceError < OpenAI::LocalAudio::Error
+    end
+
+    class PlaybackError < OpenAI::LocalAudio::Error
+    end
+
+    class TimeoutError < OpenAI::LocalAudio::Error
+    end
+
+    class FormatError < OpenAI::LocalAudio::Error
+    end
+
+  end
+end

data/rbi/openai/helpers/realtime/connection.rbi

@@ -39,9 +39,9 @@ module OpenAI
 
         # @api private
         sig do
-          params(socket: T.untyped, url: URI::Generic).returns(T.attached_class)
+          params(socket: T.untyped, url: URI::Generic, recovery: T.untyped).returns(T.attached_class)
         end
-        def self.new(socket:, url:)
+        def self.new(socket:, url:, recovery: nil)
         end
 
         sig do
@@ -75,6 +75,22 @@ module OpenAI
         def send_raw(data)
         end
 
+        sig { returns(T::Boolean) }
+        def reconnecting?
+        end
+
+        sig { returns(T::Array[String]) }
+        def pending_messages
+        end
+
+        sig { returns(T::Array[String]) }
+        def take_pending_messages
+        end
+
+        sig { void }
+        def flush_pending
+        end
+
         sig { params(code: Integer, reason: String).void }
         def close(code: 1000, reason: "")
         end

data/rbi/openai/helpers/realtime/extensions.rbi

@@ -98,6 +98,10 @@ module OpenAI
       sig do
         params(
           model: String,
+          reconnect: T::Boolean,
+          max_reconnect_attempts: Integer,
+          max_queue_bytes: Integer,
+          on_reconnected: T.nilable(T.proc.params(connection: OpenAI::Realtime::Connection).void),
           websocket_base_url: T.nilable(String),
           request_options: T.nilable(OpenAI::RequestOptions::OrHash),
           transport: T.untyped,
@@ -111,6 +115,10 @@ module OpenAI
       end
       def connect(
         model:,
+        reconnect: false,
+        max_reconnect_attempts: 5,
+        max_queue_bytes: 0,
+        on_reconnected: nil,
         websocket_base_url: nil,
         request_options: nil,
         transport: nil,

data/rbi/openai/helpers/realtime/recovery.rbi

@@ -0,0 +1,27 @@
+# typed: strong
+
+module OpenAI
+  module Errors
+    class RealtimeQueueFullError < OpenAI::Errors::Error
+      sig { returns(T.attached_class) }
+      def self.new
+      end
+    end
+
+    class RealtimeReconnectError < OpenAI::Errors::Error
+      sig { returns(T::Array[String]) }
+      attr_reader :unsent_messages
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :uncertain_message
+
+      # @api private
+      sig do
+        params(message: String, unsent_messages: T::Array[String], uncertain_message: T.nilable(String))
+          .returns(T.attached_class)
+      end
+      def self.new(message:, unsent_messages: [], uncertain_message: nil)
+      end
+    end
+  end
+end

data/rbi/openai/models/beta/beta_response_input_item.rbi

@@ -2109,6 +2109,17 @@ module OpenAI
           }
           attr_writer :agent
 
+          # The quality of the image generated by the image generation tool call. One of
+          # `low`, `medium`, `high`, `xhigh`, `max`, or `auto`.
+          sig { returns(T.nilable(OpenAI::Beta::BetaResponseInputItem::ImageGenerationCall::Quality::OrSymbol)) }
+          attr_accessor :quality
+
+          # The image dimensions as a `WIDTHxHEIGHT` string, for example `1536x864`.
+          sig {
+            returns(T.nilable(T.any(String, OpenAI::Beta::BetaResponseInputItem::ImageGenerationCall::Size::OrSymbol)))
+          }
+          attr_accessor :size
+
           # An image generation request made by the model.
           sig do
             params(
@@ -2121,6 +2132,10 @@ module OpenAI
 
               agent: T.nilable(OpenAI::Beta::BetaResponseInputItem::ImageGenerationCall::Agent::OrHash),
 
+              quality: T.nilable(OpenAI::Beta::BetaResponseInputItem::ImageGenerationCall::Quality::OrSymbol),
+
+              size: T.nilable(T.any(String, OpenAI::Beta::BetaResponseInputItem::ImageGenerationCall::Size::OrSymbol)),
+
               type: Symbol
             )
               .returns(T.attached_class)
@@ -2139,6 +2154,13 @@ module OpenAI
             # The agent that produced this item.
             agent: nil,
 
+            # The quality of the image generated by the image generation tool call. One of
+            # `low`, `medium`, `high`, `xhigh`, `max`, or `auto`.
+            quality: nil,
+
+            # The image dimensions as a `WIDTHxHEIGHT` string, for example `1536x864`.
+            size: nil,
+
             # The type of the image generation call. Always `image_generation_call`.
 
             type: :image_generation_call
@@ -2152,7 +2174,9 @@ module OpenAI
                 result: T.nilable(String),
                 status: OpenAI::Beta::BetaResponseInputItem::ImageGenerationCall::Status::OrSymbol,
                 type: Symbol,
-                agent: T.nilable(OpenAI::Beta::BetaResponseInputItem::ImageGenerationCall::Agent)
+                agent: T.nilable(OpenAI::Beta::BetaResponseInputItem::ImageGenerationCall::Agent),
+                quality: T.nilable(OpenAI::Beta::BetaResponseInputItem::ImageGenerationCall::Quality::OrSymbol),
+                size: T.nilable(T.any(String, OpenAI::Beta::BetaResponseInputItem::ImageGenerationCall::Size::OrSymbol))
               }
             )
           end
@@ -2226,6 +2250,67 @@ module OpenAI
             end
 
           end
+
+          # The quality of the image generated by the image generation tool call. One of
+          # `low`, `medium`, `high`, `xhigh`, `max`, or `auto`.
+          module Quality
+            extend OpenAI::Internal::Type::Enum
+
+            TaggedSymbol = T.type_alias {
+              T.all(Symbol, OpenAI::Beta::BetaResponseInputItem::ImageGenerationCall::Quality)
+            }
+            OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+            LOW = T.let(:low, OpenAI::Beta::BetaResponseInputItem::ImageGenerationCall::Quality::TaggedSymbol)
+            MEDIUM = T.let(:medium, OpenAI::Beta::BetaResponseInputItem::ImageGenerationCall::Quality::TaggedSymbol)
+            HIGH = T.let(:high, OpenAI::Beta::BetaResponseInputItem::ImageGenerationCall::Quality::TaggedSymbol)
+            XHIGH = T.let(:xhigh, OpenAI::Beta::BetaResponseInputItem::ImageGenerationCall::Quality::TaggedSymbol)
+            MAX = T.let(:max, OpenAI::Beta::BetaResponseInputItem::ImageGenerationCall::Quality::TaggedSymbol)
+            AUTO = T.let(:auto, OpenAI::Beta::BetaResponseInputItem::ImageGenerationCall::Quality::TaggedSymbol)
+
+            sig {
+              override.returns(
+                T::Array[OpenAI::Beta::BetaResponseInputItem::ImageGenerationCall::Quality::TaggedSymbol]
+              )
+            }
+            def self.values
+            end
+          end
+
+          # The image dimensions as a `WIDTHxHEIGHT` string, for example `1536x864`.
+          module Size
+            extend OpenAI::Internal::Type::Union
+
+            Variants = T.type_alias {
+              T.any(String, OpenAI::Beta::BetaResponseInputItem::ImageGenerationCall::Size::TaggedSymbol)
+            }
+
+            sig {
+              override.returns(T::Array[OpenAI::Beta::BetaResponseInputItem::ImageGenerationCall::Size::Variants])
+            }
+            def self.variants
+            end
+
+            TaggedSymbol = T.type_alias do
+              T.all(Symbol, OpenAI::Beta::BetaResponseInputItem::ImageGenerationCall::Size)
+            end
+
+            OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+            SIZE_1024X1024 = T.let(
+              :"1024x1024",
+              OpenAI::Beta::BetaResponseInputItem::ImageGenerationCall::Size::TaggedSymbol
+            )
+            SIZE_1024X1536 = T.let(
+              :"1024x1536",
+              OpenAI::Beta::BetaResponseInputItem::ImageGenerationCall::Size::TaggedSymbol
+            )
+            SIZE_1536X1024 = T.let(
+              :"1536x1024",
+              OpenAI::Beta::BetaResponseInputItem::ImageGenerationCall::Size::TaggedSymbol
+            )
+
+          end
         end
 
         class LocalShellCall < OpenAI::Internal::Type::BaseModel