openai 0.88.0 → 0.89.0

data/rbi/openai/models/webhooks/live_transport_incoming_webhook_event.rbi

@@ -0,0 +1,226 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Webhooks
+
+      class LiveTransportIncomingWebhookEvent < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Webhooks::LiveTransportIncomingWebhookEvent,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # The unique ID of the event.
+        sig { returns(String) }
+        attr_accessor :id
+
+        # The Unix timestamp (in seconds) of when the event was created.
+        sig { returns(Integer) }
+        attr_accessor :created_at
+
+        # Event data payload.
+        sig { returns(OpenAI::Webhooks::LiveTransportIncomingWebhookEvent::Data) }
+        attr_reader :data
+
+        sig { params(data: OpenAI::Webhooks::LiveTransportIncomingWebhookEvent::Data::OrHash).void }
+        attr_writer :data
+
+        # The type of the event. Always `live.transport.incoming`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # The object of the event. Always `event`.
+        sig { returns(T.nilable(OpenAI::Webhooks::LiveTransportIncomingWebhookEvent::Object::TaggedSymbol)) }
+        attr_reader :object
+
+        sig { params(object: OpenAI::Webhooks::LiveTransportIncomingWebhookEvent::Object::OrSymbol).void }
+        attr_writer :object
+
+        # Sent when an incoming API SIP session is available for Live acceptance. The same
+        # pending session can also emit `realtime.call.incoming`; the first successful
+        # Realtime or Live accept endpoint selects the runtime surface.
+        sig do
+          params(
+
+            id: String,
+
+            created_at: Integer,
+
+            data: OpenAI::Webhooks::LiveTransportIncomingWebhookEvent::Data::OrHash,
+
+            object: OpenAI::Webhooks::LiveTransportIncomingWebhookEvent::Object::OrSymbol,
+
+            type: Symbol
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # The unique ID of the event.
+          id:,
+
+          # The Unix timestamp (in seconds) of when the event was created.
+          created_at:,
+
+          # Event data payload.
+          data:,
+
+          # The object of the event. Always `event`.
+          object: nil,
+
+          # The type of the event. Always `live.transport.incoming`.
+
+          type: :"live.transport.incoming"
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              id: String,
+              created_at: Integer,
+              data: OpenAI::Webhooks::LiveTransportIncomingWebhookEvent::Data,
+              type: Symbol,
+              object: OpenAI::Webhooks::LiveTransportIncomingWebhookEvent::Object::TaggedSymbol
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class Data < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Webhooks::LiveTransportIncomingWebhookEvent::Data,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          # The `live_...` ID of the pending SIP session. Forward this value unchanged when
+          # accepting or rejecting the call through the Live API.
+          sig { returns(String) }
+          attr_accessor :session_id
+
+          # Headers from the SIP INVITE, excluding SIP authorization headers. Retained
+          # names, values, repeated entries, and order are preserved. Treat these values as
+          # untrusted call metadata.
+          sig { returns(T::Array[OpenAI::Webhooks::LiveTransportIncomingWebhookEvent::Data::SipHeader]) }
+          attr_accessor :sip_headers
+
+          # The incoming transport type. Always `sip`.
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # Event data payload.
+          sig do
+            params(
+
+              session_id: String,
+
+              sip_headers: T::Array[OpenAI::Webhooks::LiveTransportIncomingWebhookEvent::Data::SipHeader::OrHash],
+
+              type: Symbol
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            # The `live_...` ID of the pending SIP session. Forward this value unchanged when
+            # accepting or rejecting the call through the Live API.
+            session_id:,
+
+            # Headers from the SIP INVITE, excluding SIP authorization headers. Retained
+            # names, values, repeated entries, and order are preserved. Treat these values as
+            # untrusted call metadata.
+            sip_headers:,
+
+            # The incoming transport type. Always `sip`.
+
+            type: :sip
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                session_id: String,
+                sip_headers: T::Array[OpenAI::Webhooks::LiveTransportIncomingWebhookEvent::Data::SipHeader],
+                type: Symbol
+              }
+            )
+          end
+          def to_hash
+          end
+
+          class SipHeader < OpenAI::Internal::Type::BaseModel
+            OrHash = T.type_alias do
+              T.any(
+                OpenAI::Webhooks::LiveTransportIncomingWebhookEvent::Data::SipHeader,
+                OpenAI::Internal::AnyHash
+              )
+            end
+
+            # Name of the SIP Header.
+            sig { returns(String) }
+            attr_accessor :name
+
+            # Value of the SIP Header.
+            sig { returns(String) }
+            attr_accessor :value
+
+            # A header from the SIP Invite.
+            sig do
+              params(
+
+                name: String,
+
+                value: String
+              )
+                .returns(T.attached_class)
+            end
+            def self.new(
+
+              # Name of the SIP Header.
+              name:,
+
+              # Value of the SIP Header.
+
+              value:
+            )
+            end
+
+            sig do
+              override.returns(
+                {name: String, value: String}
+              )
+            end
+            def to_hash
+            end
+
+          end
+        end
+
+        # The object of the event. Always `event`.
+        module Object
+          extend OpenAI::Internal::Type::Enum
+
+          TaggedSymbol = T.type_alias { T.all(Symbol, OpenAI::Webhooks::LiveTransportIncomingWebhookEvent::Object) }
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          EVENT = T.let(:event, OpenAI::Webhooks::LiveTransportIncomingWebhookEvent::Object::TaggedSymbol)
+
+          sig { override.returns(T::Array[OpenAI::Webhooks::LiveTransportIncomingWebhookEvent::Object::TaggedSymbol]) }
+          def self.values
+          end
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/webhooks/realtime_call_incoming_webhook_event.rbi

