openai 0.105.0 → 0.107.0

data/rbi/openai/models/decision_input_image.rbi

@@ -24,6 +24,15 @@ module OpenAI
       sig { returns(T.nilable(OpenAI::DecisionInputImage::Detail::OrSymbol)) }
       attr_accessor :detail
 
+      # Marks the exact end of a reusable prompt prefix. The breakpoint inherits its TTL
+      # from the request's `prompt_cache_options.ttl`; the boundary is not rounded to a
+      # token block.
+      sig { returns(T.nilable(OpenAI::DecisionPromptCacheBreakpoint::OrHash)) }
+      attr_reader :prompt_cache_breakpoint
+
+      sig { params(prompt_cache_breakpoint: T.nilable(OpenAI::DecisionPromptCacheBreakpoint::OrHash)).void }
+      attr_writer :prompt_cache_breakpoint
+
       # An image provided as a base64 data URL or a publicly accessible HTTP(S) URL.
       # File IDs are not supported.
       sig do
@@ -33,6 +42,8 @@ module OpenAI
 
           detail: T.nilable(OpenAI::DecisionInputImage::Detail::OrSymbol),
 
+          prompt_cache_breakpoint: T.nilable(OpenAI::DecisionPromptCacheBreakpoint::OrHash),
+
           type: Symbol
         )
           .returns(T.attached_class)
@@ -46,13 +57,23 @@ module OpenAI
         # auto.
         detail: nil,
 
+        # Marks the exact end of a reusable prompt prefix. The breakpoint inherits its TTL
+        # from the request's `prompt_cache_options.ttl`; the boundary is not rounded to a
+        # token block.
+        prompt_cache_breakpoint: nil,
+
         type: :input_image
       )
       end
 
       sig do
         override.returns(
-          {image_url: String, type: Symbol, detail: T.nilable(OpenAI::DecisionInputImage::Detail::OrSymbol)}
+          {
+            image_url: String,
+            type: Symbol,
+            detail: T.nilable(OpenAI::DecisionInputImage::Detail::OrSymbol),
+            prompt_cache_breakpoint: T.nilable(OpenAI::DecisionPromptCacheBreakpoint::OrHash)
+          }
         )
       end
       def to_hash

data/rbi/openai/models/decision_input_text.rbi

@@ -18,11 +18,22 @@ module OpenAI
       sig { returns(Symbol) }
       attr_accessor :type
 
+      # Marks the exact end of a reusable prompt prefix. The breakpoint inherits its TTL
+      # from the request's `prompt_cache_options.ttl`; the boundary is not rounded to a
+      # token block.
+      sig { returns(T.nilable(OpenAI::DecisionPromptCacheBreakpoint::OrHash)) }
+      attr_reader :prompt_cache_breakpoint
+
+      sig { params(prompt_cache_breakpoint: T.nilable(OpenAI::DecisionPromptCacheBreakpoint::OrHash)).void }
+      attr_writer :prompt_cache_breakpoint
+
       sig do
         params(
 
           text: String,
 
+          prompt_cache_breakpoint: T.nilable(OpenAI::DecisionPromptCacheBreakpoint::OrHash),
+
           type: Symbol
         )
           .returns(T.attached_class)
@@ -31,13 +42,22 @@ module OpenAI
 
         text:,
 
+        # Marks the exact end of a reusable prompt prefix. The breakpoint inherits its TTL
+        # from the request's `prompt_cache_options.ttl`; the boundary is not rounded to a
+        # token block.
+        prompt_cache_breakpoint: nil,
+
         type: :input_text
       )
       end
 
       sig do
         override.returns(
-          {text: String, type: Symbol}
+          {
+            text: String,
+            type: Symbol,
+            prompt_cache_breakpoint: T.nilable(OpenAI::DecisionPromptCacheBreakpoint::OrHash)
+          }
         )
       end
       def to_hash

data/rbi/openai/models/decision_prompt_cache_breakpoint.rbi

