@telnyx/webrtc 2.25.18 → 2.25.20

package/lib/packages/js/src/Modules/Verto/BaseSession.d.ts

@@ -1,4 +1,4 @@
-import * as log from 'loglevel';
+import type { Logger } from 'loglevel';
 import BaseMessage from './messages/BaseMessage';
 import Connection from './services/Connection';
 import { BroadcastParams, ILoginParams, IVertoOptions } from './util/interfaces';
@@ -17,6 +17,7 @@ export default abstract class BaseSession {
     timeoutErrorCode: number;
     invalidMethodErrorCode: number;
     authenticationRequiredErrorCode: number;
+    callReportId: string | null;
     connection: Connection;
     protected _jwtAuth: boolean;
     protected _keepAliveTimeout: any;
@@ -27,7 +28,7 @@ export default abstract class BaseSession {
     private _pong;
     private registerAgent;
     constructor(options: IVertoOptions);
-    get __logger(): log.Logger;
+    get __logger(): Logger;
     get connected(): boolean;
     getIsRegistered(): Promise<boolean>;
     get reconnectDelay(): number;

package/lib/packages/js/src/Modules/Verto/index.d.ts

@@ -6,6 +6,7 @@ export declare const VERTO_PROTOCOL = "verto-protocol";
 export default class Verto extends BrowserSession {
     relayProtocol: string;
     timeoutErrorCode: number;
+    private _vertoHandler;
     constructor(options: IVertoOptions);
     validateOptions(): boolean;
     newCall(options: IVertoCallOptions): Call;

package/lib/packages/js/src/Modules/Verto/services/Connection.d.ts

@@ -8,8 +8,9 @@ export default class Connection {
     private _timers;
     private _useCanaryRtcServer;
     private _hasCanaryBeenUsed;
-    upDur: number;
-    downDur: number;
+    private _safetyTimeoutId;
+    upDur: number | null;
+    downDur: number | null;
     constructor(session: BaseSession);
     get connected(): boolean;
     get connecting(): boolean;
@@ -17,10 +18,16 @@ export default class Connection {
     get closed(): boolean;
     get isAlive(): boolean;
     get isDead(): boolean;
+    get host(): string;
     connect(): void;
     sendRawText(request: string): void;
     send(bladeObj: any): Promise<any>;
     close(): void;
+    private _registerSocketEvents;
+    private _deregisterSocketEvents;
+    private _handleCloseTimeout;
+    private _clearSafetyTimeout;
+    private _safetyCleanupSocket;
     private _unsetTimer;
     private _handleStringResponse;
 }

package/lib/packages/js/src/Modules/Verto/util/LogCollector.d.ts

@@ -0,0 +1,30 @@
+export declare type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+export interface ILogEntry {
+    timestamp: string;
+    level: LogLevel;
+    message: string;
+    context?: Record<string, unknown>;
+}
+export interface ILogCollectorOptions {
+    enabled: boolean;
+    level: LogLevel;
+    maxEntries: number;
+}
+export declare class LogCollector {
+    private options;
+    private buffer;
+    private isCapturing;
+    constructor(options?: Partial<ILogCollectorOptions>);
+    start(): void;
+    stop(): void;
+    addEntry(level: LogLevel, message: string, context?: Record<string, unknown>): void;
+    getLogs(): ILogEntry[];
+    getLogCount(): number;
+    drain(): ILogEntry[];
+    clear(): void;
+    isActive(): boolean;
+    isEnabled(): boolean;
+}
+export declare function getGlobalLogCollector(): LogCollector | null;
+export declare function setGlobalLogCollector(collector: LogCollector | null): void;
+export declare function createLogCollector(options: Partial<ILogCollectorOptions>): LogCollector;

package/lib/packages/js/src/Modules/Verto/util/constants/index.d.ts

@@ -5,6 +5,18 @@ export declare const SESSION_ID = "sessId";
 export declare const TIME_CALL_INVITE = "Time to call invite";
 export declare const PROD_HOST = "wss://rtc.telnyx.com";
 export declare const DEV_HOST = "wss://rtcdev.telnyx.com";
+export declare const WS_CLOSE_CODES: {
+    readonly NORMAL_CLOSURE: 1000;
+    readonly GOING_AWAY: 1001;
+    readonly PROTOCOL_ERROR: 1002;
+    readonly UNSUPPORTED_DATA: 1003;
+    readonly NO_STATUS_RECEIVED: 1005;
+    readonly ABNORMAL_CLOSURE: 1006;
+    readonly INVALID_FRAME_PAYLOAD: 1007;
+    readonly POLICY_VIOLATION: 1008;
+    readonly MESSAGE_TOO_BIG: 1009;
+    readonly INTERNAL_ERROR: 1011;
+};
 export declare const GOOGLE_STUN_SERVER: {
     urls: string;
 };

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

@@ -31,6 +31,10 @@ export interface IVertoOptions {
     rtcIp?: string;
     rtcPort?: number;
     mutedMicOnStart?: boolean;
+    enableCallReports?: boolean;
+    callReportInterval?: number;
+    debugLogLevel?: 'debug' | 'info' | 'warn' | 'error';
+    debugLogMaxEntries?: number;
 }
 export interface ILoginParams {
     login?: string;

package/lib/packages/js/src/Modules/Verto/util/logger.d.ts

@@ -1,3 +1,4 @@
 import log from 'loglevel';
 declare const logger: log.Logger;
+export declare function setConsoleLoggerMinLevel(level: string): void;
 export default logger;

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

@@ -7,6 +7,7 @@ export default abstract class BaseCall implements IWebRTCCall {
     protected session: BrowserSession;
     private _isRecovering;
     private _webRTCStats;
+    private _callReportCollector;
     id: string;
     state: string;
     prevState: string;
@@ -113,6 +114,8 @@ export default abstract class BaseCall implements IWebRTCCall {
     private _execute;
     private _init;
     protected _finalize(): void;
+    private _flushIntermediateReport;
+    private _postCallReport;
     private _startStats;
     private _stopStats;
     private _doStats;

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

@@ -0,0 +1,100 @@
+import { ILogEntry } from '../../../Modules/Verto/util/LogCollector';
+export interface ICallReportOptions {
+    enabled: boolean;
+    interval: number;
+}
+export interface ILogCollectorOptions {
+    enabled: boolean;
+    level: 'debug' | 'info' | 'warn' | 'error';
+    maxEntries: number;
+}
+export interface IStatsInterval {
+    intervalStartUtc: string;
+    intervalEndUtc: string;
+    audio?: {
+        outbound?: {
+            packetsSent?: number;
+            bytesSent?: number;
+            audioLevelAvg?: number;
+            bitrateAvg?: number;
+        };
+        inbound?: {
+            packetsReceived?: number;
+            bytesReceived?: number;
+            packetsLost?: number;
+            packetsDiscarded?: number;
+            jitterBufferDelay?: number;
+            jitterBufferEmittedCount?: number;
+            totalSamplesReceived?: number;
+            concealedSamples?: number;
+            concealmentEvents?: number;
+            audioLevelAvg?: number;
+            jitterAvg?: number;
+            bitrateAvg?: number;
+        };
+    };
+    connection?: {
+        roundTripTimeAvg?: number;
+        packetsSent?: number;
+        packetsReceived?: number;
+        bytesSent?: number;
+        bytesReceived?: number;
+    };
+}
+export interface ICallSummary {
+    callId: string;
+    destinationNumber?: string;
+    callerNumber?: string;
+    direction?: 'inbound' | 'outbound';
+    state?: string;
+    durationSeconds?: number;
+    telnyxSessionId?: string;
+    telnyxLegId?: string;
+    voiceSdkSessionId?: string;
+    sdkVersion?: string;
+    startTimestamp?: string;
+    endTimestamp?: string;
+}
+export interface ICallReportPayload {
+    summary: ICallSummary;
+    stats: IStatsInterval[];
+    logs?: ILogEntry[];
+    segment?: number;
+}
+export declare class CallReportCollector {
+    private options;
+    private logCollectorOptions;
+    private peerConnection;
+    private intervalId;
+    private statsBuffer;
+    private intervalStartTime;
+    private callStartTime;
+    private callEndTime;
+    private logCollector;
+    private intervalAudioLevels;
+    private intervalJitters;
+    private intervalRTTs;
+    private intervalBitrates;
+    private previousStats;
+    private readonly MAX_BUFFER_SIZE;
+    private static readonly STATS_FLUSH_THRESHOLD;
+    private static readonly LOGS_FLUSH_THRESHOLD;
+    onFlushNeeded: (() => void) | null;
+    private _segmentIndex;
+    private _flushing;
+    constructor(options: ICallReportOptions, logCollectorOptions?: ILogCollectorOptions);
+    start(peerConnection: RTCPeerConnection): void;
+    stop(): void;
+    flush(summary: ICallSummary): ICallReportPayload | null;
+    postReport(summary: ICallSummary, callReportId: string, host: string, voiceSdkId?: string): Promise<void>;
+    sendPayload(payload: ICallReportPayload, callReportId: string, host: string, voiceSdkId?: string): Promise<void>;
+    private _sendPayload;
+    getStatsBuffer(): IStatsInterval[];
+    getLogs(): ILogEntry[];
+    cleanup(): void;
+    private _collectStats;
+    private _createStatsEntry;
+    private _getTrackAudioLevel;
+    private _average;
+    private _resetIntervalAccumulators;
+}

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

@@ -2,9 +2,9 @@ import BrowserSession from '../BrowserSession';
 declare class VertoHandler {
     session: BrowserSession;
     nodeId: string;
-    static retriedConnect: number;
-    static retriedRegister: number;
-    static receivedAuthenticationRequired: number;
+    retriedConnect: number;
+    retriedRegister: number;
+    receivedAuthenticationRequired: number;
     constructor(session: BrowserSession);
     private _ack;
     private reconnectDelay;

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

@@ -29,6 +29,8 @@ export interface IClientOptions {
     env?: Environment;
     iceServers?: RTCIceServer[];
     mutedMicOnStart?: boolean;
+    enableCallReports?: boolean;
+    callReportInterval?: number;
 }
 export interface ICallOptions {
     destinationNumber?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@telnyx/webrtc",
-  "version": "2.25.18",
+  "version": "2.25.20",
   "description": "Telnyx WebRTC Client",
   "keywords": [
     "telnyx",