openai 0.36.1 → 0.37.0

data/rbi/openai/models/realtime/realtime_server_event.rbi

@@ -21,6 +21,7 @@ module OpenAI
               OpenAI::Realtime::RealtimeErrorEvent,
               OpenAI::Realtime::InputAudioBufferClearedEvent,
               OpenAI::Realtime::InputAudioBufferCommittedEvent,
+              OpenAI::Realtime::InputAudioBufferDtmfEventReceivedEvent,
               OpenAI::Realtime::InputAudioBufferSpeechStartedEvent,
               OpenAI::Realtime::InputAudioBufferSpeechStoppedEvent,
               OpenAI::Realtime::RateLimitsUpdatedEvent,
@@ -171,8 +172,8 @@ module OpenAI
           sig { returns(Symbol) }
           attr_accessor :type
 
-          # **WebRTC Only:** Emitted when the server begins streaming audio to the client.
-          # This event is emitted after an audio content part has been added
+          # **WebRTC/SIP Only:** Emitted when the server begins streaming audio to the
+          # client. This event is emitted after an audio content part has been added
           # (`response.content_part.added`) to the response.
           # [Learn more](https://platform.openai.com/docs/guides/realtime-conversations#client-and-server-events-for-audio-in-webrtc).
           sig do
@@ -220,7 +221,7 @@ module OpenAI
           sig { returns(Symbol) }
           attr_accessor :type
 
-          # **WebRTC Only:** Emitted when the output audio buffer has been completely
+          # **WebRTC/SIP Only:** Emitted when the output audio buffer has been completely
           # drained on the server, and no more audio is forthcoming. This event is emitted
           # after the full response data has been sent to the client (`response.done`).
           # [Learn more](https://platform.openai.com/docs/guides/realtime-conversations#client-and-server-events-for-audio-in-webrtc).
@@ -269,8 +270,8 @@ module OpenAI
           sig { returns(Symbol) }
           attr_accessor :type
 
-          # **WebRTC Only:** Emitted when the output audio buffer is cleared. This happens
-          # either in VAD mode when the user has interrupted
+          # **WebRTC/SIP Only:** Emitted when the output audio buffer is cleared. This
+          # happens either in VAD mode when the user has interrupted
           # (`input_audio_buffer.speech_started`), or when the client has emitted the
           # `output_audio_buffer.clear` event to manually cut off the current audio
           # response.

data/rbi/openai/models/realtime/realtime_session.rbi

@@ -933,7 +933,11 @@ module OpenAI
             attr_accessor :type
 
             # Whether or not to automatically generate a response when a VAD stop event
-            # occurs.
+            # occurs. If `interrupt_response` is set to `false` this may fail to create a
+            # response if the model is already responding.
+            #
+            # If both `create_response` and `interrupt_response` are set to `false`, the model
+            # will never respond automatically but VAD events will still be emitted.
             sig { returns(T.nilable(T::Boolean)) }
             attr_reader :create_response
 
@@ -955,9 +959,13 @@ module OpenAI
             sig { returns(T.nilable(Integer)) }
             attr_accessor :idle_timeout_ms
 
-            # Whether or not to automatically interrupt any ongoing response with output to
-            # the default conversation (i.e. `conversation` of `auto`) when a VAD start event
-            # occurs.
+            # Whether or not to automatically interrupt (cancel) any ongoing response with
+            # output to the default conversation (i.e. `conversation` of `auto`) when a VAD
+            # start event occurs. If `true` then the response will be cancelled, otherwise it
+            # will continue until complete.
+            #
+            # If both `create_response` and `interrupt_response` are set to `false`, the model
+            # will never respond automatically but VAD events will still be emitted.
             sig { returns(T.nilable(T::Boolean)) }
             attr_reader :interrupt_response
 
