openai 0.20.0 → 0.21.1

data/lib/openai/models/realtime/conversation_item_truncate_event.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module OpenAI
+  module Models
+    module Realtime
+      class ConversationItemTruncateEvent < OpenAI::Internal::Type::BaseModel
+        # @!attribute audio_end_ms
+        #   Inclusive duration up to which audio is truncated, in milliseconds. If the
+        #   audio_end_ms is greater than the actual audio duration, the server will respond
+        #   with an error.
+        #
+        #   @return [Integer]
+        required :audio_end_ms, Integer
+
+        # @!attribute content_index
+        #   The index of the content part to truncate. Set this to 0.
+        #
+        #   @return [Integer]
+        required :content_index, Integer
+
+        # @!attribute item_id
+        #   The ID of the assistant message item to truncate. Only assistant message items
+        #   can be truncated.
+        #
+        #   @return [String]
+        required :item_id, String
+
+        # @!attribute type
+        #   The event type, must be `conversation.item.truncate`.
+        #
+        #   @return [Symbol, :"conversation.item.truncate"]
+        required :type, const: :"conversation.item.truncate"
+
+        # @!attribute event_id
+        #   Optional client-generated ID used to identify this event.
+        #
+        #   @return [String, nil]
+        optional :event_id, String
+
+        # @!method initialize(audio_end_ms:, content_index:, item_id:, event_id: nil, type: :"conversation.item.truncate")
+        #   Some parameter documentations has been truncated, see
+        #   {OpenAI::Models::Realtime::ConversationItemTruncateEvent} for more details.
+        #
+        #   Send this event to truncate a previous assistant message’s audio. The server
+        #   will produce audio faster than realtime, so this event is useful when the user
+        #   interrupts to truncate audio that has already been sent to the client but not
+        #   yet played. This will synchronize the server's understanding of the audio with
+        #   the client's playback.
+        #
+        #   Truncating audio will delete the server-side text transcript to ensure there is
+        #   not text in the context that hasn't been heard by the user.
+        #
+        #   If successful, the server will respond with a `conversation.item.truncated`
+        #   event.
+        #
+        #   @param audio_end_ms [Integer] Inclusive duration up to which audio is truncated, in milliseconds. If
+        #
+        #   @param content_index [Integer] The index of the content part to truncate. Set this to 0.
+        #
+        #   @param item_id [String] The ID of the assistant message item to truncate. Only assistant message
+        #
+        #   @param event_id [String] Optional client-generated ID used to identify this event.
+        #
+        #   @param type [Symbol, :"conversation.item.truncate"] The event type, must be `conversation.item.truncate`.
+      end
+    end
+  end
+end

data/lib/openai/models/realtime/conversation_item_truncated_event.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module OpenAI
+  module Models
+    module Realtime
+      class ConversationItemTruncatedEvent < OpenAI::Internal::Type::BaseModel
+        # @!attribute audio_end_ms
+        #   The duration up to which the audio was truncated, in milliseconds.
+        #
+        #   @return [Integer]
+        required :audio_end_ms, Integer
+
+        # @!attribute content_index
+        #   The index of the content part that was truncated.
+        #
+        #   @return [Integer]
+        required :content_index, Integer
+
+        # @!attribute event_id
+        #   The unique ID of the server event.
+        #
+        #   @return [String]
+        required :event_id, String
+
+        # @!attribute item_id
+        #   The ID of the assistant message item that was truncated.
+        #
+        #   @return [String]
+        required :item_id, String
+
+        # @!attribute type
+        #   The event type, must be `conversation.item.truncated`.
+        #
+        #   @return [Symbol, :"conversation.item.truncated"]
+        required :type, const: :"conversation.item.truncated"
+
+        # @!method initialize(audio_end_ms:, content_index:, event_id:, item_id:, type: :"conversation.item.truncated")
+        #   Some parameter documentations has been truncated, see
+        #   {OpenAI::Models::Realtime::ConversationItemTruncatedEvent} for more details.
+        #
+        #   Returned when an earlier assistant audio message item is truncated by the client
+        #   with a `conversation.item.truncate` event. This event is used to synchronize the
+        #   server's understanding of the audio with the client's playback.
+        #
+        #   This action will truncate the audio and remove the server-side text transcript
+        #   to ensure there is no text in the context that hasn't been heard by the user.
+        #
+        #   @param audio_end_ms [Integer] The duration up to which the audio was truncated, in milliseconds.
+        #
+        #   @param content_index [Integer] The index of the content part that was truncated.
+        #
+        #   @param event_id [String] The unique ID of the server event.
+        #
+        #   @param item_id [String] The ID of the assistant message item that was truncated.
+        #
+        #   @param type [Symbol, :"conversation.item.truncated"] The event type, must be `conversation.item.truncated`.
+      end
+    end
+  end
+end

