openai 0.34.1 → 0.35.0

data/lib/openai/models/responses/tool.rb

@@ -30,8 +30,10 @@ module OpenAI
         # A tool that generates images using a model like `gpt-image-1`.
         variant :image_generation, -> { OpenAI::Responses::Tool::ImageGeneration }
 
+        # A tool that allows the model to execute shell commands in a local environment.
         variant :local_shell, -> { OpenAI::Responses::Tool::LocalShell }
 
+        # A custom tool that processes input using a specified format. Learn more about   [custom tools](https://platform.openai.com/docs/guides/function-calling#custom-tools)
         variant :custom, -> { OpenAI::Responses::CustomTool }
 
         # Search the Internet for sources related to the prompt. Learn more about the
@@ -388,13 +390,37 @@ module OpenAI
               #   @return [Array<String>, nil]
               optional :file_ids, OpenAI::Internal::Type::ArrayOf[String]
 
-              # @!method initialize(file_ids: nil, type: :auto)
+              # @!attribute memory_limit
+              #
+              #   @return [Symbol, OpenAI::Models::Responses::Tool::CodeInterpreter::Container::CodeInterpreterToolAuto::MemoryLimit, nil]
+              optional :memory_limit,
+                       enum: -> {
+                         OpenAI::Responses::Tool::CodeInterpreter::Container::CodeInterpreterToolAuto::MemoryLimit
+                       },
+                       nil?: true
+
+              # @!method initialize(file_ids: nil, memory_limit: nil, type: :auto)
               #   Configuration for a code interpreter container. Optionally specify the IDs of
               #   the files to run the code on.
               #
               #   @param file_ids [Array<String>] An optional list of uploaded files to make available to your code.
               #
+              #   @param memory_limit [Symbol, OpenAI::Models::Responses::Tool::CodeInterpreter::Container::CodeInterpreterToolAuto::MemoryLimit, nil]
+              #
               #   @param type [Symbol, :auto] Always `auto`.
+
+              # @see OpenAI::Models::Responses::Tool::CodeInterpreter::Container::CodeInterpreterToolAuto#memory_limit
+              module MemoryLimit
+                extend OpenAI::Internal::Type::Enum
+
+                MEMORY_LIMIT_1G = :"1g"
+                MEMORY_LIMIT_4G = :"4g"
+                MEMORY_LIMIT_16G = :"16g"
+                MEMORY_LIMIT_64G = :"64g"
+
+                # @!method self.values
+                #   @return [Array<Symbol>]
+              end
             end
 
             # @!method self.variants
@@ -490,7 +516,7 @@ module OpenAI
           #
           #   @param background [Symbol, OpenAI::Models::Responses::Tool::ImageGeneration::Background] Background type for the generated image. One of `transparent`,
           #
-          #   @param input_fidelity [Symbol, OpenAI::Models::Responses::Tool::ImageGeneration::InputFidelity, nil]
+          #   @param input_fidelity [Symbol, OpenAI::Models::Responses::Tool::ImageGeneration::InputFidelity, nil] Control how much effort the model will exert to match the style and features, es
           #
           #   @param input_image_mask [OpenAI::Models::Responses::Tool::ImageGeneration::InputImageMask] Optional mask for inpainting. Contains `image_url`
           #
@@ -650,6 +676,8 @@ module OpenAI
           required :type, const: :local_shell
 
           # @!method initialize(type: :local_shell)
+          #   A tool that allows the model to execute shell commands in a local environment.
+          #
           #   @param type [Symbol, :local_shell] The type of the local shell tool. Always `local_shell`.
         end
 

data/lib/openai/models/vector_stores/file_batch_create_params.rb

@@ -8,14 +8,6 @@ module OpenAI
         extend OpenAI::Internal::Type::RequestParameters::Converter
         include OpenAI::Internal::Type::RequestParameters
 
