openai 0.107.0 → 0.109.0

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/audio/voice_consents.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+module OpenAI
+  module Resources
+    class Audio
+      # Turn audio into text or text into audio.
+      class VoiceConsents
+        # Upload a voice consent recording.
+        #
+        # `String`, `StringIO`, and pathless `IO` inputs are sent with generic upload
+        # metadata. Use `OpenAI::FilePart` when you need to override the filename or
+        # content type.
+        #
+        # @overload create(language:, name:, recording:, request_options: {})
+        #
+        # @param language [String]
+        #   The BCP 47 language tag for the consent phrase (for example, `en-US`).
+        #
+        # @param name [String]
+        #   The label to use for this consent recording.
+        #
+        # @param recording [Pathname, StringIO, IO, String, OpenAI::FilePart]
+        #   The consent audio recording file. Maximum size is 10 MiB.
+        #
+        #   Supported MIME types: `audio/mpeg`, `audio/wav`, `audio/x-wav`, `audio/ogg`,
+        #   `audio/aac`, `audio/flac`, `audio/webm`, `audio/mp4`.
+        #
+        #   `String`, `StringIO`, and pathless `IO` inputs are sent with generic upload
+        #   metadata. Use `OpenAI::FilePart` when you need to override the filename or
+        #   content type.
+        #
+        # @param request_options [OpenAI::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [OpenAI::Models::Audio::VoiceConsent]
+        #
+        # @see OpenAI::Models::Audio::VoiceConsentCreateParams
+        def create(params)
+          parsed, options = OpenAI::Audio::VoiceConsentCreateParams.dump_request(params)
+          @client.request(
+            method: :post,
+            path: "audio/voice_consents",
+            headers: {"content-type" => "multipart/form-data"},
+            body: parsed,
+            model: OpenAI::Audio::VoiceConsent,
+            security: {bearer_auth: true},
+            options: options
+          )
+        end
+
+        # Retrieves a voice consent recording.
+        #
+        # @overload retrieve(consent_id, request_options: {})
+        #
+        # @param consent_id [String]
+        #   The ID of the consent recording to retrieve.
+        #
+        # @param request_options [OpenAI::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [OpenAI::Models::Audio::VoiceConsent]
+        #
+        # @see OpenAI::Models::Audio::VoiceConsentRetrieveParams
+        def retrieve(consent_id, params = {})
+          @client.request(
+            method: :get,
+            path: ["audio/voice_consents/%1$s", consent_id],
+            model: OpenAI::Audio::VoiceConsent,
+            security: {bearer_auth: true},
+            options: params[:request_options]
+          )
+        end
+
+        # Updates a voice consent recording (metadata only).
+        #
+        # @overload update(consent_id, name:, request_options: {})
+        #
+        # @param consent_id [String]
+        #   The ID of the consent recording to update.
+        #
+        # @param name [String]
+        #   The updated label for this consent recording.
+        #
+        # @param request_options [OpenAI::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [OpenAI::Models::Audio::VoiceConsent]
+        #
+        # @see OpenAI::Models::Audio::VoiceConsentUpdateParams
+        def update(consent_id, params)
+          parsed, options = OpenAI::Audio::VoiceConsentUpdateParams.dump_request(params)
+          @client.request(
+            method: :post,
+            path: ["audio/voice_consents/%1$s", consent_id],
+            body: parsed,
+            model: OpenAI::Audio::VoiceConsent,
+            security: {bearer_auth: true},
+            options: options
+          )
+        end
+
+        # Returns a list of voice consent recordings.
+        #
+        # @overload list(after: nil, limit: nil, request_options: {})
+        #
+        # @param after [String]
+        #   A cursor for use in pagination. `after` is an object ID that defines your place
+        #   in the list. For instance, if you make a list request and receive 100 objects,
+        #   ending with obj_foo, your subsequent call can include after=obj_foo in order to
+        #   fetch the next page of the list.
+        #
+        # @param limit [Integer]
+        #   A limit on the number of objects to be returned. Limit can range between 1 and
+        #   100, and the default is 20.
+        #
+        # @param request_options [OpenAI::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [OpenAI::Internal::CursorPage<OpenAI::Models::Audio::VoiceConsent>]
+        #
+        # @see OpenAI::Models::Audio::VoiceConsentListParams
+        def list(params = {})
+          parsed, options = OpenAI::Audio::VoiceConsentListParams.dump_request(params)
+          query = OpenAI::Internal::Util.encode_query_params(parsed)
+          @client.request(
+            method: :get,
+            path: "audio/voice_consents",
+            query: query,
+            page: OpenAI::Internal::CursorPage,
+            model: OpenAI::Audio::VoiceConsent,
+            security: {bearer_auth: true},
+            options: options
+          )
+        end
+
+        # Deletes a voice consent recording.
+        #
+        # @overload delete(consent_id, request_options: {})
+        #
+        # @param consent_id [String]
+        #   The ID of the consent recording to delete.
+        #
+        # @param request_options [OpenAI::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [OpenAI::Models::Audio::VoiceConsentDeleted]
+        #
+        # @see OpenAI::Models::Audio::VoiceConsentDeleteParams
+        def delete(consent_id, params = {})
+          @client.request(
+            method: :delete,
+            path: ["audio/voice_consents/%1$s", consent_id],
+            model: OpenAI::Audio::VoiceConsentDeleted,
+            security: {bearer_auth: true},
+            options: params[:request_options]
+          )
+        end
+
+        # @api private
+        #
+        # @param client [OpenAI::Client]
+        def initialize(client:)
+          @client = client
+        end
+      end
+    end
+  end
+end