data/lib/openai/models/realtime/conversation_item_with_reference.rb

@@ -0,0 +1,235 @@
+# frozen_string_literal: true
+
+module OpenAI
+  module Models
+    module Realtime
+      class ConversationItemWithReference < OpenAI::Internal::Type::BaseModel
+        # @!attribute id
+        #   For an item of type (`message` | `function_call` | `function_call_output`) this
+        #   field allows the client to assign the unique ID of the item. It is not required
+        #   because the server will generate one if not provided.
+        #
+        #   For an item of type `item_reference`, this field is required and is a reference
+        #   to any item that has previously existed in the conversation.
+        #
+        #   @return [String, nil]
+        optional :id, String
+
+        # @!attribute arguments
+        #   The arguments of the function call (for `function_call` items).
+        #
+        #   @return [String, nil]
+        optional :arguments, String
+
+        # @!attribute call_id
+        #   The ID of the function call (for `function_call` and `function_call_output`
+        #   items). If passed on a `function_call_output` item, the server will check that a
+        #   `function_call` item with the same ID exists in the conversation history.
+        #
+        #   @return [String, nil]
+        optional :call_id, String
+
+        # @!attribute content
+        #   The content of the message, applicable for `message` items.
+        #
+        #   - Message items of role `system` support only `input_text` content
+        #   - Message items of role `user` support `input_text` and `input_audio` content
+        #   - Message items of role `assistant` support `text` content.
+        #
+        #   @return [Array<OpenAI::Models::Realtime::ConversationItemWithReference::Content>, nil]
+        optional :content,
+                 -> { OpenAI::Internal::Type::ArrayOf[OpenAI::Realtime::ConversationItemWithReference::Content] }
+
+        # @!attribute name
+        #   The name of the function being called (for `function_call` items).
+        #
+        #   @return [String, nil]
+        optional :name, String
+
+        # @!attribute object
+        #   Identifier for the API object being returned - always `realtime.item`.
+        #
+        #   @return [Symbol, OpenAI::Models::Realtime::ConversationItemWithReference::Object, nil]
+        optional :object, enum: -> { OpenAI::Realtime::ConversationItemWithReference::Object }
+
+        # @!attribute output
+        #   The output of the function call (for `function_call_output` items).
+        #
+        #   @return [String, nil]
+        optional :output, String
+
+        # @!attribute role
+        #   The role of the message sender (`user`, `assistant`, `system`), only applicable
+        #   for `message` items.
+        #
+        #   @return [Symbol, OpenAI::Models::Realtime::ConversationItemWithReference::Role, nil]
+        optional :role, enum: -> { OpenAI::Realtime::ConversationItemWithReference::Role }
+
+        # @!attribute status
+        #   The status of the item (`completed`, `incomplete`, `in_progress`). These have no
+        #   effect on the conversation, but are accepted for consistency with the
+        #   `conversation.item.created` event.
+        #
+        #   @return [Symbol, OpenAI::Models::Realtime::ConversationItemWithReference::Status, nil]
+        optional :status, enum: -> { OpenAI::Realtime::ConversationItemWithReference::Status }
+
+        # @!attribute type
+        #   The type of the item (`message`, `function_call`, `function_call_output`,
+        #   `item_reference`).
+        #
+        #   @return [Symbol, OpenAI::Models::Realtime::ConversationItemWithReference::Type, nil]
+        optional :type, enum: -> { OpenAI::Realtime::ConversationItemWithReference::Type }
+
+        # @!method initialize(id: nil, arguments: nil, call_id: nil, content: nil, name: nil, object: nil, output: nil, role: nil, status: nil, type: nil)
+        #   Some parameter documentations has been truncated, see
+        #   {OpenAI::Models::Realtime::ConversationItemWithReference} for more details.
+        #
+        #   The item to add to the conversation.
+        #
+        #   @param id [String] For an item of type (`message` | `function_call` | `function_call_output`)
+        #
+        #   @param arguments [String] The arguments of the function call (for `function_call` items).
+        #
+        #   @param call_id [String] The ID of the function call (for `function_call` and
+        #
+        #   @param content [Array<OpenAI::Models::Realtime::ConversationItemWithReference::Content>] The content of the message, applicable for `message` items.
+        #
+        #   @param name [String] The name of the function being called (for `function_call` items).
+        #
+        #   @param object [Symbol, OpenAI::Models::Realtime::ConversationItemWithReference::Object] Identifier for the API object being returned - always `realtime.item`.
+        #
+        #   @param output [String] The output of the function call (for `function_call_output` items).
+        #
+        #   @param role [Symbol, OpenAI::Models::Realtime::ConversationItemWithReference::Role] The role of the message sender (`user`, `assistant`, `system`), only
+        #
+        #   @param status [Symbol, OpenAI::Models::Realtime::ConversationItemWithReference::Status] The status of the item (`completed`, `incomplete`, `in_progress`). These have no
+        #
+        #   @param type [Symbol, OpenAI::Models::Realtime::ConversationItemWithReference::Type] The type of the item (`message`, `function_call`, `function_call_output`,
+        #   `item\_
+
+        class Content < OpenAI::Internal::Type::BaseModel
+          # @!attribute id
+          #   ID of a previous conversation item to reference (for `item_reference` content
+          #   types in `response.create` events). These can reference both client and server
+          #   created items.
+          #
+          #   @return [String, nil]
+          optional :id, String
+
+          # @!attribute audio
+          #   Base64-encoded audio bytes, used for `input_audio` content type.
+          #
+          #   @return [String, nil]
+          optional :audio, String
+
+          # @!attribute text
+          #   The text content, used for `input_text` and `text` content types.
+          #
+          #   @return [String, nil]
+          optional :text, String
+
+          # @!attribute transcript
+          #   The transcript of the audio, used for `input_audio` content type.
+          #
+          #   @return [String, nil]
+          optional :transcript, String
+
+          # @!attribute type
+          #   The content type (`input_text`, `input_audio`, `item_reference`, `text`).
+          #
+          #   @return [Symbol, OpenAI::Models::Realtime::ConversationItemWithReference::Content::Type, nil]
+          optional :type, enum: -> { OpenAI::Realtime::ConversationItemWithReference::Content::Type }
+
+          # @!method initialize(id: nil, audio: nil, text: nil, transcript: nil, type: nil)
+          #   Some parameter documentations has been truncated, see
+          #   {OpenAI::Models::Realtime::ConversationItemWithReference::Content} for more
+          #   details.
+          #
+          #   @param id [String] ID of a previous conversation item to reference (for `item_reference`
+          #
+          #   @param audio [String] Base64-encoded audio bytes, used for `input_audio` content type.
+          #
+          #   @param text [String] The text content, used for `input_text` and `text` content types.
+          #
+          #   @param transcript [String] The transcript of the audio, used for `input_audio` content type.
+          #
+          #   @param type [Symbol, OpenAI::Models::Realtime::ConversationItemWithReference::Content::Type] The content type (`input_text`, `input_audio`, `item_reference`, `text`).
+
+          # The content type (`input_text`, `input_audio`, `item_reference`, `text`).
+          #
+          # @see OpenAI::Models::Realtime::ConversationItemWithReference::Content#type
+          module Type
+            extend OpenAI::Internal::Type::Enum
+
+            INPUT_TEXT = :input_text
+            INPUT_AUDIO = :input_audio
+            ITEM_REFERENCE = :item_reference
+            TEXT = :text
+
+            # @!method self.values
+            #   @return [Array<Symbol>]
+          end
+        end
+
+        # Identifier for the API object being returned - always `realtime.item`.
+        #
+        # @see OpenAI::Models::Realtime::ConversationItemWithReference#object
+        module Object
+          extend OpenAI::Internal::Type::Enum
+
+          REALTIME_ITEM = :"realtime.item"
+
+          # @!method self.values
+          #   @return [Array<Symbol>]
+        end
+
+        # The role of the message sender (`user`, `assistant`, `system`), only applicable
+        # for `message` items.
+        #
+        # @see OpenAI::Models::Realtime::ConversationItemWithReference#role
+        module Role
+          extend OpenAI::Internal::Type::Enum
+
+          USER = :user
+          ASSISTANT = :assistant
+          SYSTEM = :system
+
+          # @!method self.values
+          #   @return [Array<Symbol>]
+        end
+
+        # The status of the item (`completed`, `incomplete`, `in_progress`). These have no
+        # effect on the conversation, but are accepted for consistency with the
+        # `conversation.item.created` event.
+        #
+        # @see OpenAI::Models::Realtime::ConversationItemWithReference#status
+        module Status
+          extend OpenAI::Internal::Type::Enum
+
+          COMPLETED = :completed
+          INCOMPLETE = :incomplete
+          IN_PROGRESS = :in_progress
+
+          # @!method self.values
+          #   @return [Array<Symbol>]
+        end
+
+        # The type of the item (`message`, `function_call`, `function_call_output`,
+        # `item_reference`).
+        #
+        # @see OpenAI::Models::Realtime::ConversationItemWithReference#type
+        module Type
+          extend OpenAI::Internal::Type::Enum
+
+          MESSAGE = :message
+          FUNCTION_CALL = :function_call
+          FUNCTION_CALL_OUTPUT = :function_call_output
+          ITEM_REFERENCE = :item_reference
+
+          # @!method self.values
+          #   @return [Array<Symbol>]
+        end
+      end
+    end
+  end
+end

