@telnyx/webrtc 2.27.2-beta.0 → 2.27.2-beta.1

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

@@ -131,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/Call.d.ts

@@ -1,6 +1,5 @@
 import BaseCall from './BaseCall';
 import { IVertoCallOptions } from './interfaces';
-import type { FunctionCallOutputItem } from './AIConversationTypes';
 export declare class Call extends BaseCall {
     screenShare: Call;
     private _statsInterval;
@@ -8,7 +7,6 @@ export declare class Call extends BaseCall {
     startScreenShare(opts?: IVertoCallOptions): Promise<Call>;
     stopScreenShare(): Promise<void>;
     sendConversationMessage: (message: string, attachments?: string[]) => Promise<any>;
-    sendAIConversationMessage: (item: FunctionCallOutputItem) => void;
     setAudioOutDevice(deviceId: string): Promise<boolean>;
     protected _finalize(): void;
     private _stats;

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/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/interfaces.d.ts

@@ -140,9 +140,6 @@ export interface IWebRTCCall {
     stopScreenShare?: () => Promise<void>;
     setAudioOutDevice?: (deviceId: string) => Promise<boolean>;
     setSpeakerPhone?: (flag: boolean) => void;
-    sendConversationMessage?: (message: string, attachments?: string[]) => void;
-    sendAIConversationMessage?: (item: import('./AIConversationTypes').FunctionCallOutputItem) => void;
-    recordSessionWarning?: (code: string, name: string, message: string, activeCallIds?: string[]) => void;
 }
 export interface IWebRTCInfo {
     browserInfo: any;

package/lib/src/index.d.ts

@@ -9,5 +9,3 @@ export { TELNYX_ERROR_CODES, TELNYX_WARNING_CODES, } from './Modules/Verto/util/
 export type { ITelnyxError, ITelnyxMediaError, ITelnyxErrorEvent, ITelnyxMediaRecoveryErrorEvent, ITelnyxStandardErrorEvent, TelnyxMediaErrorCode, } from './Modules/Verto/util/errors';
 export type { ITelnyxWarning, ITelnyxWarningEvent, } from './Modules/Verto/util/constants/warnings';
 export * from './PreCallDiagnosis';
-export type { FunctionCallItem, FunctionCallOutputItem, AIConversationParams, AIConversationFunctionCallParams, AIConversationFunctionCallOutputParams, IAIConversationMessageEvent, ISendAIConversationMessageOptions, } from './Modules/Verto/webrtc/AIConversationTypes';
-export { isFunctionCallParams, isFunctionCallOutputParams, } from './Modules/Verto/webrtc/AIConversationTypes';

package/package.json

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

package/lib/src/Modules/Verto/messages/verto/AIConversationMessage.d.ts

@@ -1,6 +0,0 @@
-import BaseMessage from '../BaseMessage';
-import type { FunctionCallOutputItem } from '../../webrtc/AIConversationTypes';
-declare class AIConversationMessage extends BaseMessage {
-    constructor(item: FunctionCallOutputItem);
-}
-export { AIConversationMessage };

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

@@ -1,33 +0,0 @@
-export declare type FunctionCallItem = {
-    type: 'function_call';
-    call_id: string;
-    name: string;
-    arguments: string;
-};
-export declare type FunctionCallOutputItem = {
-    type: 'function_call_output';
-    call_id: string;
-    output: string;
-};
-export declare type AIConversationFunctionCallParams = {
-    type: 'conversation.item.created';
-    item: FunctionCallItem;
-};
-export declare type AIConversationFunctionCallOutputParams = {
-    type: 'conversation.item.create';
-    item: FunctionCallOutputItem;
-};
-export declare type AIConversationParams = AIConversationFunctionCallParams | AIConversationFunctionCallOutputParams | {
-    type: string;
-    [key: string]: unknown;
-};
-export declare type IAIConversationMessageEvent = {
-    method: 'ai_conversation';
-    params: AIConversationParams;
-    voice_sdk_id?: string;
-};
-export declare type ISendAIConversationMessageOptions = {
-    item: FunctionCallOutputItem;
-};
-export declare function isFunctionCallParams(params: AIConversationParams): params is AIConversationFunctionCallParams;
-export declare function isFunctionCallOutputParams(params: AIConversationParams): params is AIConversationFunctionCallOutputParams;