@telnyx/webrtc 2.27.4-beta.0 → 2.27.4-beta.2

package/lib/src/Modules/Verto/BrowserSession.d.ts

@@ -25,9 +25,6 @@ export default abstract class BrowserSession extends BaseSession {
     private _previousAudioConstraints;
     protected _videoConstraints: boolean | MediaTrackConstraints;
     protected _speaker: string;
-    private _onlineHandler;
-    private _offlineHandler;
-    private _wasOffline;
     constructor(options: IVertoOptions);
     getIsRegistered(): Promise<boolean>;
     connect(): Promise<void>;
@@ -62,7 +59,5 @@ export default abstract class BrowserSession extends BaseSession {
     vertoBroadcast({ nodeId, channel: eventChannel, data, }: BroadcastParams): void;
     vertoSubscribe({ nodeId, channels: eventChannel, handler, }: SubscribeParams): Promise<any>;
     vertoUnsubscribe({ nodeId, channels: eventChannel, }: SubscribeParams): Promise<any>;
-    private _setupNetworkListeners;
-    private _cleanupNetworkListeners;
     static telnyxStateCall(call: Call): Call;
 }

package/lib/src/Modules/Verto/services/SignalingHealthMonitor.d.ts

@@ -6,6 +6,9 @@ export default class SignalingHealthMonitor {
     private _probeInFlight;
     private _intervalId;
     private _pendingMediaRecovery;
+    private _browserWasOffline;
+    private _onlineHandler;
+    private _offlineHandler;
     private static readonly CRITICAL_METHODS;
     static isCriticalMethod(method: string): boolean;
     constructor(_session: ISignalingHealthSession);
@@ -19,6 +22,8 @@ export default class SignalingHealthMonitor {
     onRequestTimeout(requestId: string, timeoutMs: number, method?: string): void;
     onPeerFailure(callId: string, evidence: PeerFailureEvidence): void;
     onNoRtp(callId: string, direction: 'inbound' | 'outbound'): void;
+    private _setupBrowserListeners;
+    private _cleanupBrowserListeners;
     onIceRestartFailed(callId: string): void;
     private _check;
     private _sendProbe;

package/lib/src/Modules/Verto/util/constants/errorCodes.d.ts

@@ -33,6 +33,8 @@ export declare const TELNYX_WARNING_CODES: {
     readonly LOW_INBOUND_AUDIO: 31006;
     readonly LOW_BYTES_RECEIVED: 32001;
     readonly LOW_BYTES_SENT: 32002;
+    readonly RECORDING_UNAVAILABLE: 32003;
+    readonly RECORDING_BUFFER_OVERFLOW: 32004;
     readonly ICE_CONNECTIVITY_LOST: 33001;
     readonly ICE_GATHERING_TIMEOUT: 33002;
     readonly ICE_GATHERING_EMPTY: 33003;
@@ -50,5 +52,5 @@ export declare const TELNYX_WARNING_CODES: {
     readonly RECONNECTION_FAILED_WITH_NO_AUTO_RECONNECT: 36005;
 };
 export declare const SDP_CREATE_OFFER_FAILED: 40001, SDP_CREATE_ANSWER_FAILED: 40002, SDP_SET_LOCAL_DESCRIPTION_FAILED: 40003, SDP_SET_REMOTE_DESCRIPTION_FAILED: 40004, SDP_SEND_FAILED: 40005, MEDIA_MICROPHONE_PERMISSION_DENIED: 42001, MEDIA_DEVICE_NOT_FOUND: 42002, MEDIA_GET_USER_MEDIA_FAILED: 42003, HOLD_FAILED: 44001, INVALID_CALL_PARAMETERS: 44002, BYE_SEND_FAILED: 44003, SUBSCRIBE_FAILED: 44004, PEER_CLOSED_DURING_INIT: 44005, WEBSOCKET_CONNECTION_FAILED: 45001, WEBSOCKET_ERROR: 45002, RECONNECTION_EXHAUSTED: 45003, GATEWAY_FAILED: 45004, LOGIN_FAILED: 46001, INVALID_CREDENTIALS: 46002, AUTHENTICATION_REQUIRED: 46003, ICE_RESTART_FAILED: 47001, NETWORK_OFFLINE: 48001, SESSION_NOT_REATTACHED: 48501, UNEXPECTED_ERROR: 49001;
-export declare const HIGH_RTT: 31001, HIGH_JITTER: 31002, HIGH_PACKET_LOSS: 31003, LOW_MOS: 31004, LOW_LOCAL_AUDIO: 31005, LOW_INBOUND_AUDIO: 31006, LOW_BYTES_RECEIVED: 32001, LOW_BYTES_SENT: 32002, ICE_CONNECTIVITY_LOST: 33001, ICE_GATHERING_TIMEOUT: 33002, ICE_GATHERING_EMPTY: 33003, PEER_CONNECTION_FAILED: 33004, ONLY_HOST_ICE_CANDIDATES: 33005, ANSWER_WHILE_PEER_ACTIVE: 33006, ICE_CANDIDATE_PAIR_CHANGED: 33008, AUDIO_INPUT_DEVICE_CHANGE_SKIPPED: 33009, MULTIPLE_ACTIVE_CALLS_DETECTED: 33010, DUPLICATE_INBOUND_ANSWER: 33007, TOKEN_EXPIRING_SOON: 34001, UNKNOWN_REATTACHED_SESSION: 35002, SIGNALING_RECOVERY_REQUIRED: 36003, MEDIA_RECOVERY_REQUIRED: 36004, RECONNECTION_FAILED_WITH_NO_AUTO_RECONNECT: 36005;
+export declare const HIGH_RTT: 31001, HIGH_JITTER: 31002, HIGH_PACKET_LOSS: 31003, LOW_MOS: 31004, LOW_LOCAL_AUDIO: 31005, LOW_INBOUND_AUDIO: 31006, LOW_BYTES_RECEIVED: 32001, LOW_BYTES_SENT: 32002, RECORDING_UNAVAILABLE: 32003, RECORDING_BUFFER_OVERFLOW: 32004, ICE_CONNECTIVITY_LOST: 33001, ICE_GATHERING_TIMEOUT: 33002, ICE_GATHERING_EMPTY: 33003, PEER_CONNECTION_FAILED: 33004, ONLY_HOST_ICE_CANDIDATES: 33005, ANSWER_WHILE_PEER_ACTIVE: 33006, ICE_CANDIDATE_PAIR_CHANGED: 33008, AUDIO_INPUT_DEVICE_CHANGE_SKIPPED: 33009, MULTIPLE_ACTIVE_CALLS_DETECTED: 33010, DUPLICATE_INBOUND_ANSWER: 33007, TOKEN_EXPIRING_SOON: 34001, UNKNOWN_REATTACHED_SESSION: 35002, SIGNALING_RECOVERY_REQUIRED: 36003, MEDIA_RECOVERY_REQUIRED: 36004, RECONNECTION_FAILED_WITH_NO_AUTO_RECONNECT: 36005;
 export declare const HAS_NON_HOST_ICE_CANDIDATE_REGEX: RegExp;

package/lib/src/Modules/Verto/util/constants/warnings.d.ts

@@ -68,6 +68,20 @@ export declare const SDK_WARNINGS: {
         readonly causes: readonly ["Microphone muted or disconnected", "Network interruption", "Local media track ended"];
         readonly solutions: readonly ["Check that the microphone is not muted", "Verify the microphone is still connected", "Check network connectivity"];
     };
+    readonly 32003: {
+        readonly name: "RECORDING_UNAVAILABLE";
+        readonly message: "Call recording is not available in this browser";
+        readonly description: "Call recording was enabled (enableCallRecording is true), but the browser does not support MediaStreamTrackProcessor (required to capture raw audio PCM). Recording is disabled for this call; the call proceeds normally. Currently affects Firefox and older Chromium (< 94).";
+        readonly causes: readonly ["Browser does not implement MediaStreamTrackProcessor (Firefox, Safari)", "Chromium version older than 94", "Recording enabled on an unsupported platform"];
+        readonly solutions: readonly ["Use a recent Chromium-based browser (Chrome 94+, Edge 94+) to capture recordings", "Disable enableCallRecording if recording is not required for this deployment", "See the enableCallRecording JSDoc for platform support details"];
+    };
+    readonly 32004: {
+        readonly name: "RECORDING_BUFFER_OVERFLOW";
+        readonly message: "Call recording buffer overflow — oldest packets dropped";
+        readonly description: "The in-memory call recording buffer reached its maxBufferBytes cap before the next scheduled flush. The oldest captured RTP packets were dropped to keep memory bounded. This indicates the flush interval is too long for the call audio rate, or the upload endpoint is slow/unreachable. The recording continues with the remaining (newer) packets.";
+        readonly causes: readonly ["Flush interval (callRecordingFlushIntervalMs) is larger than the buffer can hold at the current audio rate", "Upload endpoint (/call_recording) is slow or unreachable, so intermediate flushes back up", "A very long call with high sample rate filling the buffer between flushes"];
+        readonly solutions: readonly ["Reduce callRecordingFlushIntervalMs so flushes happen more frequently", "Increase callRecordingMaxBufferBytes if memory headroom allows", "Check the /call_recording endpoint health and network path to voice-sdk-proxy"];
+    };
     readonly 33001: {
         readonly name: "ICE_CONNECTIVITY_LOST";
         readonly message: "Connection interrupted";

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

@@ -38,6 +38,12 @@ export interface IVertoOptions {
     enableCallReports?: boolean;
     callReportInterval?: number;
     callReportFlushInterval?: number;
+    enableCallRecording?: boolean;
+    callRecordingFlushIntervalMs?: number;
+    callRecordingMaxBufferBytes?: number;
+    callRecordingSampleRate?: number;
+    callRecordingTracks?: Array<'local' | 'remote'>;
+    callRecordingEndpoint?: string;
     debugLogLevel?: 'debug' | 'info' | 'warn' | 'error';
     debugLogMaxEntries?: number;
     skipLastVoiceSdkId?: boolean;

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

@@ -26,8 +26,6 @@ export declare type IAIConversationMessageEvent = {
     params: AIConversationParams;
     voice_sdk_id?: string;
 };
-export declare type ISendAIConversationMessageOptions = {
-    item: FunctionCallOutputItem;
-};
+export declare type ISendAIConversationMessageOptions = FunctionCallOutputItem;
 export declare function isFunctionCallParams(params: AIConversationParams): params is AIConversationFunctionCallParams;
 export declare function isFunctionCallOutputParams(params: AIConversationParams): params is AIConversationFunctionCallOutputParams;

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 _callRecorder;
     private _mediaDeviceCollector;
     id: string;
     recoveredCallId: string;
@@ -125,9 +126,6 @@ export default abstract class BaseCall implements IWebRTCCall {
     private _dispatchNotification;
     private _execute;
     private _registerInboundAnswerAttempt;
-    private _getSessionInboundAnswerCalls;
-    private _isBlockingInboundAnswer;
-    private _hasUsablePeerConnection;
     private _init;
     protected _finalize(): void;
     private _getCallReportVoiceSdkId;

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

@@ -0,0 +1,96 @@
+import { type ITelnyxWarning } from '../util/constants/warnings';
+export interface IRecordingPacket {
+    rtpSeq: number;
+    rtpTs: number;
+    rtpSsrc: number;
+    capturedAt: string;
+    payloadBytes: Uint8Array;
+}
+export declare type RecordingTrackKind = 'local' | 'remote';
+export interface ICallRecordingOptions {
+    enabled: boolean;
+    flushIntervalMs?: number;
+    maxBufferBytes?: number;
+    sampleRate?: number;
+    tracks?: RecordingTrackKind[];
+    endpoint?: string;
+    fetchImpl?: typeof fetch;
+}
+export interface ICallRecordingContext {
+    callId: string;
+    sessionId?: string;
+    voiceSdkId?: string;
+    callReportId: string;
+    host?: string;
+    recordingId?: string;
+}
+export interface ICallRecordingEnvelope {
+    call_report_id: string;
+    call_id: string;
+    voice_sdk_id?: string;
+    recording_id: string;
+    segment: 'intermediate' | 'final';
+    track: RecordingTrackKind;
+    codec: 'pcm-f32-le';
+    sample_rate: number;
+    channels: 1;
+    started_at: string;
+    ended_at: string;
+    packet_count: number;
+    byte_count: number;
+    packets: Array<{
+        rtp_seq: number;
+        rtp_ts: number;
+        rtp_ssrc: number;
+        captured_at: string;
+        payload_b64: string;
+    }>;
+}
+export declare class CallRecorder {
+    private options;
+    private callContext;
+    private recordingId;
+    private _buffers;
+    private _bufferBytes;
+    private _trackStates;
+    private _processors;
+    private _readerCancellers;
+    private _flushTimerId;
+    private _flushing;
+    private _stopped;
+    private _started;
+    private _startedAt;
+    private _endedAt;
+    private _overflowWarnedThisWindow;
+    onWarning: ((warning: ITelnyxWarning) => void) | null;
+    private static readonly RETRY_DELAYS_MS;
+    private static readonly KEEPALIVE_BODY_LIMIT_BYTES;
+    private static readonly PACKET_OVERHEAD_BYTES;
+    constructor(options: ICallRecordingOptions, callContext: ICallRecordingContext);
+    start(localTrack?: MediaStreamTrack, remoteTrack?: MediaStreamTrack): void;
+    stop(): void;
+    postFinalReport(): Promise<void>;
+    cleanup(): void;
+    private _attach;
+    private _onFrame;
+    private _pushPacket;
+    private _flushIntervalMs;
+    private _maxBufferBytes;
+    private _sampleRate;
+    private _scheduleFlush;
+    private _clearFlushTimer;
+    private _cancelReaders;
+    private _periodicFlush;
+    private _drain;
+    private _resolveEndpointFromContext;
+    private _host;
+    _setHost(host: string): void;
+    private _callReportId;
+    _setCallReportId(callReportId: string): void;
+    private _resolveCallReportId;
+    private _resolveEndpoint;
+    private _buildEnvelope;
+    private _postRecording;
+    private _emitWarning;
+    private _toBase64;
+}

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

@@ -236,7 +236,7 @@ export declare type SanitizedClientOption = string | number | boolean | null | S
     [key: string]: SanitizedClientOption;
 };
 export interface ICallReportFlushReason {
-    type: 'buffer-limit' | 'manual' | 'socket-close' | 'socket-error';
+    type: 'buffer-limit' | 'manual' | 'socket-close' | 'socket-error' | 'page-unload';
     socketClose?: {
         code?: number;
         codeName?: string;
@@ -304,7 +304,7 @@ export declare class CallReportCollector {
     stop(): Promise<void>;
     flush(summary: ICallSummary, flushReason?: ICallReportFlushReason): ICallReportPayload | null;
     postReport(summary: ICallSummary, callReportId: string, host: string, voiceSdkId?: string): Promise<void>;
-    sendPayload(payload: ICallReportPayload, callReportId: string, host: string, voiceSdkId?: string): Promise<void>;
+    sendPayload(payload: ICallReportPayload, callReportId: string, host: string, voiceSdkId?: string, forceKeepalive?: boolean): Promise<void>;
     private _sendPayload;
     getStatsBuffer(): IStatsInterval[];
     shouldForceRelayCandidateForRecovery(): boolean;

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

@@ -43,6 +43,9 @@ export declare const NOTIFICATION_TYPE: {
 export declare const ERROR_TYPE: {
     invalidCredentialsOptions: string;
 };
+export declare const DEFAULT_CALL_RECORDING_FLUSH_INTERVAL_MS = 240000;
+export declare const DEFAULT_CALL_RECORDING_MAX_BUFFER_BYTES = 8000000;
+export declare const DEFAULT_CALL_RECORDING_SAMPLE_RATE = 48000;
 export declare const DEFAULT_CALL_OPTIONS: IVertoCallOptions;
 export declare enum State {
     New = 0,

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

@@ -41,6 +41,12 @@ export interface IClientOptions {
     enableCallReports?: boolean;
     callReportInterval?: number;
     callReportFlushInterval?: number;
+    enableCallRecording?: boolean;
+    callRecordingFlushIntervalMs?: number;
+    callRecordingMaxBufferBytes?: number;
+    callRecordingSampleRate?: number;
+    callRecordingTracks?: Array<'local' | 'remote'>;
+    callRecordingEndpoint?: string;
     mediaPermissionsRecovery?: {
         enabled: boolean;
         timeout: number;

package/package.json

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