data/lib/openai/resources/audio.rb

@@ -19,6 +19,10 @@ module OpenAI
       # @return [OpenAI::Resources::Audio::Voices]
       attr_reader :voices
 
+      # Turn audio into text or text into audio.
+      # @return [OpenAI::Resources::Audio::VoiceConsents]
+      attr_reader :voice_consents
+
       # @api private
       #
       # @param client [OpenAI::Client]
@@ -28,6 +32,7 @@ module OpenAI
         @translations = OpenAI::Resources::Audio::Translations.new(client: client)
         @speech = OpenAI::Resources::Audio::Speech.new(client: client)
         @voices = OpenAI::Resources::Audio::Voices.new(client: client)
+        @voice_consents = OpenAI::Resources::Audio::VoiceConsents.new(client: client)
       end
     end
   end

data/lib/openai/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module OpenAI
-  VERSION = "0.107.0"
+  VERSION = "0.109.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"
@@ -462,6 +463,13 @@ require_relative "openai/models/audio/translation_create_params"
 require_relative "openai/models/audio/translation_create_response"
 require_relative "openai/models/audio/translation_verbose"
 require_relative "openai/models/audio/voice"
+require_relative "openai/models/audio/voice_consent"
+require_relative "openai/models/audio/voice_consent_create_params"
+require_relative "openai/models/audio/voice_consent_deleted"
+require_relative "openai/models/audio/voice_consent_delete_params"
+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_model"
 require_relative "openai/models/audio_response_format"
@@ -1558,6 +1566,7 @@ require_relative "openai/resources/audio"
 require_relative "openai/resources/audio/speech"
 require_relative "openai/resources/audio/transcriptions"
 require_relative "openai/resources/audio/translations"
+require_relative "openai/resources/audio/voice_consents"
 require_relative "openai/resources/audio/voices"
 require_relative "openai/resources/batches"
 require_relative "openai/resources/beta"

data/rbi/openai/helpers/chat/tool_runner.rbi