-        # @!attribute file_ids
-        #   A list of [File](https://platform.openai.com/docs/api-reference/files) IDs that
-        #   the vector store should use. Useful for tools like `file_search` that can access
-        #   files.
-        #
-        #   @return [Array<String>]
-        required :file_ids, OpenAI::Internal::Type::ArrayOf[String]
-
         # @!attribute attributes
         #   Set of 16 key-value pairs that can be attached to an object. This can be useful
         #   for storing additional information about the object in a structured format, and
@@ -37,16 +29,36 @@ module OpenAI
         #   @return [OpenAI::Models::AutoFileChunkingStrategyParam, OpenAI::Models::StaticFileChunkingStrategyObjectParam, nil]
         optional :chunking_strategy, union: -> { OpenAI::FileChunkingStrategyParam }
 
-        # @!method initialize(file_ids:, attributes: nil, chunking_strategy: nil, request_options: {})
+        # @!attribute file_ids
+        #   A list of [File](https://platform.openai.com/docs/api-reference/files) IDs that
+        #   the vector store should use. Useful for tools like `file_search` that can access
+        #   files. If `attributes` or `chunking_strategy` are provided, they will be applied
+        #   to all files in the batch. Mutually exclusive with `files`.
+        #
+        #   @return [Array<String>, nil]
+        optional :file_ids, OpenAI::Internal::Type::ArrayOf[String]
+
+        # @!attribute files
+        #   A list of objects that each include a `file_id` plus optional `attributes` or
+        #   `chunking_strategy`. Use this when you need to override metadata for specific
+        #   files. The global `attributes` or `chunking_strategy` will be ignored and must
+        #   be specified for each file. Mutually exclusive with `file_ids`.
+        #
+        #   @return [Array<OpenAI::Models::VectorStores::FileBatchCreateParams::File>, nil]
+        optional :files, -> { OpenAI::Internal::Type::ArrayOf[OpenAI::VectorStores::FileBatchCreateParams::File] }
+
+        # @!method initialize(attributes: nil, chunking_strategy: nil, file_ids: nil, files: nil, request_options: {})
         #   Some parameter documentations has been truncated, see
         #   {OpenAI::Models::VectorStores::FileBatchCreateParams} for more details.
         #
-        #   @param file_ids [Array<String>] A list of [File](https://platform.openai.com/docs/api-reference/files) IDs that
-        #
         #   @param attributes [Hash{Symbol=>String, Float, Boolean}, nil] Set of 16 key-value pairs that can be attached to an object. This can be
         #
         #   @param chunking_strategy [OpenAI::Models::AutoFileChunkingStrategyParam, OpenAI::Models::StaticFileChunkingStrategyObjectParam] The chunking strategy used to chunk the file(s). If not set, will use the `auto`
         #
+        #   @param file_ids [Array<String>] A list of [File](https://platform.openai.com/docs/api-reference/files) IDs that
+        #
+        #   @param files [Array<OpenAI::Models::VectorStores::FileBatchCreateParams::File>] A list of objects that each include a `file_id` plus optional `attributes` or `c
+        #
         #   @param request_options [OpenAI::RequestOptions, Hash{Symbol=>Object}]
 
         module Attribute
@@ -61,6 +73,60 @@ module OpenAI
           # @!method self.variants
           #   @return [Array(String, Float, Boolean)]
         end
