openai 0.88.0 → 0.89.0

data/rbi/openai/models/live/input_audio_append_event.rbi

@@ -0,0 +1,79 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Live
+
+      class InputAudioAppendEvent < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Live::InputAudioAppendEvent,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # Base64-encoded raw audio in the startup-selected format, without a WAV or other
+        # container header. Primary WebSocket only; media transports use their audio
+        # track. Audio appends have no acknowledgment. Reflected sideband server events
+        # reuse this event type and audio key, with no timestamps or event_id; their audio
+        # is always mono PCM16LE at 24 kHz.
+        sig { returns(String) }
+        attr_accessor :audio
+
+        # The Live client event type. Always `session.input_audio.append`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # Optional client identifier for correlating this command with a server event's
+        # client_event_id or error.client_event_id.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :event_id
+
+        # Send audio to a Live session over its primary WebSocket. WebRTC and SIP sessions
+        # send audio over their media transport.
+        sig do
+          params(
+
+            audio: String,
+
+            event_id: T.nilable(String),
+
+            type: Symbol
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # Base64-encoded raw audio in the startup-selected format, without a WAV or other
+          # container header. Primary WebSocket only; media transports use their audio
+          # track. Audio appends have no acknowledgment. Reflected sideband server events
+          # reuse this event type and audio key, with no timestamps or event_id; their audio
+          # is always mono PCM16LE at 24 kHz.
+          audio:,
+
+          # Optional client identifier for correlating this command with a server event's
+          # client_event_id or error.client_event_id.
+          event_id: nil,
+
+          # The Live client event type. Always `session.input_audio.append`.
+
+          type: :"session.input_audio.append"
+        )
+        end
+
+        sig do
+          override.returns(
+            {audio: String, type: Symbol, event_id: T.nilable(String)}
+          )
+        end
+        def to_hash
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/live/input_audio_mute_event.rbi

@@ -0,0 +1,62 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Live
+
+      class InputAudioMuteEvent < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Live::InputAudioMuteEvent,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # The Live client event type. Always `session.input_audio.mute`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # Optional client identifier for correlating this command with a server event's
+        # client_event_id or error.client_event_id.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :event_id
+
+        # Mute audio input to the Live model without closing the session. The server
+        # acknowledges with `session.input_audio.muted`.
+        sig do
+          params(
+
+            event_id: T.nilable(String),
+
+            type: Symbol
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # Optional client identifier for correlating this command with a server event's
+          # client_event_id or error.client_event_id.
+          event_id: nil,
+
+          # The Live client event type. Always `session.input_audio.mute`.
+
+          type: :"session.input_audio.mute"
+        )
+        end
+
+        sig do
+          override.returns(
+            {type: Symbol, event_id: T.nilable(String)}
+          )
+        end
+        def to_hash
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/live/input_audio_muted_event.rbi

@@ -0,0 +1,74 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Live
+
+      class InputAudioMutedEvent < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Live::InputAudioMutedEvent,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # The unique ID of the Live server event.
+        sig { returns(String) }
+        attr_accessor :event_id
+
+        # The event type, always `session.input_audio.muted`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # The event_id of the client command associated with this server event, when
+        # supplied.
+        sig { returns(T.nilable(String)) }
+        attr_reader :client_event_id
+
+        sig { params(client_event_id: String).void }
+        attr_writer :client_event_id
+
+        # Returned when a session.input_audio.mute command is accepted. Input audio is no
+        # longer sent to the model; sideband audio reflection continues.
+        sig do
+          params(
+
+            event_id: String,
+
+            client_event_id: String,
+
+            type: Symbol
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # The unique ID of the Live server event.
+          event_id:,
+
+          # The event_id of the client command associated with this server event, when
+          # supplied.
+          client_event_id: nil,
+
+          # The event type, always `session.input_audio.muted`.
+
+          type: :"session.input_audio.muted"
+        )
+        end
+
+        sig do
+          override.returns(
+            {event_id: String, type: Symbol, client_event_id: T.nilable(String)}
+          )
+        end
+        def to_hash
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/live/input_audio_unmute_event.rbi

