@stream-io/video-client 1.18.9 → 1.19.1

package/dist/src/Call.d.ts

@@ -81,6 +81,7 @@ export declare class Call {
     private readonly reconnectConcurrencyTag;
     private reconnectAttempts;
     private reconnectStrategy;
+    private reconnectReason;
     private fastReconnectDeadlineSeconds;
     private disconnectionTimeoutSeconds;
     private lastOfflineTimestamp;
@@ -265,6 +266,7 @@ export declare class Call {
      *
      * @internal
      * @param sfuClient the SFU client instance that was closed.
+     * @param reason the reason for the closure.
      */
     private handleSfuSignalClose;
     /**
@@ -273,6 +275,7 @@ export declare class Call {
      * @internal
      *
      * @param strategy the reconnection strategy to use.
+     * @param reason the reason for the reconnection.
      */
     private reconnect;
     /**

package/dist/src/StreamSfuClient.d.ts

@@ -4,6 +4,7 @@ import { ICERestartRequest, SendAnswerRequest, SendStatsRequest, SetPublisherReq
 import { ICETrickle } from './gen/video/sfu/models/models';
 import { StreamClient } from './coordinator/connection/client';
 import { Credentials } from './gen/coordinator';
+import { TraceSlice } from './stats';
 export type StreamSfuClientConstructor = {
     /**
      * The event dispatcher instance to use.
@@ -29,11 +30,15 @@ export type StreamSfuClientConstructor = {
     /**
      * Callback for when the WebSocket connection is closed.
      */
-    onSignalClose?: () => void;
+    onSignalClose?: (reason: string) => void;
     /**
      * The StreamClient instance to use for the connection.
      */
     streamClient: StreamClient;
+    /**
+     * Flag to enable tracing.
+     */
+    enableTracing: boolean;
 };
 /**
  * The client used for exchanging information with the SFU.
@@ -72,6 +77,7 @@ export declare class StreamSfuClient {
     private pingIntervalInMs;
     private unhealthyTimeoutInMs;
     private lastMessageTimestamp?;
+    private readonly tracer?;
     private readonly unsubscribeIceTrickle;
     private readonly unsubscribeNetworkChanged;
     private readonly onSignalClose;
@@ -115,7 +121,7 @@ export declare class StreamSfuClient {
     /**
      * Constructs a new SFU client.
      */
-    constructor({ dispatcher, credentials, sessionId, logTag, joinResponseTimeout, onSignalClose, streamClient, }: StreamSfuClientConstructor);
+    constructor({ dispatcher, credentials, sessionId, logTag, joinResponseTimeout, onSignalClose, streamClient, enableTracing, }: StreamSfuClientConstructor);
     private createWebSocket;
     private cleanUpWebSocket;
     get isHealthy(): boolean;
@@ -123,6 +129,7 @@ export declare class StreamSfuClient {
     private handleWebSocketClose;
     close: (code?: number, reason?: string) => void;
     private dispose;
+    getTrace: () => TraceSlice | undefined;
     leaveAndClose: (reason: string) => Promise<void>;
     updateSubscriptions: (tracks: TrackSubscriptionDetails[]) => Promise<import("@protobuf-ts/runtime-rpc").FinishedUnaryCall<import("./gen/video/sfu/signal_rpc/signal").UpdateSubscriptionsRequest, import("./gen/video/sfu/signal_rpc/signal").UpdateSubscriptionsResponse>>;
     setPublisher: (data: Omit<SetPublisherRequest, "sessionId">) => Promise<import("@protobuf-ts/runtime-rpc").FinishedUnaryCall<SetPublisherRequest, import("./gen/video/sfu/signal_rpc/signal").SetPublisherResponse>>;

package/dist/src/gen/coordinator/index.d.ts

@@ -720,6 +720,180 @@ export interface CallEvent {
      */
     type: string;
 }
+/**
+ * This event is sent when frame recording has failed
+ * @export
+ * @interface CallFrameRecordingFailedEvent
+ */
+export interface CallFrameRecordingFailedEvent {
+    /**
+     *
+     * @type {CallResponse}
+     * @memberof CallFrameRecordingFailedEvent
+     */
+    call: CallResponse;
+    /**
+     *
+     * @type {string}
+     * @memberof CallFrameRecordingFailedEvent
+     */
+    call_cid: string;
+    /**
+     *
+     * @type {string}
+     * @memberof CallFrameRecordingFailedEvent
+     */
+    created_at: string;
+    /**
+     *
+     * @type {string}
+     * @memberof CallFrameRecordingFailedEvent
+     */
+    egress_id: string;
+    /**
+     * The type of event: "call.frame_recording_failed" in this case
+     * @type {string}
+     * @memberof CallFrameRecordingFailedEvent
+     */
+    type: string;
+}
+/**
+ * This event is sent when a frame is captured from a call
+ * @export
+ * @interface CallFrameRecordingFrameReadyEvent
+ */
+export interface CallFrameRecordingFrameReadyEvent {
+    /**
+     *
+     * @type {string}
+     * @memberof CallFrameRecordingFrameReadyEvent
+     */
+    call_cid: string;
+    /**
+     * The time the frame was captured
+     * @type {string}
+     * @memberof CallFrameRecordingFrameReadyEvent
+     */
+    captured_at: string;
+    /**
+     *
+     * @type {string}
+     * @memberof CallFrameRecordingFrameReadyEvent
+     */
+    created_at: string;
+    /**
+     *
+     * @type {string}
+     * @memberof CallFrameRecordingFrameReadyEvent
+     */
+    egress_id: string;
+    /**
+     * Call session ID
+     * @type {string}
+     * @memberof CallFrameRecordingFrameReadyEvent
+     */
+    session_id: string;
+    /**
+     * The type of the track frame was captured from (TRACK_TYPE_VIDEO|TRACK_TYPE_SCREEN_SHARE)
+     * @type {string}
+     * @memberof CallFrameRecordingFrameReadyEvent
+     */
+    track_type: string;
+    /**
+     * The type of event: "call.frame_recording_ready" in this case
+     * @type {string}
+     * @memberof CallFrameRecordingFrameReadyEvent
+     */
+    type: string;
+    /**
+     * The URL of the frame
+     * @type {string}
+     * @memberof CallFrameRecordingFrameReadyEvent
+     */
+    url: string;
+    /**
+     * The users in the frame
+     * @type {{ [key: string]: UserResponse; }}
+     * @memberof CallFrameRecordingFrameReadyEvent
+     */
+    users: {
+        [key: string]: UserResponse;
+    };
+}
+/**
+ * This event is sent when frame recording has started
+ * @export
+ * @interface CallFrameRecordingStartedEvent
+ */
+export interface CallFrameRecordingStartedEvent {
+    /**
+     *
+     * @type {CallResponse}
+     * @memberof CallFrameRecordingStartedEvent
+     */
+    call: CallResponse;
+    /**
+     *
+     * @type {string}
+     * @memberof CallFrameRecordingStartedEvent
+     */
+    call_cid: string;
+    /**
+     *
+     * @type {string}
+     * @memberof CallFrameRecordingStartedEvent
+     */
+    created_at: string;
+    /**
+     *
+     * @type {string}
+     * @memberof CallFrameRecordingStartedEvent
+     */
+    egress_id: string;
+    /**
+     * The type of event: "call.frame_recording_started" in this case
+     * @type {string}
+     * @memberof CallFrameRecordingStartedEvent
+     */
+    type: string;
+}
+/**
+ * This event is sent when frame recording has stopped
+ * @export
+ * @interface CallFrameRecordingStoppedEvent
+ */
+export interface CallFrameRecordingStoppedEvent {
+    /**
+     *
+     * @type {CallResponse}
+     * @memberof CallFrameRecordingStoppedEvent
+     */
+    call: CallResponse;
+    /**
+     *
+     * @type {string}
+     * @memberof CallFrameRecordingStoppedEvent
+     */
+    call_cid: string;
+    /**
+     *
+     * @type {string}
+     * @memberof CallFrameRecordingStoppedEvent
+     */
+    created_at: string;
+    /**
+     *
+     * @type {string}
+     * @memberof CallFrameRecordingStoppedEvent
+     */
+    egress_id: string;
+    /**
+     * The type of event: "call.frame_recording_stopped" in this case
+     * @type {string}
+     * @memberof CallFrameRecordingStoppedEvent
+     */
+    type: string;
+}
 /**
  * This event is sent when HLS broadcasting has failed
  * @export
@@ -1217,6 +1391,12 @@ export interface CallRecording {
      * @memberof CallRecording
      */
     filename: string;
+    /**
+     *
+     * @type {string}
+     * @memberof CallRecording
+     */
+    session_id: string;
     /**
      *
      * @type {string}
@@ -1385,7 +1565,7 @@ export interface CallRejectedEvent {
      */
     created_at: string;
     /**
-     *
+     * Provides information about why the call was rejected. You can provide any value, but the Stream API and SDKs use these default values: rejected, cancel, timeout and busy
      * @type {string}
      * @memberof CallRejectedEvent
      */
@@ -3301,6 +3481,12 @@ export interface EgressResponse {
      * @memberof EgressResponse
      */
     broadcasting: boolean;
+    /**
+     *
+     * @type {FrameRecordingResponse}
+     * @memberof EgressResponse
+     */
+    frame_recording?: FrameRecordingResponse;
     /**
      *
      * @type {EgressHLSResponse}
@@ -3327,6 +3513,38 @@ export interface EndCallResponse {
      */
     duration: string;
 }
+/**
+ *
+ * @export
+ * @interface FPSStats
+ */
+export interface FPSStats {
+    /**
+     *
+     * @type {number}
+     * @memberof FPSStats
+     */
+    average_fps: number;
+    /**
+     *
+     * @type {number}
+     * @memberof FPSStats
+     */
+    tracked: number;
+}
+/**
+ *
+ * @export
+ * @interface FrameRecordingResponse
+ */
+export interface FrameRecordingResponse {
+    /**
+     *
+     * @type {string}
+     * @memberof FrameRecordingResponse
+     */
+    status: string;
+}
 /**
  *
  * @export
@@ -3350,7 +3568,7 @@ export interface FrameRecordingSettingsRequest {
      * @type {string}
      * @memberof FrameRecordingSettingsRequest
      */
-    quality?: string;
+    quality?: FrameRecordingSettingsRequestQualityEnum;
 }
 /**
  * @export
@@ -3361,6 +3579,17 @@ export declare const FrameRecordingSettingsRequestModeEnum: {
     readonly AUTO_ON: "auto-on";
 };
 export type FrameRecordingSettingsRequestModeEnum = (typeof FrameRecordingSettingsRequestModeEnum)[keyof typeof FrameRecordingSettingsRequestModeEnum];
+/**
+ * @export
+ */
+export declare const FrameRecordingSettingsRequestQualityEnum: {
+    readonly _360P: "360p";
+    readonly _480P: "480p";
+    readonly _720P: "720p";
+    readonly _1080P: "1080p";
+    readonly _1440P: "1440p";
+};
+export type FrameRecordingSettingsRequestQualityEnum = (typeof FrameRecordingSettingsRequestQualityEnum)[keyof typeof FrameRecordingSettingsRequestQualityEnum];
 /**
  *
  * @export
@@ -3567,6 +3796,12 @@ export interface GetCallStatsResponse {
      * @memberof GetCallStatsResponse
      */
     duration: string;
+    /**
+     *
+     * @type {boolean}
+     * @memberof GetCallStatsResponse
+     */
+    is_truncated_report: boolean;
     /**
      *
      * @type {TimeStats}
@@ -5394,19 +5629,19 @@ export interface Response {
  */
 export interface RingSettingsRequest {
     /**
-     *
+     * When none of the callees accept a ring call in this time a rejection will be sent by the caller with reason 'timeout' by the SDKs
      * @type {number}
      * @memberof RingSettingsRequest
      */
     auto_cancel_timeout_ms: number;
     /**
-     *
+     * When a callee is online but doesn't answer a ring call in this time a rejection will be sent with reason 'timeout' by the SDKs
      * @type {number}
      * @memberof RingSettingsRequest
      */
     incoming_call_timeout_ms: number;
     /**
-     *
+     * When a callee doesn't accept or reject a ring call in this time a missed call event will be sent
      * @type {number}
      * @memberof RingSettingsRequest
      */
@@ -5869,6 +6104,12 @@ export interface StartTranscriptionResponse {
  * @interface StatsOptions
  */
 export interface StatsOptions {
+    /**
+     *
+     * @type {boolean}
+     * @memberof StatsOptions
+     */
+    enable_rtc_stats: boolean;
     /**
      *
      * @type {number}
@@ -6989,6 +7230,12 @@ export interface UserSessionStats {
      * @memberof UserSessionStats
      */
     distance_to_sfu_kilometers?: number;
+    /**
+     *
+     * @type {FPSStats}
+     * @memberof UserSessionStats
+     */
+    fps?: FPSStats;
     /**
      *
      * @type {number}
@@ -7262,6 +7509,12 @@ export interface UserSessionStats {
  * @interface UserStats
  */
 export interface UserStats {
+    /**
+     *
+     * @type {string}
+     * @memberof UserStats
+     */
+    feedback?: string;
     /**
      *
      * @type {UserInfoResponse}
@@ -7369,6 +7622,14 @@ export type VideoEvent = ({
 } & CallDeletedEvent) | ({
     type: 'call.ended';
 } & CallEndedEvent) | ({
+    type: 'call.frame_recording_failed';
+} & CallFrameRecordingFailedEvent) | ({
+    type: 'call.frame_recording_ready';
+} & CallFrameRecordingFrameReadyEvent) | ({
+    type: 'call.frame_recording_started';
+} & CallFrameRecordingStartedEvent) | ({
+    type: 'call.frame_recording_stopped';
+} & CallFrameRecordingStoppedEvent) | ({
     type: 'call.hls_broadcasting_failed';
 } & CallHLSBroadcastingFailedEvent) | ({
     type: 'call.hls_broadcasting_started';

package/dist/src/gen/google/protobuf/struct.d.ts

@@ -1,6 +1,4 @@
-import type { JsonValue } from '@protobuf-ts/runtime';
-import type { JsonReadOptions } from '@protobuf-ts/runtime';
-import type { JsonWriteOptions } from '@protobuf-ts/runtime';
+import type { JsonReadOptions, JsonValue, JsonWriteOptions } from '@protobuf-ts/runtime';
 import { MessageType } from '@protobuf-ts/runtime';
 /**
  * `Struct` represents a structured data value, consisting of fields

package/dist/src/gen/google/protobuf/timestamp.d.ts

@@ -1,6 +1,4 @@
-import type { JsonValue } from '@protobuf-ts/runtime';
-import type { JsonReadOptions } from '@protobuf-ts/runtime';
-import type { JsonWriteOptions } from '@protobuf-ts/runtime';
+import type { JsonReadOptions, JsonValue, JsonWriteOptions } from '@protobuf-ts/runtime';
 import { MessageType } from '@protobuf-ts/runtime';
 /**
  * A Timestamp represents a point in time independent of any time zone or local

package/dist/src/gen/video/sfu/event/events.d.ts

@@ -491,6 +491,12 @@ export interface ReconnectDetails {
      * @generated from protobuf field: string previous_session_id = 7;
      */
     previousSessionId: string;
+    /**
+     * the reconnect reason
+     *
+     * @generated from protobuf field: string reason = 8;
+     */
+    reason: string;
 }
 /**
  * @generated from protobuf message stream.video.sfu.event.Migration

package/dist/src/gen/video/sfu/models/models.d.ts

@@ -464,6 +464,45 @@ export interface Browser {
      */
     version: string;
 }
+/**
+ * @generated from protobuf message stream.video.sfu.models.RTMPIngress
+ */
+export interface RTMPIngress {
+    /**
+     * Video dimensions and frame rate
+     *
+     * @generated from protobuf field: uint32 width = 1;
+     */
+    width: number;
+    /**
+     * @generated from protobuf field: uint32 height = 2;
+     */
+    height: number;
+    /**
+     * @generated from protobuf field: double frame_rate = 3;
+     */
+    frameRate: number;
+    /**
+     * Client info
+     *
+     * @generated from protobuf field: string software = 4;
+     */
+    software: string;
+    /**
+     * @generated from protobuf field: string version = 5;
+     */
+    version: string;
+    /**
+     * @generated from protobuf field: string encoder = 6;
+     */
+    encoder: string;
+    /**
+     * Connection info
+     *
+     * @generated from protobuf field: string remote_addr = 7;
+     */
+    remoteAddr: string;
+}
 /**
  * @generated from protobuf message stream.video.sfu.models.Device
  */
@@ -1101,6 +1140,13 @@ declare class Browser$Type extends MessageType<Browser> {
  * @generated MessageType for protobuf message stream.video.sfu.models.Browser
  */
 export declare const Browser: Browser$Type;
+declare class RTMPIngress$Type extends MessageType<RTMPIngress> {
+    constructor();
+}
+/**
+ * @generated MessageType for protobuf message stream.video.sfu.models.RTMPIngress
+ */
+export declare const RTMPIngress: RTMPIngress$Type;
 declare class Device$Type extends MessageType<Device> {
     constructor();
 }

package/dist/src/gen/video/sfu/signal_rpc/signal.d.ts

@@ -1,4 +1,4 @@
-import { AndroidState, AppleState, Error, InputDevices, PeerType, TrackInfo, TrackType, VideoDimension, WebsocketReconnectStrategy } from '../models/models';
+import { AndroidState, AppleState, Error, InputDevices, PeerType, RTMPIngress, TrackInfo, TrackType, VideoDimension, WebsocketReconnectStrategy } from '../models/models';
 import { ServiceType } from '@protobuf-ts/runtime-rpc';
 import { MessageType } from '@protobuf-ts/runtime';
 /**
@@ -131,6 +131,18 @@ export interface SendStatsRequest {
      * @generated from protobuf field: stream.video.sfu.signal.Telemetry telemetry = 11;
      */
     telemetry?: Telemetry;
+    /**
+     * @generated from protobuf field: stream.video.sfu.models.RTMPIngress rtmp = 12;
+     */
+    rtmp?: RTMPIngress;
+    /**
+     * @generated from protobuf field: string subscriber_rtc_stats = 13;
+     */
+    subscriberRtcStats: string;
+    /**
+     * @generated from protobuf field: string publisher_rtc_stats = 14;
+     */
+    publisherRtcStats: string;
 }
 /**
  * @generated from protobuf message stream.video.sfu.signal.SendStatsResponse

package/dist/src/rpc/createClient.d.ts

@@ -2,8 +2,10 @@ import { RpcInterceptor } from '@protobuf-ts/runtime-rpc';
 import { TwirpOptions } from '@protobuf-ts/twirp-transport';
 import { SignalServerClient } from '../gen/video/sfu/signal_rpc/signal.client';
 import { Logger, LogLevel } from '../coordinator/connection/types';
+import type { Trace } from '../stats/rtc/types';
 export declare const withHeaders: (headers: Record<string, string>) => RpcInterceptor;
 export declare const withRequestLogger: (logger: Logger, level: LogLevel) => RpcInterceptor;
+export declare const withRequestTracer: (trace: Trace) => RpcInterceptor;
 /**
  * Creates new SignalServerClient instance.
  *

package/dist/src/rtc/BasePeerConnection.d.ts

@@ -3,13 +3,15 @@ import { CallState } from '../store';
 import { PeerType } from '../gen/video/sfu/models/models';
 import { StreamSfuClient } from '../StreamSfuClient';
 import { AllSfuEvents, Dispatcher } from './Dispatcher';
+import { TraceSlice } from '../stats';
 export type BasePeerConnectionOpts = {
     sfuClient: StreamSfuClient;
     state: CallState;
     connectionConfig?: RTCConfiguration;
     dispatcher: Dispatcher;
-    onUnrecoverableError?: () => void;
+    onUnrecoverableError?: (reason: string) => void;
     logTag: string;
+    enableTracing: boolean;
 };
 /**
  * A base class for the `Publisher` and `Subscriber` classes.
@@ -22,15 +24,16 @@ export declare abstract class BasePeerConnection {
     protected readonly state: CallState;
     protected readonly dispatcher: Dispatcher;
     protected sfuClient: StreamSfuClient;
-    protected onUnrecoverableError?: () => void;
+    protected onUnrecoverableError?: (reason: string) => void;
     protected isIceRestarting: boolean;
     private isDisposed;
+    private readonly tracer?;
     private readonly subscriptions;
     private unsubscribeIceTrickle?;
     /**
      * Constructs a new `BasePeerConnection` instance.
      */
-    protected constructor(peerType: PeerType, { sfuClient, connectionConfig, state, dispatcher, onUnrecoverableError, logTag, }: BasePeerConnectionOpts);
+    protected constructor(peerType: PeerType, { sfuClient, connectionConfig, state, dispatcher, onUnrecoverableError, logTag, enableTracing, }: BasePeerConnectionOpts);
     /**
      * Disposes the `RTCPeerConnection` instance.
      */
@@ -63,6 +66,10 @@ export declare abstract class BasePeerConnection {
      * @param selector an optional `MediaStreamTrack` to get the stats for.
      */
     getStats: (selector?: MediaStreamTrack | null) => Promise<RTCStatsReport>;
+    /**
+     * Returns the current tracing buffer.
+     */
+    getTrace: () => TraceSlice | undefined;
     /**
      * Handles the ICECandidate event and
      * Initiates an ICE Trickle process with the SFU.

package/dist/src/stats/index.d.ts

@@ -1,3 +1,5 @@
 export * from './CallStateStatsReporter';
 export * from './SfuStatsReporter';
 export * from './types';
+export * from './utils';
+export * from './rtc';

package/dist/src/stats/rtc/Tracer.d.ts

@@ -0,0 +1,15 @@
+import type { Trace, TraceRecord } from './types';
+export type TraceSlice = {
+    snapshot: TraceRecord[];
+    rollback: () => void;
+};
+export declare class Tracer {
+    private buffer;
+    private enabled;
+    private readonly id;
+    constructor(id: string | null);
+    setEnabled: (enabled: boolean) => void;
+    trace: Trace;
+    take: () => TraceSlice;
+    dispose: () => void;
+}

package/dist/src/stats/rtc/index.d.ts

@@ -0,0 +1,2 @@
+export * from './pc';
+export * from './Tracer';

package/dist/src/stats/rtc/mediaDevices.d.ts

@@ -0,0 +1,2 @@
+import { Tracer } from './Tracer';
+export declare const tracer: Tracer;

package/dist/src/stats/rtc/pc.d.ts

@@ -0,0 +1,2 @@
+import type { Trace } from './types';
+export declare const traceRTCPeerConnection: (pc: RTCPeerConnection, trace: Trace) => void;

package/dist/src/stats/rtc/types.d.ts

@@ -0,0 +1,8 @@
+export type RTCStatsDataType = RTCConfiguration | RTCIceCandidate | RTCSignalingState | RTCIceConnectionState | RTCIceGatheringState | RTCPeerConnectionState | [number | null | string] | string | RTCOfferOptions | [string | RTCDataChannelInit | undefined] | (RTCOfferOptions | undefined) | RTCSessionDescriptionInit | (RTCIceCandidateInit | RTCIceCandidate) | object | null | undefined;
+export type Trace = (tag: string, data: RTCStatsDataType) => void;
+export type TraceRecord = [
+    tag: string,
+    id: string | null,
+    data: RTCStatsDataType,
+    timestamp: number
+];

package/index.ts

@@ -1,5 +1,9 @@
 import 'webrtc-adapter';
 
+// side effect: we patch the mediaDevices APIs here
+// so we can intercept invocations and collect statistics
+import './src/stats/rtc/mediaDevices';
+
 export * from './src/gen/coordinator';
 export * from './src/coordinator/connection/types';
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stream-io/video-client",
-  "version": "1.18.9",
+  "version": "1.19.1",
   "main": "dist/index.cjs.js",
   "module": "dist/index.es.js",
   "browser": "dist/index.browser.es.js",