@volter/twin-livekit 0.1.0

package/dist/test-fixtures/protobufs/livekit_ingress.proto

@@ -0,0 +1,222 @@
+// Copyright 2023 LiveKit, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+syntax = "proto3";
+
+package livekit;
+
+import "livekit_models.proto";
+import "logger/options.proto";
+
+option go_package = "github.com/livekit/protocol/livekit";
+option csharp_namespace = "LiveKit.Proto";
+option ruby_package = "LiveKit::Proto";
+
+service Ingress {
+  // Create a new Ingress
+  rpc CreateIngress(CreateIngressRequest) returns (IngressInfo);
+  // Update an existing Ingress. Ingress can only be updated when it's in ENDPOINT_WAITING state.
+  rpc UpdateIngress(UpdateIngressRequest) returns (IngressInfo);
+  rpc ListIngress(ListIngressRequest) returns (ListIngressResponse);
+  rpc DeleteIngress(DeleteIngressRequest) returns (IngressInfo);
+}
+
+message CreateIngressRequest {
+  IngressInput input_type = 1;
+  // Where to pull media from, only for URL input type
+  string url = 9;
+  // User provided identifier for the ingress
+  string name = 2;
+  // room to publish to
+  string room_name = 3;
+  // publish as participant
+  string participant_identity = 4;
+  // name of publishing participant (used for display only)
+  string participant_name = 5 [(logger.sensitivity) = SENSITIVITY_PII];
+  // metadata associated with the publishing participant
+  string participant_metadata = 10 [
+    (logger.sensitivity) = SENSITIVITY_PII,
+    (logger.redact_format) = "<redacted ({{ .Size }} bytes)>"
+  ];
+  // [depreacted ] whether to pass through the incoming media without transcoding, only compatible with some input types. Use `enable_transcoding` instead.
+  bool bypass_transcoding = 8 [deprecated = true];
+  // Whether to transcode the ingested media. Only WHIP supports disabling transcoding currently. WHIP will default to transcoding disabled. Replaces `bypass_transcoding. 
+  optional bool enable_transcoding = 11;
+  IngressAudioOptions audio = 6;
+  IngressVideoOptions video = 7;
+  optional bool enabled = 12; // The default value is true and when set to false, the new connection attempts will be rejected
+
+   // NEXT_ID: 13
+}
+
+enum IngressInput {
+  RTMP_INPUT = 0;
+  WHIP_INPUT = 1;
+  URL_INPUT = 2; // Pull from the provided URL. Only HTTP url are supported, serving either a single media file or a HLS stream
+  //  FILE_INPUT = 3;
+  //  SRT_INPUT = 4;
+}
+
+message IngressAudioOptions {
+  string name = 1;
+  TrackSource source = 2;
+  oneof encoding_options {
+    IngressAudioEncodingPreset preset = 3;
+    IngressAudioEncodingOptions options = 4;
+  }
+}
+
+message IngressVideoOptions {
+  string name = 1;
+  TrackSource source = 2;
+  oneof encoding_options {
+    IngressVideoEncodingPreset preset = 3;
+    IngressVideoEncodingOptions options = 4;
+  }
+}
+
+enum IngressAudioEncodingPreset {
+  OPUS_STEREO_96KBPS = 0;    // OPUS, 2 channels, 96kbps
+  OPUS_MONO_64KBS = 1;       // OPUS, 1 channel, 64kbps
+}
+
+enum IngressVideoEncodingPreset {
+  H264_720P_30FPS_3_LAYERS = 0;                 // 1280x720,  30fps, 1900kbps main layer, 3 layers total
+  H264_1080P_30FPS_3_LAYERS = 1;                // 1980x1080, 30fps, 3500kbps main layer, 3 layers total
+  H264_540P_25FPS_2_LAYERS = 2;                 //  960x540,  25fps, 1000kbps  main layer, 2 layers total
+  H264_720P_30FPS_1_LAYER = 3;                  // 1280x720,  30fps, 1900kbps, no simulcast
+  H264_1080P_30FPS_1_LAYER = 4;                 // 1980x1080, 30fps, 3500kbps, no simulcast
+  H264_720P_30FPS_3_LAYERS_HIGH_MOTION = 5;     // 1280x720,  30fps, 2500kbps main layer, 3 layers total, higher bitrate for high motion, harder to encode content
+  H264_1080P_30FPS_3_LAYERS_HIGH_MOTION = 6;    // 1980x1080, 30fps, 4500kbps main layer, 3 layers total, higher bitrate for high motion, harder to encode content
+  H264_540P_25FPS_2_LAYERS_HIGH_MOTION = 7;     //  960x540,  25fps, 1300kbps  main layer, 2 layers total, higher bitrate for high motion, harder to encode content
+  H264_720P_30FPS_1_LAYER_HIGH_MOTION = 8;      // 1280x720,  30fps, 2500kbps, no simulcast, higher bitrate for high motion, harder to encode content
+  H264_1080P_30FPS_1_LAYER_HIGH_MOTION = 9;     // 1980x1080, 30fps, 4500kbps, no simulcast, higher bitrate for high motion, harder to encode content
+}
+
+message IngressAudioEncodingOptions {
+  // desired audio codec to publish to room
+  AudioCodec audio_codec = 1;
+  uint32 bitrate = 2;
+  bool disable_dtx = 3;
+  uint32 channels = 4;
+}
+
+message IngressVideoEncodingOptions {
+  // desired codec to publish to room
+  VideoCodec video_codec = 1;
+  double frame_rate = 2; 
+  // simulcast layers to publish, when empty, should usually be set to layers at 1/2 and 1/4 of the dimensions
+  repeated VideoLayer layers = 3;
+}
+
+message IngressInfo {
+  string ingress_id = 1 [(logger.name) = "ingressID"];
+  string name = 2;
+  string stream_key = 3;
+  string url = 4; // URL to point the encoder to for push (RTMP, WHIP), or location to pull media from for pull (URL)
+  // for RTMP input, it'll be a rtmp:// URL
+  // for FILE input, it'll be a http:// URL
+  // for SRT input, it'll be a srt:// URL
+  IngressInput input_type = 5;
+  bool bypass_transcoding = 13 [deprecated = true];
+  optional bool enable_transcoding = 15;
+  IngressAudioOptions audio = 6;
+  IngressVideoOptions video = 7;
+  string room_name = 8;
+  string participant_identity = 9;
+  string participant_name = 10 [(logger.sensitivity) = SENSITIVITY_PII];
+  string participant_metadata = 14 [
+    (logger.sensitivity) = SENSITIVITY_PII,
+    (logger.redact_format) = "<redacted ({{ .Size }} bytes)>"
+  ];
+  bool reusable = 11;
+  IngressState state = 12; // Description of error/stream non compliance and debug info for publisher otherwise (received bitrate, resolution, bandwidth)
+  optional bool enabled = 16; // The default value is true and when set to false, the new connection attempts will be rejected
+
+  // NEXT_ID: 17
+}
+
+message IngressState {
+  enum Status {
+    ENDPOINT_INACTIVE = 0;
+    ENDPOINT_BUFFERING = 1;
+    ENDPOINT_PUBLISHING = 2;
+    ENDPOINT_ERROR = 3;
+    ENDPOINT_COMPLETE = 4;
+  }
+
+  Status status = 1;
+  string error = 2; // Error/non compliance description if any
+  InputVideoState video = 3;
+  InputAudioState audio = 4;
+  string room_id = 5 [(logger.name) = "roomID"]; // ID of the current/previous room published to
+  int64 started_at = 7;
+  int64 ended_at = 8;
+  int64 updated_at = 10;
+  string resource_id = 9 [(logger.name) = "resourceID"];
+  repeated TrackInfo tracks = 6;
+
+  // next ID: 11
+}
+
+message InputVideoState {
+  string mime_type = 1;
+  uint32 average_bitrate = 2;
+  uint32 width = 3;
+  uint32 height = 4;
+  double framerate = 5;
+}
+
+message InputAudioState {
+  string mime_type = 1;
+  uint32 average_bitrate = 2;
+  uint32 channels = 3;
+  uint32 sample_rate = 4;
+}
+
+message UpdateIngressRequest {
+  string ingress_id = 1 [(logger.name) = "ingressID"];
+  string name = 2;
+  string room_name = 3;
+  string participant_identity = 4;
+  string participant_name = 5 [(logger.sensitivity) = SENSITIVITY_PII];
+  string participant_metadata = 9 [
+    (logger.sensitivity) = SENSITIVITY_PII,
+    (logger.redact_format) = "<redacted ({{ .Size }} bytes)>"
+  ];
+  optional bool bypass_transcoding = 8 [deprecated = true];
+  optional bool enable_transcoding = 10;
+  IngressAudioOptions audio = 6;
+  IngressVideoOptions video = 7;
+  optional bool enabled = 11; // The default value is true and when set to false, the new connection attempts will be rejected
+  // NEXT_ID: 12
+}
+
+message ListIngressRequest {
+  TokenPagination page_token = 3;
+  // when blank, lists all ingress endpoints
+  string room_name = 1;  // (optional, filter by room name)
+  string ingress_id = 2 [(logger.name) = "ingressID"]; // (optional, filter by ingress ID)
+  // next field id: 4
+}
+
+message ListIngressResponse {
+  TokenPagination next_page_token = 2;
+  repeated IngressInfo items = 1;
+  // next field id: 3
+}
+
+message DeleteIngressRequest {
+  string ingress_id = 1 [(logger.name) = "ingressID"];
+}