@@ -41,8 +41,8 @@ module OpenAI
         attr_writer :object
 
         # Sent when an incoming API SIP session is available for Realtime acceptance. The
-        # same pending session can also emit `live.call.incoming`; the first successful
-        # Realtime or Live accept endpoint selects the runtime surface.
+        # same pending session can also emit `live.transport.incoming`; the first
+        # successful Realtime or Live accept endpoint selects the runtime surface.
         sig do
           params(
 
@@ -101,7 +101,7 @@ module OpenAI
           end
 
           # The Transceiver `rtc_...` ID of the pending SIP session. The paired
-          # `live.call.incoming` event derives its `session_id` by replacing the `rtc_`
+          # `live.transport.incoming` event derives its `session_id` by replacing the `rtc_`
           # prefix with `live_`. Use the ID returned by the event with the corresponding
           # Realtime or Live API.
           sig { returns(String) }
@@ -126,7 +126,7 @@ module OpenAI
           def self.new(
 
             # The Transceiver `rtc_...` ID of the pending SIP session. The paired
-            # `live.call.incoming` event derives its `session_id` by replacing the `rtc_`
+            # `live.transport.incoming` event derives its `session_id` by replacing the `rtc_`
             # prefix with `live_`. Use the ID returned by the event with the corresponding
             # Realtime or Live API.
             call_id:,

data/rbi/openai/models/webhooks/unwrap_webhook_event.rbi

@@ -22,6 +22,7 @@ module OpenAI
             OpenAI::Webhooks::FineTuningJobFailedWebhookEvent,
             OpenAI::Webhooks::FineTuningJobSucceededWebhookEvent,
             OpenAI::Webhooks::LiveCallIncomingWebhookEvent,
+            OpenAI::Webhooks::LiveTransportIncomingWebhookEvent,
             OpenAI::Webhooks::RealtimeCallIncomingWebhookEvent,
             OpenAI::Webhooks::ResponseCancelledWebhookEvent,
             OpenAI::Webhooks::ResponseCompletedWebhookEvent,

data/rbi/openai/models.rbi

@@ -150,6 +150,8 @@ module OpenAI
 
   ImagesResponse = OpenAI::Models::ImagesResponse
 
+  Live = OpenAI::Models::Live
+
   Metadata = T.let(OpenAI::Models::Metadata, OpenAI::Internal::Type::Converter)
 
   Model = OpenAI::Models::Model

data/rbi/openai/resources/live/forks.rbi

@@ -0,0 +1,19 @@
+# typed: strong
+
+module OpenAI
+  module Resources
+
+    class Live
+
+      class Forks
+
+        # @api private
+        sig { params(client: OpenAI::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+
+    end
+
+  end
+end

data/rbi/openai/resources/live/sessions.rbi

@@ -0,0 +1,110 @@
+# typed: strong
+
+module OpenAI
+  module Resources
+
+    class Live
+
+      class Sessions
+
+        # Accept an incoming SIP call with Live startup configuration.
+        sig {
+          params(
+            session_id: String,
+            session: OpenAI::Live::SessionAcceptParams::Session::OrHash,
+            request_options: OpenAI::RequestOptions::OrHash
+          )
+            .void
+        }
+        def accept(
+          # Opaque Live session identifier from the creation response or incoming-call
+          # webhook. Preserve the returned value unchanged, including its prefix.
+          session_id,
+          # Model and startup configuration for the Live session that answers the incoming
+          # SIP call.
+          session:,
+          request_options: {}
+        )
+        end
+
+        # Get Live session content
+        sig {
+          params(session_id: String, request_options: OpenAI::RequestOptions::OrHash).returns(
+            T.all(StringIO, OpenAI::ResponseCarrier)
+          )
+        }
+        def download_recording(
+          # The ID of the stored Live session to download. Use the session ID returned when
+          # the session started with storage enabled.
+          session_id,
+          request_options: {}
+        )
+        end
+
+        # Fork a stored Live session onto a new WebRTC connection.
+        sig {
+          params(
+            session_id: String,
+            transport: OpenAI::Live::SessionForkParams::Transport::OrHash,
+            session: OpenAI::Live::MediaSessionForkConfig::OrHash,
+            request_options: OpenAI::RequestOptions::OrHash
+          )
+            .returns(OpenAI::Models::Live::SessionForkResponse)
+        }
+        def fork(
+          # The ID of the stored Live session to fork.
+          session_id,
+          # WebRTC transport with an SDP offer for the new connection to the forked session.
+          transport:,
+          # Optional configuration overrides for the new Live session. Omit this object or
+          # send an empty object to inherit the stored session's settings.
+          session: nil,
+          request_options: {}
+        )
+        end
+
+        # Hang up a Live session.
+        sig { params(session_id: String, request_options: OpenAI::RequestOptions::OrHash).void }
+        def hangup(
+          # Opaque Live session identifier from the creation response or incoming-call
+          # webhook. Preserve the returned value unchanged, including its prefix.
+          session_id,
+          request_options: {}
+        )
+        end
+
+        # Transfer a Live SIP call to another destination.
+        sig { params(session_id: String, target_uri: String, request_options: OpenAI::RequestOptions::OrHash).void }
+        def refer(
+          # Opaque Live session identifier from the creation response or incoming-call
+          # webhook. Preserve the returned value unchanged, including its prefix.
+          session_id,
+          # Nonblank URI for the SIP Refer-To header, such as tel:+14155550123 or
+          # sip:agent@example.com.
+          target_uri:,
+          request_options: {}
+        )
+        end
+
+        # Reject an incoming SIP call.
+        sig { params(session_id: String, status_code: Integer, request_options: OpenAI::RequestOptions::OrHash).void }
+        def reject(
+          # Opaque Live session identifier from the creation response or incoming-call
+          # webhook. Preserve the returned value unchanged, including its prefix.
+          session_id,
+          # SIP rejection status sent to the caller. This field is required.
+          status_code:,
+          request_options: {}
+        )
+        end
+
+        # @api private
+        sig { params(client: OpenAI::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+
+    end
+
+  end
+end

data/rbi/openai/resources/live/sideband.rbi

@@ -0,0 +1,19 @@
+# typed: strong
+
+module OpenAI
+  module Resources
+
+    class Live
+
+      class Sideband
+
+        # @api private
+        sig { params(client: OpenAI::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+
+    end
+
+  end
+end

data/rbi/openai/resources/live.rbi

@@ -0,0 +1,43 @@
+# typed: strong
+
+module OpenAI
+  module Resources
+
+    class Live
+
+      sig { returns(OpenAI::Resources::Live::Sideband) }
+      attr_reader :sideband
+
+      sig { returns(OpenAI::Resources::Live::Forks) }
+      attr_reader :forks
+
+      sig { returns(OpenAI::Resources::Live::Sessions) }
+      attr_reader :sessions
+
+      # Create a Live WebRTC session. Start with the
+      # [Live prompting guide](https://developers.openai.com/api/docs/guides/live-prompting).
+      sig {
+        params(
+          session: OpenAI::Live::MediaSessionConfig::OrHash,
+          transport: OpenAI::Live::LiveCreateParams::Transport::OrHash,
+          request_options: OpenAI::RequestOptions::OrHash
+        )
+          .returns(OpenAI::Models::Live::LiveCreateResponse)
+      }
+      def create(
+        # Startup configuration for the Live session.
+        session:,
+        # WebRTC transport with the browser's SDP offer.
+        transport:,
+        request_options: {}
+      )
+      end
+
+      # @api private
+      sig { params(client: OpenAI::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+
+  end
+end

data/rbi/openai/resources/responses.rbi

@@ -662,6 +662,8 @@ module OpenAI
           previous_response_id: T.nilable(String),
           prompt: T.nilable(OpenAI::Responses::ResponsePrompt::OrHash),
           prompt_cache_key: String,
+          prompt_cache_options: T.nilable(OpenAI::Responses::ResponseCreateParams::PromptCacheOptions::OrHash),
+          prompt_cache_retention: T.nilable(OpenAI::Responses::ResponseCreateParams::PromptCacheRetention::OrSymbol),
           reasoning: T.nilable(OpenAI::Reasoning::OrHash),
           response_id: T.nilable(String),
           safety_identifier: String,
@@ -711,7 +713,7 @@ module OpenAI
       end
       def stream(
         # Whether to run the model response in the background.
-        # [Learn more](https://platform.openai.com/docs/guides/background).
+        # [Learn more](https://developers.openai.com/api/docs/guides/background).
         background: nil,
         # Specify additional output data to include in the model response. Currently
         # supported values are:
@@ -734,11 +736,11 @@ module OpenAI
         #
         # Learn more:
         #
-        # - [Text inputs and outputs](https://platform.openai.com/docs/guides/text)
-        # - [Image inputs](https://platform.openai.com/docs/guides/images)
-        # - [File inputs](https://platform.openai.com/docs/guides/pdf-files)
-        # - [Conversation state](https://platform.openai.com/docs/guides/conversation-state)
-        # - [Function calling](https://platform.openai.com/docs/guides/function-calling)
+        # - [Text inputs and outputs](https://developers.openai.com/api/docs/guides/text)
+        # - [Image inputs](https://developers.openai.com/api/docs/guides/images-vision)
+        # - [File inputs](https://developers.openai.com/api/docs/guides/file-inputs)
+        # - [Conversation state](https://developers.openai.com/api/docs/guides/conversation-state)
+        # - [Function calling](https://developers.openai.com/api/docs/guides/function-calling)
         input: nil,
         # A system (or developer) message inserted into the model's context.
         #
@@ -748,7 +750,7 @@ module OpenAI
         instructions: nil,
         # An upper bound for the number of tokens that can be generated for a response,
         # including visible output tokens and
-        # [reasoning tokens](https://platform.openai.com/docs/guides/reasoning).
+        # [reasoning tokens](https://developers.openai.com/api/docs/guides/reasoning).
         max_output_tokens: nil,
         # The maximum number of total calls to built-in tools that can be processed in a
         # response. This maximum number applies across all built-in tool calls, not per
@@ -762,37 +764,65 @@ module OpenAI
         # Keys are strings with a maximum length of 64 characters. Values are strings with
         # a maximum length of 512 characters.
         metadata: nil,
-        # Model ID used to generate the response, like `gpt-4o` or `o3`. OpenAI offers a
-        # wide range of models with different capabilities, performance characteristics,
-        # and price points. Refer to the
-        # [model guide](https://platform.openai.com/docs/models) to browse and compare
-        # available models.
+        # Model ID used to generate the response, like `gpt-6-astra`. OpenAI offers a wide
+        # range of models with different capabilities, performance characteristics, and
+        # price points. Refer to the
+        # [model guide](https://developers.openai.com/api/docs/models) to browse and
+        # compare available models.
         model: nil,
         # Whether to allow the model to run tool calls in parallel.
         parallel_tool_calls: nil,
         # The unique ID of the previous response to the model. Use this to create
         # multi-turn conversations. Learn more about
-        # [conversation state](https://platform.openai.com/docs/guides/conversation-state).
+        # [conversation state](https://developers.openai.com/api/docs/guides/conversation-state).
+        # Cannot be used in conjunction with `conversation`.
         previous_response_id: nil,
         # Reference to a prompt template and its variables.
-        # [Learn more](https://platform.openai.com/docs/guides/text?api-mode=responses#reusable-prompts).
+        # [Learn more](https://developers.openai.com/api/docs/guides/text?api-mode=responses#version-prompts-in-code).
         prompt: nil,
         # Used by OpenAI to cache responses for similar requests to optimize your cache
         # hit rates. Replaces the `user` field.
-        # [Learn more](https://platform.openai.com/docs/guides/prompt-caching).
+        # [Learn more](https://developers.openai.com/api/docs/guides/prompt-caching).
         prompt_cache_key: nil,
-        # **o-series models only**
+        # 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,
+        # Deprecated. Use `prompt_cache_options.ttl` instead.
+        #
+        # The retention policy for the prompt cache. Set to `24h` to enable extended
+        # prompt caching, which keeps cached prefixes active for longer, up to a maximum
+        # of 24 hours.
+        # [Learn more](https://developers.openai.com/api/docs/guides/prompt-caching#prompt-cache-retention).
+        # This field expresses a maximum retention policy, while
+        # `prompt_cache_options.ttl` expresses a minimum cache lifetime. The two fields
+        # are independent and do not interact. For `gpt-5.5`, `gpt-5.5-pro`, and future
+        # models, only `24h` is supported.
         #
+        # For older models that support both `in_memory` and `24h`, the default depends on
+        # your organization's data retention policy:
+        #
+        # - Organizations without ZDR enabled default to `24h`.
+        # - Organizations with ZDR enabled default to `in_memory` when
+        #   `prompt_cache_retention` is not specified.
+        prompt_cache_retention: nil,
         # Configuration options for
-        # [reasoning models](https://platform.openai.com/docs/guides/reasoning).
+        # [reasoning models](https://developers.openai.com/api/docs/guides/reasoning).
         reasoning: nil,
         # The ID of the response whose stream to resume.
         response_id: nil,
         # A stable identifier used to help detect users of your application that may be
         # violating OpenAI's usage policies. The IDs should be a string that uniquely
-        # identifies each user. We recommend hashing their username or email address, in
-        # order to avoid sending us any identifying information.
-        # [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#safety-identifiers).
+        # identifies each user, with a maximum length of 64 characters. We recommend
+        # hashing their username or email address, in order to avoid sending us any
+        # identifying information.
+        # [Learn more](https://developers.openai.com/api/docs/guides/safety-best-practices#implement-safety-identifiers).
         safety_identifier: nil,
         # Specifies the processing type used for serving the request.
         #
@@ -801,10 +831,19 @@ module OpenAI
         #   will use 'default'.
         # - If set to 'default', then the request will be processed with the standard
         #   pricing and performance for the selected model.
-        # - If set to '[flex](https://platform.openai.com/docs/guides/flex-processing)' or
-        #   'priority', then the request will be processed with the corresponding service
-        #   tier. [Contact sales](https://openai.com/contact-sales) to learn more about
-        #   Priority processing.
+        # - If set to
+        #   '[flex](https://developers.openai.com/api/docs/guides/flex-processing)', then
+        #   the request will be processed with the Flex Processing service tier.
+        # - To opt-in to
+        #   [Fast mode](https://developers.openai.com/api/docs/guides/fast-mode) at the
+        #   request level, include the `service_tier=fast` or `service_tier=priority`
+        #   parameter for Responses or Chat Completions. The response will show
+        #   `service_tier=priority` regardless of if you specify `service_tier=fast` or
+        #   `priority` in your request.
+        # - If set to 'ultrafast', then the request will be processed with the
+        #   access-controlled Ultrafast Processing service tier. This tier is currently
+        #   available for `gpt-5.6-sol`; a response served through it will show
+        #   `service_tier=ultrafast`.
         # - When not set, the default behavior is 'auto'.
         #
         # When the `service_tier` parameter is set, the response body will include the
@@ -825,9 +864,8 @@ module OpenAI
         # Configuration options for a text response from the model. Can be plain text,
         # structured JSON data, or text that conforms to a custom grammar. Learn more:
         #
-        # - [Text inputs and outputs](https://platform.openai.com/docs/guides/text)
-        # - [Structured Outputs](https://platform.openai.com/docs/guides/structured-outputs)
-        # - [Custom grammars](https://platform.openai.com/docs/guides/custom-grammars)
+        # - [Text inputs and outputs](https://developers.openai.com/api/docs/guides/text)
+        # - [Structured Outputs](https://developers.openai.com/api/docs/guides/structured-outputs)
         text: nil,
         # How the model should select which tool (or tools) to use when generating a
         # response. See the `tools` parameter to see how to specify which tools the model
@@ -840,20 +878,19 @@ module OpenAI
         #
         # - **Built-in tools**: Tools that are provided by OpenAI that extend the model's
         #   capabilities, like
-        #   [web search](https://platform.openai.com/docs/guides/tools-web-search) or
-        #   [file search](https://platform.openai.com/docs/guides/tools-file-search).
+        #   [web search](https://developers.openai.com/api/docs/guides/tools-web-search)
+        #   or
+        #   [file search](https://developers.openai.com/api/docs/guides/tools-file-search).
         #   Learn more about
-        #   [built-in tools](https://platform.openai.com/docs/guides/tools).
-        # - **Custom tools**: Free form tools which the model can call with flexible
-        #   inputs and outputs. Learn more about
-        #   [custom tools](https://platform.openai.com/docs/guides/custom-tools).
+        #   [built-in tools](https://developers.openai.com/api/docs/guides/tools).
+        # - **MCP Tools**: Integrations with third-party systems via custom MCP servers or
+        #   predefined connectors such as Google Drive and SharePoint. Learn more about
+        #   [MCP Tools](https://developers.openai.com/api/docs/guides/tools-connectors-mcp).
         # - **Function calls (custom tools)**: Functions that are defined by you, enabling
         #   the model to call your own code with strongly typed arguments and outputs.
         #   Learn more about
-        #   [function calling](https://platform.openai.com/docs/guides/function-calling).
-        #   You can also use
-        #   [custom tools](https://platform.openai.com/docs/guides/custom-tools) to call
-        #   your own code.
+        #   [function calling](https://developers.openai.com/api/docs/guides/function-calling).
+        #   You can also use custom tools to call your own code.
         tools: nil,
         # An integer between 0 and 20 specifying the number of most likely tokens to
         # return at each token position, each with an associated log probability.
@@ -876,7 +913,7 @@ module OpenAI
         # `prompt_cache_key` instead to maintain caching optimizations. A stable
         # identifier for your end-users. Used to boost cache hit rates by better bucketing
         # similar requests and to help OpenAI detect and prevent abuse.
-        # [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#safety-identifiers).
+        # [Learn more](https://developers.openai.com/api/docs/guides/safety-best-practices#implement-safety-identifiers).
         user: nil,
         request_options: {}
       )

data/rbi/openai/resources/webhooks.rbi

@@ -25,6 +25,7 @@ module OpenAI
               OpenAI::Webhooks::FineTuningJobFailedWebhookEvent,
               OpenAI::Webhooks::FineTuningJobSucceededWebhookEvent,
               OpenAI::Webhooks::LiveCallIncomingWebhookEvent,
+              OpenAI::Webhooks::LiveTransportIncomingWebhookEvent,
               OpenAI::Webhooks::RealtimeCallIncomingWebhookEvent,
               OpenAI::Webhooks::ResponseCancelledWebhookEvent,
               OpenAI::Webhooks::ResponseCompletedWebhookEvent,