data/lib/openai/models/realtime/input_audio_buffer_append_event.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module OpenAI
+  module Models
+    module Realtime
+      class InputAudioBufferAppendEvent < OpenAI::Internal::Type::BaseModel
+        # @!attribute audio
+        #   Base64-encoded audio bytes. This must be in the format specified by the
+        #   `input_audio_format` field in the session configuration.
+        #
+        #   @return [String]
+        required :audio, String
+
+        # @!attribute type
+        #   The event type, must be `input_audio_buffer.append`.
+        #
+        #   @return [Symbol, :"input_audio_buffer.append"]
+        required :type, const: :"input_audio_buffer.append"
+
+        # @!attribute event_id
+        #   Optional client-generated ID used to identify this event.
+        #
+        #   @return [String, nil]
+        optional :event_id, String
+
+        # @!method initialize(audio:, event_id: nil, type: :"input_audio_buffer.append")
+        #   Some parameter documentations has been truncated, see
+        #   {OpenAI::Models::Realtime::InputAudioBufferAppendEvent} for more details.
+        #
+        #   Send this event to append audio bytes to the input audio buffer. The audio
+        #   buffer is temporary storage you can write to and later commit. In Server VAD
+        #   mode, the audio buffer is used to detect speech and the server will decide when
+        #   to commit. When Server VAD is disabled, you must commit the audio buffer
+        #   manually.
+        #
+        #   The client may choose how much audio to place in each event up to a maximum of
+        #   15 MiB, for example streaming smaller chunks from the client may allow the VAD
+        #   to be more responsive. Unlike made other client events, the server will not send
+        #   a confirmation response to this event.
+        #
+        #   @param audio [String] Base64-encoded audio bytes. This must be in the format specified by the
+        #
+        #   @param event_id [String] Optional client-generated ID used to identify this event.
+        #
+        #   @param type [Symbol, :"input_audio_buffer.append"] The event type, must be `input_audio_buffer.append`.
+      end
+    end
+  end
+end

