@telnyx/webrtc 2.27.1 → 2.27.2-beta.1

package/lib/src/Modules/Verto/util/interfaces.d.ts

@@ -41,6 +41,7 @@ export interface IVertoOptions {
     debugLogLevel?: 'debug' | 'info' | 'warn' | 'error';
     debugLogMaxEntries?: number;
     skipLastVoiceSdkId?: boolean;
+    skipTrailing?: boolean;
     mediaPermissionsRecovery?: {
         enabled: boolean;
         timeout: number;

package/lib/src/Modules/Verto/util/reconnect.d.ts

@@ -1,7 +1,21 @@
+import { IWebRTCCall } from '../webrtc/interfaces';
+export interface IStoredActiveCall {
+    id: IWebRTCCall['id'];
+    customHeaders: IWebRTCCall['options']['customHeaders'];
+}
+export interface IStoredActiveCalls {
+    sessionId: string;
+    calls: IStoredActiveCall[];
+    storedAt: number;
+}
 export declare const RECONNECT_SESSION_ID_MAX_AGE_MS: number;
+export declare const RECOVERY_MARKER_MAX_AGE_MS: number;
 export declare function isReconnectSessionIdFresh(now?: number): boolean;
 export declare function getReconnectToken(): string | null;
 export declare function setReconnectToken(token: string): void;
 export declare function getReconnectSessionId(now?: number): string | null;
 export declare function setReconnectSessionId(sessionId: string, storedAt?: number): void;
 export declare function clearReconnectToken(): void;
+export declare function clearActiveCallsRecoveryMarker(): void;
+export declare function getActiveCallsRecoveryMarker(now?: number): IStoredActiveCalls | null;
+export declare function setActiveCallsRecoveryMarker(calls: IStoredActiveCall[], sessionId: string, storedAt?: number): void;

package/lib/src/Modules/Verto/webrtc/BaseCall.d.ts

@@ -8,6 +8,7 @@ export default abstract class BaseCall implements IWebRTCCall {
     protected session: BrowserSession;
     private _webRTCStats;
     private _callReportCollector;
+    private _mediaDeviceCollector;
     id: string;
     recoveredCallId: string;
     state: string;
@@ -40,6 +41,7 @@ export default abstract class BaseCall implements IWebRTCCall {
     private _isRemoteDescriptionSet;
     private _signalingStateClosed;
     private _creatingPeer;
+    private _desiredAudioMuted;
     private _firstCandidateSent;
     private _firstNonHostCandidateSent;
     private _isRecovering;
@@ -57,6 +59,7 @@ export default abstract class BaseCall implements IWebRTCCall {
     get remoteStream(): MediaStream;
     get memberChannel(): string;
     get isAudioMuted(): boolean;
+    private _getLocalAudioTrackId;
     private _hasActiveUnmutedLocalAudioTrack;
     shouldForceRelayCandidateForRecovery(): boolean;
     invite(): Promise<void>;
@@ -74,6 +77,7 @@ export default abstract class BaseCall implements IWebRTCCall {
     message(to: string, body: string): void;
     muteAudio(): void;
     unmuteAudio(): void;
+    _applyDesiredAudioMuteState(): void;
     toggleAudioMute(): void;
     setAudioInDevice(deviceId: string, muted?: boolean): Promise<void>;
     muteVideo(): void;
@@ -127,6 +131,11 @@ export default abstract class BaseCall implements IWebRTCCall {
     private _init;
     protected _finalize(): void;
     private _getCallReportVoiceSdkId;
+    private _getClientSummary;
+    private _getAuthenticationType;
+    private _sanitizeIceServers;
+    private _sanitizeClientOption;
+    private _isSensitiveClientOptionKey;
     flushIntermediateCallReport(flushReason?: ICallReportFlushReason): void;
     private _flushIntermediateReport;
     private _postCallReport;

package/lib/src/Modules/Verto/webrtc/CallReportCollector.d.ts

@@ -29,17 +29,23 @@ export interface ILocalAudioSourceStats {
     echoReturnLossEnhancement?: number;
 }
 interface ICECandidateInfo {
+    id?: string;
     address?: string;
     port?: number;
     candidateType?: string;
     protocol?: string;
     networkType?: string;
+    url?: string;
+    relayProtocol?: string;
 }
 export interface IICECandidatePair {
     id?: string;
+    localCandidateId?: string;
+    remoteCandidateId?: string;
     state?: string;
     nominated?: boolean;
     writable?: boolean;
+    currentRoundTripTime?: number;
     local?: ICECandidateInfo;
     remote?: ICECandidateInfo;
     requestsSent?: number;
@@ -51,6 +57,7 @@ export interface ITransportStats {
     srtpCipher?: string;
     tlsVersion?: string;
     selectedCandidatePairChanges?: number;
+    selectedCandidatePairId?: string;
 }
 export interface ICallReportOptions {
     enabled: boolean;
@@ -73,6 +80,21 @@ export interface IStatsInterval {
             bitrateAvg?: number;
             localTrack?: ILocalAudioTrackSnapshot;
             mediaSource?: ILocalAudioSourceStats;
+            retransmittedPacketsSent?: number;
+            retransmittedBytesSent?: number;
+            headerBytesSent?: number;
+            nackCount?: number;
+            targetBitrate?: number;
+            totalPacketSendDelay?: number;
+            active?: boolean;
+            codec?: {
+                mimeType?: string;
+                clockRate?: number;
+                channels?: number;
+                payloadType?: number;
+                sdpFmtpLine?: string;
+                codecId?: string;
+            };
         };
         inbound?: {
             packetsReceived?: number;
@@ -87,10 +109,31 @@ export interface IStatsInterval {
             audioLevelAvg?: number;
             jitterAvg?: number;
             bitrateAvg?: number;
+            nackCount?: number;
+            headerBytesReceived?: number;
+            fecPacketsReceived?: number;
+            fecPacketsDiscarded?: number;
+            jitterBufferTargetDelay?: number;
+            jitterBufferMinimumDelay?: number;
+            totalSamplesDecoded?: number;
+            samplesDecodedWithSilence?: number;
+            samplesDecodedWithConcealment?: number;
+            totalAudioEnergy?: number;
+            totalSamplesDuration?: number;
+            codec?: {
+                mimeType?: string;
+                clockRate?: number;
+                channels?: number;
+                payloadType?: number;
+                sdpFmtpLine?: string;
+                codecId?: string;
+            };
         };
     };
     connection?: {
         roundTripTimeAvg?: number;
+        currentRoundTripTime?: number;
+        roundTripTimeSource?: string;
         packetsSent?: number;
         packetsReceived?: number;
         bytesSent?: number;
@@ -98,6 +141,34 @@ export interface IStatsInterval {
     };
     ice?: IICECandidatePair;
     transport?: ITransportStats;
+    mediaPlayout?: {
+        synthesizedSamples?: number;
+        synthesizedDuration?: number;
+        totalPlayoutDelay?: number;
+        totalSampleCount?: number;
+    };
+    remoteRtcp?: {
+        inbound?: {
+            packetsReceived?: number;
+            packetsLost?: number;
+            fractionLost?: number;
+            jitter?: number;
+            roundTripTime?: number;
+            totalRoundTripTime?: number;
+            roundTripTimeMeasurements?: number;
+            roundTripTimeAvg?: number;
+            nackCount?: number;
+            reportsReceived?: number;
+            packetsDiscarded?: number;
+        };
+        outbound?: {
+            packetsSent?: number;
+            bytesSent?: number;
+            reportsCount?: number;
+            roundTripTime?: number;
+            totalPacketSendDelay?: number;
+        };
+    };
 }
 export interface ICallSummary {
     callId: string;
@@ -112,7 +183,58 @@ export interface ICallSummary {
     sdkVersion?: string;
     startTimestamp?: string;
     endTimestamp?: string;
+    clientSummary?: IClientSummary;
+}
+export interface IClientSummary {
+    authentication?: {
+        type?: 'anonymous_login' | 'login_token' | 'login_password' | 'token' | 'unknown';
+        anonymousLogin?: {
+            targetType?: string;
+            targetId?: string;
+            targetVersionId?: string;
+            targetParams?: SanitizedClientOption;
+        };
+    };
+    connection?: {
+        env?: string;
+        host?: string;
+        project?: string;
+        region?: string;
+        dc?: string;
+        rtcIp?: string;
+        rtcPort?: number;
+        autoReconnect?: boolean;
+        maxReconnectAttempts?: number;
+        keepConnectionAliveOnSocketClose?: boolean;
+        hangupOnBeforeUnload?: boolean;
+        useCanaryRtcServer?: boolean;
+        skipLastVoiceSdkId?: boolean;
+        skipTrailing?: boolean;
+    };
+    media?: {
+        audio?: unknown;
+        video?: unknown;
+        mutedMicOnStart?: boolean;
+        prefetchIceCandidates?: boolean;
+        forceRelayCandidate?: boolean;
+        trickleIce?: boolean;
+        iceServers?: Array<{
+            urls?: string | string[];
+            hasUsername?: boolean;
+            hasCredential?: boolean;
+        }>;
+    };
+    callReports?: {
+        enabled?: boolean;
+        intervalMs?: number;
+        flushIntervalMs?: number;
+        debugLogLevel?: string;
+        debugLogMaxEntries?: number;
+    };
 }
+export declare type SanitizedClientOption = string | number | boolean | null | SanitizedClientOption[] | {
+    [key: string]: SanitizedClientOption;
+};
 export interface ICallReportFlushReason {
     type: 'buffer-limit' | 'manual' | 'socket-close' | 'socket-error';
     socketClose?: {
@@ -147,7 +269,6 @@ export declare class CallReportCollector {
     private previousStats;
     private previousCandidatePairSnapshot;
     private static readonly INITIAL_COLLECTION_INTERVAL_MS;
-    private static readonly INITIAL_COLLECTION_DURATION_MS;
     private readonly MAX_BUFFER_SIZE;
     private static readonly STATS_FLUSH_THRESHOLD;
     private static readonly LOGS_FLUSH_THRESHOLD;
@@ -161,6 +282,7 @@ export declare class CallReportCollector {
     private static readonly THRESHOLD_MOS;
     private static readonly THRESHOLD_LOCAL_AUDIO_LEVEL;
     private static readonly CONFIRMED_LOCAL_AUDIO_SILENCE_MS;
+    private static readonly THRESHOLD_INBOUND_AUDIO_LEVEL;
     private _breachCounters;
     private _activeWarnings;
     private _lastWarningEmitted;
@@ -199,11 +321,14 @@ export declare class CallReportCollector {
     private _trackLowLocalAudio;
     private _resetLowLocalAudioWarning;
     private _getStatsIntervalDurationMs;
+    private _trackLowInboundAudio;
     private _trackBreach;
     private _emitWarningOncePerEpisode;
     private _emitWarning;
     private _createStatsEntry;
     private _resolveCandidate;
+    private _getCodec;
+    private _buildCodecSnapshot;
     private _getOutboundMediaSource;
     private _getLocalAudioTrackSnapshot;
     private _getOutboundAudioSourceStats;

package/lib/src/Modules/Verto/webrtc/MediaDeviceCollector.d.ts

@@ -0,0 +1,11 @@
+export declare class MediaDeviceCollector {
+    private _rawDeviceCache;
+    private _deviceChangeHandler;
+    private _stopped;
+    logDevicesAtStart(): Promise<void>;
+    stop(): void;
+    private _enumerateAudioDevices;
+    private _startDeviceChangeListener;
+    private _removeDeviceChangeListener;
+    private _onDeviceChange;
+}

package/lib/src/Modules/Verto/webrtc/Peer.d.ts

@@ -40,6 +40,7 @@ export default class Peer {
     isConnectionHealthy(): boolean;
     startNegotiation(): void;
     startTrickleIceNegotiation(): Promise<void>;
+    private _emitNegotiationError;
     private _logTransceivers;
     private handleSignalingStateChangeEvent;
     private handleNegotiationNeededEvent;

package/lib/src/Modules/Verto/webrtc/VertoHandler.d.ts

@@ -8,6 +8,7 @@ declare class VertoHandler {
     private _ack;
     private reconnectDelay;
     handleMessage(msg: any): Promise<void>;
+    private isDuplicateGatewayState;
     private _retrieveCallId;
     private _handlePvtEvent;
     private _handleSessionEvent;

package/lib/src/Modules/Verto/webrtc/constants.d.ts

@@ -88,6 +88,7 @@ export declare enum GatewayStateType {
     NOREG = "NOREG",
     FAILED = "FAILED",
     FAIL_WAIT = "FAIL_WAIT",
+    TIMEOUT = "TIMEOUT",
     REGISTER = "REGISTER",
     TRYING = "TRYING",
     EXPIRED = "EXPIRED",

package/lib/src/Modules/Verto/webrtc/helpers.d.ts

@@ -9,9 +9,24 @@ declare function hasVideo(sdp: any): boolean;
 declare const assureDeviceId: (id: string, label: string, kind: MediaDeviceInfo['kind']) => Promise<string>;
 declare const removeUnsupportedConstraints: (constraints: MediaTrackConstraints) => void;
 declare const checkDeviceIdConstraints: (id: string, label: string, kind: MediaDeviceInfo['kind'], constraints: MediaTrackConstraints) => Promise<MediaTrackConstraints>;
+declare const getTrackDebugInfo: (track?: MediaStreamTrack | null) => {
+    id: string;
+    kind: string;
+    enabled: boolean;
+    muted: boolean;
+    readyState: MediaStreamTrackState;
+};
+declare const getStreamTrackDebugInfo: (stream?: MediaStream | null) => {
+    id: string;
+    kind: string;
+    enabled: boolean;
+    muted: boolean;
+    readyState: MediaStreamTrackState;
+}[];
 declare const sdpStereoHack: (sdp: string) => string;
 declare const sdpMediaOrderHack: (answer: string, localOffer: string) => string;
-declare const checkSubscribeResponse: (response: any, channel: string) => boolean;
+declare type SubscribeResponse = Record<string, string[] | undefined>;
+declare const checkSubscribeResponse: (response: SubscribeResponse, channel: string) => boolean;
 declare type DestructuredResult = {
     subscribed: string[];
     alreadySubscribed: string[];
@@ -19,7 +34,7 @@ declare type DestructuredResult = {
     unsubscribed: string[];
     notSubscribed: string[];
 };
-declare const destructSubscribeResponse: (response: any) => DestructuredResult;
+declare const destructSubscribeResponse: (response: SubscribeResponse) => DestructuredResult;
 declare const enableAudioTracks: (stream: MediaStream) => void;
 declare const disableAudioTracks: (stream: MediaStream) => void;
 declare const toggleAudioTracks: (stream: MediaStream) => void;
@@ -50,4 +65,4 @@ declare const getPreferredCodecs: (preferred_codecs?: RTCRtpCodecCapability[]) =
     audioCodecs: RTCRtpCodecCapability[];
     videoCodecs: RTCRtpCodecCapability[];
 };
-export { getUserMedia, getDevices, scanResolutions, getMediaConstraints, assureDeviceId, removeUnsupportedConstraints, checkDeviceIdConstraints, sdpStereoHack, sdpMediaOrderHack, sdpBitrateHack, sdpBitrateASHack, checkSubscribeResponse, destructSubscribeResponse, enableAudioTracks, disableAudioTracks, toggleAudioTracks, isAudioTrackEnabled, enableVideoTracks, disableVideoTracks, toggleVideoTracks, getBrowserInfo, getWebRTCInfo, getWebRTCSupportedBrowserList, createAudio, playAudio, stopAudio, hasVideo, getPreferredCodecs, isDeviceNotFoundError, getConstraintsWithoutDeviceId, };
+export { getUserMedia, getDevices, scanResolutions, getMediaConstraints, assureDeviceId, removeUnsupportedConstraints, checkDeviceIdConstraints, sdpStereoHack, sdpMediaOrderHack, sdpBitrateHack, sdpBitrateASHack, checkSubscribeResponse, destructSubscribeResponse, enableAudioTracks, disableAudioTracks, toggleAudioTracks, isAudioTrackEnabled, enableVideoTracks, disableVideoTracks, toggleVideoTracks, getBrowserInfo, getWebRTCInfo, getWebRTCSupportedBrowserList, createAudio, playAudio, stopAudio, hasVideo, getPreferredCodecs, getTrackDebugInfo, getStreamTrackDebugInfo, isDeviceNotFoundError, getConstraintsWithoutDeviceId, };

package/lib/src/Modules/Verto/webrtc/interfaces.d.ts

@@ -70,6 +70,7 @@ export interface IVertoCallOptions {
     trickleIce?: boolean;
     keepConnectionAliveOnSocketClose?: boolean;
     mutedMicOnStart?: boolean;
+    applyDesiredAudioMuteState?: () => void;
     recoveredCallId?: string;
 }
 export interface IStatsBinding {

package/lib/src/utils/interfaces.d.ts

@@ -33,6 +33,7 @@ export interface IClientOptions {
     rtcPort?: number;
     useCanaryRtcServer?: boolean;
     skipLastVoiceSdkId?: boolean;
+    skipTrailing?: boolean;
     env?: Environment;
     iceServers?: RTCIceServer[];
     mutedMicOnStart?: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@telnyx/webrtc",
-  "version": "2.27.1",
+  "version": "2.27.2-beta.1",
   "description": "Telnyx WebRTC Client",
   "keywords": [
     "telnyx",