@@ -0,0 +1,48 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    class DecisionPromptCacheBreakpoint < OpenAI::Internal::Type::BaseModel
+
+      OrHash = T.type_alias do
+        T.any(
+          OpenAI::DecisionPromptCacheBreakpoint,
+          OpenAI::Internal::AnyHash
+        )
+      end
+
+      # The breakpoint mode. Always `explicit`.
+      sig { returns(Symbol) }
+      attr_accessor :mode
+
+      # Marks the exact end of a reusable prompt prefix. The breakpoint inherits its TTL
+      # from the request's `prompt_cache_options.ttl`; the boundary is not rounded to a
+      # token block.
+      sig do
+        params(
+
+          mode: Symbol
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(
+
+        # The breakpoint mode. Always `explicit`.
+
+        mode: :explicit
+      )
+      end
+
+      sig do
+        override.returns(
+          {mode: Symbol}
+        )
+      end
+      def to_hash
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/live/output_audio_delta_event.rbi

@@ -79,7 +79,7 @@ module OpenAI
 
         sig do
           override.returns(
-            {delta: String, type: Symbol, end_ms: Integer, start_ms: Integer}
+            {delta: String, type: Symbol, end_ms: T.nilable(Integer), start_ms: T.nilable(Integer)}
           )
         end
         def to_hash

data/rbi/openai/models/live/sideband_server_event.rbi

@@ -5,8 +5,8 @@ module OpenAI
 
     module Live
 
-      # Server events received by an attached Live sideband WebSocket. Audio deltas are
-      # delivered over the primary connection.
+      # Server events received by an attached Live sideband WebSocket, including
+      # reflected input and output audio and transport notifications.
       module SidebandServerEvent
         extend OpenAI::Internal::Type::Union
 
@@ -31,10 +31,413 @@ module OpenAI
             OpenAI::Live::SessionUsageUpdatedEvent,
             OpenAI::Live::SessionClosedEvent,
             OpenAI::Live::ErrorEvent,
-            OpenAI::Live::InfoEvent
+            OpenAI::Live::InfoEvent,
+            OpenAI::Live::SidebandServerEvent::SessionInputAudioAppend,
+            OpenAI::Live::OutputAudioDeltaEvent,
+            OpenAI::Live::SidebandServerEvent::TransportDtmfReceived,
+            OpenAI::Live::SidebandServerEvent::TransportDtmfSend,
+            OpenAI::Live::SidebandServerEvent::TransportRinging,
+            OpenAI::Live::SidebandServerEvent::TransportAnswered,
+            OpenAI::Live::SidebandServerEvent::TransportFailed
           )
         end
 