+
+        class File < OpenAI::Internal::Type::BaseModel
+          # @!attribute file_id
+          #   A [File](https://platform.openai.com/docs/api-reference/files) ID that the
+          #   vector store should use. Useful for tools like `file_search` that can access
+          #   files.
+          #
+          #   @return [String]
+          required :file_id, String
+
+          # @!attribute attributes
+          #   Set of 16 key-value pairs that can be attached to an object. This can be useful
+          #   for storing additional information about the object in a structured format, and
+          #   querying for objects via API or the dashboard. Keys are strings with a maximum
+          #   length of 64 characters. Values are strings with a maximum length of 512
+          #   characters, booleans, or numbers.
+          #
+          #   @return [Hash{Symbol=>String, Float, Boolean}, nil]
+          optional :attributes,
+                   -> {
+                     OpenAI::Internal::Type::HashOf[union: OpenAI::VectorStores::FileBatchCreateParams::File::Attribute]
+                   },
+                   nil?: true
+
+          # @!attribute chunking_strategy
+          #   The chunking strategy used to chunk the file(s). If not set, will use the `auto`
+          #   strategy. Only applicable if `file_ids` is non-empty.
+          #
+          #   @return [OpenAI::Models::AutoFileChunkingStrategyParam, OpenAI::Models::StaticFileChunkingStrategyObjectParam, nil]
+          optional :chunking_strategy, union: -> { OpenAI::FileChunkingStrategyParam }
+
+          # @!method initialize(file_id:, attributes: nil, chunking_strategy: nil)
+          #   Some parameter documentations has been truncated, see
+          #   {OpenAI::Models::VectorStores::FileBatchCreateParams::File} for more details.
+          #
+          #   @param file_id [String] A [File](https://platform.openai.com/docs/api-reference/files) ID that the vecto
+          #
+          #   @param attributes [Hash{Symbol=>String, Float, Boolean}, nil] Set of 16 key-value pairs that can be attached to an object. This can be
+          #
+          #   @param chunking_strategy [OpenAI::Models::AutoFileChunkingStrategyParam, OpenAI::Models::StaticFileChunkingStrategyObjectParam] The chunking strategy used to chunk the file(s). If not set, will use the `auto`
+
+          module Attribute
+            extend OpenAI::Internal::Type::Union
+
+            variant String
+
+            variant Float
+
+            variant OpenAI::Internal::Type::Boolean
+
+            # @!method self.variants
+            #   @return [Array(String, Float, Boolean)]
+          end
+        end
       end
     end
   end

data/lib/openai/models/video.rb

@@ -52,6 +52,12 @@ module OpenAI
       #   @return [Integer]
       required :progress, Integer
 
+      # @!attribute prompt
+      #   The prompt that was used to generate the video.
+      #
+      #   @return [String, nil]
+      required :prompt, String, nil?: true
+
       # @!attribute remixed_from_video_id
       #   Identifier of the source video if this video is a remix.
       #
@@ -76,7 +82,7 @@ module OpenAI
       #   @return [Symbol, OpenAI::Models::Video::Status]
       required :status, enum: -> { OpenAI::Video::Status }
 
-      # @!method initialize(id:, completed_at:, created_at:, error:, expires_at:, model:, progress:, remixed_from_video_id:, seconds:, size:, status:, object: :video)
+      # @!method initialize(id:, completed_at:, created_at:, error:, expires_at:, model:, progress:, prompt:, remixed_from_video_id:, seconds:, size:, status:, object: :video)
       #   Structured information describing a generated video job.
       #
       #   @param id [String] Unique identifier for the video job.
@@ -93,6 +99,8 @@ module OpenAI
       #
       #   @param progress [Integer] Approximate completion percentage for the generation task.
       #
+      #   @param prompt [String, nil] The prompt that was used to generate the video.
+      #
       #   @param remixed_from_video_id [String, nil] Identifier of the source video if this video is a remix.
       #
       #   @param seconds [Symbol, OpenAI::Models::VideoSeconds] Duration of the generated clip in seconds.

data/lib/openai/resources/files.rb

@@ -10,20 +10,19 @@ module OpenAI
       # up to 512 MB, and the size of all files uploaded by one organization can be up
       # to 1 TB.
       #