package/dist/test-fixtures/protobufs/livekit_internal.proto

@@ -0,0 +1,228 @@
+// Copyright 2023 LiveKit, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+syntax = "proto3";
+
+package livekit;
+
+import "livekit_agent_dispatch.proto";
+import "livekit_egress.proto";
+// internal protos, not exposed to clients
+import "livekit_models.proto";
+import "livekit_room.proto";
+import "livekit_rtc.proto";
+import "logger/options.proto";
+
+option csharp_namespace = "LiveKit.Proto";
+option go_package = "github.com/livekit/protocol/livekit";
+option ruby_package = "LiveKit::Proto";
+
+enum NodeType {
+  SERVER = 0;
+  CONTROLLER = 1;
+  MEDIA = 2;
+  TURN = 4;
+  SWEEPER = 5;
+  DIRECTOR = 6;
+  HOSTED_AGENT = 7;
+  SETTINGS = 8;
+}
+
+enum NodeState {
+  STARTING_UP = 0;
+  SERVING = 1;
+  SHUTTING_DOWN = 2;
+  SUSPENDED = 3;
+}
+
+message Node {
+  string id = 1;
+  string ip = 2;
+  uint32 num_cpus = 3;
+  NodeStats stats = 4;
+  NodeType type = 5;
+  NodeState state = 6;
+  string region = 7;
+}
+
+message NodeStats {
+  // when server was started
+  int64 started_at = 1;
+  // when server last reported its status
+  int64 updated_at = 2;
+
+  // room
+  int32 num_rooms = 3;
+  int32 num_clients = 4;
+  int32 num_tracks_in = 5;
+  int32 num_tracks_out = 6;
+  int32 num_track_publish_attempts = 36;
+  float track_publish_attempts_per_sec = 37 [deprecated = true];
+  int32 num_track_publish_success = 38;
+  float track_publish_success_per_sec = 39 [deprecated = true];
+  int32 num_track_publish_cancels = 51;
+  int32 num_track_subscribe_attempts = 40;
+  float track_subscribe_attempts_per_sec = 41 [deprecated = true];
+  int32 num_track_subscribe_success = 42;
+  float track_subscribe_success_per_sec = 43 [deprecated = true];
+  int32 num_track_subscribe_cancels = 52;
+
+  // packet
+  uint64 bytes_in = 7;
+  uint64 bytes_out = 8;
+  uint64 packets_in = 9;
+  uint64 packets_out = 10;
+  uint64 nack_total = 11;
+  float bytes_in_per_sec = 12 [deprecated = true];
+  float bytes_out_per_sec = 13 [deprecated = true];
+  float packets_in_per_sec = 14;
+  float packets_out_per_sec = 15 [deprecated = true];
+  float nack_per_sec = 16 [deprecated = true];
+
+  // system
+  uint32 num_cpus = 17;
+  float load_avg_last1min = 18;
+  float load_avg_last5min = 19;
+  float load_avg_last15min = 20;
+  float cpu_load = 21;
+  float memory_load = 33 [deprecated = true];
+  uint64 memory_total = 34;
+  uint64 memory_used = 35;
+  uint32 sys_packets_out = 28;
+  uint32 sys_packets_dropped = 29;
+  float sys_packets_out_per_sec = 30 [deprecated = true];
+  float sys_packets_dropped_per_sec = 31 [deprecated = true];
+  float sys_packets_dropped_pct_per_sec = 32 [deprecated = true];
+
+  // retransmissions
+  uint64 retransmit_bytes_out = 22;
+  uint64 retransmit_packets_out = 23;
+  float retransmit_bytes_out_per_sec = 24 [deprecated = true];
+  float retransmit_packets_out_per_sec = 25 [deprecated = true];
+
+  // participant joins
+  uint64 participant_signal_connected = 26;
+  float participant_signal_connected_per_sec = 27 [deprecated = true];
+  uint64 participant_signal_failed = 55 [deprecated = true];
+  uint64 participant_signal_validation_failed = 56 [deprecated = true];
+  uint64 participant_rtc_connected = 44;
+  float participant_rtc_connected_per_sec = 45 [deprecated = true];
+  uint64 participant_rtc_init = 46;
+  float participant_rtc_init_per_sec = 47 [deprecated = true];
+  uint64 participant_rtc_canceled = 53;
+  uint64 participant_rtc_active = 54;
+
+  // forward metrics
+  uint32 forward_latency = 48;
+  uint32 forward_jitter = 49;
+
+  repeated NodeStatsRate rates = 50;
+
+  // NEXT ID: 57
+}
+
+// rates of different node stats (per second)
+message NodeStatsRate {
+  int64 started_at = 1;
+  int64 ended_at = 2;
+  int64 duration = 3;
+
+  float track_publish_attempts = 4;
+  float track_publish_success = 5;
+  float track_publish_cancels = 24;
+  float track_subscribe_attempts = 6;
+  float track_subscribe_success = 7;
+  float track_subscribe_cancels = 25;
+
+  float bytes_in = 8;
+  float bytes_out = 9;
+  float packets_in = 10;
+  float packets_out = 11;
+  float nack_total = 12;
+
+  float sys_packets_out = 13;
+  float sys_packets_dropped = 14;
+
+  float retransmit_bytes_out = 15;
+  float retransmit_packets_out = 16;
+
+  float participant_signal_connected = 17;
+  float participant_signal_failed = 28;
+  float participant_signal_validation_failed = 29;
+  float participant_rtc_connected = 18;
+  float participant_rtc_init = 19;
+  float participant_rtc_canceled = 26;
+  float participant_rtc_active = 27;
+
+  // time weighted averages across stats windows forming part of a rate measurement interval
+  float cpu_load = 20;
+  float memory_load = 21;
+  float memory_used = 22;
+  float memory_total = 23;
+
+  // NEXT ID: 30
+}
+
+message StartSession {
+  string room_name = 1;
+  string identity = 2;
+  string connection_id = 3 [(logger.name) = "connectionID"];
+  // if a client is reconnecting (i.e. resume instead of restart)
+  bool reconnect = 4;
+  bool auto_subscribe = 9;
+  optional bool auto_subscribe_data_track = 25;
+  bool hidden = 10 [deprecated = true];
+  ClientInfo client = 11;
+  bool recorder = 12 [deprecated = true];
+  string name = 13;
+  // A user's ClaimGrants serialized in JSON
+  string grants_json = 14;
+  bool adaptive_stream = 15;
+  //if reconnect, client will set current sid
+  string participant_id = 16 [(logger.name) = "participantID"];
+  ReconnectReason reconnect_reason = 17;
+  optional bool subscriber_allow_pause = 18;
+  bool disable_ice_lite = 19;
+  CreateRoomRequest create_room = 20;
+  repeated livekit.AddTrackRequest add_track_requests = 21;
+  SessionDescription publisher_offer = 22;
+  SyncState sync_state = 23;
+  bool use_single_peer_connection = 24;
+  int64 token_expires_at = 26;
+
+  // NEXT ID: 27
+}
+
+// room info that should not be returned to clients
+message RoomInternal {
+  AutoTrackEgress track_egress = 1;
+  AutoParticipantEgress participant_egress = 2;
+  PlayoutDelay playout_delay = 3;
+  repeated RoomAgentDispatch agent_dispatches = 5;
+  bool sync_streams = 4;
+  bool replay_enabled = 6;
+  bool export_room = 7;
+  map<string, string> tags = 8;
+}
+
+enum ICECandidateType {
+  ICT_NONE = 0;
+  ICT_TCP = 1;
+  ICT_TLS = 2;
+}
+
+message ICEConfig {
+  ICECandidateType preference_subscriber = 1;
+  ICECandidateType preference_publisher = 2;
+}