@@ -0,0 +1,62 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Live
+
+      class InputAudioUnmuteEvent < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Live::InputAudioUnmuteEvent,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # The Live client event type. Always `session.input_audio.unmute`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # Optional client identifier for correlating this command with a server event's
+        # client_event_id or error.client_event_id.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :event_id
+
+        # Resume audio input to a Live model after muting it. The server acknowledges with
+        # `session.input_audio.unmuted`.
+        sig do
+          params(
+
+            event_id: T.nilable(String),
+
+            type: Symbol
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # Optional client identifier for correlating this command with a server event's
+          # client_event_id or error.client_event_id.
+          event_id: nil,
+
+          # The Live client event type. Always `session.input_audio.unmute`.
+
+          type: :"session.input_audio.unmute"
+        )
+        end
+
+        sig do
+          override.returns(
+            {type: Symbol, event_id: T.nilable(String)}
+          )
+        end
+        def to_hash
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/live/input_audio_unmuted_event.rbi

@@ -0,0 +1,74 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Live
+
+      class InputAudioUnmutedEvent < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Live::InputAudioUnmutedEvent,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # The unique ID of the Live server event.
+        sig { returns(String) }
+        attr_accessor :event_id
+
+        # The event type, always `session.input_audio.unmuted`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # The event_id of the client command associated with this server event, when
+        # supplied.
+        sig { returns(T.nilable(String)) }
+        attr_reader :client_event_id
+
+        sig { params(client_event_id: String).void }
+        attr_writer :client_event_id
+
+        # Returned when a session.input_audio.unmute command is accepted. Input audio is
+        # sent to the model again.
+        sig do
+          params(
+
+            event_id: String,
+
+            client_event_id: String,
+
+            type: Symbol
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # The unique ID of the Live server event.
+          event_id:,
+
+          # The event_id of the client command associated with this server event, when
+          # supplied.
+          client_event_id: nil,
+
+          # The event type, always `session.input_audio.unmuted`.
+
+          type: :"session.input_audio.unmuted"
+        )
+        end
+
+        sig do
+          override.returns(
+            {event_id: String, type: Symbol, client_event_id: T.nilable(String)}
+          )
+        end
+        def to_hash
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/live/input_transcript_delta_event.rbi

@@ -0,0 +1,115 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Live
+
+      class InputTranscriptDeltaEvent < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Live::InputTranscriptDeltaEvent,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # The transcript text fragment for the audio in this time range. Append fragments
+        # in delivery order to build the transcript.
+        sig { returns(String) }
+        attr_accessor :delta
+
+        # The end of this event on the Live session timeline, in milliseconds from the
+        # beginning of the session. For appended context, this can equal start_ms.
+        sig { returns(Integer) }
+        attr_accessor :end_ms
+
+        # The unique ID of the Live server event.
+        sig { returns(String) }
+        attr_accessor :event_id
+
+        # The start of this event on the Live session timeline, in milliseconds from the
+        # beginning of the session.
+        sig { returns(Integer) }
+        attr_accessor :start_ms
+
+        # The event type, always `session.input_transcript.delta`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # The event_id of the client command associated with this server event, 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 transcript fragment for user input audio in the Live session. Accumulate
+        # fragments in delivery order; these events do not define complete turns or
+        # include a transcript-done event.
+        sig do
+          params(
+
+            delta: String,
+
+            end_ms: Integer,
+
+            event_id: String,
+
+            start_ms: Integer,
+
+            client_event_id: String,
+
+            type: Symbol
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # The transcript text fragment for the audio in this time range. Append fragments
+          # in delivery order to build the transcript.
+          delta:,
+
+          # The end of this event on the Live session timeline, in milliseconds from the
+          # beginning of the session. For appended context, this can equal start_ms.
+          end_ms:,
+
+          # The unique ID of the Live server event.
+          event_id:,
+
+          # The start of this event on the Live session timeline, in milliseconds from the
+          # beginning of the session.
+          start_ms:,
+
+          # The event_id of the client command associated with this server event, when
+          # supplied.
+          client_event_id: nil,
+
+          # The event type, always `session.input_transcript.delta`.
+
+          type: :"session.input_transcript.delta"
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              delta: String,
+              end_ms: Integer,
+              event_id: String,
+              start_ms: Integer,
+              type: Symbol,
+              client_event_id: T.nilable(String)
+            }
+          )
+        end
+        def to_hash
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/live/instructions_append_event.rbi