-      # The Assistants API supports files up to 2 million tokens and of specific file
-      # types. See the
-      # [Assistants Tools guide](https://platform.openai.com/docs/assistants/tools) for
-      # details.
-      #
-      # The Fine-tuning API only supports `.jsonl` files. The input also has certain
-      # required formats for fine-tuning
-      # [chat](https://platform.openai.com/docs/api-reference/fine-tuning/chat-input) or
-      # [completions](https://platform.openai.com/docs/api-reference/fine-tuning/completions-input)
-      # models.
-      #
-      # The Batch API only supports `.jsonl` files up to 200 MB in size. The input also
-      # has a specific required
-      # [format](https://platform.openai.com/docs/api-reference/batch/request-input).
+      # - The Assistants API supports files up to 2 million tokens and of specific file
+      #   types. See the
+      #   [Assistants Tools guide](https://platform.openai.com/docs/assistants/tools)
+      #   for details.
+      # - The Fine-tuning API only supports `.jsonl` files. The input also has certain
+      #   required formats for fine-tuning
+      #   [chat](https://platform.openai.com/docs/api-reference/fine-tuning/chat-input)
+      #   or
+      #   [completions](https://platform.openai.com/docs/api-reference/fine-tuning/completions-input)
+      #   models.
+      # - The Batch API only supports `.jsonl` files up to 200 MB in size. The input
+      #   also has a specific required
+      #   [format](https://platform.openai.com/docs/api-reference/batch/request-input).
       #
       # Please [contact us](https://help.openai.com/) if you need to increase these
       # storage limits.

data/lib/openai/resources/images.rb

@@ -55,7 +55,7 @@ module OpenAI
       #
       # @param background [Symbol, OpenAI::Models::ImageEditParams::Background, nil] Allows to set transparency for the background of the generated image(s).
       #
-      # @param input_fidelity [Symbol, OpenAI::Models::ImageEditParams::InputFidelity, nil]
+      # @param input_fidelity [Symbol, OpenAI::Models::ImageEditParams::InputFidelity, nil] Control how much effort the model will exert to match the style and features, es
       #
       # @param mask [Pathname, StringIO, IO, String, OpenAI::FilePart] An additional image whose fully transparent areas (e.g. where alpha is zero) ind
       #
@@ -114,7 +114,7 @@ module OpenAI
       #
       # @param background [Symbol, OpenAI::Models::ImageEditParams::Background, nil] Allows to set transparency for the background of the generated image(s).
       #
-      # @param input_fidelity [Symbol, OpenAI::Models::ImageEditParams::InputFidelity, nil]
+      # @param input_fidelity [Symbol, OpenAI::Models::ImageEditParams::InputFidelity, nil] Control how much effort the model will exert to match the style and features, es
       #
       # @param mask [Pathname, StringIO, IO, String, OpenAI::FilePart] An additional image whose fully transparent areas (e.g. where alpha is zero) ind
       #

data/lib/openai/resources/realtime/calls.rb

@@ -34,7 +34,7 @@ module OpenAI
         #
         # @param tracing [Symbol, :auto, OpenAI::Models::Realtime::RealtimeTracingConfig::TracingConfiguration, nil] Realtime API can write session traces to the [Traces Dashboard](/logs?api=traces
         #
-        # @param truncation [Symbol, OpenAI::Models::Realtime::RealtimeTruncation::RealtimeTruncationStrategy, OpenAI::Models::Realtime::RealtimeTruncationRetentionRatio] Controls how the realtime conversation is truncated prior to model inference.
+        # @param truncation [Symbol, OpenAI::Models::Realtime::RealtimeTruncation::RealtimeTruncationStrategy, OpenAI::Models::Realtime::RealtimeTruncationRetentionRatio] When the number of tokens in a conversation exceeds the model's input token limi
         #
         # @param type [Symbol, :realtime] The type of session to create. Always `realtime` for the Realtime API.
         #

data/lib/openai/resources/responses.rb

@@ -559,6 +559,10 @@ module OpenAI
         in {text: {format: {type: :json_schema,
                             schema: OpenAI::StructuredOutput::JsonSchemaConverter => model}}}
           parsed.dig(:text, :format).store(:schema, model.to_json_schema)