package/dist/test-fixtures/protobufs/livekit_metrics.proto

@@ -0,0 +1,103 @@
+syntax = "proto3";
+
+package livekit;
+option go_package = "github.com/livekit/protocol/livekit";
+option csharp_namespace = "LiveKit.Proto";
+option ruby_package = "LiveKit::Proto";
+
+import "google/protobuf/timestamp.proto";
+import "logger/options.proto";
+
+
+/*
+  Protocol used to record metrics for a specific session.
+
+  Clients send their timestamp in their own monotonically increasing time (e.g `performance.now` on JS).
+  These timestamps are then augmented by the SFU to its time base.
+
+  A metric can be linked to a specific track by setting `track_sid`.
+*/
+
+
+// index from [0: MAX_LABEL_PREDEFINED_MAX_VALUE) are for predefined labels (`MetricLabel`)
+enum MetricLabel {
+  AGENTS_LLM_TTFT = 0; // time to first token from LLM
+  AGENTS_STT_TTFT = 1; // time to final transcription
+  AGENTS_TTS_TTFB = 2; // time to first byte
+
+  CLIENT_VIDEO_SUBSCRIBER_FREEZE_COUNT = 3;                           // Number of video freezes
+  CLIENT_VIDEO_SUBSCRIBER_TOTAL_FREEZE_DURATION = 4;                  // total duration of freezes
+  CLIENT_VIDEO_SUBSCRIBER_PAUSE_COUNT = 5;                            // number of video pauses
+  CLIENT_VIDEO_SUBSCRIBER_TOTAL_PAUSES_DURATION = 6;                  // total duration of pauses
+  CLIENT_AUDIO_SUBSCRIBER_CONCEALED_SAMPLES = 7;                      // number of concealed (synthesized) audio samples
+  CLIENT_AUDIO_SUBSCRIBER_SILENT_CONCEALED_SAMPLES = 8;               // number of silent concealed samples
+  CLIENT_AUDIO_SUBSCRIBER_CONCEALMENT_EVENTS = 9;                     // number of concealment events
+  CLIENT_AUDIO_SUBSCRIBER_INTERRUPTION_COUNT = 10;                    // number of interruptions
+  CLIENT_AUDIO_SUBSCRIBER_TOTAL_INTERRUPTION_DURATION = 11;           // total duration of interruptions
+  CLIENT_SUBSCRIBER_JITTER_BUFFER_DELAY = 12;                         // total time spent in jitter buffer
+  CLIENT_SUBSCRIBER_JITTER_BUFFER_EMITTED_COUNT = 13;                 // total time spent in jitter buffer
+  CLIENT_VIDEO_PUBLISHER_QUALITY_LIMITATION_DURATION_BANDWIDTH = 14;  // total duration spent in bandwidth quality limitation
+  CLIENT_VIDEO_PUBLISHER_QUALITY_LIMITATION_DURATION_CPU = 15;        // total duration spent in cpu quality limitation
+  CLIENT_VIDEO_PUBLISHER_QUALITY_LIMITATION_DURATION_OTHER = 16;      // total duration spent in other quality limitation
+
+  PUBLISHER_RTT = 17;   // Publisher RTT (participant -> server)
+  SERVER_MESH_RTT = 18; // RTT between publisher node and subscriber node (could involve intermedia node(s))
+  SUBSCRIBER_RTT = 19;  // Subscribe RTT (server -> participant)
+
+  METRIC_LABEL_PREDEFINED_MAX_VALUE = 4096;
+}
+
+message MetricsBatch {
+  int64 timestamp_ms = 1; // time at which this batch is sent based on a monotonic clock (millisecond resolution)
+  google.protobuf.Timestamp normalized_timestamp = 2;
+  // To avoid repeating string values, we store them in a separate list and reference them by index
+  // This is useful for storing participant identities, track names, etc.
+  // There is also a predefined list of labels that can be used to reference common metrics.
+  // They have reserved indices from 0 to (METRIC_LABEL_PREDEFINED_MAX_VALUE - 1).
+  // Indexes pointing at str_data should start from METRIC_LABEL_PREDEFINED_MAX_VALUE,
+  // such that str_data[0] == index of METRIC_LABEL_PREDEFINED_MAX_VALUE.
+  repeated string str_data = 3;
+  repeated TimeSeriesMetric time_series = 4;
+  repeated EventMetric events = 5;
+}
+
+message TimeSeriesMetric {
+  // Metric name e.g "speech_probablity". The string value is not directly stored in the message, but referenced by index
+  // in the `str_data` field of `MetricsBatch`
+  uint32 label = 1;
+  uint32 participant_identity = 2; // index into `str_data`
+  uint32 track_sid = 3; // index into `str_data`
+  repeated MetricSample samples = 4;
+  uint32 rid = 5; // index into 'str_data'
+}
+
+message MetricSample {
+  int64 timestamp_ms = 1; // time of metric based on a monotonic clock (in milliseconds)
+  google.protobuf.Timestamp normalized_timestamp = 2;
+  float value = 3;
+}
+
+message EventMetric {
+  uint32 label = 1;
+  uint32 participant_identity = 2; // index into `str_data`
+  uint32 track_sid = 3; // index into `str_data`
+  int64 start_timestamp_ms = 4; // start time of event based on a monotonic clock (in milliseconds)
+  optional int64 end_timestamp_ms = 5; // end time of event based on a monotonic clock (in milliseconds), if needed
+  google.protobuf.Timestamp normalized_start_timestamp = 6;
+  optional google.protobuf.Timestamp normalized_end_timestamp = 7;
+  string metadata = 8;
+  uint32 rid = 9; // index into 'str_data'
+}
+
+message MetricsRecordingHeader {
+  reserved 2; // was observability field, removed in #1294
+  string room_id = 1 [(logger.name) = "roomID"];
+  uint64 duration = 3; // milliseconds
+  google.protobuf.Timestamp start_time = 4;
+  map<string, string> room_tags = 5;
+  string room_name = 6;
+  google.protobuf.Timestamp room_start_time = 7;
+  string job_id = 8;
+  bool simulated = 9;  // session is a simulation; the collector skips PII redaction for it unless redaction_enabled is set
+  bool redaction_enabled = 10;  // force PII redaction on for this session (only ever enables, never disables)
+}