openai 0.108.0 → 0.110.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bbaffc5b480678a26851b73b6b49f9f63419801d8bbec633d6ed4f3765fe4717
-  data.tar.gz: 127b19570f47781df5644f2217d9405e1ea0e82279b319a7683c59b567cbbd72
+  metadata.gz: 31d71682626485e6fb27ecd72cd1d35bb2a3eb279e37b59e1e372345227a1c99
+  data.tar.gz: bc386aa30fb3e76d27e51eaa4892d668c55d1a91491b6d2477d06943308a5040
 SHA512:
-  metadata.gz: ffe2a7748064e0cb03c1eb2482670a4f581323b02a0275fd9654e1f97ecaf85f9128e064f22b5075af7d615d0e9d4fee73144d57f07ceaa9dcde25a419f7b066
-  data.tar.gz: c531be809fb0b7dd69d4cb089eea59680a01dbcc258265e47ef6b16052ffd78eeba8f2ccf094ffaa694cdd2dca602b9ebceffa65e362de1427f51e04219a6192
+  metadata.gz: 8004eea7d6c06815daea855a26cca2160fea55de5034030b3faf2cb93e5ac2bcd3545c0528b8aaa5a541521d844756401e6b09e9f6ef41247cd0a7890ebd7328
+  data.tar.gz: cfdbe5bb232b0272a269e8179f74333f94296bb8fafc251a425536567910c3b3230a946d5e59162cc5e15ab99c28f74f29a9deaeda53363193b935231349f68b