data/lib/openai/models/realtime/input_audio_buffer_clear_event.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module OpenAI
+  module Models
+    module Realtime
+      class InputAudioBufferClearEvent < OpenAI::Internal::Type::BaseModel
+        # @!attribute type
+        #   The event type, must be `input_audio_buffer.clear`.
+        #
+        #   @return [Symbol, :"input_audio_buffer.clear"]
+        required :type, const: :"input_audio_buffer.clear"
+
+        # @!attribute event_id
+        #   Optional client-generated ID used to identify this event.
+        #
+        #   @return [String, nil]
+        optional :event_id, String
+
+        # @!method initialize(event_id: nil, type: :"input_audio_buffer.clear")
+        #   Send this event to clear the audio bytes in the buffer. The server will respond
+        #   with an `input_audio_buffer.cleared` event.
+        #
+        #   @param event_id [String] Optional client-generated ID used to identify this event.
+        #
+        #   @param type [Symbol, :"input_audio_buffer.clear"] The event type, must be `input_audio_buffer.clear`.
+      end
+    end
+  end
+end

data/lib/openai/models/realtime/input_audio_buffer_cleared_event.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module OpenAI
+  module Models
+    module Realtime
+      class InputAudioBufferClearedEvent < OpenAI::Internal::Type::BaseModel
+        # @!attribute event_id
+        #   The unique ID of the server event.
+        #
+        #   @return [String]
+        required :event_id, String
+
+        # @!attribute type
+        #   The event type, must be `input_audio_buffer.cleared`.
+        #
+        #   @return [Symbol, :"input_audio_buffer.cleared"]
+        required :type, const: :"input_audio_buffer.cleared"
+
+        # @!method initialize(event_id:, type: :"input_audio_buffer.cleared")
+        #   Returned when the input audio buffer is cleared by the client with a
+        #   `input_audio_buffer.clear` event.
+        #
+        #   @param event_id [String] The unique ID of the server event.
+        #
+        #   @param type [Symbol, :"input_audio_buffer.cleared"] The event type, must be `input_audio_buffer.cleared`.
+      end
+    end
+  end
+end