@@ -0,0 +1,74 @@
+# typed: strong
+
+module OpenAI
+  module Helpers
+    module Chat
+      class ToolRunner
+        Handler = T.type_alias { T.proc.params(arguments: T::Hash[String, T.untyped]).returns(T.untyped) }
+
+        class Error < StandardError
+        end
+
+        class MaxRoundsError < Error
+        end
+
+        # @api private
+        sig do
+          params(
+            completions: OpenAI::Resources::Chat::Completions,
+            params: T::Hash[Symbol, T.untyped],
+            tool_handlers: T::Hash[String, Handler],
+            max_rounds: Integer
+          )
+            .void
+        end
+        def initialize(completions:, params:, tool_handlers:, max_rounds:)
+        end
+
+        # @api private
+        sig { returns(OpenAI::Chat::ChatCompletion) }
+        def run
+        end
+      end
+    end
+  end
+
+  module Resources
+    class Chat
+      class Completions
+        # @api private
+        sig { params(params: T::Hash[Symbol, T.untyped]).returns(OpenAI::Chat::ChatCompletion) }
+        def create_for_tool_runner(params)
+        end
+
+        sig do
+          params(
+            model: T.any(String, OpenAI::ChatModel::OrSymbol),
+            messages: T::Array[
+              T.any(
+                OpenAI::Chat::ChatCompletionDeveloperMessageParam::OrHash,
+                OpenAI::Chat::ChatCompletionSystemMessageParam::OrHash,
+                OpenAI::Chat::ChatCompletionUserMessageParam::OrHash,
+                OpenAI::Chat::ChatCompletionAssistantMessageParam::OrHash,
+                OpenAI::Chat::ChatCompletionToolMessageParam::OrHash,
+                OpenAI::Chat::ChatCompletionFunctionMessageParam::OrHash
+              )
+            ],
+            tools: T::Array[
+              T.any(
+                OpenAI::StructuredOutput::JsonSchemaConverter,
+                OpenAI::Chat::ChatCompletionFunctionTool::OrHash
+              )
+            ],
+            tool_handlers: T::Hash[String, OpenAI::Helpers::Chat::ToolRunner::Handler],
+            max_rounds: Integer,
+            params: T.untyped
+          )
+            .returns(OpenAI::Chat::ChatCompletion)
+        end
+        def run_tools(model:, messages:, tools:, tool_handlers:, max_rounds: 10, **params)
+        end
+      end
+    end
+  end
+end

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/admin/organization/usage_audio_speeches_response.rbi

@@ -232,8 +232,8 @@ module OpenAI
                 sig { returns(T.nilable(Integer)) }
                 attr_accessor :input_cache_write_30m_tokens
 
-                # The aggregated number of input tokens written to the cache with a 30-minute
-                # retention period.
+                # The aggregated number of input tokens written to the cache across 30-minute and
+                # 12-hour retention periods.
                 sig { returns(T.nilable(Integer)) }
                 attr_reader :input_cache_write_tokens
 
@@ -431,8 +431,8 @@ module OpenAI
                   # retention period. May be absent or null for older responses.
                   input_cache_write_30m_tokens: nil,
 
-                  # The aggregated number of input tokens written to the cache with a 30-minute
-                  # retention period.
+                  # The aggregated number of input tokens written to the cache across 30-minute and
+                  # 12-hour retention periods.
                   input_cache_write_tokens: nil,
 
                   # The aggregated number of cached audio input tokens used.

data/rbi/openai/models/admin/organization/usage_audio_transcriptions_response.rbi

@@ -234,8 +234,8 @@ module OpenAI
                 sig { returns(T.nilable(Integer)) }
                 attr_accessor :input_cache_write_30m_tokens
 
-                # The aggregated number of input tokens written to the cache with a 30-minute
-                # retention period.
+                # The aggregated number of input tokens written to the cache across 30-minute and
+                # 12-hour retention periods.
                 sig { returns(T.nilable(Integer)) }
                 attr_reader :input_cache_write_tokens
 
@@ -433,8 +433,8 @@ module OpenAI
                   # retention period. May be absent or null for older responses.
                   input_cache_write_30m_tokens: nil,
 
-                  # The aggregated number of input tokens written to the cache with a 30-minute
-                  # retention period.
+                  # The aggregated number of input tokens written to the cache across 30-minute and
+                  # 12-hour retention periods.
                   input_cache_write_tokens: nil,
 
                   # The aggregated number of cached audio input tokens used.