+        else
+        end
+
+        case parsed
         in {tools: Array => tools}
           # rubocop:disable Metrics/BlockLength
           mapped = tools.map do |tool|

data/lib/openai/resources/vector_stores/file_batches.rb

@@ -9,22 +9,24 @@ module OpenAI
         #
         # Create a vector store file batch.
         #
-        # @overload create(vector_store_id, file_ids:, attributes: nil, chunking_strategy: nil, request_options: {})
+        # @overload create(vector_store_id, attributes: nil, chunking_strategy: nil, file_ids: nil, files: nil, request_options: {})
         #
         # @param vector_store_id [String] The ID of the vector store for which to create a File Batch.
         #
-        # @param file_ids [Array<String>] A list of [File](https://platform.openai.com/docs/api-reference/files) IDs that
-        #
         # @param attributes [Hash{Symbol=>String, Float, Boolean}, nil] Set of 16 key-value pairs that can be attached to an object. This can be
         #
         # @param chunking_strategy [OpenAI::Models::AutoFileChunkingStrategyParam, OpenAI::Models::StaticFileChunkingStrategyObjectParam] The chunking strategy used to chunk the file(s). If not set, will use the `auto`
         #
+        # @param file_ids [Array<String>] A list of [File](https://platform.openai.com/docs/api-reference/files) IDs that
+        #
+        # @param files [Array<OpenAI::Models::VectorStores::FileBatchCreateParams::File>] A list of objects that each include a `file_id` plus optional `attributes` or `c
+        #
         # @param request_options [OpenAI::RequestOptions, Hash{Symbol=>Object}, nil]
         #
         # @return [OpenAI::Models::VectorStores::VectorStoreFileBatch]
         #
         # @see OpenAI::Models::VectorStores::FileBatchCreateParams