data/lib/openai/models/realtime/input_audio_buffer_commit_event.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module OpenAI
+  module Models
+    module Realtime
+      class InputAudioBufferCommitEvent < OpenAI::Internal::Type::BaseModel
+        # @!attribute type
+        #   The event type, must be `input_audio_buffer.commit`.
+        #
+        #   @return [Symbol, :"input_audio_buffer.commit"]
+        required :type, const: :"input_audio_buffer.commit"
+
+        # @!attribute event_id
+        #   Optional client-generated ID used to identify this event.
+        #
+        #   @return [String, nil]
+        optional :event_id, String
+
+        # @!method initialize(event_id: nil, type: :"input_audio_buffer.commit")
+        #   Send this event to commit the user input audio buffer, which will create a new
+        #   user message item in the conversation. This event will produce an error if the
+        #   input audio buffer is empty. When in Server VAD mode, the client does not need
+        #   to send this event, the server will commit the audio buffer automatically.
+        #
+        #   Committing the input audio buffer will trigger input audio transcription (if
+        #   enabled in session configuration), but it will not create a response from the
+        #   model. The server will respond with an `input_audio_buffer.committed` event.
+        #
+        #   @param event_id [String] Optional client-generated ID used to identify this event.
+        #
+        #   @param type [Symbol, :"input_audio_buffer.commit"] The event type, must be `input_audio_buffer.commit`.
+      end
+    end
+  end
+end

data/lib/openai/models/realtime/input_audio_buffer_committed_event.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module OpenAI
+  module Models
+    module Realtime
+      class InputAudioBufferCommittedEvent < OpenAI::Internal::Type::BaseModel
+        # @!attribute event_id
+        #   The unique ID of the server event.
+        #
+        #   @return [String]
+        required :event_id, String
+
+        # @!attribute item_id
+        #   The ID of the user message item that will be created.
+        #
+        #   @return [String]
+        required :item_id, String
+
+        # @!attribute type
+        #   The event type, must be `input_audio_buffer.committed`.
+        #
+        #   @return [Symbol, :"input_audio_buffer.committed"]
+        required :type, const: :"input_audio_buffer.committed"
+
+        # @!attribute previous_item_id
+        #   The ID of the preceding item after which the new item will be inserted. Can be
+        #   `null` if the item has no predecessor.
+        #
+        #   @return [String, nil]
+        optional :previous_item_id, String, nil?: true
+
+        # @!method initialize(event_id:, item_id:, previous_item_id: nil, type: :"input_audio_buffer.committed")
+        #   Some parameter documentations has been truncated, see
+        #   {OpenAI::Models::Realtime::InputAudioBufferCommittedEvent} for more details.
+        #
+        #   Returned when an input audio buffer is committed, either by the client or
+        #   automatically in server VAD mode. The `item_id` property is the ID of the user
+        #   message item that will be created, thus a `conversation.item.created` event will
+        #   also be sent to the client.
+        #
+        #   @param event_id [String] The unique ID of the server event.
+        #
+        #   @param item_id [String] The ID of the user message item that will be created.
+        #
+        #   @param previous_item_id [String, nil] The ID of the preceding item after which the new item will be inserted.
+        #
+        #   @param type [Symbol, :"input_audio_buffer.committed"] The event type, must be `input_audio_buffer.committed`.
+      end
+    end
+  end
+end