data/rbi/openai/models/admin/organization/usage_code_interpreter_sessions_response.rbi

@@ -236,8 +236,8 @@ module OpenAI
                 sig { returns(T.nilable(Integer)) }
                 attr_accessor :input_cache_write_30m_tokens
 
-                # The aggregated number of input tokens written to the cache with a 30-minute
-                # retention period.
+                # The aggregated number of input tokens written to the cache across 30-minute and
+                # 12-hour retention periods.
                 sig { returns(T.nilable(Integer)) }
                 attr_reader :input_cache_write_tokens
 
@@ -435,8 +435,8 @@ module OpenAI
                   # retention period. May be absent or null for older responses.
                   input_cache_write_30m_tokens: nil,
 
-                  # The aggregated number of input tokens written to the cache with a 30-minute
-                  # retention period.
+                  # The aggregated number of input tokens written to the cache across 30-minute and
+                  # 12-hour retention periods.
                   input_cache_write_tokens: nil,
 
                   # The aggregated number of cached audio input tokens used.

data/rbi/openai/models/admin/organization/usage_completions_response.rbi

@@ -232,8 +232,8 @@ module OpenAI
                 sig { returns(T.nilable(Integer)) }
                 attr_accessor :input_cache_write_30m_tokens
 
-                # The aggregated number of input tokens written to the cache with a 30-minute
-                # retention period.
+                # The aggregated number of input tokens written to the cache across 30-minute and
+                # 12-hour retention periods.
                 sig { returns(T.nilable(Integer)) }
                 attr_reader :input_cache_write_tokens
 
@@ -431,8 +431,8 @@ module OpenAI
                   # retention period. May be absent or null for older responses.
                   input_cache_write_30m_tokens: nil,
 
-                  # The aggregated number of input tokens written to the cache with a 30-minute
-                  # retention period.
+                  # The aggregated number of input tokens written to the cache across 30-minute and
+                  # 12-hour retention periods.
                   input_cache_write_tokens: nil,
 
                   # The aggregated number of cached audio input tokens used.

data/rbi/openai/models/admin/organization/usage_costs_response.rbi

@@ -228,8 +228,8 @@ module OpenAI
                 sig { returns(T.nilable(Integer)) }
                 attr_accessor :input_cache_write_30m_tokens
 
-                # The aggregated number of input tokens written to the cache with a 30-minute
-                # retention period.
+                # The aggregated number of input tokens written to the cache across 30-minute and
+                # 12-hour retention periods.
                 sig { returns(T.nilable(Integer)) }
                 attr_reader :input_cache_write_tokens
 
@@ -427,8 +427,8 @@ module OpenAI
                   # retention period. May be absent or null for older responses.
                   input_cache_write_30m_tokens: nil,
 
-                  # The aggregated number of input tokens written to the cache with a 30-minute
-                  # retention period.
+                  # The aggregated number of input tokens written to the cache across 30-minute and
+                  # 12-hour retention periods.
                   input_cache_write_tokens: nil,
 
                   # The aggregated number of cached audio input tokens used.

data/rbi/openai/models/admin/organization/usage_decisions_response.rbi

@@ -188,8 +188,8 @@ module OpenAI
               sig { returns(T.nilable(Integer)) }
               attr_accessor :input_cache_write_30m_tokens
 
-              # The aggregated number of input tokens written to the cache with a 30-minute
-              # retention period.
+              # The aggregated number of input tokens written to the cache across 30-minute and
+              # 12-hour retention periods.
               sig { returns(T.nilable(Integer)) }
               attr_accessor :input_cache_write_tokens
 
@@ -354,8 +354,8 @@ module OpenAI
                 # retention period.
                 input_cache_write_30m_tokens: nil,
 
-                # The aggregated number of input tokens written to the cache with a 30-minute
-                # retention period.
+                # The aggregated number of input tokens written to the cache across 30-minute and
+                # 12-hour retention periods.
                 input_cache_write_tokens: nil,
 
                 # The aggregated number of cached audio input tokens used.