+        class SessionInputAudioAppend < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Live::SidebandServerEvent::SessionInputAudioAppend,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          # Base64-encoded raw mono PCM16LE at 24 kHz received from the primary transport,
+          # reflected to the sideband before model-input muting. This server event uses the
+          # same audio key as the client command, but is not an acknowledgment of it.
+          sig { returns(String) }
+          attr_accessor :audio
+
+          # The event type, always `session.input_audio.append`.
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # Input audio received from the primary transport and reflected to a Live sideband
+          # connection before model-input muting.
+          sig do
+            params(
+
+              audio: String,
+
+              type: Symbol
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            # Base64-encoded raw mono PCM16LE at 24 kHz received from the primary transport,
+            # reflected to the sideband before model-input muting. This server event uses the
+            # same audio key as the client command, but is not an acknowledgment of it.
+            audio:,
+
+            # The event type, always `session.input_audio.append`.
+
+            type: :"session.input_audio.append"
+          )
+          end
+
+          sig do
+            override.returns(
+              {audio: String, type: Symbol}
+            )
+          end
+          def to_hash
+          end
+
+        end
+
+        class TransportDtmfReceived < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Live::SidebandServerEvent::TransportDtmfReceived,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          sig { returns(String) }
+          attr_accessor :event
+
+          sig { returns(String) }
+          attr_accessor :event_id
+
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # A SIP DTMF keypress received from the caller. Delivered only to sideband
+          # observers.
+          sig do
+            params(
+
+              event: String,
+
+              event_id: String,
+
+              type: Symbol
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            event:,
+
+            event_id:,
+
+            type: :"transport.dtmf.received"
+          )
+          end
+
+          sig do
+            override.returns(
+              {event: String, event_id: String, type: Symbol}
+            )
+          end
+          def to_hash
+          end
+
+        end
+
+        class TransportDtmfSend < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Live::SidebandServerEvent::TransportDtmfSend,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          sig { returns(String) }
+          attr_accessor :event
+
+          sig { returns(String) }
+          attr_accessor :event_id
+
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # The event_id of the client command, when supplied.
+          sig { returns(T.nilable(String)) }
+          attr_reader :client_event_id
+
+          sig { params(client_event_id: String).void }
+          attr_writer :client_event_id
+
+          # A SIP DTMF keypress successfully sent to the SIP trunk. Delivered only to
+          # sideband observers; this is not a client command.
+          sig do
+            params(
+
+              event: String,
+
+              event_id: String,
+
+              client_event_id: String,
+
+              type: Symbol
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            event:,
+
+            event_id:,
+
+            # The event_id of the client command, when supplied.
+            client_event_id: nil,
+
+            type: :"transport.dtmf.send"
+          )
+          end
+
+          sig do
+            override.returns(
+              {event: String, event_id: String, type: Symbol, client_event_id: T.nilable(String)}
+            )
+          end
+          def to_hash
+          end
+
+        end
+
+        class TransportRinging < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Live::SidebandServerEvent::TransportRinging,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          sig { returns(String) }
+          attr_accessor :event_id
+
+          # The canonical Live session ID.
+          sig { returns(String) }
+          attr_accessor :session_id
+
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # The outbound SIP provider leg is ringing or providing early media. Delivered
+          # only to sideband observers.
+          sig do
+            params(
+
+              event_id: String,
+
+              session_id: String,
+
+              type: Symbol
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            event_id:,
+
+            # The canonical Live session ID.
+            session_id:,
+
+            type: :"transport.ringing"
+          )
+          end
+
+          sig do
+            override.returns(
+              {event_id: String, session_id: String, type: Symbol}
+            )
+          end
+          def to_hash
+          end
+
+        end
+
+        class TransportAnswered < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Live::SidebandServerEvent::TransportAnswered,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          sig { returns(String) }
+          attr_accessor :event_id
+
+          # The canonical Live session ID.
+          sig { returns(String) }
+          attr_accessor :session_id
+
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # The outbound SIP provider leg answered and media is established. Delivered only
+          # to sideband observers.
+          sig do
+            params(
+
+              event_id: String,
+
+              session_id: String,
+
+              type: Symbol
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            event_id:,
+
+            # The canonical Live session ID.
+            session_id:,
+
+            type: :"transport.answered"
+          )
+          end
+
+          sig do
+            override.returns(
+              {event_id: String, session_id: String, type: Symbol}
+            )
+          end
+          def to_hash
+          end
+
+        end
+
+        class TransportFailed < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Live::SidebandServerEvent::TransportFailed,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          sig { returns(OpenAI::Live::SidebandServerEvent::TransportFailed::Error) }
+          attr_reader :error
+
+          sig { params(error: OpenAI::Live::SidebandServerEvent::TransportFailed::Error::OrHash).void }
+          attr_writer :error
+
+          sig { returns(String) }
+          attr_accessor :event_id
+
+          # The canonical Live session ID.
+          sig { returns(String) }
+          attr_accessor :session_id
+
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # An asynchronous outbound SIP setup failure. Delivered only to sideband
+          # observers.
+          sig do
+            params(
+
+              error: OpenAI::Live::SidebandServerEvent::TransportFailed::Error::OrHash,
+
+              event_id: String,
+
+              session_id: String,
+
+              type: Symbol
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            error:,
+
+            event_id:,
+
+            # The canonical Live session ID.
+            session_id:,
+
+            type: :"transport.failed"
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                error: OpenAI::Live::SidebandServerEvent::TransportFailed::Error,
+                event_id: String,
+                session_id: String,
+                type: Symbol
+              }
+            )
+          end
+          def to_hash
+          end
+
+          class Error < OpenAI::Internal::Type::BaseModel
+            OrHash = T.type_alias do
+              T.any(
+                OpenAI::Live::SidebandServerEvent::TransportFailed::Error,
+                OpenAI::Internal::AnyHash
+              )
+            end
+
+            # The call setup failure code.
+            sig { returns(String) }
+            attr_accessor :code
+
+            sig { returns(String) }
+            attr_accessor :message
+
+            sig { returns(Symbol) }
+            attr_accessor :type
+
+            # The parameter related to the error, if any. Empty when no parameter applies.
+            sig { returns(T.nilable(String)) }
+            attr_reader :param
+
+            sig { params(param: String).void }
+            attr_writer :param
+
+            sig do
+              params(
+
+                code: String,
+
+                message: String,
+
+                param: String,
+
+                type: Symbol
+              )
+                .returns(T.attached_class)
+            end
+            def self.new(
+
+              # The call setup failure code.
+              code:,
+
+              message:,
+
+              # The parameter related to the error, if any. Empty when no parameter applies.
+              param: nil,
+
+              type: :call_error
+            )
+            end
+
+            sig do
+              override.returns(
+                {code: String, message: String, type: Symbol, param: T.nilable(String)}
+              )
+            end
+            def to_hash
+            end
+
+          end
+        end
+
         sig { override.returns(T::Array[OpenAI::Live::SidebandServerEvent::Variants]) }
         def self.variants
         end

