openai 0.20.0 → 0.21.0

data/rbi/openai/models/realtime/input_audio_buffer_commit_event.rbi

@@ -0,0 +1,49 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    module Realtime
+      class InputAudioBufferCommitEvent < OpenAI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              OpenAI::Realtime::InputAudioBufferCommitEvent,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+        # The event type, must be `input_audio_buffer.commit`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # Optional client-generated ID used to identify this event.
+        sig { returns(T.nilable(String)) }
+        attr_reader :event_id
+
+        sig { params(event_id: String).void }
+        attr_writer :event_id
+
+        # 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.
+        sig { params(event_id: String, type: Symbol).returns(T.attached_class) }
+        def self.new(
+          # Optional client-generated ID used to identify this event.
+          event_id: nil,
+          # The event type, must be `input_audio_buffer.commit`.
+          type: :"input_audio_buffer.commit"
+        )
+        end
+
+        sig { override.returns({ type: Symbol, event_id: String }) }
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/openai/models/realtime/input_audio_buffer_committed_event.rbi

@@ -0,0 +1,72 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    module Realtime
+      class InputAudioBufferCommittedEvent < OpenAI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              OpenAI::Realtime::InputAudioBufferCommittedEvent,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+        # The unique ID of the server event.
+        sig { returns(String) }
+        attr_accessor :event_id
+
+        # The ID of the user message item that will be created.
+        sig { returns(String) }
+        attr_accessor :item_id
+
+        # The event type, must be `input_audio_buffer.committed`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # The ID of the preceding item after which the new item will be inserted. Can be
+        # `null` if the item has no predecessor.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :previous_item_id
+
+        # 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.
+        sig do
+          params(
+            event_id: String,
+            item_id: String,
+            previous_item_id: T.nilable(String),
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # The unique ID of the server event.
+          event_id:,
+          # The ID of the user message item that will be created.
+          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.
+          previous_item_id: nil,
+          # The event type, must be `input_audio_buffer.committed`.
+          type: :"input_audio_buffer.committed"
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              event_id: String,
+              item_id: String,
+              type: Symbol,
+              previous_item_id: T.nilable(String)
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/openai/models/realtime/input_audio_buffer_speech_started_event.rbi

@@ -0,0 +1,82 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    module Realtime
+      class InputAudioBufferSpeechStartedEvent < OpenAI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              OpenAI::Realtime::InputAudioBufferSpeechStartedEvent,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+        # 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.
+        sig { returns(Integer) }
+        attr_accessor :audio_start_ms
+
+        # The unique ID of the server event.
+        sig { returns(String) }
+        attr_accessor :event_id
+
+        # The ID of the user message item that will be created when speech stops.
+        sig { returns(String) }
+        attr_accessor :item_id
+
+        # The event type, must be `input_audio_buffer.speech_started`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # 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).
+        sig do
+          params(
+            audio_start_ms: Integer,
+            event_id: String,
+            item_id: String,
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # 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.
+          audio_start_ms:,
+          # The unique ID of the server event.
+          event_id:,
+          # The ID of the user message item that will be created when speech stops.
+          item_id:,
+          # The event type, must be `input_audio_buffer.speech_started`.
+          type: :"input_audio_buffer.speech_started"
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              audio_start_ms: Integer,
+              event_id: String,
+              item_id: String,
+              type: Symbol
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/openai/models/realtime/input_audio_buffer_speech_stopped_event.rbi

@@ -0,0 +1,73 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    module Realtime
+      class InputAudioBufferSpeechStoppedEvent < OpenAI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              OpenAI::Realtime::InputAudioBufferSpeechStoppedEvent,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+        # 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.
+        sig { returns(Integer) }
+        attr_accessor :audio_end_ms
+
+        # The unique ID of the server event.
+        sig { returns(String) }
+        attr_accessor :event_id
+
+        # The ID of the user message item that will be created.
+        sig { returns(String) }
+        attr_accessor :item_id
+
+        # The event type, must be `input_audio_buffer.speech_stopped`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # 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.
+        sig do
+          params(
+            audio_end_ms: Integer,
+            event_id: String,
+            item_id: String,
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # 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.
+          audio_end_ms:,
+          # The unique ID of the server event.
+          event_id:,
+          # The ID of the user message item that will be created.
+          item_id:,
+          # The event type, must be `input_audio_buffer.speech_stopped`.
+          type: :"input_audio_buffer.speech_stopped"
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              audio_end_ms: Integer,
+              event_id: String,
+              item_id: String,
+              type: Symbol
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/openai/models/realtime/input_audio_buffer_timeout_triggered.rbi

@@ -0,0 +1,75 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    module Realtime
+      class InputAudioBufferTimeoutTriggered < OpenAI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              OpenAI::Realtime::InputAudioBufferTimeoutTriggered,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+        # Millisecond offset where speech ended within the buffered audio.
+        sig { returns(Integer) }
+        attr_accessor :audio_end_ms
+
+        # Millisecond offset where speech started within the buffered audio.
+        sig { returns(Integer) }
+        attr_accessor :audio_start_ms
+
+        # The unique ID of the server event.
+        sig { returns(String) }
+        attr_accessor :event_id
+
+        # The ID of the item associated with this segment.
+        sig { returns(String) }
+        attr_accessor :item_id
+
+        # The event type, must be `input_audio_buffer.timeout_triggered`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # Returned when the server VAD timeout is triggered for the input audio buffer.
+        sig do
+          params(
+            audio_end_ms: Integer,
+            audio_start_ms: Integer,
+            event_id: String,
+            item_id: String,
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Millisecond offset where speech ended within the buffered audio.
+          audio_end_ms:,
+          # Millisecond offset where speech started within the buffered audio.
+          audio_start_ms:,
+          # The unique ID of the server event.
+          event_id:,
+          # The ID of the item associated with this segment.
+          item_id:,
+          # The event type, must be `input_audio_buffer.timeout_triggered`.
+          type: :"input_audio_buffer.timeout_triggered"
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              audio_end_ms: Integer,
+              audio_start_ms: Integer,
+              event_id: String,
+              item_id: String,
+              type: Symbol
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/openai/models/realtime/log_prob_properties.rbi

@@ -0,0 +1,55 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    module Realtime
+      class LogProbProperties < OpenAI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              OpenAI::Realtime::LogProbProperties,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+        # The token that was used to generate the log probability.
+        sig { returns(String) }
+        attr_accessor :token
+
+        # The bytes that were used to generate the log probability.
+        sig { returns(T::Array[Integer]) }
+        attr_accessor :bytes
+
+        # The log probability of the token.
+        sig { returns(Float) }
+        attr_accessor :logprob
+
+        # A log probability object.
+        sig do
+          params(
+            token: String,
+            bytes: T::Array[Integer],
+            logprob: Float
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # The token that was used to generate the log probability.
+          token:,
+          # The bytes that were used to generate the log probability.
+          bytes:,
+          # The log probability of the token.
+          logprob:
+        )
+        end
+
+        sig do
+          override.returns(
+            { token: String, bytes: T::Array[Integer], logprob: Float }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/openai/models/realtime/mcp_list_tools_completed.rbi

@@ -0,0 +1,51 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    module Realtime
+      class McpListToolsCompleted < OpenAI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              OpenAI::Realtime::McpListToolsCompleted,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+        # The unique ID of the server event.
+        sig { returns(String) }
+        attr_accessor :event_id
+
+        # The ID of the MCP list tools item.
+        sig { returns(String) }
+        attr_accessor :item_id
+
+        # The event type, must be `mcp_list_tools.completed`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # Returned when listing MCP tools has completed for an item.
+        sig do
+          params(event_id: String, item_id: String, type: Symbol).returns(
+            T.attached_class
+          )
+        end
+        def self.new(
+          # The unique ID of the server event.
+          event_id:,
+          # The ID of the MCP list tools item.
+          item_id:,
+          # The event type, must be `mcp_list_tools.completed`.
+          type: :"mcp_list_tools.completed"
+        )
+        end
+
+        sig do
+          override.returns({ event_id: String, item_id: String, type: Symbol })
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/openai/models/realtime/mcp_list_tools_failed.rbi

@@ -0,0 +1,51 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    module Realtime
+      class McpListToolsFailed < OpenAI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              OpenAI::Realtime::McpListToolsFailed,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+        # The unique ID of the server event.
+        sig { returns(String) }
+        attr_accessor :event_id
+
+        # The ID of the MCP list tools item.
+        sig { returns(String) }
+        attr_accessor :item_id
+
+        # The event type, must be `mcp_list_tools.failed`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # Returned when listing MCP tools has failed for an item.
+        sig do
+          params(event_id: String, item_id: String, type: Symbol).returns(
+            T.attached_class
+          )
+        end
+        def self.new(
+          # The unique ID of the server event.
+          event_id:,
+          # The ID of the MCP list tools item.
+          item_id:,
+          # The event type, must be `mcp_list_tools.failed`.
+          type: :"mcp_list_tools.failed"
+        )
+        end
+
+        sig do
+          override.returns({ event_id: String, item_id: String, type: Symbol })
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/openai/models/realtime/mcp_list_tools_in_progress.rbi

@@ -0,0 +1,51 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    module Realtime
+      class McpListToolsInProgress < OpenAI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              OpenAI::Realtime::McpListToolsInProgress,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+        # The unique ID of the server event.
+        sig { returns(String) }
+        attr_accessor :event_id
+
+        # The ID of the MCP list tools item.
+        sig { returns(String) }
+        attr_accessor :item_id
+
+        # The event type, must be `mcp_list_tools.in_progress`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # Returned when listing MCP tools is in progress for an item.
+        sig do
+          params(event_id: String, item_id: String, type: Symbol).returns(
+            T.attached_class
+          )
+        end
+        def self.new(
+          # The unique ID of the server event.
+          event_id:,
+          # The ID of the MCP list tools item.
+          item_id:,
+          # The event type, must be `mcp_list_tools.in_progress`.
+          type: :"mcp_list_tools.in_progress"
+        )
+        end
+
+        sig do
+          override.returns({ event_id: String, item_id: String, type: Symbol })
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/openai/models/realtime/output_audio_buffer_clear_event.rbi

@@ -0,0 +1,46 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    module Realtime
+      class OutputAudioBufferClearEvent < OpenAI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              OpenAI::Realtime::OutputAudioBufferClearEvent,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+        # The event type, must be `output_audio_buffer.clear`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # The unique ID of the client event used for error handling.
+        sig { returns(T.nilable(String)) }
+        attr_reader :event_id
+
+        sig { params(event_id: String).void }
+        attr_writer :event_id
+
+        # **WebRTC Only:** Emit to cut off the current audio response. This will trigger
+        # the server to stop generating audio and emit a `output_audio_buffer.cleared`
+        # event. This event should be preceded by a `response.cancel` client event to stop
+        # the generation of the current response.
+        # [Learn more](https://platform.openai.com/docs/guides/realtime-conversations#client-and-server-events-for-audio-in-webrtc).
+        sig { params(event_id: String, type: Symbol).returns(T.attached_class) }
+        def self.new(
+          # The unique ID of the client event used for error handling.
+          event_id: nil,
+          # The event type, must be `output_audio_buffer.clear`.
+          type: :"output_audio_buffer.clear"
+        )
+        end
+
+        sig { override.returns({ type: Symbol, event_id: String }) }
+        def to_hash
+        end
+      end
+    end
+  end
+end