@@ -0,0 +1,86 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Live
+
+      class InstructionsAppendEvent < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Live::InstructionsAppendEvent,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # Instruction text to append, limited to 500 tokens. This is a plain string, not
+        # an array of content parts.
+        sig { returns(String) }
+        attr_accessor :content
+
+        # Required, nullable. Set null for general session context, or use the ID from
+        # session.delegation.created for an existing client delegation. Non-null IDs are
+        # not accepted with Responses delegation.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :delegation_id
+
+        # The Live client event type. Always `session.instructions.append`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # Optional client identifier for correlating this command with a server event's
+        # client_event_id or error.client_event_id.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :event_id
+
+        # Append instructions to the Live conversation while it is running, optionally
+        # associating them with an existing client delegation.
+        sig do
+          params(
+
+            content: String,
+
+            delegation_id: T.nilable(String),
+
+            event_id: T.nilable(String),
+
+            type: Symbol
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # Instruction text to append, limited to 500 tokens. This is a plain string, not
+          # an array of content parts.
+          content:,
+
+          # Required, nullable. Set null for general session context, or use the ID from
+          # session.delegation.created for an existing client delegation. Non-null IDs are
+          # not accepted with Responses delegation.
+          delegation_id:,
+
+          # Optional client identifier for correlating this command with a server event's
+          # client_event_id or error.client_event_id.
+          event_id: nil,
+
+          # The Live client event type. Always `session.instructions.append`.
+
+          type: :"session.instructions.append"
+        )
+        end
+
+        sig do
+          override.returns(
+            {content: String, delegation_id: T.nilable(String), type: Symbol, event_id: T.nilable(String)}
+          )
+        end
+        def to_hash
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/live/instructions_appended_event.rbi

@@ -0,0 +1,97 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Live
+
+      class InstructionsAppendedEvent < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Live::InstructionsAppendedEvent,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # The end of this event on the Live session timeline, in milliseconds from the
+        # beginning of the session. For appended context, this can equal start_ms.
+        sig { returns(Integer) }
+        attr_accessor :end_ms
+
+        # The unique ID of the Live server event.
+        sig { returns(String) }
+        attr_accessor :event_id
+
+        # The start of this event on the Live session timeline, in milliseconds from the
+        # beginning of the session.
+        sig { returns(Integer) }
+        attr_accessor :start_ms
+
+        # The event type, always `session.instructions.appended`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # The event_id of the client command associated with this server event, when
+        # supplied.
+        sig { returns(T.nilable(String)) }
+        attr_reader :client_event_id
+
+        sig { params(client_event_id: String).void }
+        attr_writer :client_event_id
+
+        # Returned when a session.instructions.append command is accepted into the Live
+        # session timeline. Acknowledges the appended instructions without guaranteeing
+        # that the model has acted on them.
+        sig do
+          params(
+
+            end_ms: Integer,
+
+            event_id: String,
+
+            start_ms: Integer,
+
+            client_event_id: String,
+
+            type: Symbol
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # The end of this event on the Live session timeline, in milliseconds from the
+          # beginning of the session. For appended context, this can equal start_ms.
+          end_ms:,
+
+          # The unique ID of the Live server event.
+          event_id:,
+
+          # The start of this event on the Live session timeline, in milliseconds from the
+          # beginning of the session.
+          start_ms:,
+
+          # The event_id of the client command associated with this server event, when
+          # supplied.
+          client_event_id: nil,
+
+          # The event type, always `session.instructions.appended`.
+
+          type: :"session.instructions.appended"
+        )
+        end
+
+        sig do
+          override.returns(
+            {end_ms: Integer, event_id: String, start_ms: Integer, type: Symbol, client_event_id: T.nilable(String)}
+          )
+        end
+        def to_hash
+        end
+
+      end
+
+    end
+
+  end
+end