@@ -1005,7 +1013,11 @@ module OpenAI
             end
             def self.new(
               # Whether or not to automatically generate a response when a VAD stop event
-              # occurs.
+              # occurs. If `interrupt_response` is set to `false` this may fail to create a
+              # response if the model is already responding.
+              #
+              # If both `create_response` and `interrupt_response` are set to `false`, the model
+              # will never respond automatically but VAD events will still be emitted.
               create_response: nil,
               # Optional timeout after which a model response will be triggered automatically.
               # This is useful for situations in which a long pause from the user is unexpected,
@@ -1020,9 +1032,13 @@ module OpenAI
               # Response) will be emitted when the timeout is reached. Idle timeout is currently
               # only supported for `server_vad` mode.
               idle_timeout_ms: nil,
-              # Whether or not to automatically interrupt any ongoing response with output to
-              # the default conversation (i.e. `conversation` of `auto`) when a VAD start event
-              # occurs.
+              # Whether or not to automatically interrupt (cancel) any ongoing response with
+              # output to the default conversation (i.e. `conversation` of `auto`) when a VAD
+              # start event occurs. If `true` then the response will be cancelled, otherwise it
+              # will continue until complete.
+              #
+              # If both `create_response` and `interrupt_response` are set to `false`, the model
+              # will never respond automatically but VAD events will still be emitted.
               interrupt_response: nil,
               # Used only for `server_vad` mode. Amount of audio to include before the VAD
               # detected speech (in milliseconds). Defaults to 300ms.

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

@@ -214,15 +214,20 @@ module OpenAI
         # 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 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(
@@ -344,15 +349,20 @@ module OpenAI
           # 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 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

@@ -227,15 +227,20 @@ module OpenAI
         # 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 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
@@ -356,15 +361,20 @@ module OpenAI
           # 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 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
@@ -730,7 +740,11 @@ module OpenAI
                 attr_accessor :type
 
                 # Whether or not to automatically generate a response when a VAD stop event
-                # occurs.
+                # occurs. If `interrupt_response` is set to `false` this may fail to create a
+                # response if the model is already responding.
+                #
+                # If both `create_response` and `interrupt_response` are set to `false`, the model
+                # will never respond automatically but VAD events will still be emitted.
                 sig { returns(T.nilable(T::Boolean)) }
                 attr_reader :create_response
 
@@ -752,9 +766,13 @@ module OpenAI
                 sig { returns(T.nilable(Integer)) }
                 attr_accessor :idle_timeout_ms
 
-                # Whether or not to automatically interrupt any ongoing response with output to
-                # the default conversation (i.e. `conversation` of `auto`) when a VAD start event
-                # occurs.
+                # Whether or not to automatically interrupt (cancel) any ongoing response with
+                # output to the default conversation (i.e. `conversation` of `auto`) when a VAD
+                # start event occurs. If `true` then the response will be cancelled, otherwise it
+                # will continue until complete.
+                #
+                # If both `create_response` and `interrupt_response` are set to `false`, the model
+                # will never respond automatically but VAD events will still be emitted.
                 sig { returns(T.nilable(T::Boolean)) }
                 attr_reader :interrupt_response
 
@@ -802,7 +820,11 @@ module OpenAI
                 end
                 def self.new(
                   # Whether or not to automatically generate a response when a VAD stop event
-                  # occurs.
+                  # occurs. If `interrupt_response` is set to `false` this may fail to create a
+                  # response if the model is already responding.
+                  #
+                  # If both `create_response` and `interrupt_response` are set to `false`, the model
+                  # will never respond automatically but VAD events will still be emitted.
                   create_response: nil,
                   # Optional timeout after which a model response will be triggered automatically.
                   # This is useful for situations in which a long pause from the user is unexpected,
@@ -817,9 +839,13 @@ module OpenAI
                   # Response) will be emitted when the timeout is reached. Idle timeout is currently
                   # only supported for `server_vad` mode.
                   idle_timeout_ms: nil,
-                  # Whether or not to automatically interrupt any ongoing response with output to
-                  # the default conversation (i.e. `conversation` of `auto`) when a VAD start event
-                  # occurs.
+                  # Whether or not to automatically interrupt (cancel) any ongoing response with
+                  # output to the default conversation (i.e. `conversation` of `auto`) when a VAD
+                  # start event occurs. If `true` then the response will be cancelled, otherwise it
+                  # will continue until complete.
+                  #
+                  # If both `create_response` and `interrupt_response` are set to `false`, the model
+                  # will never respond automatically but VAD events will still be emitted.
                   interrupt_response: nil,
                   # Used only for `server_vad` mode. Amount of audio to include before the VAD
                   # detected speech (in milliseconds). Defaults to 300ms.

data/rbi/openai/models/realtime/realtime_transcription_session_audio_input_turn_detection.rbi

@@ -41,7 +41,11 @@ module OpenAI
           attr_accessor :type
 
           # Whether or not to automatically generate a response when a VAD stop event
-          # occurs.
+          # occurs. If `interrupt_response` is set to `false` this may fail to create a
+          # response if the model is already responding.
+          #
+          # If both `create_response` and `interrupt_response` are set to `false`, the model
+          # will never respond automatically but VAD events will still be emitted.
           sig { returns(T.nilable(T::Boolean)) }
           attr_reader :create_response
 
@@ -63,9 +67,13 @@ module OpenAI
           sig { returns(T.nilable(Integer)) }
           attr_accessor :idle_timeout_ms
 
-          # Whether or not to automatically interrupt any ongoing response with output to
-          # the default conversation (i.e. `conversation` of `auto`) when a VAD start event
-          # occurs.
+          # Whether or not to automatically interrupt (cancel) any ongoing response with
+          # output to the default conversation (i.e. `conversation` of `auto`) when a VAD
+          # start event occurs. If `true` then the response will be cancelled, otherwise it
+          # will continue until complete.
+          #
+          # If both `create_response` and `interrupt_response` are set to `false`, the model
+          # will never respond automatically but VAD events will still be emitted.
           sig { returns(T.nilable(T::Boolean)) }
           attr_reader :interrupt_response
 
@@ -113,7 +121,11 @@ module OpenAI
           end
           def self.new(
             # Whether or not to automatically generate a response when a VAD stop event
-            # occurs.
+            # occurs. If `interrupt_response` is set to `false` this may fail to create a
+            # response if the model is already responding.
+            #
+            # If both `create_response` and `interrupt_response` are set to `false`, the model
+            # will never respond automatically but VAD events will still be emitted.
             create_response: nil,
             # Optional timeout after which a model response will be triggered automatically.
             # This is useful for situations in which a long pause from the user is unexpected,
@@ -128,9 +140,13 @@ module OpenAI
             # Response) will be emitted when the timeout is reached. Idle timeout is currently
             # only supported for `server_vad` mode.
             idle_timeout_ms: nil,
-            # Whether or not to automatically interrupt any ongoing response with output to
-            # the default conversation (i.e. `conversation` of `auto`) when a VAD start event
-            # occurs.
+            # Whether or not to automatically interrupt (cancel) any ongoing response with
+            # output to the default conversation (i.e. `conversation` of `auto`) when a VAD
+            # start event occurs. If `true` then the response will be cancelled, otherwise it
+            # will continue until complete.
+            #
+            # If both `create_response` and `interrupt_response` are set to `false`, the model
+            # will never respond automatically but VAD events will still be emitted.
             interrupt_response: nil,
             # Used only for `server_vad` mode. Amount of audio to include before the VAD
             # detected speech (in milliseconds). Defaults to 300ms.

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

@@ -7,15 +7,20 @@ module OpenAI
       # 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 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/reasoning.rbi

@@ -8,9 +8,9 @@ module OpenAI
 
       # Constrains effort on reasoning for
       # [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently
-      # supported values are `none`, `minimal`, `low`, `medium`, and `high`. Reducing
-      # reasoning effort can result in faster responses and fewer tokens used on
-      # reasoning in a response.
+      # supported values are `none`, `minimal`, `low`, `medium`, `high`, and `xhigh`.
+      # Reducing reasoning effort can result in faster responses and fewer tokens used
+      # on reasoning in a response.
       #
       # - `gpt-5.1` defaults to `none`, which does not perform reasoning. The supported
       #   reasoning values for `gpt-5.1` are `none`, `low`, `medium`, and `high`. Tool
@@ -18,6 +18,7 @@ module OpenAI
       # - All models before `gpt-5.1` default to `medium` reasoning effort, and do not
       #   support `none`.
       # - The `gpt-5-pro` model defaults to (and only supports) `high` reasoning effort.
+      # - `xhigh` is currently only supported for `gpt-5.1-codex-max`.
       sig { returns(T.nilable(OpenAI::ReasoningEffort::OrSymbol)) }
       attr_accessor :effort
 
@@ -52,9 +53,9 @@ module OpenAI
       def self.new(
         # Constrains effort on reasoning for
         # [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently
-        # supported values are `none`, `minimal`, `low`, `medium`, and `high`. Reducing
-        # reasoning effort can result in faster responses and fewer tokens used on
-        # reasoning in a response.
+        # supported values are `none`, `minimal`, `low`, `medium`, `high`, and `xhigh`.
+        # Reducing reasoning effort can result in faster responses and fewer tokens used
+        # on reasoning in a response.
         #
         # - `gpt-5.1` defaults to `none`, which does not perform reasoning. The supported
         #   reasoning values for `gpt-5.1` are `none`, `low`, `medium`, and `high`. Tool
@@ -62,6 +63,7 @@ module OpenAI
         # - All models before `gpt-5.1` default to `medium` reasoning effort, and do not
         #   support `none`.
         # - The `gpt-5-pro` model defaults to (and only supports) `high` reasoning effort.
+        # - `xhigh` is currently only supported for `gpt-5.1-codex-max`.
         effort: nil,
         # **Deprecated:** use `summary` instead.
         #

data/rbi/openai/models/reasoning_effort.rbi

@@ -4,9 +4,9 @@ module OpenAI
   module Models
     # Constrains effort on reasoning for
     # [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently
-    # supported values are `none`, `minimal`, `low`, `medium`, and `high`. Reducing
-    # reasoning effort can result in faster responses and fewer tokens used on
-    # reasoning in a response.
+    # supported values are `none`, `minimal`, `low`, `medium`, `high`, and `xhigh`.
+    # Reducing reasoning effort can result in faster responses and fewer tokens used
+    # on reasoning in a response.
     #
     # - `gpt-5.1` defaults to `none`, which does not perform reasoning. The supported
     #   reasoning values for `gpt-5.1` are `none`, `low`, `medium`, and `high`. Tool
@@ -14,6 +14,7 @@ module OpenAI
     # - All models before `gpt-5.1` default to `medium` reasoning effort, and do not
     #   support `none`.
     # - The `gpt-5-pro` model defaults to (and only supports) `high` reasoning effort.
+    # - `xhigh` is currently only supported for `gpt-5.1-codex-max`.
     module ReasoningEffort
       extend OpenAI::Internal::Type::Enum
 
@@ -25,6 +26,7 @@ module OpenAI
       LOW = T.let(:low, OpenAI::ReasoningEffort::TaggedSymbol)
       MEDIUM = T.let(:medium, OpenAI::ReasoningEffort::TaggedSymbol)
       HIGH = T.let(:high, OpenAI::ReasoningEffort::TaggedSymbol)
+      XHIGH = T.let(:xhigh, OpenAI::ReasoningEffort::TaggedSymbol)
 
       sig { override.returns(T::Array[OpenAI::ReasoningEffort::TaggedSymbol]) }
       def self.values

data/rbi/openai/models/responses/compacted_response.rbi

@@ -0,0 +1,105 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    module Responses
+      class CompactedResponse < OpenAI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              OpenAI::Responses::CompactedResponse,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+        # The unique identifier for the compacted response.
+        sig { returns(String) }
+        attr_accessor :id
+
+        # Unix timestamp (in seconds) when the compacted conversation was created.
+        sig { returns(Integer) }
+        attr_accessor :created_at
+
+        # The object type. Always `response.compaction`.
+        sig { returns(Symbol) }
+        attr_accessor :object
+
+        # The compacted list of output items. This is a list of all user messages,
+        # followed by a single compaction item.
+        sig do
+          returns(T::Array[OpenAI::Responses::ResponseOutputItem::Variants])
+        end
+        attr_accessor :output
+
+        # Token accounting for the compaction pass, including cached, reasoning, and total
+        # tokens.
+        sig { returns(OpenAI::Responses::ResponseUsage) }
+        attr_reader :usage
+
+        sig { params(usage: OpenAI::Responses::ResponseUsage::OrHash).void }
+        attr_writer :usage
+
+        sig do
+          params(
+            id: String,
+            created_at: Integer,
+            output:
+              T::Array[
+                T.any(
+                  OpenAI::Responses::ResponseOutputMessage::OrHash,
+                  OpenAI::Responses::ResponseFileSearchToolCall::OrHash,
+                  OpenAI::Responses::ResponseFunctionToolCall::OrHash,
+                  OpenAI::Responses::ResponseFunctionWebSearch::OrHash,
+                  OpenAI::Responses::ResponseComputerToolCall::OrHash,
+                  OpenAI::Responses::ResponseReasoningItem::OrHash,
+                  OpenAI::Responses::ResponseCompactionItem::OrHash,
+                  OpenAI::Responses::ResponseOutputItem::ImageGenerationCall::OrHash,
+                  OpenAI::Responses::ResponseCodeInterpreterToolCall::OrHash,
+                  OpenAI::Responses::ResponseOutputItem::LocalShellCall::OrHash,
+                  OpenAI::Responses::ResponseFunctionShellToolCall::OrHash,
+                  OpenAI::Responses::ResponseFunctionShellToolCallOutput::OrHash,
+                  OpenAI::Responses::ResponseApplyPatchToolCall::OrHash,
+                  OpenAI::Responses::ResponseApplyPatchToolCallOutput::OrHash,
+                  OpenAI::Responses::ResponseOutputItem::McpCall::OrHash,
+                  OpenAI::Responses::ResponseOutputItem::McpListTools::OrHash,
+                  OpenAI::Responses::ResponseOutputItem::McpApprovalRequest::OrHash,
+                  OpenAI::Responses::ResponseCustomToolCall::OrHash
+                )
+              ],
+            usage: OpenAI::Responses::ResponseUsage::OrHash,
+            object: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # The unique identifier for the compacted response.
+          id:,
+          # Unix timestamp (in seconds) when the compacted conversation was created.
+          created_at:,
+          # The compacted list of output items. This is a list of all user messages,
+          # followed by a single compaction item.
+          output:,
+          # Token accounting for the compaction pass, including cached, reasoning, and total
+          # tokens.
+          usage:,
+          # The object type. Always `response.compaction`.
+          object: :"response.compaction"
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              id: String,
+              created_at: Integer,
+              object: Symbol,
+              output: T::Array[OpenAI::Responses::ResponseOutputItem::Variants],
+              usage: OpenAI::Responses::ResponseUsage
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/openai/models/responses/response.rbi

@@ -334,6 +334,7 @@ module OpenAI
                   OpenAI::Responses::ResponseFunctionWebSearch::OrHash,
                   OpenAI::Responses::ResponseComputerToolCall::OrHash,
                   OpenAI::Responses::ResponseReasoningItem::OrHash,
+                  OpenAI::Responses::ResponseCompactionItem::OrHash,
                   OpenAI::Responses::ResponseOutputItem::ImageGenerationCall::OrHash,
                   OpenAI::Responses::ResponseCodeInterpreterToolCall::OrHash,
                   OpenAI::Responses::ResponseOutputItem::LocalShellCall::OrHash,