data/rbi/openai/models/responses/response_input_item.rbi

@@ -3433,16 +3433,25 @@ module OpenAI
           sig { returns(Symbol) }
           attr_accessor :type
 
+          # The unique ID of this compaction trigger.
+          sig { returns(T.nilable(String)) }
+          attr_accessor :id
+
           # Compacts the current context. Must be the final input item.
           sig do
             params(
 
+              id: T.nilable(String),
+
               type: Symbol
             )
               .returns(T.attached_class)
           end
           def self.new(
 
+            # The unique ID of this compaction trigger.
+            id: nil,
+
             # The type of the item. Always `compaction_trigger`.
 
             type: :compaction_trigger
@@ -3451,7 +3460,7 @@ module OpenAI
 
           sig do
             override.returns(
-              {type: Symbol}
+              {type: Symbol, id: T.nilable(String)}
             )
           end
           def to_hash

data/rbi/openai/models.rbi

@@ -80,6 +80,8 @@ module OpenAI
 
   DecisionInputText = OpenAI::Models::DecisionInputText
 
+  DecisionPromptCacheBreakpoint = OpenAI::Models::DecisionPromptCacheBreakpoint
+
   DeletedSkill = OpenAI::Models::DeletedSkill
 
   Embedding = OpenAI::Models::Embedding

data/rbi/openai/resources/beta/responses.rbi

@@ -8,6 +8,23 @@ module OpenAI
       # Create and manage model responses.
       class Responses
 
+        include OpenAI::WebSocket::Resource
+
+        # @api private
+        sig { params(query: T::Hash[T.untyped, T.untyped]).returns(T::Hash[Symbol, T.untyped]) }
+        def __websocket_request(query: {})
+        end
+
+        # @api private
+        sig { returns(T.untyped) }
+        def __websocket_client_event
+        end
+
+        # @api private
+        sig { returns(T.untyped) }
+        def __websocket_server_event
+        end
+
         # Create and manage model responses.
         sig { returns(OpenAI::Resources::Beta::Responses::InputItems) }
         attr_reader :input_items

data/rbi/openai/resources/decisions.rbi

@@ -18,6 +18,8 @@ module OpenAI
               OpenAI::DecisionCreateParams::Question::Score::OrHash
             )
           ],
+          prompt_cache_key: T.nilable(String),
+          prompt_cache_options: T.nilable(OpenAI::DecisionCreateParams::PromptCacheOptions::OrHash),
           safety_identifier: T.nilable(String),
           request_options: OpenAI::RequestOptions::OrHash
         )
@@ -34,6 +36,18 @@ module OpenAI
         # Ask 1–200 questions about the input. Each question can be a predicate, choice,
         # or score. Answers come back in the same order.
         questions:,
+        # Partition prompt cache reuse by caller-provided key.
+        prompt_cache_key: nil,
+        # Options for prompt caching. Supported for `gpt-5.6` and later models. By
+        # default, OpenAI automatically chooses one implicit cache breakpoint. You can add
+        # explicit breakpoints to content blocks with `prompt_cache_breakpoint`. Each
+        # request can write up to four breakpoints. For cache matching, OpenAI considers
+        # up to the latest 80 breakpoints in the conversation, without a content-block
+        # lookback limit. Set `mode` to `explicit` to disable the implicit breakpoint. The
+        # `ttl` defaults to `30m`, which is currently the only supported value. See the
+        # [prompt caching guide](https://developers.openai.com/api/docs/guides/prompt-caching)
+        # for current details.
+        prompt_cache_options: nil,
         # Opaque caller-provided end-user identifier, scoped by the verified org. Match
         # Responses' limit; this is never the authenticated user identity.
         safety_identifier: nil,