data/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## [0.110.0](https://github.com/openai/openai-ruby/compare/v0.109.0...v0.110.0) (2026-10-22)
+
+
+### Features
+
+* **api:** add voice deletion ([#954](https://github.com/openai/openai-ruby/issues/954)) ([a6257f2](https://github.com/openai/openai-ruby/commit/a6257f2737b1b98d6bda684a4fed8e2726052a3a))
+
+
+### Chores
+
+* **api:** clarify service-account API key deletion ([#956](https://github.com/openai/openai-ruby/issues/956)) ([fac910a](https://github.com/openai/openai-ruby/commit/fac910a671e53a7c5499e1cb323dffe23c9e247d))
+
+## [0.109.0](https://github.com/openai/openai-ruby/compare/v0.108.0...v0.109.0) (2026-10-21)
+
+
+### Features
+
+* add Vertex AI support for the Responses API ([#952](https://github.com/openai/openai-ruby/issues/952)) ([98f5359](https://github.com/openai/openai-ruby/commit/98f5359e3ad2133abc5e914610fe7bbd2a058f8d))
+
 ## [0.108.0](https://github.com/openai/openai-ruby/compare/v0.107.0...v0.108.0) (2026-10-21)
 
 

data/README.md

@@ -15,7 +15,7 @@ To use this gem, install via Bundler by adding the following to your application
 <!-- x-release-please-start-version -->
 
 ```ruby
-gem "openai", "~> 0.108.0"
+gem "openai", "~> 0.110.0"
 ```
 
 <!-- x-release-please-end -->
@@ -556,6 +556,12 @@ client = OpenAI::Client.new(
 
 See [bedrock.md](bedrock.md) for authentication precedence, static and refreshable credentials, endpoint configuration, and SigV4 request constraints.
 
+## Google Vertex AI
+
+Use `OpenAI::Providers.vertex` with the Responses API. See [vertex.md](vertex.md)
+for setup with Google Application Default Credentials, a credentials object, or
+an access-token callback.
+
 ## Workload Identity Authentication
 
 For secure, automated environments like cloud-managed Kubernetes, Azure, and GCP, you can use workload identity authentication with short-lived tokens from cloud identity providers instead of long-lived API keys.

data/lib/openai/helpers/client_runtime.rb

@@ -101,6 +101,17 @@ module OpenAI
 
     # @api private
     private def send_request(request, redirect_count:, retry_count:, send_retry_header:)
+      if (wrapper = @provider_runtime&.wrap_request)
+        return wrapper.call(request, request_replayable?(request), retry_count) do |attempt, attempt_retry_count|
+          super(
+            attempt,
+            redirect_count: redirect_count,
+            retry_count: attempt_retry_count,
+            send_retry_header: send_retry_header
+          )
+        end
+      end
+
       if @workload_identity_auth && x509_transport?(@requester)
         canonical_headers = @requester.validate_api_request!(
           url: request.fetch(:url),

data/lib/openai/internal/provider.rb

@@ -11,6 +11,7 @@ module OpenAI
         :name,
         :base_url,
         :prepare_request,
+        :wrap_request,
         :authentication_headers,
         keyword_init: true
       )

data/lib/openai/models/audio/voice_delete_params.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module OpenAI
+  module Models
+    module Audio
+      # @see OpenAI::Resources::Audio::Voices#delete
+      class VoiceDeleteParams < OpenAI::Internal::Type::BaseModel
+        extend OpenAI::Internal::Type::RequestParameters::Converter
+        include OpenAI::Internal::Type::RequestParameters
+
+        # @!attribute voice_id
+        #
+        #   @return [String]
+        required :voice_id, String
+
+        # @!method initialize(voice_id:, request_options: {})
+        #   @param voice_id [String]
+        #   @param request_options [OpenAI::RequestOptions, Hash{Symbol=>Object}]
+      end
+    end
+  end
+end

data/lib/openai/models/audio/voice_deleted.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module OpenAI
+  module Models
+    module Audio
+      # @see OpenAI::Resources::Audio::Voices#delete
+      class VoiceDeleted < OpenAI::Internal::Type::BaseModel
+        # @!attribute id
+        #   The voice identifier.
+        #
+        #   @return [String]
+        required :id, String
+
+        # @!attribute deleted
+        #   Whether the voice was deleted.
+        #
+        #   @return [Boolean]
+        required :deleted, OpenAI::Internal::Type::Boolean
+
+        # @!attribute object
+        #   The object type, which is always `audio.voice.deleted`.
+        #
+        #   @return [Symbol, :"audio.voice.deleted"]
+        required :object, const: :"audio.voice.deleted"
+
+        # @!method initialize(id:, deleted:, object: :"audio.voice.deleted")
+        #   @param id [String]
+        #     The voice identifier.
+        #
+        #   @param deleted [Boolean]
+        #     Whether the voice was deleted.
+        #
+        #   @param object [Symbol, :"audio.voice.deleted"]
+        #     The object type, which is always `audio.voice.deleted`.
+      end
+    end
+  end
+end

data/lib/openai/providers/vertex.rb

@@ -0,0 +1,229 @@
+# frozen_string_literal: true
+
+require "timeout"
+
+module OpenAI
+  module Providers
+    # @api private
+    module Vertex
+      SCOPE = "https://www.googleapis.com/auth/cloud-platform"
+      AUTH_MARKER = :openai_vertex_bearer
+
+      class Definition
+        def initialize(base_url:, token_provider:, credentials:)
+          @base_url = base_url.freeze
+          @token_provider = token_provider
+          @credentials = credentials
+          @credentials_mutex = Mutex.new
+        end
+
+        def name = "vertex"
+
+        def configure
+          token_provider = @token_provider
+          credentials = @credentials
+          unless token_provider || credentials
+            begin
+              require "googleauth"
+
+            rescue LoadError => e
+              raise LoadError.new("Vertex ADC requires optional gem \"googleauth\"; add it to your Gemfile."), cause: e
+            end
+
+            begin
+              credentials = Google::Auth.get_application_default(SCOPE)
+            rescue StandardError => e
+              raise OpenAI::Errors::Error.new("Vertex could not load Google Application Default Credentials."), cause: e
+            end
+          end
+
+          if credentials
+            # googleauth apply! refreshes expired tokens. Serialize just this
+            # cache/refresh step across all clients using this provider.
+            mutex = @credentials_mutex
+            rejected_token = nil
+            token_provider = lambda do
+              headers = {}
+              mutex.synchronize do
+                credentials.apply!(headers)
+                token = headers.fetch(:authorization) { headers.fetch("authorization") }.delete_prefix("Bearer ")
+                if token == rejected_token && credentials.respond_to?(:fetch_access_token!)
+                  credentials.fetch_access_token!
+                  credentials.apply!(headers)
+                  token = headers.fetch(:authorization) { headers.fetch("authorization") }.delete_prefix("Bearer ")
+                  rejected_token = nil
+                end
+
+                token
+              end
+            end
+          end
+
+          # Share the replay allowance and retry count, but reset the deadline
+          # for each ordinary transport retry. A 401 replay keeps its deadline.
+          # Refresh itself happens in prepare_request, under its timeout and mutex.
+          if credentials.respond_to?(:fetch_access_token!)
+            wrapper = lambda do |request, replayable, retry_count, &send_request|
+              context = request[:vertex_auth_context] || {replayed: false}
+              context[:retry_count] = retry_count
+              context[:deadline] = request[:timeout]&.then { OpenAI::Internal::Util.monotonic_secs + _1 }
+              request = request.merge(vertex_auth_context: context)
+              begin
+                send_request.call(request, context[:retry_count])
+              rescue OpenAI::Errors::AuthenticationError
+                remaining = context[:deadline] && (context[:deadline] - OpenAI::Internal::Util.monotonic_secs)
+                if remaining && remaining <= 0
+                  raise OpenAI::Errors::APITimeoutError.new(url: request.fetch(:url))
+                end
+
+                begin
+                  Timeout.timeout(remaining) { mutex.synchronize { rejected_token = context[:token] } }
+                rescue Timeout::Error
+                  raise OpenAI::Errors::APITimeoutError.new(url: request.fetch(:url)), cause: nil
+                end
+
+                raise if context[:replayed] || !replayable || context[:retry_count] >= request.fetch(:max_retries)
+
+                context[:replayed] = true
+                context[:retry_count] += 1
+                retry
+              end
+            end
+          end
+
+          base = URI(@base_url)
+          OpenAI::Internal::Provider::Runtime.new(
+            name: name,
+            base_url: @base_url,
+            authentication_headers: %w[authorization],
+            wrap_request: wrapper,
+            prepare_request: lambda do |request|
+              url = request.fetch(:url)
+              unless OpenAI::Internal::Util.uri_origin(url) == OpenAI::Internal::Util.uri_origin(base)
+                raise OpenAI::Errors::Error, "Vertex refuses credentials for an origin other than the configured URL."
+              end
+
+              headers = request.fetch(:headers).dup
+              if request[:provider_auth] == AUTH_MARKER
+                headers.delete("authorization")
+              elsif headers.key?("authorization")
+                raise(
+                  OpenAI::Errors::Error,
+                  "Vertex authentication cannot be combined with a custom Authorization header."
+                )
+              end
+
+              if headers.key?("api-key")
+                raise OpenAI::Errors::Error, "Vertex authentication cannot be combined with a custom api-key header."
+              end
+              # The outer Google API version differs for stored Responses.
+              # Do not change other gateway layouts.
+              prefix = "#{base.path.delete_suffix("/")}/responses/"
+              if [:get, :delete].include?(request[:method]) &&
+                  url.path.start_with?(prefix) &&
+                  base.path.start_with?("/v1/projects/")
+                url = url.dup
+                url.path = url.path.sub(%r{\A/v1/}, "/v1beta1/")
+              end
+
+              headers.delete("openai-organization")
+              headers.delete("openai-project")
+              timeout = request[:timeout]
+              context = request[:vertex_auth_context]
+              timeout = context[:deadline] - OpenAI::Internal::Util.monotonic_secs if context&.dig(:deadline)
+              if timeout && timeout <= 0
+                raise OpenAI::Errors::APITimeoutError.new(url: url, message: "Vertex credential lookup timed out")
+              end
+
+              started = OpenAI::Internal::Util.monotonic_secs
+              token = begin
+                Timeout.timeout(timeout) { token_provider.call }
+              rescue Timeout::Error => e
+                raise(
+                  OpenAI::Errors::APITimeoutError.new(url: url, message: "Vertex credential lookup timed out"),
+                  cause: e
+                )
+              rescue StandardError => e
+                raise OpenAI::Errors::Error.new("Vertex failed to resolve Google credentials."), cause: e
+              end
+
+              remaining = timeout && (timeout - (OpenAI::Internal::Util.monotonic_secs - started))
+              if remaining && remaining <= 0
+                raise OpenAI::Errors::APITimeoutError.new(url: url, message: "Vertex credential lookup timed out")
+              end
+
+              if credentials.respond_to?(:quota_project_id) && (quota = credentials.quota_project_id)
+                headers["x-goog-user-project"] = quota
+              end
+
+              unless token.is_a?(String) && !token.strip.empty?
+                raise OpenAI::Errors::Error, "Vertex token_provider must return a non-empty access token string."
+              end
+
+              context[:token] = token if context
+
+              request.merge(
+                url: url,
+                timeout: remaining,
+                headers: headers.merge("authorization" => "Bearer #{token}"),
+                provider_auth: AUTH_MARKER,
+                follow_redirects: false
+              )
+            end
+          )
+        end
+      end
+    end
+
+    class << self
+      # Use Google Application Default Credentials with the regular Responses
+      # client. Supply token_provider: -> { ... } for application-managed credentials.
+      # It is called per attempt and should cache/refresh tokens as needed.
+      #
+      # Base URL is the complete trusted provider URL before /responses. When
+      # omitted, project and location are required. OpenAI environment defaults
+      # and top-level auth/base_url options are ignored/rejected by Client.
+      def vertex(project: nil, location: nil, base_url: nil, token_provider: nil, credentials: nil)
+        if credentials && token_provider
+          raise ArgumentError, "Vertex credentials and token_provider are mutually exclusive."
+        end
+
+        if credentials && !credentials.respond_to?(:apply!)
+          raise ArgumentError, "Vertex credentials must provide Google's apply! method."
+        end
+
+        unless token_provider.nil? || token_provider.respond_to?(:call)
+          raise ArgumentError, "Vertex token_provider must respond to call."
+        end
+
+        if base_url.nil?
+          project_segment = /\A[a-zA-Z0-9][a-zA-Z0-9_.:-]*\z/
+          location_segment = /\A[a-zA-Z0-9][a-zA-Z0-9_-]*\z/
+          unless project.is_a?(String) &&
+              location.is_a?(String) &&
+              project_segment.match?(project) &&
+              location_segment.match?(location)
+            raise ArgumentError, "Vertex project and location are required and must be single path segments."
+          end
+
+          host = location == "global" ? "aiplatform.googleapis.com" : "#{location}-aiplatform.googleapis.com"
+          base_url = "https://#{host}/v1/projects/#{project}/locations/#{location}/publishers/openai/v1"
+        end
+
+        begin
+          uri = URI(base_url.to_s)
+          unless %w[http https].include?(uri.scheme) && uri.host && !uri.userinfo && !uri.query && !uri.fragment
+            raise URI::InvalidURIError
+          end
+
+        rescue URI::InvalidURIError
+          raise ArgumentError, "Vertex base_url must be an absolute HTTP(S) URL without credentials, query or fragment."
+        end
+
+        OpenAI::Internal::Provider.create(
+          Vertex::Definition.new(base_url: uri.to_s, token_provider: token_provider, credentials: credentials)
+        )
+      end
+    end
+  end
+end

data/lib/openai/resources/admin/organization/projects/api_keys.rb

@@ -140,10 +140,12 @@ module OpenAI
               )
             end
 
-            # Deletes an API key from the project.
+            # Deletes an API key from the project, including keys owned by service accounts.
             #
-            # Returns confirmation of the key deletion, or an error if the key belonged to a
-            # service account.
+            # Requires permission to write project API keys. Deleting a service-account key
+            # does not delete the service account or its other keys.
+            #
+            # Returns confirmation of the key deletion.
             #
             # @overload delete(api_key_id, project_id:, request_options: {})
             #

data/lib/openai/resources/audio/voices.rb

@@ -41,6 +41,35 @@ module OpenAI
           )
         end
 
+        # Deletes a voice created from a text prompt or an audio sample.
+        #
+        # Requires voice write permission and access to the voice's project. Access to
+        # voices created from recordings is limited to eligible customers. See the
+        # [custom voices guide](https://developers.openai.com/api/docs/guides/custom-voices).
+        #
+        # Deleting a voice does not delete its consent recording. Deleting an already
+        # deleted voice returns a 404 error.
+        #
+        # @overload delete(voice_id, request_options: {})
+        #
+        # @param voice_id [String]
+        #   The ID of the voice to delete.
+        #
+        # @param request_options [OpenAI::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [OpenAI::Models::Audio::VoiceDeleted]
+        #
+        # @see OpenAI::Models::Audio::VoiceDeleteParams
+        def delete(voice_id, params = {})
+          @client.request(
+            method: :delete,
+            path: ["audio/voices/%1$s", voice_id],
+            model: OpenAI::Audio::VoiceDeleted,
+            security: {bearer_auth: true},
+            options: params[:request_options]
+          )
+        end
+
         # @api private
         #
         # @param client [OpenAI::Client]

data/lib/openai/version.rb

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

data/lib/openai.rb

@@ -69,6 +69,7 @@ require_relative "openai/provider"
 require_relative "openai/internal/provider"
 require_relative "openai/providers/azure"
 require_relative "openai/providers/bedrock"
+require_relative "openai/providers/vertex"
 require_relative "openai/internal/transport/request_body_merge"
 require_relative "openai/internal/transport/base_client"
 require_relative "openai/helpers/client_options"
@@ -470,6 +471,8 @@ require_relative "openai/models/audio/voice_consent_list_params"
 require_relative "openai/models/audio/voice_consent_retrieve_params"
 require_relative "openai/models/audio/voice_consent_update_params"
 require_relative "openai/models/audio/voice_create_params"
+require_relative "openai/models/audio/voice_deleted"
+require_relative "openai/models/audio/voice_delete_params"
 require_relative "openai/models/audio_model"
 require_relative "openai/models/audio_response_format"
 require_relative "openai/models/auto_file_chunking_strategy_param"

data/rbi/openai/internal/provider.rbi

@@ -25,6 +25,9 @@ module OpenAI
 
         attr_accessor :prepare_request
 
+        sig { returns(T.nilable(Proc)) }
+        attr_accessor :wrap_request
+
         sig { returns(T::Array[String]) }
         attr_accessor :authentication_headers
       end

data/rbi/openai/models/audio/voice_delete_params.rbi

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

data/rbi/openai/models/audio/voice_deleted.rbi

@@ -0,0 +1,67 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Audio
+
+      class VoiceDeleted < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Audio::VoiceDeleted,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # The voice identifier.
+        sig { returns(String) }
+        attr_accessor :id
+
+        # Whether the voice was deleted.
+        sig { returns(T::Boolean) }
+        attr_accessor :deleted
+
+        # The object type, which is always `audio.voice.deleted`.
+        sig { returns(Symbol) }
+        attr_accessor :object
+
+        sig do
+          params(
+
+            id: String,
+
+            deleted: T::Boolean,
+
+            object: Symbol
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # The voice identifier.
+          id:,
+
+          # Whether the voice was deleted.
+          deleted:,
+
+          # The object type, which is always `audio.voice.deleted`.
+
+          object: :"audio.voice.deleted"
+        )
+        end
+
+        sig do
+          override.returns(
+            {id: String, deleted: T::Boolean, object: Symbol}
+          )
+        end
+        def to_hash
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/providers.rbi

@@ -14,6 +14,19 @@ module OpenAI
       def azure(endpoint: nil, api_key: nil, token_provider: nil)
       end
 
+      sig do
+        params(
+          project: T.nilable(String),
+          location: T.nilable(String),
+          base_url: T.nilable(String),
+          token_provider: T.nilable(T.proc.returns(String)),
+          credentials: T.untyped
+        )
+          .returns(OpenAI::Provider)
+      end
+      def vertex(project: nil, location: nil, base_url: nil, token_provider: nil, credentials: nil)
+      end
+
       sig do
         params(
           endpoint: T.nilable(T.any(String, Symbol)),

data/rbi/openai/resources/admin/organization/projects/api_keys.rbi

@@ -106,10 +106,12 @@ module OpenAI
             )
             end
 
-            # Deletes an API key from the project.
+            # Deletes an API key from the project, including keys owned by service accounts.
             #
-            # Returns confirmation of the key deletion, or an error if the key belonged to a
-            # service account.
+            # Requires permission to write project API keys. Deleting a service-account key
+            # does not delete the service account or its other keys.
+            #
+            # Returns confirmation of the key deletion.
             sig {
               params(api_key_id: String, project_id: String, request_options: OpenAI::RequestOptions::OrHash).returns(
                 OpenAI::Models::Admin::Organization::Projects::APIKeyDeleteResponse

data/rbi/openai/resources/audio/voices.rbi

@@ -37,6 +37,24 @@ module OpenAI
         )
         end
 
+        # Deletes a voice created from a text prompt or an audio sample.
+        #
+        # Requires voice write permission and access to the voice's project. Access to
+        # voices created from recordings is limited to eligible customers. See the
+        # [custom voices guide](https://developers.openai.com/api/docs/guides/custom-voices).
+        #
+        # Deleting a voice does not delete its consent recording. Deleting an already
+        # deleted voice returns a 404 error.
+        sig {
+          params(voice_id: String, request_options: OpenAI::RequestOptions::OrHash).returns(OpenAI::Audio::VoiceDeleted)
+        }
+        def delete(
+          # The ID of the voice to delete.
+          voice_id,
+          request_options: {}
+        )
+        end
+
         # @api private
         sig { params(client: OpenAI::Client).returns(T.attached_class) }
         def self.new(client:)

data/sig/openai/internal/provider.rbs

@@ -8,6 +8,7 @@ module OpenAI
           OpenAI::Internal::Transport::BaseClient::request_input
         ) -> OpenAI::Internal::Transport::BaseClient::request_input)?
         attr_accessor authentication_headers: Array[String]
+        attr_accessor wrap_request: Proc?
 
         def initialize: (
           name: String,
@@ -15,7 +16,8 @@ module OpenAI
           prepare_request: (^(
             OpenAI::Internal::Transport::BaseClient::request_input
           ) -> OpenAI::Internal::Transport::BaseClient::request_input)?,
-          authentication_headers: Array[String]
+          authentication_headers: Array[String],
+          ?wrap_request: Proc?
         ) -> void
       end
 

data/sig/openai/models/audio/voice_delete_params.rbs

@@ -0,0 +1,25 @@
+module OpenAI
+  module Models
+    module Audio
+      type voice_delete_params =
+        { voice_id: String, ?request_options: OpenAI::request_opts }
+
+      class VoiceDeleteParams < OpenAI::Internal::Type::BaseModel
+        extend OpenAI::Internal::Type::RequestParameters::Converter
+        include OpenAI::Internal::Type::RequestParameters
+
+        attr_accessor voice_id: String
+
+        def initialize: (
+          voice_id: String,
+          ?request_options: OpenAI::request_opts
+        ) -> void
+
+        def to_hash: -> {
+          voice_id: String,
+          ?request_options: OpenAI::RequestOptions
+        }
+      end
+    end
+  end
+end

data/sig/openai/models/audio/voice_deleted.rbs

@@ -0,0 +1,37 @@
+module OpenAI
+  module Models
+    module Audio
+      type voice_deleted =
+        { id: String, deleted: bool, ?object: :"audio.voice.deleted" }
+
+      class VoiceDeleted < OpenAI::Internal::Type::BaseModel
+        # The voice identifier.
+        attr_accessor id: String
+
+        # Whether the voice was deleted.
+        attr_accessor deleted: bool
+
+        # The object type, which is always `audio.voice.deleted`.
+        attr_accessor object: :"audio.voice.deleted"
+
+        # @param id
+        #   The voice identifier.
+        # @param deleted
+        #   Whether the voice was deleted.
+        # @param object
+        #   The object type, which is always `audio.voice.deleted`.
+        def initialize: (
+          id: String,
+          deleted: bool,
+          ?object: :"audio.voice.deleted"
+        ) -> void
+
+        def to_hash: -> {
+          id: String,
+          deleted: bool,
+          ?object: :"audio.voice.deleted"
+        }
+      end
+    end
+  end
+end

data/sig/openai/providers.rbs

@@ -6,6 +6,14 @@ module OpenAI
       ?token_provider: (^-> String)?
     ) -> OpenAI::Provider
 
+    def self.vertex: (
+      ?project: String?,
+      ?location: String?,
+      ?base_url: String?,
+      ?token_provider: (^-> String)?,
+      ?credentials: untyped
+    ) -> OpenAI::Provider
+
     def self.bedrock: (
       ?endpoint: (:mantle | :runtime | "mantle" | "runtime")?,
       ?region: String?,

data/sig/openai/resources/audio/voices.rbs

@@ -7,6 +7,11 @@ module OpenAI
           ?request_options: OpenAI::request_opts
         ) -> OpenAI::Audio::Voice
 
+        def delete: (
+          String voice_id,
+          ?request_options: OpenAI::request_opts
+        ) -> OpenAI::Audio::VoiceDeleted
+
         def initialize: (client: OpenAI::Client) -> void
       end
     end

data/vertex.md

@@ -0,0 +1,29 @@
+# Google Vertex AI
+
+Configure the standard `OpenAI::Client` to use the Responses API through Vertex AI. For Google Application Default Credentials (ADC), add the optional `googleauth` gem to your application's Gemfile and run `bundle install`:
+
+```ruby
+gem "googleauth", "~> 1"
+```
+
+Configure ADC in your environment, then create a client:
+
+```ruby
+require "openai"
+
+client = OpenAI::Client.new(
+  provider: OpenAI::Providers.vertex(
+    project: "your-project-id",
+    location: "your-vertex-location"
+  )
+)
+
+response = client.responses.create(model: "your-enabled-model", input: "Say hello!")
+puts(response.output_text)
+```
+
+Use a model enabled for your project and location. Vertex AI determines which Responses features are available.
+
+To manage credentials in your application, pass either `credentials:` with a Google credentials object or `token_provider:` with a callback that returns a current access token. The callback runs once per request attempt, including retries; cache and refresh tokens as needed. The `googleauth` gem is not required when using `token_provider:`.
+
+To use a test server or trusted gateway, set `base_url:` to the full API root before `/responses`. The configured origin receives your bearer token. HTTP test roots are supported; use HTTPS in production.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: openai
 version: !ruby/object:Gem::Version
-  version: 0.108.0
+  version: 0.110.0
 platform: ruby
 authors:
 - OpenAI
@@ -49,6 +49,7 @@ extra_rdoc_files:
 - local-audio.md
 - realtime.md
 - responses-websocket.md
+- vertex.md
 files:
 - ".ignore"
 - CHANGELOG.md
@@ -452,6 +453,8 @@ files:
 - lib/openai/models/audio/voice_consent_retrieve_params.rb
 - lib/openai/models/audio/voice_consent_update_params.rb
 - lib/openai/models/audio/voice_create_params.rb
+- lib/openai/models/audio/voice_delete_params.rb
+- lib/openai/models/audio/voice_deleted.rb
 - lib/openai/models/audio_model.rb
 - lib/openai/models/audio_response_format.rb
 - lib/openai/models/auto_file_chunking_strategy_param.rb
@@ -1648,6 +1651,7 @@ files:
 - lib/openai/provider.rb
 - lib/openai/providers/azure.rb
 - lib/openai/providers/bedrock.rb
+- lib/openai/providers/vertex.rb
 - lib/openai/request_options.rb
 - lib/openai/resources/admin.rb
 - lib/openai/resources/admin/organization.rb
@@ -2117,6 +2121,8 @@ files:
 - rbi/openai/models/audio/voice_consent_retrieve_params.rbi
 - rbi/openai/models/audio/voice_consent_update_params.rbi
 - rbi/openai/models/audio/voice_create_params.rbi
+- rbi/openai/models/audio/voice_delete_params.rbi
+- rbi/openai/models/audio/voice_deleted.rbi
 - rbi/openai/models/audio_model.rbi
 - rbi/openai/models/audio_response_format.rbi
 - rbi/openai/models/auto_file_chunking_strategy_param.rbi
@@ -3770,6 +3776,8 @@ files:
 - sig/openai/models/audio/voice_consent_retrieve_params.rbs
 - sig/openai/models/audio/voice_consent_update_params.rbs
 - sig/openai/models/audio/voice_create_params.rbs
+- sig/openai/models/audio/voice_delete_params.rbs
+- sig/openai/models/audio/voice_deleted.rbs
 - sig/openai/models/audio_model.rbs
 - sig/openai/models/audio_response_format.rbs
 - sig/openai/models/auto_file_chunking_strategy_param.rbs
@@ -5093,6 +5101,7 @@ files:
 - sig/openai/response_carrier.rbs
 - sig/openai/streaming.rbs
 - sig/openai/version.rbs
+- vertex.md
 homepage: https://gemdocs.org/gems/openai
 licenses:
 - Apache-2.0