data/lib/openai/models/realtime/input_audio_buffer_speech_started_event.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module OpenAI
+  module Models
+    module Realtime
+      class InputAudioBufferSpeechStartedEvent < OpenAI::Internal::Type::BaseModel
+        # @!attribute audio_start_ms
+        #   Milliseconds from the start of all audio written to the buffer during the
+        #   session when speech was first detected. This will correspond to the beginning of
+        #   audio sent to the model, and thus includes the `prefix_padding_ms` configured in
+        #   the Session.
+        #
+        #   @return [Integer]
+        required :audio_start_ms, Integer
+
+        # @!attribute event_id
+        #   The unique ID of the server event.
+        #
+        #   @return [String]
+        required :event_id, String
+
+        # @!attribute item_id
+        #   The ID of the user message item that will be created when speech stops.
+        #
+        #   @return [String]
+        required :item_id, String
+
+        # @!attribute type
+        #   The event type, must be `input_audio_buffer.speech_started`.
+        #
+        #   @return [Symbol, :"input_audio_buffer.speech_started"]
+        required :type, const: :"input_audio_buffer.speech_started"
+
+        # @!method initialize(audio_start_ms:, event_id:, item_id:, type: :"input_audio_buffer.speech_started")
+        #   Some parameter documentations has been truncated, see
+        #   {OpenAI::Models::Realtime::InputAudioBufferSpeechStartedEvent} for more details.
+        #
+        #   Sent by the server when in `server_vad` mode to indicate that speech has been
+        #   detected in the audio buffer. This can happen any time audio is added to the
+        #   buffer (unless speech is already detected). The client may want to use this
+        #   event to interrupt audio playback or provide visual feedback to the user.
+        #
+        #   The client should expect to receive a `input_audio_buffer.speech_stopped` event
+        #   when speech stops. The `item_id` property is the ID of the user message item
+        #   that will be created when speech stops and will also be included in the
+        #   `input_audio_buffer.speech_stopped` event (unless the client manually commits
+        #   the audio buffer during VAD activation).
+        #
+        #   @param audio_start_ms [Integer] Milliseconds from the start of all audio written to the buffer during the
+        #
+        #   @param event_id [String] The unique ID of the server event.
+        #
+        #   @param item_id [String] The ID of the user message item that will be created when speech stops.
+        #
+        #   @param type [Symbol, :"input_audio_buffer.speech_started"] The event type, must be `input_audio_buffer.speech_started`.
+      end
+    end
+  end
+end

data/lib/openai/models/realtime/input_audio_buffer_speech_stopped_event.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module OpenAI
+  module Models
+    module Realtime
+      class InputAudioBufferSpeechStoppedEvent < OpenAI::Internal::Type::BaseModel
+        # @!attribute audio_end_ms
+        #   Milliseconds since the session started when speech stopped. This will correspond
+        #   to the end of audio sent to the model, and thus includes the
+        #   `min_silence_duration_ms` configured in the Session.
+        #
+        #   @return [Integer]
+        required :audio_end_ms, Integer
+
+        # @!attribute event_id
+        #   The unique ID of the server event.
+        #
+        #   @return [String]
+        required :event_id, String
+
+        # @!attribute item_id
+        #   The ID of the user message item that will be created.
+        #
+        #   @return [String]
+        required :item_id, String
+
+        # @!attribute type
+        #   The event type, must be `input_audio_buffer.speech_stopped`.
+        #
+        #   @return [Symbol, :"input_audio_buffer.speech_stopped"]
+        required :type, const: :"input_audio_buffer.speech_stopped"
+
+        # @!method initialize(audio_end_ms:, event_id:, item_id:, type: :"input_audio_buffer.speech_stopped")
+        #   Some parameter documentations has been truncated, see
+        #   {OpenAI::Models::Realtime::InputAudioBufferSpeechStoppedEvent} for more details.
+        #
+        #   Returned in `server_vad` mode when the server detects the end of speech in the
+        #   audio buffer. The server will also send an `conversation.item.created` event
+        #   with the user message item that is created from the audio buffer.
+        #
+        #   @param audio_end_ms [Integer] Milliseconds since the session started when speech stopped. This will
+        #
+        #   @param event_id [String] The unique ID of the server event.
+        #
+        #   @param item_id [String] The ID of the user message item that will be created.
+        #
+        #   @param type [Symbol, :"input_audio_buffer.speech_stopped"] The event type, must be `input_audio_buffer.speech_stopped`.
+      end
+    end
+  end
+end