-        def create(vector_store_id, params)
+        def create(vector_store_id, params = {})
           parsed, options = OpenAI::VectorStores::FileBatchCreateParams.dump_request(params)
           @client.request(
             method: :post,

data/lib/openai/version.rb

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

data/rbi/openai/internal/transport/base_client.rbi

@@ -184,6 +184,11 @@ module OpenAI
         private def auth_headers
         end
 
+        # @api private
+        sig { returns(String) }
+        private def user_agent
+        end
+
         # @api private
         sig { returns(String) }
         private def generate_idempotency_key

data/rbi/openai/internal/type/base_model.rbi

@@ -28,7 +28,7 @@ module OpenAI
           #
           # Assumes superclass fields are totally defined before fields are accessed /
           # defined on subclasses.
-          sig { params(child: T.self_type).void }
+          sig { params(child: OpenAI::Internal::Type::BaseModel).void }
           def inherited(child)
           end
 
@@ -267,9 +267,13 @@ module OpenAI
 
         # Create a new instance of a model.
         sig do
-          params(data: T.any(T::Hash[Symbol, T.anything], T.self_type)).returns(
-            T.attached_class
-          )
+          params(
+            data:
+              T.any(
+                T::Hash[Symbol, T.anything],
+                OpenAI::Internal::Type::BaseModel
+              )
+          ).returns(T.attached_class)
         end
         def self.new(data = {})
         end

data/rbi/openai/models/custom_tool_input_format.rbi

@@ -27,6 +27,7 @@ module OpenAI
         sig { returns(Symbol) }
         attr_accessor :type
 
+        # Unconstrained free-form text.
         sig { params(type: Symbol).returns(T.attached_class) }
         def self.new(
           # Unconstrained text format. Always `text`.
@@ -62,6 +63,7 @@ module OpenAI
         sig { returns(Symbol) }
         attr_accessor :type
 
+        # A grammar defined by the user.
         sig do
           params(
             definition: String,

data/rbi/openai/models/realtime/realtime_session_create_request.rbi

@@ -210,8 +210,19 @@ module OpenAI
         end
         attr_accessor :tracing
 
-        # Controls how the realtime conversation is truncated prior to model inference.
-        # The default is `auto`.
+        # When the number of tokens in a conversation exceeds the model's input token
+        # limit, the conversation be truncated, meaning messages (starting from the
+        # oldest) will not be included in the model's context. A 32k context model with
+        # 4,096 max output tokens can only include 28,224 tokens in the context before
+        # truncation occurs. Clients can configure truncation behavior to truncate with a
+        # lower max token limit, which is an effective way to control token usage and
+        # cost. Truncation will reduce the number of cached tokens on the next turn
+        # (busting the cache), since messages are dropped from the beginning of the
+        # context. However, clients can also configure truncation to retain messages up to
+        # a fraction of the maximum context size, which will reduce the need for future
+        # truncations and thus improve the cache rate. Truncation can be disabled
+        # entirely, which means the server will never truncate but would instead return an
+        # error if the conversation exceeds the model's input token limit.
         sig do
           returns(
             T.nilable(
@@ -329,8 +340,19 @@ module OpenAI
           # `auto` will create a trace for the session with default values for the workflow
           # name, group id, and metadata.
           tracing: nil,
-          # Controls how the realtime conversation is truncated prior to model inference.
-          # The default is `auto`.
+          # When the number of tokens in a conversation exceeds the model's input token
+          # limit, the conversation be truncated, meaning messages (starting from the
+          # oldest) will not be included in the model's context. A 32k context model with
+          # 4,096 max output tokens can only include 28,224 tokens in the context before
+          # truncation occurs. Clients can configure truncation behavior to truncate with a
+          # lower max token limit, which is an effective way to control token usage and
+          # cost. Truncation will reduce the number of cached tokens on the next turn
+          # (busting the cache), since messages are dropped from the beginning of the
+          # context. However, clients can also configure truncation to retain messages up to
+          # a fraction of the maximum context size, which will reduce the need for future
+          # truncations and thus improve the cache rate. Truncation can be disabled
+          # entirely, which means the server will never truncate but would instead return an
+          # error if the conversation exceeds the model's input token limit.
           truncation: nil,
           # The type of session to create. Always `realtime` for the Realtime API.
           type: :realtime

data/rbi/openai/models/realtime/realtime_session_create_response.rbi

@@ -223,8 +223,19 @@ module OpenAI
         end
         attr_accessor :tracing
 
-        # Controls how the realtime conversation is truncated prior to model inference.
-        # The default is `auto`.
+        # When the number of tokens in a conversation exceeds the model's input token
+        # limit, the conversation be truncated, meaning messages (starting from the
+        # oldest) will not be included in the model's context. A 32k context model with
+        # 4,096 max output tokens can only include 28,224 tokens in the context before
+        # truncation occurs. Clients can configure truncation behavior to truncate with a
+        # lower max token limit, which is an effective way to control token usage and
+        # cost. Truncation will reduce the number of cached tokens on the next turn
+        # (busting the cache), since messages are dropped from the beginning of the
+        # context. However, clients can also configure truncation to retain messages up to
+        # a fraction of the maximum context size, which will reduce the need for future
+        # truncations and thus improve the cache rate. Truncation can be disabled
+        # entirely, which means the server will never truncate but would instead return an
+        # error if the conversation exceeds the model's input token limit.
         sig do
           returns(T.nilable(OpenAI::Realtime::RealtimeTruncation::Variants))
         end
@@ -341,8 +352,19 @@ module OpenAI
           # `auto` will create a trace for the session with default values for the workflow
           # name, group id, and metadata.
           tracing: nil,
-          # Controls how the realtime conversation is truncated prior to model inference.
-          # The default is `auto`.
+          # When the number of tokens in a conversation exceeds the model's input token
+          # limit, the conversation be truncated, meaning messages (starting from the
+          # oldest) will not be included in the model's context. A 32k context model with
+          # 4,096 max output tokens can only include 28,224 tokens in the context before
+          # truncation occurs. Clients can configure truncation behavior to truncate with a
+          # lower max token limit, which is an effective way to control token usage and
+          # cost. Truncation will reduce the number of cached tokens on the next turn
+          # (busting the cache), since messages are dropped from the beginning of the
+          # context. However, clients can also configure truncation to retain messages up to
+          # a fraction of the maximum context size, which will reduce the need for future
+          # truncations and thus improve the cache rate. Truncation can be disabled
+          # entirely, which means the server will never truncate but would instead return an
+          # error if the conversation exceeds the model's input token limit.
           truncation: nil,
           # The type of session to create. Always `realtime` for the Realtime API.
           type: :realtime

data/rbi/openai/models/realtime/realtime_truncation.rbi

@@ -3,8 +3,19 @@
 module OpenAI
   module Models
     module Realtime
-      # Controls how the realtime conversation is truncated prior to model inference.
-      # The default is `auto`.
+      # When the number of tokens in a conversation exceeds the model's input token
+      # limit, the conversation be truncated, meaning messages (starting from the
+      # oldest) will not be included in the model's context. A 32k context model with
+      # 4,096 max output tokens can only include 28,224 tokens in the context before
+      # truncation occurs. Clients can configure truncation behavior to truncate with a
+      # lower max token limit, which is an effective way to control token usage and
+      # cost. Truncation will reduce the number of cached tokens on the next turn
+      # (busting the cache), since messages are dropped from the beginning of the
+      # context. However, clients can also configure truncation to retain messages up to
+      # a fraction of the maximum context size, which will reduce the need for future
+      # truncations and thus improve the cache rate. Truncation can be disabled
+      # entirely, which means the server will never truncate but would instead return an
+      # error if the conversation exceeds the model's input token limit.
       module RealtimeTruncation
         extend OpenAI::Internal::Type::Union
 

data/rbi/openai/models/realtime/realtime_truncation_retention_ratio.rbi

@@ -12,8 +12,10 @@ module OpenAI
             )
           end
 
-        # Fraction of post-instruction conversation tokens to retain (0.0 - 1.0) when the
-        # conversation exceeds the input token limit.
+        # Fraction of post-instruction conversation tokens to retain (`0.0` - `1.0`) when
+        # the conversation exceeds the input token limit. Setting this to `0.8` means that
+        # messages will be dropped until 80% of the maximum allowed tokens are used. This
+        # helps reduce the frequency of truncations and improve cache rates.
         sig { returns(Float) }
         attr_accessor :retention_ratio
 
@@ -21,24 +23,100 @@ module OpenAI
         sig { returns(Symbol) }
         attr_accessor :type
 
+        # Optional custom token limits for this truncation strategy. If not provided, the
+        # model's default token limits will be used.
+        sig do
+          returns(
+            T.nilable(
+              OpenAI::Realtime::RealtimeTruncationRetentionRatio::TokenLimits
+            )
+          )
+        end
+        attr_reader :token_limits
+
+        sig do
+          params(
+            token_limits:
+              OpenAI::Realtime::RealtimeTruncationRetentionRatio::TokenLimits::OrHash
+          ).void
+        end
+        attr_writer :token_limits
+
         # Retain a fraction of the conversation tokens when the conversation exceeds the
         # input token limit. This allows you to amortize truncations across multiple
         # turns, which can help improve cached token usage.
         sig do
-          params(retention_ratio: Float, type: Symbol).returns(T.attached_class)
+          params(
+            retention_ratio: Float,
+            token_limits:
+              OpenAI::Realtime::RealtimeTruncationRetentionRatio::TokenLimits::OrHash,
+            type: Symbol
+          ).returns(T.attached_class)
         end
         def self.new(
-          # Fraction of post-instruction conversation tokens to retain (0.0 - 1.0) when the
-          # conversation exceeds the input token limit.
+          # Fraction of post-instruction conversation tokens to retain (`0.0` - `1.0`) when
+          # the conversation exceeds the input token limit. Setting this to `0.8` means that
+          # messages will be dropped until 80% of the maximum allowed tokens are used. This
+          # helps reduce the frequency of truncations and improve cache rates.
           retention_ratio:,
+          # Optional custom token limits for this truncation strategy. If not provided, the
+          # model's default token limits will be used.
+          token_limits: nil,
           # Use retention ratio truncation.
           type: :retention_ratio
         )
         end
 
-        sig { override.returns({ retention_ratio: Float, type: Symbol }) }
+        sig do
+          override.returns(
+            {
+              retention_ratio: Float,
+              type: Symbol,
+              token_limits:
+                OpenAI::Realtime::RealtimeTruncationRetentionRatio::TokenLimits
+            }
+          )
+        end
         def to_hash
         end
+
+        class TokenLimits < OpenAI::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                OpenAI::Realtime::RealtimeTruncationRetentionRatio::TokenLimits,
+                OpenAI::Internal::AnyHash
+              )
+            end
+
+          # Maximum tokens allowed in the conversation after instructions (which including
+          # tool definitions). For example, setting this to 5,000 would mean that truncation
+          # would occur when the conversation exceeds 5,000 tokens after instructions. This
+          # cannot be higher than the model's context window size minus the maximum output
+          # tokens.
+          sig { returns(T.nilable(Integer)) }
+          attr_reader :post_instructions
+
+          sig { params(post_instructions: Integer).void }
+          attr_writer :post_instructions
+
+          # Optional custom token limits for this truncation strategy. If not provided, the
+          # model's default token limits will be used.
+          sig { params(post_instructions: Integer).returns(T.attached_class) }
+          def self.new(
+            # Maximum tokens allowed in the conversation after instructions (which including
+            # tool definitions). For example, setting this to 5,000 would mean that truncation
+            # would occur when the conversation exceeds 5,000 tokens after instructions. This
+            # cannot be higher than the model's context window size minus the maximum output
+            # tokens.
+            post_instructions: nil
+          )
+          end
+
+          sig { override.returns({ post_instructions: Integer }) }
+          def to_hash
+          end
+        end
       end
     end
   end

data/rbi/openai/models/reasoning.rbi

@@ -28,6 +28,8 @@ module OpenAI
       # A summary of the reasoning performed by the model. This can be useful for
       # debugging and understanding the model's reasoning process. One of `auto`,
       # `concise`, or `detailed`.
+      #
+      # `concise` is only supported for `computer-use-preview` models.
       sig { returns(T.nilable(OpenAI::Reasoning::Summary::OrSymbol)) }
       attr_accessor :summary
 
@@ -62,6 +64,8 @@ module OpenAI
         # A summary of the reasoning performed by the model. This can be useful for
         # debugging and understanding the model's reasoning process. One of `auto`,
         # `concise`, or `detailed`.
+        #
+        # `concise` is only supported for `computer-use-preview` models.
         summary: nil
       )
       end
@@ -109,6 +113,8 @@ module OpenAI
       # A summary of the reasoning performed by the model. This can be useful for
       # debugging and understanding the model's reasoning process. One of `auto`,
       # `concise`, or `detailed`.
+      #
+      # `concise` is only supported for `computer-use-preview` models.
       module Summary
         extend OpenAI::Internal::Type::Enum
 

data/rbi/openai/models/responses/custom_tool.rbi

@@ -48,6 +48,8 @@ module OpenAI
         end
         attr_writer :format_
 
+        # A custom tool that processes input using a specified format. Learn more about
+        # [custom tools](https://platform.openai.com/docs/guides/function-calling#custom-tools)
         sig do
           params(
             name: String,